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};
90 use rustc_back::slice::ref_slice;
91 use namespace::Namespace;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::type_variable::{TypeVariableOrigin};
94 use rustc::middle::region;
95 use rustc::ty::subst::{Kind, Subst, Substs};
96 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
97 use rustc::ty::{ParamTy, LvaluePreference, NoPreference, PreferMutLvalue};
98 use rustc::ty::{self, Ty, TyCtxt, Visibility};
99 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
100 use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
101 use rustc::ty::maps::Providers;
102 use rustc::ty::util::{Representability, IntTypeExt};
103 use errors::{DiagnosticBuilder, DiagnosticId};
104 use require_c_abi_if_variadic;
105 use session::{CompileIncomplete, Session};
108 use util::common::{ErrorReported, indenter};
109 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
111 use std::cell::{Cell, RefCell, Ref, RefMut};
113 use std::collections::hash_map::Entry;
115 use std::fmt::Display;
116 use std::mem::replace;
117 use std::ops::{self, Deref};
118 use syntax::abi::Abi;
120 use syntax::codemap::{self, original_sp, Spanned};
121 use syntax::feature_gate::{GateIssue, emit_feature_err};
123 use syntax::symbol::{Symbol, InternedString, keywords};
124 use syntax::util::lev_distance::find_best_match_for_name;
125 use syntax_pos::{self, BytePos, Span, MultiSpan};
127 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
128 use rustc::hir::itemlikevisit::ItemLikeVisitor;
129 use rustc::hir::map::Node;
130 use rustc::hir::{self, PatKind};
131 use rustc::middle::lang_items;
132 use rustc_back::slice;
133 use rustc_const_math::ConstInt;
149 mod generator_interior;
153 /// A wrapper for InferCtxt's `in_progress_tables` field.
154 #[derive(Copy, Clone)]
155 struct MaybeInProgressTables<'a, 'tcx: 'a> {
156 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
159 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
160 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
161 match self.maybe_tables {
162 Some(tables) => tables.borrow(),
164 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
169 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
170 match self.maybe_tables {
171 Some(tables) => tables.borrow_mut(),
173 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
180 /// closures defined within the function. For example:
183 /// bar(move|| { ... })
186 /// Here, the function `foo()` and the closure passed to
187 /// `bar()` will each have their own `FnCtxt`, but they will
188 /// share the inherited fields.
189 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
190 infcx: InferCtxt<'a, 'gcx, 'tcx>,
192 tables: MaybeInProgressTables<'a, 'tcx>,
194 locals: RefCell<NodeMap<Ty<'tcx>>>,
196 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
198 // When we process a call like `c()` where `c` is a closure type,
199 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
200 // `FnOnce` closure. In that case, we defer full resolution of the
201 // call until upvar inference can kick in and make the
202 // decision. We keep these deferred resolutions grouped by the
203 // def-id of the closure, so that once we decide, we can easily go
204 // back and process them.
205 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
207 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
209 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
211 // Anonymized types found in explicit return types and their
212 // associated fresh inference variable. Writeback resolves these
213 // variables to get the concrete type, which can be used to
214 // deanonymize TyAnon, after typeck is done with all functions.
215 anon_types: RefCell<NodeMap<Ty<'tcx>>>,
217 /// Each type parameter has an implicit region bound that
218 /// indicates it must outlive at least the function body (the user
219 /// may specify stronger requirements). This field indicates the
220 /// region of the callee. If it is `None`, then the parameter
221 /// environment is for an item or something where the "callee" is
223 implicit_region_bound: Option<ty::Region<'tcx>>,
225 body_id: Option<hir::BodyId>,
228 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
229 type Target = InferCtxt<'a, 'gcx, 'tcx>;
230 fn deref(&self) -> &Self::Target {
235 /// When type-checking an expression, we propagate downward
236 /// whatever type hint we are able in the form of an `Expectation`.
237 #[derive(Copy, Clone, Debug)]
238 pub enum Expectation<'tcx> {
239 /// We know nothing about what type this expression should have.
242 /// This expression is an `if` condition, it must resolve to `bool`.
245 /// This expression should have the type given (or some subtype)
246 ExpectHasType(Ty<'tcx>),
248 /// This expression will be cast to the `Ty`
249 ExpectCastableToType(Ty<'tcx>),
251 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
252 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
253 ExpectRvalueLikeUnsized(Ty<'tcx>),
256 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
257 // Disregard "castable to" expectations because they
258 // can lead us astray. Consider for example `if cond
259 // {22} else {c} as u8` -- if we propagate the
260 // "castable to u8" constraint to 22, it will pick the
261 // type 22u8, which is overly constrained (c might not
262 // be a u8). In effect, the problem is that the
263 // "castable to" expectation is not the tightest thing
264 // we can say, so we want to drop it in this case.
265 // The tightest thing we can say is "must unify with
266 // else branch". Note that in the case of a "has type"
267 // constraint, this limitation does not hold.
269 // If the expected type is just a type variable, then don't use
270 // an expected type. Otherwise, we might write parts of the type
271 // when checking the 'then' block which are incompatible with the
273 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
275 ExpectHasType(ety) => {
276 let ety = fcx.shallow_resolve(ety);
277 if !ety.is_ty_var() {
283 ExpectRvalueLikeUnsized(ety) => {
284 ExpectRvalueLikeUnsized(ety)
290 /// Provide an expectation for an rvalue expression given an *optional*
291 /// hint, which is not required for type safety (the resulting type might
292 /// be checked higher up, as is the case with `&expr` and `box expr`), but
293 /// is useful in determining the concrete type.
295 /// The primary use case is where the expected type is a fat pointer,
296 /// like `&[isize]`. For example, consider the following statement:
298 /// let x: &[isize] = &[1, 2, 3];
300 /// In this case, the expected type for the `&[1, 2, 3]` expression is
301 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
302 /// expectation `ExpectHasType([isize])`, that would be too strong --
303 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
304 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
305 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
306 /// which still is useful, because it informs integer literals and the like.
307 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
308 /// for examples of where this comes up,.
309 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
310 match fcx.tcx.struct_tail(ty).sty {
311 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
312 ExpectRvalueLikeUnsized(ty)
314 _ => ExpectHasType(ty)
318 // Resolves `expected` by a single level if it is a variable. If
319 // there is no expected type or resolution is not possible (e.g.,
320 // no constraints yet present), just returns `None`.
321 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
323 NoExpectation => NoExpectation,
324 ExpectIfCondition => ExpectIfCondition,
325 ExpectCastableToType(t) => {
326 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
328 ExpectHasType(t) => {
329 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
331 ExpectRvalueLikeUnsized(t) => {
332 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
337 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
338 match self.resolve(fcx) {
339 NoExpectation => None,
340 ExpectIfCondition => Some(fcx.tcx.types.bool),
341 ExpectCastableToType(ty) |
343 ExpectRvalueLikeUnsized(ty) => Some(ty),
347 /// It sometimes happens that we want to turn an expectation into
348 /// a **hard constraint** (i.e., something that must be satisfied
349 /// for the program to type-check). `only_has_type` will return
350 /// such a constraint, if it exists.
351 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
352 match self.resolve(fcx) {
353 ExpectHasType(ty) => Some(ty),
354 ExpectIfCondition => Some(fcx.tcx.types.bool),
355 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
359 /// Like `only_has_type`, but instead of returning `None` if no
360 /// hard constraint exists, creates a fresh type variable.
361 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
362 self.only_has_type(fcx)
363 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
367 #[derive(Copy, Clone)]
368 pub struct UnsafetyState {
369 pub def: ast::NodeId,
370 pub unsafety: hir::Unsafety,
371 pub unsafe_push_count: u32,
376 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
377 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
380 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
381 match self.unsafety {
382 // If this unsafe, then if the outer function was already marked as
383 // unsafe we shouldn't attribute the unsafe'ness to the block. This
384 // way the block can be warned about instead of ignoring this
385 // extraneous block (functions are never warned about).
386 hir::Unsafety::Unsafe if self.from_fn => *self,
389 let (unsafety, def, count) = match blk.rules {
390 hir::PushUnsafeBlock(..) =>
391 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
392 hir::PopUnsafeBlock(..) =>
393 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
394 hir::UnsafeBlock(..) =>
395 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
397 (unsafety, self.def, self.unsafe_push_count),
401 unsafe_push_count: count,
408 #[derive(Debug, Copy, Clone)]
414 /// Tracks whether executing a node may exit normally (versus
415 /// return/break/panic, which "diverge", leaving dead code in their
416 /// wake). Tracked semi-automatically (through type variables marked
417 /// as diverging), with some manual adjustments for control-flow
418 /// primitives (approximating a CFG).
419 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
421 /// Potentially unknown, some cases converge,
422 /// others require a CFG to determine them.
425 /// Definitely known to diverge and therefore
426 /// not reach the next sibling or its parent.
429 /// Same as `Always` but with a reachability
430 /// warning already emitted
434 // Convenience impls for combinig `Diverges`.
436 impl ops::BitAnd for Diverges {
438 fn bitand(self, other: Self) -> Self {
439 cmp::min(self, other)
443 impl ops::BitOr for Diverges {
445 fn bitor(self, other: Self) -> Self {
446 cmp::max(self, other)
450 impl ops::BitAndAssign for Diverges {
451 fn bitand_assign(&mut self, other: Self) {
452 *self = *self & other;
456 impl ops::BitOrAssign for Diverges {
457 fn bitor_assign(&mut self, other: Self) {
458 *self = *self | other;
463 fn always(self) -> bool {
464 self >= Diverges::Always
468 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
471 // this is `null` for loops where break with a value is illegal,
472 // such as `while`, `for`, and `while let`
473 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
476 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
477 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
478 by_id: NodeMap<usize>,
481 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
482 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
483 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
484 bug!("could not find enclosing breakable with id {}", target_id);
490 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
491 body_id: ast::NodeId,
493 /// The parameter environment used for proving trait obligations
494 /// in this function. This can change when we descend into
495 /// closures (as they bring new things into scope), hence it is
496 /// not part of `Inherited` (as of the time of this writing,
497 /// closures do not yet change the environment, but they will
499 param_env: ty::ParamEnv<'tcx>,
501 // Number of errors that had been reported when we started
502 // checking this function. On exit, if we find that *more* errors
503 // have been reported, we will skip regionck and other work that
504 // expects the types within the function to be consistent.
505 err_count_on_creation: usize,
507 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
509 yield_ty: Option<Ty<'tcx>>,
511 ps: RefCell<UnsafetyState>,
513 /// Whether the last checked node generates a divergence (e.g.,
514 /// `return` will set this to Always). In general, when entering
515 /// an expression or other node in the tree, the initial value
516 /// indicates whether prior parts of the containing expression may
517 /// have diverged. It is then typically set to `Maybe` (and the
518 /// old value remembered) for processing the subparts of the
519 /// current expression. As each subpart is processed, they may set
520 /// the flag to `Always` etc. Finally, at the end, we take the
521 /// result and "union" it with the original value, so that when we
522 /// return the flag indicates if any subpart of the the parent
523 /// expression (up to and including this part) has diverged. So,
524 /// if you read it after evaluating a subexpression `X`, the value
525 /// you get indicates whether any subexpression that was
526 /// evaluating up to and including `X` diverged.
528 /// We use this flag for two purposes:
530 /// - To warn about unreachable code: if, after processing a
531 /// sub-expression but before we have applied the effects of the
532 /// current node, we see that the flag is set to `Always`, we
533 /// can issue a warning. This corresponds to something like
534 /// `foo(return)`; we warn on the `foo()` expression. (We then
535 /// update the flag to `WarnedAlways` to suppress duplicate
536 /// reports.) Similarly, if we traverse to a fresh statement (or
537 /// tail expression) from a `Always` setting, we will issue a
538 /// warning. This corresponds to something like `{return;
539 /// foo();}` or `{return; 22}`, where we would warn on the
542 /// - To permit assignment into a local variable or other lvalue
543 /// (including the "return slot") of type `!`. This is allowed
544 /// if **either** the type of value being assigned is `!`, which
545 /// means the current code is dead, **or** the expression's
546 /// diverging flag is true, which means that a diverging value was
547 /// wrapped (e.g., `let x: ! = foo(return)`).
549 /// To repeat the last point: an expression represents dead-code
550 /// if, after checking it, **either** its type is `!` OR the
551 /// diverges flag is set to something other than `Maybe`.
552 diverges: Cell<Diverges>,
554 /// Whether any child nodes have any type errors.
555 has_errors: Cell<bool>,
557 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
559 inh: &'a Inherited<'a, 'gcx, 'tcx>,
562 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
563 type Target = Inherited<'a, 'gcx, 'tcx>;
564 fn deref(&self) -> &Self::Target {
569 /// Helper type of a temporary returned by Inherited::build(...).
570 /// Necessary because we can't write the following bound:
571 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
572 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
573 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
577 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
578 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
579 -> InheritedBuilder<'a, 'gcx, 'tcx> {
580 let hir_id_root = if def_id.is_local() {
581 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
582 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
583 DefId::local(hir_id.owner)
589 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
595 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
596 fn enter<F, R>(&'tcx mut self, f: F) -> R
597 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
599 let def_id = self.def_id;
600 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
604 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
605 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
607 let item_id = tcx.hir.as_local_node_id(def_id);
608 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
609 let implicit_region_bound = body_id.map(|body_id| {
610 let body = tcx.hir.body(body_id);
611 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
615 tables: MaybeInProgressTables {
616 maybe_tables: infcx.in_progress_tables,
619 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
620 locals: RefCell::new(NodeMap()),
621 deferred_call_resolutions: RefCell::new(DefIdMap()),
622 deferred_cast_checks: RefCell::new(Vec::new()),
623 deferred_generator_interiors: RefCell::new(Vec::new()),
624 anon_types: RefCell::new(NodeMap()),
625 implicit_region_bound,
630 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
631 debug!("register_predicate({:?})", obligation);
632 if obligation.has_escaping_regions() {
633 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
638 .register_predicate_obligation(self, obligation);
641 fn register_predicates<I>(&self, obligations: I)
642 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
643 for obligation in obligations {
644 self.register_predicate(obligation);
648 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
649 self.register_predicates(infer_ok.obligations);
653 fn normalize_associated_types_in<T>(&self,
655 body_id: ast::NodeId,
656 param_env: ty::ParamEnv<'tcx>,
658 where T : TypeFoldable<'tcx>
660 let ok = self.normalize_associated_types_in_as_infer_ok(span, body_id, param_env, value);
661 self.register_infer_ok_obligations(ok)
664 fn normalize_associated_types_in_as_infer_ok<T>(&self,
666 body_id: ast::NodeId,
667 param_env: ty::ParamEnv<'tcx>,
670 where T : TypeFoldable<'tcx>
672 debug!("normalize_associated_types_in(value={:?})", value);
673 let mut selcx = traits::SelectionContext::new(self);
674 let cause = ObligationCause::misc(span, body_id);
675 let traits::Normalized { value, obligations } =
676 traits::normalize(&mut selcx, param_env, cause, value);
677 debug!("normalize_associated_types_in: result={:?} predicates={:?}",
680 InferOk { value, obligations }
683 /// Replace any late-bound regions bound in `value` with
684 /// free variants attached to `all_outlive_scope`.
685 fn liberate_late_bound_regions<T>(&self,
686 all_outlive_scope: DefId,
687 value: &ty::Binder<T>)
689 where T: TypeFoldable<'tcx>
691 self.tcx.replace_late_bound_regions(value, |br| {
692 self.tcx.mk_region(ty::ReFree(ty::FreeRegion {
693 scope: all_outlive_scope,
700 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
702 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
703 fn visit_item(&mut self, i: &'tcx hir::Item) {
704 check_item_type(self.tcx, i);
706 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
707 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
710 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
711 tcx.sess.track_errors(|| {
712 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
713 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
717 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
718 tcx.sess.track_errors(|| {
719 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
723 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
724 tcx.typeck_item_bodies(LOCAL_CRATE)
727 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
728 -> Result<(), CompileIncomplete>
730 debug_assert!(crate_num == LOCAL_CRATE);
731 Ok(tcx.sess.track_errors(|| {
732 for body_owner_def_id in tcx.body_owners() {
733 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
738 pub fn provide(providers: &mut Providers) {
739 *providers = Providers {
751 fn generator_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
753 -> Option<ty::PolyGenSig<'tcx>> {
754 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
755 let hir_id = tcx.hir.node_to_hir_id(node_id);
756 tcx.typeck_tables_of(def_id).generator_sigs()[hir_id].map(|s| ty::Binder(s))
759 fn closure_kind<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
762 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
763 let hir_id = tcx.hir.node_to_hir_id(node_id);
764 tcx.typeck_tables_of(def_id).closure_kinds()[hir_id].0
767 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
769 -> Option<ty::Destructor> {
770 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
773 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
774 /// with information about it's body-id and fn-decl (if any). Otherwise,
777 /// If this function returns "some", then `typeck_tables(def_id)` will
778 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
779 /// may not succeed. In some cases where this function returns `None`
780 /// (notably closures), `typeck_tables(def_id)` would wind up
781 /// redirecting to the owning function.
782 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
784 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
786 match tcx.hir.get(id) {
787 hir::map::NodeItem(item) => {
789 hir::ItemConst(_, body) |
790 hir::ItemStatic(_, _, body) =>
792 hir::ItemFn(ref decl, .., body) =>
793 Some((body, Some(decl))),
798 hir::map::NodeTraitItem(item) => {
800 hir::TraitItemKind::Const(_, Some(body)) =>
802 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
803 Some((body, Some(&sig.decl))),
808 hir::map::NodeImplItem(item) => {
810 hir::ImplItemKind::Const(_, body) =>
812 hir::ImplItemKind::Method(ref sig, body) =>
813 Some((body, Some(&sig.decl))),
818 hir::map::NodeExpr(expr) => {
819 // FIXME(eddyb) Closures should have separate
820 // function definition IDs and expression IDs.
821 // Type-checking should not let closures get
822 // this far in a constant position.
823 // Assume that everything other than closures
824 // is a constant "initializer" expression.
826 hir::ExprClosure(..) =>
829 Some((hir::BodyId { node_id: expr.id }, None)),
836 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
839 // Closures' tables come from their outermost function,
840 // as they are part of the same "inference environment".
841 let outer_def_id = tcx.closure_base_def_id(def_id);
842 if outer_def_id != def_id {
843 return tcx.has_typeck_tables(outer_def_id);
846 let id = tcx.hir.as_local_node_id(def_id).unwrap();
847 primary_body_of(tcx, id).is_some()
850 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
853 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
856 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
858 -> &'tcx ty::TypeckTables<'tcx> {
859 // Closures' tables come from their outermost function,
860 // as they are part of the same "inference environment".
861 let outer_def_id = tcx.closure_base_def_id(def_id);
862 if outer_def_id != def_id {
863 return tcx.typeck_tables_of(outer_def_id);
866 let id = tcx.hir.as_local_node_id(def_id).unwrap();
867 let span = tcx.hir.span(id);
869 // Figure out what primary body this item has.
870 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
871 span_bug!(span, "can't type-check body of {:?}", def_id);
873 let body = tcx.hir.body(body_id);
875 let tables = Inherited::build(tcx, def_id).enter(|inh| {
876 let param_env = tcx.param_env(def_id);
877 let fcx = if let Some(decl) = fn_decl {
878 let fn_sig = tcx.fn_sig(def_id);
880 check_abi(tcx, span, fn_sig.abi());
882 // Compute the fty from point of view of inside fn.
884 inh.liberate_late_bound_regions(def_id, &fn_sig);
886 inh.normalize_associated_types_in(body.value.span,
891 check_fn(&inh, param_env, fn_sig, decl, id, body, false).0
893 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
894 let expected_type = tcx.type_of(def_id);
895 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
896 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
898 // Gather locals in statics (because of block expressions).
899 // This is technically unnecessary because locals in static items are forbidden,
900 // but prevents type checking from blowing up before const checking can properly
902 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
904 fcx.check_expr_coercable_to_type(&body.value, expected_type);
909 fcx.select_all_obligations_and_apply_defaults();
910 fcx.closure_analyze(body);
911 fcx.select_obligations_where_possible();
913 fcx.resolve_generator_interiors(def_id);
914 fcx.select_all_obligations_or_error();
916 if fn_decl.is_some() {
917 fcx.regionck_fn(id, body);
919 fcx.regionck_expr(body);
922 fcx.resolve_type_vars_in_body(body)
925 // Consistency check our TypeckTables instance can hold all ItemLocalIds
926 // it will need to hold.
927 assert_eq!(tables.local_id_root,
928 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
932 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
933 if !tcx.sess.target.target.is_abi_supported(abi) {
934 struct_span_err!(tcx.sess, span, E0570,
935 "The ABI `{}` is not supported for the current target", abi).emit()
939 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
940 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
943 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
944 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
947 // infer the variable's type
948 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
949 self.fcx.locals.borrow_mut().insert(nid, var_ty);
953 // take type that the user specified
954 self.fcx.locals.borrow_mut().insert(nid, typ);
961 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
962 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
963 NestedVisitorMap::None
966 // Add explicitly-declared locals.
967 fn visit_local(&mut self, local: &'gcx hir::Local) {
968 let o_ty = match local.ty {
969 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
972 self.assign(local.span, local.id, o_ty);
973 debug!("Local variable {:?} is assigned type {}",
975 self.fcx.ty_to_string(
976 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
977 intravisit::walk_local(self, local);
980 // Add pattern bindings.
981 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
982 if let PatKind::Binding(_, _, ref path1, _) = p.node {
983 let var_ty = self.assign(p.span, p.id, None);
985 self.fcx.require_type_is_sized(var_ty, p.span,
986 traits::VariableType(p.id));
988 debug!("Pattern binding {} is assigned to {} with type {:?}",
990 self.fcx.ty_to_string(
991 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
994 intravisit::walk_pat(self, p);
997 // Don't descend into the bodies of nested closures
998 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
999 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1002 /// Helper used for fns and closures. Does the grungy work of checking a function
1003 /// body and returns the function context used for that purpose, since in the case of a fn item
1004 /// there is still a bit more to do.
1007 /// * inherited: other fields inherited from the enclosing fn (if any)
1008 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1009 param_env: ty::ParamEnv<'tcx>,
1010 fn_sig: ty::FnSig<'tcx>,
1011 decl: &'gcx hir::FnDecl,
1013 body: &'gcx hir::Body,
1014 can_be_generator: bool)
1015 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<ty::GeneratorInterior<'tcx>>)
1017 let mut fn_sig = fn_sig.clone();
1019 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1021 // Create the function context. This is either derived from scratch or,
1022 // in the case of function expressions, based on the outer context.
1023 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1024 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1026 let ret_ty = fn_sig.output();
1027 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1028 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
1029 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1030 fn_sig = fcx.tcx.mk_fn_sig(
1031 fn_sig.inputs().iter().cloned(),
1038 let span = body.value.span;
1040 if body.is_generator && can_be_generator {
1041 fcx.yield_ty = Some(fcx.next_ty_var(TypeVariableOrigin::TypeInference(span)));
1044 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1046 // Add formal parameters.
1047 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1048 // Check the pattern.
1049 fcx.check_pat_walk(&arg.pat, arg_ty,
1050 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1052 // Check that argument is Sized.
1053 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1054 // for simple cases like `fn foo(x: Trait)`,
1055 // where we would error once on the parameter as a whole, and once on the binding `x`.
1056 if arg.pat.simple_name().is_none() {
1057 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1060 fcx.write_ty(arg.hir_id, arg_ty);
1063 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1064 let gen_ty = if can_be_generator && body.is_generator {
1065 let gen_sig = ty::GenSig {
1066 yield_ty: fcx.yield_ty.unwrap(),
1069 inherited.tables.borrow_mut().generator_sigs_mut().insert(fn_hir_id, Some(gen_sig));
1071 let witness = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1072 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), witness));
1073 let interior = ty::GeneratorInterior::new(witness);
1075 inherited.tables.borrow_mut().generator_interiors_mut().insert(fn_hir_id, interior);
1079 inherited.tables.borrow_mut().generator_sigs_mut().insert(fn_hir_id, None);
1082 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1084 fcx.check_return_expr(&body.value);
1086 // Finalize the return check by taking the LUB of the return types
1087 // we saw and assigning it to the expected return type. This isn't
1088 // really expected to fail, since the coercions would have failed
1089 // earlier when trying to find a LUB.
1091 // However, the behavior around `!` is sort of complex. In the
1092 // event that the `actual_return_ty` comes back as `!`, that
1093 // indicates that the fn either does not return or "returns" only
1094 // values of type `!`. In this case, if there is an expected
1095 // return type that is *not* `!`, that should be ok. But if the
1096 // return type is being inferred, we want to "fallback" to `!`:
1098 // let x = move || panic!();
1100 // To allow for that, I am creating a type variable with diverging
1101 // fallback. This was deemed ever so slightly better than unifying
1102 // the return value with `!` because it allows for the caller to
1103 // make more assumptions about the return type (e.g., they could do
1105 // let y: Option<u32> = Some(x());
1107 // which would then cause this return type to become `u32`, not
1109 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1110 let mut actual_return_ty = coercion.complete(&fcx);
1111 if actual_return_ty.is_never() {
1112 actual_return_ty = fcx.next_diverging_ty_var(
1113 TypeVariableOrigin::DivergingFn(span));
1115 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1120 fn check_struct<'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 if def.repr.simd() {
1129 check_simd(tcx, span, def_id);
1132 check_packed(tcx, span, def_id);
1135 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1138 let def_id = tcx.hir.local_def_id(id);
1139 let def = tcx.adt_def(def_id);
1140 def.destructor(tcx); // force the destructor to be evaluated
1141 check_representable(tcx, span, def_id);
1143 check_packed(tcx, span, def_id);
1146 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1147 debug!("check_item_type(it.id={}, it.name={})",
1149 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1150 let _indenter = indenter();
1152 // Consts can play a role in type-checking, so they are included here.
1153 hir::ItemStatic(..) |
1154 hir::ItemConst(..) => {
1155 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1157 hir::ItemEnum(ref enum_definition, _) => {
1160 &enum_definition.variants,
1163 hir::ItemFn(..) => {} // entirely within check_item_body
1164 hir::ItemImpl(.., ref impl_item_refs) => {
1165 debug!("ItemImpl {} with id {}", it.name, it.id);
1166 let impl_def_id = tcx.hir.local_def_id(it.id);
1167 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1168 check_impl_items_against_trait(tcx,
1173 let trait_def_id = impl_trait_ref.def_id;
1174 check_on_unimplemented(tcx, trait_def_id, it);
1177 hir::ItemTrait(..) => {
1178 let def_id = tcx.hir.local_def_id(it.id);
1179 check_on_unimplemented(tcx, def_id, it);
1181 hir::ItemStruct(..) => {
1182 check_struct(tcx, it.id, it.span);
1184 hir::ItemUnion(..) => {
1185 check_union(tcx, it.id, it.span);
1187 hir::ItemTy(_, ref generics) => {
1188 let def_id = tcx.hir.local_def_id(it.id);
1189 let pty_ty = tcx.type_of(def_id);
1190 check_bounds_are_used(tcx, generics, pty_ty);
1192 hir::ItemForeignMod(ref m) => {
1193 check_abi(tcx, it.span, m.abi);
1195 if m.abi == Abi::RustIntrinsic {
1196 for item in &m.items {
1197 intrinsic::check_intrinsic_type(tcx, item);
1199 } else if m.abi == Abi::PlatformIntrinsic {
1200 for item in &m.items {
1201 intrinsic::check_platform_intrinsic_type(tcx, item);
1204 for item in &m.items {
1205 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1206 if !generics.types.is_empty() {
1207 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1208 "foreign items may not have type parameters");
1209 span_help!(&mut err, item.span,
1210 "consider using specialization instead of \
1215 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1216 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1221 _ => {/* nothing to do */ }
1225 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1226 trait_def_id: DefId,
1228 let item_def_id = tcx.hir.local_def_id(item.id);
1229 // an error would be reported if this fails.
1230 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1233 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1234 impl_item: &hir::ImplItem,
1237 let mut err = struct_span_err!(
1238 tcx.sess, impl_item.span, E0520,
1239 "`{}` specializes an item from a parent `impl`, but \
1240 that item is not marked `default`",
1242 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1245 match tcx.span_of_impl(parent_impl) {
1247 err.span_label(span, "parent `impl` is here");
1248 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1252 err.note(&format!("parent implementation is in crate `{}`", cname));
1259 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1260 trait_def: &ty::TraitDef,
1261 trait_item: &ty::AssociatedItem,
1263 impl_item: &hir::ImplItem)
1265 let ancestors = trait_def.ancestors(tcx, impl_id);
1267 let kind = match impl_item.node {
1268 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1269 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1270 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1273 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1274 .map(|node_item| node_item.map(|parent| parent.defaultness));
1276 if let Some(parent) = parent {
1277 if tcx.impl_item_is_final(&parent) {
1278 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1284 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1287 impl_trait_ref: ty::TraitRef<'tcx>,
1288 impl_item_refs: &[hir::ImplItemRef]) {
1289 // If the trait reference itself is erroneous (so the compilation is going
1290 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1291 // isn't populated for such impls.
1292 if impl_trait_ref.references_error() { return; }
1294 // Locate trait definition and items
1295 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1296 let mut overridden_associated_type = None;
1298 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1300 // Check existing impl methods to see if they are both present in trait
1301 // and compatible with trait signature
1302 for impl_item in impl_items() {
1303 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1304 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1305 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1306 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1308 // Not compatible, but needed for the error message
1309 tcx.associated_items(impl_trait_ref.def_id)
1310 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1313 // Check that impl definition matches trait definition
1314 if let Some(ty_trait_item) = ty_trait_item {
1315 match impl_item.node {
1316 hir::ImplItemKind::Const(..) => {
1317 // Find associated const definition.
1318 if ty_trait_item.kind == ty::AssociatedKind::Const {
1319 compare_const_impl(tcx,
1325 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1326 "item `{}` is an associated const, \
1327 which doesn't match its trait `{}`",
1330 err.span_label(impl_item.span, "does not match trait");
1331 // We can only get the spans from local trait definition
1332 // Same for E0324 and E0325
1333 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1334 err.span_label(trait_span, "item in trait");
1339 hir::ImplItemKind::Method(..) => {
1340 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1341 if ty_trait_item.kind == ty::AssociatedKind::Method {
1342 let err_count = tcx.sess.err_count();
1343 compare_impl_method(tcx,
1349 true); // start with old-broken-mode
1350 if err_count == tcx.sess.err_count() {
1351 // old broken mode did not report an error. Try with the new mode.
1352 compare_impl_method(tcx,
1358 false); // use the new mode
1361 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1362 "item `{}` is an associated method, \
1363 which doesn't match its trait `{}`",
1366 err.span_label(impl_item.span, "does not match trait");
1367 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1368 err.span_label(trait_span, "item in trait");
1373 hir::ImplItemKind::Type(_) => {
1374 if ty_trait_item.kind == ty::AssociatedKind::Type {
1375 if ty_trait_item.defaultness.has_value() {
1376 overridden_associated_type = Some(impl_item);
1379 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1380 "item `{}` is an associated type, \
1381 which doesn't match its trait `{}`",
1384 err.span_label(impl_item.span, "does not match trait");
1385 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1386 err.span_label(trait_span, "item in trait");
1393 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1397 // Check for missing items from trait
1398 let mut missing_items = Vec::new();
1399 let mut invalidated_items = Vec::new();
1400 let associated_type_overridden = overridden_associated_type.is_some();
1401 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1402 let is_implemented = trait_def.ancestors(tcx, impl_id)
1403 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1405 .map(|node_item| !node_item.node.is_from_trait())
1408 if !is_implemented {
1409 if !trait_item.defaultness.has_value() {
1410 missing_items.push(trait_item);
1411 } else if associated_type_overridden {
1412 invalidated_items.push(trait_item.name);
1417 if !missing_items.is_empty() {
1418 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1419 "not all trait items implemented, missing: `{}`",
1420 missing_items.iter()
1421 .map(|trait_item| trait_item.name.to_string())
1422 .collect::<Vec<_>>().join("`, `"));
1423 err.span_label(impl_span, format!("missing `{}` in implementation",
1424 missing_items.iter()
1425 .map(|trait_item| trait_item.name.to_string())
1426 .collect::<Vec<_>>().join("`, `")));
1427 for trait_item in missing_items {
1428 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1429 err.span_label(span, format!("`{}` from trait", trait_item.name));
1431 err.note_trait_signature(trait_item.name.to_string(),
1432 trait_item.signature(&tcx));
1438 if !invalidated_items.is_empty() {
1439 let invalidator = overridden_associated_type.unwrap();
1440 span_err!(tcx.sess, invalidator.span, E0399,
1441 "the following trait items need to be reimplemented \
1442 as `{}` was overridden: `{}`",
1444 invalidated_items.iter()
1445 .map(|name| name.to_string())
1446 .collect::<Vec<_>>().join("`, `"))
1450 /// Checks whether a type can be represented in memory. In particular, it
1451 /// identifies types that contain themselves without indirection through a
1452 /// pointer, which would mean their size is unbounded.
1453 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1457 let rty = tcx.type_of(item_def_id);
1459 // Check that it is possible to represent this type. This call identifies
1460 // (1) types that contain themselves and (2) types that contain a different
1461 // recursive type. It is only necessary to throw an error on those that
1462 // contain themselves. For case 2, there must be an inner type that will be
1463 // caught by case 1.
1464 match rty.is_representable(tcx, sp) {
1465 Representability::SelfRecursive(spans) => {
1466 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1468 err.span_label(span, "recursive without indirection");
1473 Representability::Representable | Representability::ContainsRecursive => (),
1478 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1479 let t = tcx.type_of(def_id);
1481 ty::TyAdt(def, substs) if def.is_struct() => {
1482 let fields = &def.struct_variant().fields;
1483 if fields.is_empty() {
1484 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1487 let e = fields[0].ty(tcx, substs);
1488 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1489 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1490 .span_label(sp, "SIMD elements must have the same type")
1495 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1496 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1498 span_err!(tcx.sess, sp, E0077,
1499 "SIMD vector element type should be machine type");
1508 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1509 if tcx.adt_def(def_id).repr.packed() {
1510 if tcx.adt_def(def_id).repr.align > 0 {
1511 struct_span_err!(tcx.sess, sp, E0587,
1512 "type has conflicting packed and align representation hints").emit();
1514 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1515 struct_span_err!(tcx.sess, sp, E0588,
1516 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1521 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1523 stack: &mut Vec<DefId>) -> bool {
1524 let t = tcx.type_of(def_id);
1525 if stack.contains(&def_id) {
1526 debug!("check_packed_inner: {:?} is recursive", t);
1530 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1531 if tcx.adt_def(def.did).repr.align > 0 {
1534 // push struct def_id before checking fields
1536 for field in &def.struct_variant().fields {
1537 let f = field.ty(tcx, substs);
1539 ty::TyAdt(def, _) => {
1540 if check_packed_inner(tcx, def.did, stack) {
1547 // only need to pop if not early out
1555 #[allow(trivial_numeric_casts)]
1556 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1558 vs: &'tcx [hir::Variant],
1560 let def_id = tcx.hir.local_def_id(id);
1561 let def = tcx.adt_def(def_id);
1562 def.destructor(tcx); // force the destructor to be evaluated
1564 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1566 tcx.sess, sp, E0084,
1567 "unsupported representation for zero-variant enum")
1568 .span_label(sp, "unsupported enum representation")
1572 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1573 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1574 if !tcx.sess.features.borrow().repr128 {
1575 emit_feature_err(&tcx.sess.parse_sess,
1578 GateIssue::Language,
1579 "repr with 128-bit type is unstable");
1584 if let Some(e) = v.node.disr_expr {
1585 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1589 let mut disr_vals: Vec<ConstInt> = Vec::new();
1590 for (discr, v) in def.discriminants(tcx).zip(vs) {
1591 // Check for duplicate discriminant values
1592 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1593 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1594 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1595 let i_span = match variant_i.node.disr_expr {
1596 Some(expr) => tcx.hir.span(expr.node_id),
1597 None => tcx.hir.span(variant_i_node_id)
1599 let span = match v.node.disr_expr {
1600 Some(expr) => tcx.hir.span(expr.node_id),
1603 struct_span_err!(tcx.sess, span, E0081,
1604 "discriminant value `{}` already exists", disr_vals[i])
1605 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1606 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1609 disr_vals.push(discr);
1612 check_representable(tcx, sp, def_id);
1615 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1616 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1618 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1619 -> ty::GenericPredicates<'tcx>
1622 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1623 let item_id = tcx.hir.ty_param_owner(node_id);
1624 let item_def_id = tcx.hir.local_def_id(item_id);
1625 let generics = tcx.generics_of(item_def_id);
1626 let index = generics.type_param_to_index[&def_id.index];
1627 ty::GenericPredicates {
1629 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1631 ty::Predicate::Trait(ref data) => {
1632 data.0.self_ty().is_param(index)
1636 }).cloned().collect()
1640 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1641 -> Option<ty::Region<'tcx>> {
1643 Some(def) => infer::EarlyBoundRegion(span, def.name),
1644 None => infer::MiscVariable(span)
1646 Some(self.next_region_var(v))
1649 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1650 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1653 fn ty_infer_for_def(&self,
1654 ty_param_def: &ty::TypeParameterDef,
1655 substs: &[Kind<'tcx>],
1656 span: Span) -> Ty<'tcx> {
1657 self.type_var_for_def(span, ty_param_def, substs)
1660 fn projected_ty_from_poly_trait_ref(&self,
1663 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1666 let (trait_ref, _) =
1667 self.replace_late_bound_regions_with_fresh_var(
1669 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1672 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1675 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1676 if ty.has_escaping_regions() {
1677 ty // FIXME: normalization and escaping regions
1679 self.normalize_associated_types_in(span, &ty)
1683 fn set_tainted_by_errors(&self) {
1684 self.infcx.set_tainted_by_errors()
1687 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1688 self.write_ty(hir_id, ty)
1692 /// Controls whether the arguments are tupled. This is used for the call
1695 /// Tupling means that all call-side arguments are packed into a tuple and
1696 /// passed as a single parameter. For example, if tupling is enabled, this
1699 /// fn f(x: (isize, isize))
1701 /// Can be called as:
1708 #[derive(Clone, Eq, PartialEq)]
1709 enum TupleArgumentsFlag {
1714 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1715 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1716 param_env: ty::ParamEnv<'tcx>,
1717 body_id: ast::NodeId)
1718 -> FnCtxt<'a, 'gcx, 'tcx> {
1722 err_count_on_creation: inh.tcx.sess.err_count(),
1725 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1726 ast::CRATE_NODE_ID)),
1727 diverges: Cell::new(Diverges::Maybe),
1728 has_errors: Cell::new(false),
1729 enclosing_breakables: RefCell::new(EnclosingBreakables {
1737 pub fn sess(&self) -> &Session {
1741 pub fn err_count_since_creation(&self) -> usize {
1742 self.tcx.sess.err_count() - self.err_count_on_creation
1745 /// Produce warning on the given node, if the current point in the
1746 /// function is unreachable, and there hasn't been another warning.
1747 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1748 if self.diverges.get() == Diverges::Always {
1749 self.diverges.set(Diverges::WarnedAlways);
1751 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1753 self.tcx().lint_node(
1754 lint::builtin::UNREACHABLE_CODE,
1756 &format!("unreachable {}", kind));
1762 code: ObligationCauseCode<'tcx>)
1763 -> ObligationCause<'tcx> {
1764 ObligationCause::new(span, self.body_id, code)
1767 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1768 self.cause(span, ObligationCauseCode::MiscObligation)
1771 /// Resolves type variables in `ty` if possible. Unlike the infcx
1772 /// version (resolve_type_vars_if_possible), this version will
1773 /// also select obligations if it seems useful, in an effort
1774 /// to get more type information.
1775 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1776 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1778 // No TyInfer()? Nothing needs doing.
1779 if !ty.has_infer_types() {
1780 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1784 // If `ty` is a type variable, see whether we already know what it is.
1785 ty = self.resolve_type_vars_if_possible(&ty);
1786 if !ty.has_infer_types() {
1787 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1791 // If not, try resolving pending obligations as much as
1792 // possible. This can help substantially when there are
1793 // indirect dependencies that don't seem worth tracking
1795 self.select_obligations_where_possible();
1796 ty = self.resolve_type_vars_if_possible(&ty);
1798 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1802 fn record_deferred_call_resolution(&self,
1803 closure_def_id: DefId,
1804 r: DeferredCallResolution<'gcx, 'tcx>) {
1805 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1806 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1809 fn remove_deferred_call_resolutions(&self,
1810 closure_def_id: DefId)
1811 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1813 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1814 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1817 pub fn tag(&self) -> String {
1818 let self_ptr: *const FnCtxt = self;
1819 format!("{:?}", self_ptr)
1822 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1823 match self.locals.borrow().get(&nid) {
1826 span_bug!(span, "no type for local variable {}",
1827 self.tcx.hir.node_to_string(nid));
1833 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1834 debug!("write_ty({:?}, {:?}) in fcx {}",
1835 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1836 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1838 if ty.references_error() {
1839 self.has_errors.set(true);
1840 self.set_tainted_by_errors();
1844 // The NodeId and the ItemLocalId must identify the same item. We just pass
1845 // both of them for consistency checking.
1846 pub fn write_method_call(&self,
1848 method: MethodCallee<'tcx>) {
1851 .type_dependent_defs_mut()
1852 .insert(hir_id, Def::Method(method.def_id));
1853 self.write_substs(hir_id, method.substs);
1856 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1857 if !substs.is_noop() {
1858 debug!("write_substs({:?}, {:?}) in fcx {}",
1863 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1867 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1868 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1874 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1875 Entry::Vacant(entry) => { entry.insert(adj); },
1876 Entry::Occupied(mut entry) => {
1877 debug!(" - composing on top of {:?}", entry.get());
1878 match (&entry.get()[..], &adj[..]) {
1879 // Applying any adjustment on top of a NeverToAny
1880 // is a valid NeverToAny adjustment, because it can't
1882 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1884 Adjustment { kind: Adjust::Deref(_), .. },
1885 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1887 Adjustment { kind: Adjust::Deref(_), .. },
1888 .. // Any following adjustments are allowed.
1890 // A reborrow has no effect before a dereference.
1892 // FIXME: currently we never try to compose autoderefs
1893 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1895 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1896 expr, entry.get(), adj)
1898 *entry.get_mut() = adj;
1903 /// Basically whenever we are converting from a type scheme into
1904 /// the fn body space, we always want to normalize associated
1905 /// types as well. This function combines the two.
1906 fn instantiate_type_scheme<T>(&self,
1908 substs: &Substs<'tcx>,
1911 where T : TypeFoldable<'tcx>
1913 let value = value.subst(self.tcx, substs);
1914 let result = self.normalize_associated_types_in(span, &value);
1915 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1922 /// As `instantiate_type_scheme`, but for the bounds found in a
1923 /// generic type scheme.
1924 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1925 -> ty::InstantiatedPredicates<'tcx> {
1926 let bounds = self.tcx.predicates_of(def_id);
1927 let result = bounds.instantiate(self.tcx, substs);
1928 let result = self.normalize_associated_types_in(span, &result);
1929 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1936 /// Replace all anonymized types with fresh inference variables
1937 /// and record them for writeback.
1938 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1939 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1940 if let ty::TyAnon(def_id, substs) = ty.sty {
1941 // Use the same type variable if the exact same TyAnon appears more
1942 // than once in the return type (e.g. if it's passed to a type alias).
1943 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1944 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1947 let span = self.tcx.def_span(def_id);
1948 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1949 self.anon_types.borrow_mut().insert(id, ty_var);
1951 let predicates_of = self.tcx.predicates_of(def_id);
1952 let bounds = predicates_of.instantiate(self.tcx, substs);
1954 for predicate in bounds.predicates {
1955 // Change the predicate to refer to the type variable,
1956 // which will be the concrete type, instead of the TyAnon.
1957 // This also instantiates nested `impl Trait`.
1958 let predicate = self.instantiate_anon_types(&predicate);
1960 // Require that the predicate holds for the concrete type.
1961 let cause = traits::ObligationCause::new(span, self.body_id,
1962 traits::SizedReturnType);
1963 self.register_predicate(traits::Obligation::new(cause,
1975 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1976 where T : TypeFoldable<'tcx>
1978 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
1981 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1983 where T : TypeFoldable<'tcx>
1985 self.inh.normalize_associated_types_in_as_infer_ok(span,
1991 pub fn require_type_meets(&self,
1994 code: traits::ObligationCauseCode<'tcx>,
1997 self.register_bound(
2000 traits::ObligationCause::new(span, self.body_id, code));
2003 pub fn require_type_is_sized(&self,
2006 code: traits::ObligationCauseCode<'tcx>)
2008 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2009 self.require_type_meets(ty, span, code, lang_item);
2012 pub fn register_bound(&self,
2015 cause: traits::ObligationCause<'tcx>)
2017 self.fulfillment_cx.borrow_mut()
2018 .register_bound(self, self.param_env, ty, def_id, cause);
2021 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2022 let t = AstConv::ast_ty_to_ty(self, ast_t);
2023 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2027 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2028 match self.tables.borrow().node_types().get(id) {
2030 None if self.is_tainted_by_errors() => self.tcx.types.err,
2032 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2033 bug!("no type for node {}: {} in fcx {}",
2034 node_id, self.tcx.hir.node_to_string(node_id),
2040 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2041 /// outlive the region `r`.
2042 pub fn register_wf_obligation(&self,
2045 code: traits::ObligationCauseCode<'tcx>)
2047 // WF obligations never themselves fail, so no real need to give a detailed cause:
2048 let cause = traits::ObligationCause::new(span, self.body_id, code);
2049 self.register_predicate(traits::Obligation::new(cause,
2051 ty::Predicate::WellFormed(ty)));
2054 /// Registers obligations that all types appearing in `substs` are well-formed.
2055 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2057 for ty in substs.types() {
2058 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2062 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2063 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2064 /// trait/region obligations.
2066 /// For example, if there is a function:
2069 /// fn foo<'a,T:'a>(...)
2072 /// and a reference:
2078 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2079 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2080 pub fn add_obligations_for_parameters(&self,
2081 cause: traits::ObligationCause<'tcx>,
2082 predicates: &ty::InstantiatedPredicates<'tcx>)
2084 assert!(!predicates.has_escaping_regions());
2086 debug!("add_obligations_for_parameters(predicates={:?})",
2089 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2090 self.register_predicate(obligation);
2094 // FIXME(arielb1): use this instead of field.ty everywhere
2095 // Only for fields! Returns <none> for methods>
2096 // Indifferent to privacy flags
2097 pub fn field_ty(&self,
2099 field: &'tcx ty::FieldDef,
2100 substs: &Substs<'tcx>)
2103 self.normalize_associated_types_in(span,
2104 &field.ty(self.tcx, substs))
2107 fn check_casts(&self) {
2108 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2109 for cast in deferred_cast_checks.drain(..) {
2114 fn resolve_generator_interiors(&self, def_id: DefId) {
2115 let mut deferred_generator_interiors = self.deferred_generator_interiors.borrow_mut();
2116 for (body_id, witness) in deferred_generator_interiors.drain(..) {
2117 generator_interior::resolve_interior(self, def_id, body_id, witness);
2121 /// Apply "fallbacks" to some types
2122 /// unconstrained types get replaced with ! or () (depending on whether
2123 /// feature(never_type) is enabled), unconstrained ints with i32, and
2124 /// unconstrained floats with f64.
2125 fn default_type_parameters(&self) {
2126 use rustc::ty::error::UnconstrainedNumeric::Neither;
2127 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2129 // Defaulting inference variables becomes very dubious if we have
2130 // encountered type-checking errors. Therefore, if we think we saw
2131 // some errors in this function, just resolve all uninstanted type
2132 // varibles to TyError.
2133 if self.is_tainted_by_errors() {
2134 for ty in &self.unsolved_variables() {
2135 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2136 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2137 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2143 for ty in &self.unsolved_variables() {
2144 let resolved = self.resolve_type_vars_if_possible(ty);
2145 if self.type_var_diverges(resolved) {
2146 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2148 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2149 self.tcx.mk_diverging_default());
2151 match self.type_is_unconstrained_numeric(resolved) {
2152 UnconstrainedInt => {
2153 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2155 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2157 UnconstrainedFloat => {
2158 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2160 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2168 // Implements type inference fallback algorithm
2169 fn select_all_obligations_and_apply_defaults(&self) {
2170 self.select_obligations_where_possible();
2171 self.default_type_parameters();
2172 self.select_obligations_where_possible();
2175 fn select_all_obligations_or_error(&self) {
2176 debug!("select_all_obligations_or_error");
2178 // upvar inference should have ensured that all deferred call
2179 // resolutions are handled by now.
2180 assert!(self.deferred_call_resolutions.borrow().is_empty());
2182 self.select_all_obligations_and_apply_defaults();
2184 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2186 match fulfillment_cx.select_all_or_error(self) {
2188 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2192 /// Select as many obligations as we can at present.
2193 fn select_obligations_where_possible(&self) {
2194 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2196 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2200 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2201 /// returns a type of `&T`, but the actual type we assign to the
2202 /// *expression* is `T`. So this function just peels off the return
2203 /// type by one layer to yield `T`.
2204 fn make_overloaded_lvalue_return_type(&self,
2205 method: MethodCallee<'tcx>)
2206 -> ty::TypeAndMut<'tcx>
2208 // extract method return type, which will be &T;
2209 let ret_ty = method.sig.output();
2211 // method returns &T, but the type as visible to user is T, so deref
2212 ret_ty.builtin_deref(true, NoPreference).unwrap()
2215 fn lookup_indexing(&self,
2217 base_expr: &'gcx hir::Expr,
2220 lvalue_pref: LvaluePreference)
2221 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2223 // FIXME(#18741) -- this is almost but not quite the same as the
2224 // autoderef that normal method probing does. They could likely be
2227 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2228 let mut result = None;
2229 while result.is_none() && autoderef.next().is_some() {
2230 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2232 autoderef.finalize();
2236 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2237 /// (and otherwise adjust) `base_expr`, looking for a type which either
2238 /// supports builtin indexing or overloaded indexing.
2239 /// This loop implements one step in that search; the autoderef loop
2240 /// is implemented by `lookup_indexing`.
2241 fn try_index_step(&self,
2243 base_expr: &hir::Expr,
2244 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2245 lvalue_pref: LvaluePreference,
2247 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2249 let adjusted_ty = autoderef.unambiguous_final_ty();
2250 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2257 // First, try built-in indexing.
2258 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2259 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2260 debug!("try_index_step: success, using built-in indexing");
2261 let adjustments = autoderef.adjust_steps(lvalue_pref);
2262 self.apply_adjustments(base_expr, adjustments);
2263 return Some((self.tcx.types.usize, ty));
2268 for &unsize in &[false, true] {
2269 let mut self_ty = adjusted_ty;
2271 // We only unsize arrays here.
2272 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2273 self_ty = self.tcx.mk_slice(element_ty);
2279 // If some lookup succeeds, write callee into table and extract index/element
2280 // type from the method signature.
2281 // If some lookup succeeded, install method in table
2282 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2283 let method = self.try_overloaded_lvalue_op(
2284 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2286 let result = method.map(|ok| {
2287 debug!("try_index_step: success, using overloaded indexing");
2288 let method = self.register_infer_ok_obligations(ok);
2290 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2291 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2292 adjustments.push(Adjustment {
2293 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2294 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2301 adjustments.push(Adjustment {
2302 kind: Adjust::Unsize,
2303 target: method.sig.inputs()[0]
2306 self.apply_adjustments(base_expr, adjustments);
2308 self.write_method_call(expr.hir_id, method);
2309 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2311 if result.is_some() {
2319 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2320 let (tr, name) = match (op, is_mut) {
2321 (LvalueOp::Deref, false) =>
2322 (self.tcx.lang_items().deref_trait(), "deref"),
2323 (LvalueOp::Deref, true) =>
2324 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2325 (LvalueOp::Index, false) =>
2326 (self.tcx.lang_items().index_trait(), "index"),
2327 (LvalueOp::Index, true) =>
2328 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2330 (tr, Symbol::intern(name))
2333 fn try_overloaded_lvalue_op(&self,
2336 arg_tys: &[Ty<'tcx>],
2337 lvalue_pref: LvaluePreference,
2339 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2341 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2347 // Try Mut first, if preferred.
2348 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2349 let method = match (lvalue_pref, mut_tr) {
2350 (PreferMutLvalue, Some(trait_did)) => {
2351 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2356 // Otherwise, fall back to the immutable version.
2357 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2358 let method = match (method, imm_tr) {
2359 (None, Some(trait_did)) => {
2360 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2362 (method, _) => method,
2368 fn check_method_argument_types(&self,
2371 method: Result<MethodCallee<'tcx>, ()>,
2372 args_no_rcvr: &'gcx [hir::Expr],
2373 tuple_arguments: TupleArgumentsFlag,
2374 expected: Expectation<'tcx>)
2376 let has_error = match method {
2378 method.substs.references_error() || method.sig.references_error()
2383 let err_inputs = self.err_args(args_no_rcvr.len());
2385 let err_inputs = match tuple_arguments {
2386 DontTupleArguments => err_inputs,
2387 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2390 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2391 false, tuple_arguments, None);
2392 return self.tcx.types.err;
2395 let method = method.unwrap();
2396 // HACK(eddyb) ignore self in the definition (see above).
2397 let expected_arg_tys = self.expected_inputs_for_expected_output(
2400 method.sig.output(),
2401 &method.sig.inputs()[1..]
2403 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2404 args_no_rcvr, method.sig.variadic, tuple_arguments,
2405 self.tcx.hir.span_if_local(method.def_id));
2409 /// Generic function that factors out common logic from function calls,
2410 /// method calls and overloaded operators.
2411 fn check_argument_types(&self,
2414 fn_inputs: &[Ty<'tcx>],
2415 expected_arg_tys: &[Ty<'tcx>],
2416 args: &'gcx [hir::Expr],
2418 tuple_arguments: TupleArgumentsFlag,
2419 def_span: Option<Span>) {
2422 // Grab the argument types, supplying fresh type variables
2423 // if the wrong number of arguments were supplied
2424 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2430 // All the input types from the fn signature must outlive the call
2431 // so as to validate implied bounds.
2432 for &fn_input_ty in fn_inputs {
2433 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2436 let mut expected_arg_tys = expected_arg_tys;
2437 let expected_arg_count = fn_inputs.len();
2439 let sp_args = if args.len() > 0 {
2440 let (first, args) = args.split_at(1);
2441 let mut sp_tmp = first[0].span;
2443 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2444 if ! sp_opt.is_some() {
2447 sp_tmp = sp_opt.unwrap();
2454 fn parameter_count_error<'tcx>(sess: &Session,
2457 expected_count: usize,
2461 def_span: Option<Span>,
2463 let mut err = sess.struct_span_err_with_code(sp,
2464 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2465 if variadic {"at least "} else {""},
2467 if expected_count == 1 {""} else {"s"},
2469 if arg_count == 1 {" was"} else {"s were"}),
2470 DiagnosticId::Error(error_code.to_owned()));
2472 if let Some(def_s) = def_span {
2473 err.span_label(def_s, "defined here");
2476 let sugg_span = expr_sp.end_point();
2477 // remove closing `)` from the span
2478 let sugg_span = sugg_span.with_hi(sugg_span.lo());
2479 err.span_suggestion(
2481 "expected the unit value `()`; create it with empty parentheses",
2482 String::from("()"));
2484 err.span_label(sp, format!("expected {}{} parameter{}",
2485 if variadic {"at least "} else {""},
2487 if expected_count == 1 {""} else {"s"}));
2492 let formal_tys = if tuple_arguments == TupleArguments {
2493 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2494 match tuple_type.sty {
2495 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2496 parameter_count_error(tcx.sess, sp_args, expr_sp, arg_types.len(), args.len(),
2497 "E0057", false, def_span, false);
2498 expected_arg_tys = &[];
2499 self.err_args(args.len())
2501 ty::TyTuple(arg_types, _) => {
2502 expected_arg_tys = match expected_arg_tys.get(0) {
2503 Some(&ty) => match ty.sty {
2504 ty::TyTuple(ref tys, _) => &tys,
2512 span_err!(tcx.sess, sp, E0059,
2513 "cannot use call notation; the first type parameter \
2514 for the function trait is neither a tuple nor unit");
2515 expected_arg_tys = &[];
2516 self.err_args(args.len())
2519 } else if expected_arg_count == supplied_arg_count {
2521 } else if variadic {
2522 if supplied_arg_count >= expected_arg_count {
2525 parameter_count_error(tcx.sess, sp_args, expr_sp, expected_arg_count,
2526 supplied_arg_count, "E0060", true, def_span, false);
2527 expected_arg_tys = &[];
2528 self.err_args(supplied_arg_count)
2531 // is the missing argument of type `()`?
2532 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2533 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2534 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2535 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2539 parameter_count_error(tcx.sess, sp_args, expr_sp, expected_arg_count,
2540 supplied_arg_count, "E0061", false, def_span, sugg_unit);
2541 expected_arg_tys = &[];
2542 self.err_args(supplied_arg_count)
2545 debug!("check_argument_types: formal_tys={:?}",
2546 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2548 // Check the arguments.
2549 // We do this in a pretty awful way: first we typecheck any arguments
2550 // that are not closures, then we typecheck the closures. This is so
2551 // that we have more information about the types of arguments when we
2552 // typecheck the functions. This isn't really the right way to do this.
2553 for &check_closures in &[false, true] {
2554 debug!("check_closures={}", check_closures);
2556 // More awful hacks: before we check argument types, try to do
2557 // an "opportunistic" vtable resolution of any trait bounds on
2558 // the call. This helps coercions.
2560 self.select_obligations_where_possible();
2563 // For variadic functions, we don't have a declared type for all of
2564 // the arguments hence we only do our usual type checking with
2565 // the arguments who's types we do know.
2566 let t = if variadic {
2568 } else if tuple_arguments == TupleArguments {
2573 for (i, arg) in args.iter().take(t).enumerate() {
2574 // Warn only for the first loop (the "no closures" one).
2575 // Closure arguments themselves can't be diverging, but
2576 // a previous argument can, e.g. `foo(panic!(), || {})`.
2577 if !check_closures {
2578 self.warn_if_unreachable(arg.id, arg.span, "expression");
2581 let is_closure = match arg.node {
2582 hir::ExprClosure(..) => true,
2586 if is_closure != check_closures {
2590 debug!("checking the argument");
2591 let formal_ty = formal_tys[i];
2593 // The special-cased logic below has three functions:
2594 // 1. Provide as good of an expected type as possible.
2595 let expected = expected_arg_tys.get(i).map(|&ty| {
2596 Expectation::rvalue_hint(self, ty)
2599 let checked_ty = self.check_expr_with_expectation(
2601 expected.unwrap_or(ExpectHasType(formal_ty)));
2603 // 2. Coerce to the most detailed type that could be coerced
2604 // to, which is `expected_ty` if `rvalue_hint` returns an
2605 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2606 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2607 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2609 // 3. Relate the expected type and the formal one,
2610 // if the expected type was used for the coercion.
2611 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2615 // We also need to make sure we at least write the ty of the other
2616 // arguments which we skipped above.
2618 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2619 type_error_struct!(s, span, t, E0617,
2620 "can't pass `{}` to variadic function, cast to `{}`",
2624 for arg in args.iter().skip(expected_arg_count) {
2625 let arg_ty = self.check_expr(&arg);
2627 // There are a few types which get autopromoted when passed via varargs
2628 // in C but we just error out instead and require explicit casts.
2629 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2631 ty::TyFloat(ast::FloatTy::F32) => {
2632 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2634 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2635 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2637 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2638 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2640 ty::TyFnDef(..) => {
2641 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2642 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2643 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2651 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2652 (0..len).map(|_| self.tcx.types.err).collect()
2655 // AST fragment checking
2658 expected: Expectation<'tcx>)
2664 ast::LitKind::Str(..) => tcx.mk_static_str(),
2665 ast::LitKind::ByteStr(ref v) => {
2666 tcx.mk_imm_ref(tcx.types.re_static,
2667 tcx.mk_array(tcx.types.u8, v.len() as u64))
2669 ast::LitKind::Byte(_) => tcx.types.u8,
2670 ast::LitKind::Char(_) => tcx.types.char,
2671 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2672 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2673 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2674 let opt_ty = expected.to_option(self).and_then(|ty| {
2676 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2677 ty::TyChar => Some(tcx.types.u8),
2678 ty::TyRawPtr(..) => Some(tcx.types.usize),
2679 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2683 opt_ty.unwrap_or_else(
2684 || tcx.mk_int_var(self.next_int_var_id()))
2686 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2687 ast::LitKind::FloatUnsuffixed(_) => {
2688 let opt_ty = expected.to_option(self).and_then(|ty| {
2690 ty::TyFloat(_) => Some(ty),
2694 opt_ty.unwrap_or_else(
2695 || tcx.mk_float_var(self.next_float_var_id()))
2697 ast::LitKind::Bool(_) => tcx.types.bool
2701 fn check_expr_eq_type(&self,
2702 expr: &'gcx hir::Expr,
2703 expected: Ty<'tcx>) {
2704 let ty = self.check_expr_with_hint(expr, expected);
2705 self.demand_eqtype(expr.span, expected, ty);
2708 pub fn check_expr_has_type_or_error(&self,
2709 expr: &'gcx hir::Expr,
2710 expected: Ty<'tcx>) -> Ty<'tcx> {
2711 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2714 fn check_expr_meets_expectation_or_error(&self,
2715 expr: &'gcx hir::Expr,
2716 expected: Expectation<'tcx>) -> Ty<'tcx> {
2717 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2718 let mut ty = self.check_expr_with_expectation(expr, expected);
2720 // While we don't allow *arbitrary* coercions here, we *do* allow
2721 // coercions from ! to `expected`.
2723 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2724 "expression with never type wound up being adjusted");
2725 let adj_ty = self.next_diverging_ty_var(
2726 TypeVariableOrigin::AdjustmentType(expr.span));
2727 self.apply_adjustments(expr, vec![Adjustment {
2728 kind: Adjust::NeverToAny,
2734 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2735 // Add help to type error if this is an `if` condition with an assignment
2736 match (expected, &expr.node) {
2737 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2738 let msg = "try comparing for equality";
2739 if let (Ok(left), Ok(right)) = (
2740 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2741 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2743 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2755 fn check_expr_coercable_to_type(&self,
2756 expr: &'gcx hir::Expr,
2757 expected: Ty<'tcx>) -> Ty<'tcx> {
2758 self.check_expr_coercable_to_type_with_lvalue_pref(expr, expected, NoPreference)
2761 fn check_expr_coercable_to_type_with_lvalue_pref(&self,
2762 expr: &'gcx hir::Expr,
2764 lvalue_pref: LvaluePreference)
2766 let ty = self.check_expr_with_expectation_and_lvalue_pref(
2768 ExpectHasType(expected),
2770 self.demand_coerce(expr, ty, expected)
2773 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2774 expected: Ty<'tcx>) -> Ty<'tcx> {
2775 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2778 fn check_expr_with_expectation(&self,
2779 expr: &'gcx hir::Expr,
2780 expected: Expectation<'tcx>) -> Ty<'tcx> {
2781 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2784 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2785 self.check_expr_with_expectation(expr, NoExpectation)
2788 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2789 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2790 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2793 // determine the `self` type, using fresh variables for all variables
2794 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2795 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2797 pub fn impl_self_ty(&self,
2798 span: Span, // (potential) receiver for this impl
2800 -> TypeAndSubsts<'tcx> {
2801 let ity = self.tcx.type_of(did);
2802 debug!("impl_self_ty: ity={:?}", ity);
2804 let substs = self.fresh_substs_for_item(span, did);
2805 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2807 TypeAndSubsts { substs: substs, ty: substd_ty }
2810 /// Unifies the output type with the expected type early, for more coercions
2811 /// and forward type information on the input expressions.
2812 fn expected_inputs_for_expected_output(&self,
2814 expected_ret: Expectation<'tcx>,
2815 formal_ret: Ty<'tcx>,
2816 formal_args: &[Ty<'tcx>])
2818 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2819 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2820 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2821 // Attempt to apply a subtyping relationship between the formal
2822 // return type (likely containing type variables if the function
2823 // is polymorphic) and the expected return type.
2824 // No argument expectations are produced if unification fails.
2825 let origin = self.misc(call_span);
2826 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2828 // FIXME(#15760) can't use try! here, FromError doesn't default
2829 // to identity so the resulting type is not constrained.
2832 // Process any obligations locally as much as
2833 // we can. We don't care if some things turn
2834 // out unconstrained or ambiguous, as we're
2835 // just trying to get hints here.
2836 let result = self.save_and_restore_in_snapshot_flag(|_| {
2837 let mut fulfill = FulfillmentContext::new();
2838 let ok = ok; // FIXME(#30046)
2839 for obligation in ok.obligations {
2840 fulfill.register_predicate_obligation(self, obligation);
2842 fulfill.select_where_possible(self)
2847 Err(_) => return Err(()),
2850 Err(_) => return Err(()),
2853 // Record all the argument types, with the substitutions
2854 // produced from the above subtyping unification.
2855 Ok(formal_args.iter().map(|ty| {
2856 self.resolve_type_vars_if_possible(ty)
2859 }).unwrap_or(vec![]);
2860 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2861 formal_args, formal_ret,
2862 expected_args, expected_ret);
2866 // Checks a method call.
2867 fn check_method_call(&self,
2868 expr: &'gcx hir::Expr,
2869 segment: &hir::PathSegment,
2871 args: &'gcx [hir::Expr],
2872 expected: Expectation<'tcx>,
2873 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2874 let rcvr = &args[0];
2875 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2876 // no need to check for bot/err -- callee does that
2877 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2879 let method = match self.lookup_method(rcvr_t,
2885 self.write_method_call(expr.hir_id, method);
2889 if segment.name != keywords::Invalid.name() {
2890 self.report_method_error(span,
2901 // Call the generic checker.
2902 self.check_method_argument_types(span,
2910 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2914 .unwrap_or_else(|| span_bug!(return_expr.span,
2915 "check_return_expr called outside fn body"));
2917 let ret_ty = ret_coercion.borrow().expected_ty();
2918 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2919 ret_coercion.borrow_mut()
2921 &self.cause(return_expr.span,
2922 ObligationCauseCode::ReturnType(return_expr.id)),
2925 self.diverges.get());
2929 // A generic function for checking the then and else in an if
2931 fn check_then_else(&self,
2932 cond_expr: &'gcx hir::Expr,
2933 then_expr: &'gcx hir::Expr,
2934 opt_else_expr: Option<&'gcx hir::Expr>,
2936 expected: Expectation<'tcx>) -> Ty<'tcx> {
2937 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2938 let cond_diverges = self.diverges.get();
2939 self.diverges.set(Diverges::Maybe);
2941 let expected = expected.adjust_for_branches(self);
2942 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2943 let then_diverges = self.diverges.get();
2944 self.diverges.set(Diverges::Maybe);
2946 // We've already taken the expected type's preferences
2947 // into account when typing the `then` branch. To figure
2948 // out the initial shot at a LUB, we thus only consider
2949 // `expected` if it represents a *hard* constraint
2950 // (`only_has_type`); otherwise, we just go with a
2951 // fresh type variable.
2952 let coerce_to_ty = expected.coercion_target_type(self, sp);
2953 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2955 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2956 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2958 if let Some(else_expr) = opt_else_expr {
2959 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2960 let else_diverges = self.diverges.get();
2962 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2964 // We won't diverge unless both branches do (or the condition does).
2965 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2967 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2968 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2970 // If the condition is false we can't diverge.
2971 self.diverges.set(cond_diverges);
2974 let result_ty = coerce.complete(self);
2975 if cond_ty.references_error() {
2982 // Check field access expressions
2983 fn check_field(&self,
2984 expr: &'gcx hir::Expr,
2985 lvalue_pref: LvaluePreference,
2986 base: &'gcx hir::Expr,
2987 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2988 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2989 let expr_t = self.structurally_resolved_type(expr.span,
2991 let mut private_candidate = None;
2992 let mut autoderef = self.autoderef(expr.span, expr_t);
2993 while let Some((base_t, _)) = autoderef.next() {
2995 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2996 debug!("struct named {:?}", base_t);
2997 let (ident, def_scope) =
2998 self.tcx.adjust(field.node, base_def.did, self.body_id);
2999 let fields = &base_def.struct_variant().fields;
3000 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3001 let field_ty = self.field_ty(expr.span, field, substs);
3002 if field.vis.is_accessible_from(def_scope, self.tcx) {
3003 let adjustments = autoderef.adjust_steps(lvalue_pref);
3004 self.apply_adjustments(base, adjustments);
3005 autoderef.finalize();
3007 self.tcx.check_stability(field.did, expr.id, expr.span);
3011 private_candidate = Some((base_def.did, field_ty));
3017 autoderef.unambiguous_final_ty();
3019 if let Some((did, field_ty)) = private_candidate {
3020 let struct_path = self.tcx().item_path_str(did);
3021 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3022 "field `{}` of struct `{}` is private",
3023 field.node, struct_path);
3024 // Also check if an accessible method exists, which is often what is meant.
3025 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3026 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3031 } else if field.node == keywords::Invalid.name() {
3032 self.tcx().types.err
3033 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3034 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3035 "attempted to take value of method `{}` on type `{}`",
3037 .help("maybe a `()` to call it is missing?")
3039 self.tcx().types.err
3041 if !expr_t.is_primitive_ty() {
3042 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3045 ty::TyAdt(def, _) if !def.is_enum() => {
3046 if let Some(suggested_field_name) =
3047 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
3048 err.span_label(field.span,
3049 format!("did you mean `{}`?", suggested_field_name));
3051 err.span_label(field.span, "unknown field");
3052 let struct_variant_def = def.struct_variant();
3053 let field_names = self.available_field_names(struct_variant_def);
3054 if !field_names.is_empty() {
3055 err.note(&format!("available fields are: {}",
3056 self.name_series_display(field_names)));
3060 ty::TyRawPtr(..) => {
3061 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
3063 self.tcx.hir.node_to_pretty_string(base.id),
3070 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3071 "`{}` is a primitive type and therefore doesn't have fields",
3074 self.tcx().types.err
3078 // Return an hint about the closest match in field names
3079 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3080 field: &Spanned<ast::Name>,
3081 skip: Vec<InternedString>)
3083 let name = field.node.as_str();
3084 let names = variant.fields.iter().filter_map(|field| {
3085 // ignore already set fields and private fields from non-local crates
3086 if skip.iter().any(|x| *x == field.name.as_str()) ||
3087 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3094 find_best_match_for_name(names, &name, None)
3097 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3098 let mut available = Vec::new();
3099 for field in variant.fields.iter() {
3100 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3101 if field.vis.is_accessible_from(def_scope, self.tcx) {
3102 available.push(field.name);
3108 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3109 // dynamic limit, to never omit just one field
3110 let limit = if names.len() == 6 { 6 } else { 5 };
3111 let mut display = names.iter().take(limit)
3112 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3113 if names.len() > limit {
3114 display = format!("{} ... and {} others", display, names.len() - limit);
3119 // Check tuple index expressions
3120 fn check_tup_field(&self,
3121 expr: &'gcx hir::Expr,
3122 lvalue_pref: LvaluePreference,
3123 base: &'gcx hir::Expr,
3124 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3125 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3126 let expr_t = self.structurally_resolved_type(expr.span,
3128 let mut private_candidate = None;
3129 let mut tuple_like = false;
3130 let mut autoderef = self.autoderef(expr.span, expr_t);
3131 while let Some((base_t, _)) = autoderef.next() {
3132 let field = match base_t.sty {
3133 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3134 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3135 if !tuple_like { continue }
3137 debug!("tuple struct named {:?}", base_t);
3138 let ident = ast::Ident {
3139 name: Symbol::intern(&idx.node.to_string()),
3140 ctxt: idx.span.ctxt().modern(),
3142 let (ident, def_scope) =
3143 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3144 let fields = &base_def.struct_variant().fields;
3145 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3146 let field_ty = self.field_ty(expr.span, field, substs);
3147 if field.vis.is_accessible_from(def_scope, self.tcx) {
3148 self.tcx.check_stability(field.did, expr.id, expr.span);
3151 private_candidate = Some((base_def.did, field_ty));
3158 ty::TyTuple(ref v, _) => {
3160 v.get(idx.node).cloned()
3165 if let Some(field_ty) = field {
3166 let adjustments = autoderef.adjust_steps(lvalue_pref);
3167 self.apply_adjustments(base, adjustments);
3168 autoderef.finalize();
3172 autoderef.unambiguous_final_ty();
3174 if let Some((did, field_ty)) = private_candidate {
3175 let struct_path = self.tcx().item_path_str(did);
3176 struct_span_err!(self.tcx().sess, expr.span, E0611,
3177 "field `{}` of tuple-struct `{}` is private",
3178 idx.node, struct_path).emit();
3183 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3184 "attempted out-of-bounds tuple index `{}` on type `{}`",
3185 idx.node, expr_t).emit();
3187 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3190 self.tcx().types.err
3193 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3194 -> DiagnosticBuilder {
3195 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3196 "no field `{}` on type `{}`",
3200 fn report_unknown_field(&self,
3202 variant: &'tcx ty::VariantDef,
3204 skip_fields: &[hir::Field],
3206 let mut err = self.type_error_struct_with_diag(
3208 |actual| match ty.sty {
3209 ty::TyAdt(adt, ..) if adt.is_enum() => {
3210 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3211 "{} `{}::{}` has no field named `{}`",
3212 kind_name, actual, variant.name, field.name.node)
3215 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3216 "{} `{}` has no field named `{}`",
3217 kind_name, actual, field.name.node)
3221 // prevent all specified fields from being suggested
3222 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3223 if let Some(field_name) = Self::suggest_field_name(variant,
3225 skip_fields.collect()) {
3226 err.span_label(field.name.span,
3227 format!("field does not exist - did you mean `{}`?", field_name));
3230 ty::TyAdt(adt, ..) => {
3232 err.span_label(field.name.span,
3233 format!("`{}::{}` does not have this field",
3236 err.span_label(field.name.span,
3237 format!("`{}` does not have this field", ty));
3239 let available_field_names = self.available_field_names(variant);
3240 if !available_field_names.is_empty() {
3241 err.note(&format!("available fields are: {}",
3242 self.name_series_display(available_field_names)));
3245 _ => bug!("non-ADT passed to report_unknown_field")
3251 fn check_expr_struct_fields(&self,
3253 expected: Expectation<'tcx>,
3254 expr_id: ast::NodeId,
3256 variant: &'tcx ty::VariantDef,
3257 ast_fields: &'gcx [hir::Field],
3258 check_completeness: bool) {
3262 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3263 .get(0).cloned().unwrap_or(adt_ty);
3264 // re-link the regions that EIfEO can erase.
3265 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3267 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3268 &ty::TyAdt(adt, substs) => {
3269 (substs, adt.adt_kind(), adt.variant_descr())
3271 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3274 let mut remaining_fields = FxHashMap();
3275 for field in &variant.fields {
3276 remaining_fields.insert(field.name.to_ident(), field);
3279 let mut seen_fields = FxHashMap();
3281 let mut error_happened = false;
3283 // Typecheck each field.
3284 for field in ast_fields {
3285 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3286 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3287 seen_fields.insert(field.name.node, field.span);
3289 // we don't look at stability attributes on
3290 // struct-like enums (yet...), but it's definitely not
3291 // a bug to have construct one.
3292 if adt_kind != ty::AdtKind::Enum {
3293 tcx.check_stability(v_field.did, expr_id, field.span);
3296 self.field_ty(field.span, v_field, substs)
3298 error_happened = true;
3299 if let Some(_) = variant.find_field_named(field.name.node) {
3300 let mut err = struct_span_err!(self.tcx.sess,
3303 "field `{}` specified more than once",
3306 err.span_label(field.name.span, "used more than once");
3308 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3309 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3314 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3320 // Make sure to give a type to the field even if there's
3321 // an error, so we can continue typechecking
3322 self.check_expr_coercable_to_type(&field.expr, field_type);
3325 // Make sure the programmer specified correct number of fields.
3326 if kind_name == "union" {
3327 if ast_fields.len() != 1 {
3328 tcx.sess.span_err(span, "union expressions should have exactly one field");
3330 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3331 let len = remaining_fields.len();
3333 let mut displayable_field_names = remaining_fields
3335 .map(|ident| ident.name.as_str())
3336 .collect::<Vec<_>>();
3338 displayable_field_names.sort();
3340 let truncated_fields_error = if len <= 3 {
3343 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3346 let remaining_fields_names = displayable_field_names.iter().take(3)
3347 .map(|n| format!("`{}`", n))
3348 .collect::<Vec<_>>()
3351 struct_span_err!(tcx.sess, span, E0063,
3352 "missing field{} {}{} in initializer of `{}`",
3353 if remaining_fields.len() == 1 { "" } else { "s" },
3354 remaining_fields_names,
3355 truncated_fields_error,
3357 .span_label(span, format!("missing {}{}",
3358 remaining_fields_names,
3359 truncated_fields_error))
3364 fn check_struct_fields_on_error(&self,
3365 fields: &'gcx [hir::Field],
3366 base_expr: &'gcx Option<P<hir::Expr>>) {
3367 for field in fields {
3368 self.check_expr(&field.expr);
3372 self.check_expr(&base);
3378 pub fn check_struct_path(&self,
3380 node_id: ast::NodeId)
3381 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3382 let path_span = match *qpath {
3383 hir::QPath::Resolved(_, ref path) => path.span,
3384 hir::QPath::TypeRelative(ref qself, _) => qself.span
3386 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3387 let variant = match def {
3389 self.set_tainted_by_errors();
3392 Def::Variant(..) => {
3394 ty::TyAdt(adt, substs) => {
3395 Some((adt.variant_of_def(def), adt.did, substs))
3397 _ => bug!("unexpected type: {:?}", ty.sty)
3400 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3401 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3403 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3404 Some((adt.struct_variant(), adt.did, substs))
3409 _ => bug!("unexpected definition: {:?}", def)
3412 if let Some((variant, did, substs)) = variant {
3413 // Check bounds on type arguments used in the path.
3414 let bounds = self.instantiate_bounds(path_span, did, substs);
3415 let cause = traits::ObligationCause::new(path_span, self.body_id,
3416 traits::ItemObligation(did));
3417 self.add_obligations_for_parameters(cause, &bounds);
3421 struct_span_err!(self.tcx.sess, path_span, E0071,
3422 "expected struct, variant or union type, found {}",
3423 ty.sort_string(self.tcx))
3424 .span_label(path_span, "not a struct")
3430 fn check_expr_struct(&self,
3432 expected: Expectation<'tcx>,
3434 fields: &'gcx [hir::Field],
3435 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3437 // Find the relevant variant
3438 let (variant, struct_ty) =
3439 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3442 self.check_struct_fields_on_error(fields, base_expr);
3443 return self.tcx.types.err;
3446 let path_span = match *qpath {
3447 hir::QPath::Resolved(_, ref path) => path.span,
3448 hir::QPath::TypeRelative(ref qself, _) => qself.span
3451 // Prohibit struct expressions when non exhaustive flag is set.
3452 if let ty::TyAdt(adt, _) = struct_ty.sty {
3453 if !adt.did.is_local() && adt.is_non_exhaustive() {
3454 span_err!(self.tcx.sess, expr.span, E0639,
3455 "cannot create non-exhaustive {} using struct expression",
3456 adt.variant_descr());
3460 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3461 base_expr.is_none());
3462 if let &Some(ref base_expr) = base_expr {
3463 self.check_expr_has_type_or_error(base_expr, struct_ty);
3464 match struct_ty.sty {
3465 ty::TyAdt(adt, substs) if adt.is_struct() => {
3466 let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
3467 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3472 .fru_field_types_mut()
3473 .insert(expr.hir_id, fru_field_types);
3476 span_err!(self.tcx.sess, base_expr.span, E0436,
3477 "functional record update syntax requires a struct");
3481 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3487 /// If an expression has any sub-expressions that result in a type error,
3488 /// inspecting that expression's type with `ty.references_error()` will return
3489 /// true. Likewise, if an expression is known to diverge, inspecting its
3490 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3491 /// strict, _|_ can appear in the type of an expression that does not,
3492 /// itself, diverge: for example, fn() -> _|_.)
3493 /// Note that inspecting a type's structure *directly* may expose the fact
3494 /// that there are actually multiple representations for `TyError`, so avoid
3495 /// that when err needs to be handled differently.
3496 fn check_expr_with_expectation_and_lvalue_pref(&self,
3497 expr: &'gcx hir::Expr,
3498 expected: Expectation<'tcx>,
3499 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3500 debug!(">> typechecking: expr={:?} expected={:?}",
3503 // Warn for expressions after diverging siblings.
3504 self.warn_if_unreachable(expr.id, expr.span, "expression");
3506 // Hide the outer diverging and has_errors flags.
3507 let old_diverges = self.diverges.get();
3508 let old_has_errors = self.has_errors.get();
3509 self.diverges.set(Diverges::Maybe);
3510 self.has_errors.set(false);
3512 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3514 // Warn for non-block expressions with diverging children.
3517 hir::ExprLoop(..) | hir::ExprWhile(..) |
3518 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3520 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3523 // Any expression that produces a value of type `!` must have diverged
3525 self.diverges.set(self.diverges.get() | Diverges::Always);
3528 // Record the type, which applies it effects.
3529 // We need to do this after the warning above, so that
3530 // we don't warn for the diverging expression itself.
3531 self.write_ty(expr.hir_id, ty);
3533 // Combine the diverging and has_error flags.
3534 self.diverges.set(self.diverges.get() | old_diverges);
3535 self.has_errors.set(self.has_errors.get() | old_has_errors);
3537 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3538 debug!("... {:?}, expected is {:?}", ty, expected);
3543 fn check_expr_kind(&self,
3544 expr: &'gcx hir::Expr,
3545 expected: Expectation<'tcx>,
3546 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3550 hir::ExprBox(ref subexpr) => {
3551 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3553 ty::TyAdt(def, _) if def.is_box()
3554 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3558 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3559 tcx.mk_box(referent_ty)
3562 hir::ExprLit(ref lit) => {
3563 self.check_lit(&lit, expected)
3565 hir::ExprBinary(op, ref lhs, ref rhs) => {
3566 self.check_binop(expr, op, lhs, rhs)
3568 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3569 self.check_binop_assign(expr, op, lhs, rhs)
3571 hir::ExprUnary(unop, ref oprnd) => {
3572 let expected_inner = match unop {
3573 hir::UnNot | hir::UnNeg => {
3580 let lvalue_pref = match unop {
3581 hir::UnDeref => lvalue_pref,
3584 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3588 if !oprnd_t.references_error() {
3589 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3592 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3594 } else if let Some(ok) = self.try_overloaded_deref(
3595 expr.span, oprnd_t, lvalue_pref) {
3596 let method = self.register_infer_ok_obligations(ok);
3597 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3598 self.apply_adjustments(oprnd, vec![Adjustment {
3599 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3600 target: method.sig.inputs()[0]
3603 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3604 self.write_method_call(expr.hir_id, method);
3606 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3607 "type `{}` cannot be dereferenced",
3609 oprnd_t = tcx.types.err;
3613 let result = self.check_user_unop(expr, oprnd_t, unop);
3614 // If it's builtin, we can reuse the type, this helps inference.
3615 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3620 let result = self.check_user_unop(expr, oprnd_t, unop);
3621 // If it's builtin, we can reuse the type, this helps inference.
3622 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3630 hir::ExprAddrOf(mutbl, ref oprnd) => {
3631 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3633 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3634 if self.tcx.expr_is_lval(&oprnd) {
3635 // Lvalues may legitimately have unsized types.
3636 // For example, dereferences of a fat pointer and
3637 // the last field of a struct can be unsized.
3638 ExpectHasType(mt.ty)
3640 Expectation::rvalue_hint(self, mt.ty)
3646 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3647 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3649 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3650 if tm.ty.references_error() {
3653 // Note: at this point, we cannot say what the best lifetime
3654 // is to use for resulting pointer. We want to use the
3655 // shortest lifetime possible so as to avoid spurious borrowck
3656 // errors. Moreover, the longest lifetime will depend on the
3657 // precise details of the value whose address is being taken
3658 // (and how long it is valid), which we don't know yet until type
3659 // inference is complete.
3661 // Therefore, here we simply generate a region variable. The
3662 // region inferencer will then select the ultimate value.
3663 // Finally, borrowck is charged with guaranteeing that the
3664 // value whose address was taken can actually be made to live
3665 // as long as it needs to live.
3666 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3667 tcx.mk_ref(region, tm)
3670 hir::ExprPath(ref qpath) => {
3671 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3672 expr.id, expr.span);
3673 let ty = if def != Def::Err {
3674 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3676 self.set_tainted_by_errors();
3680 // We always require that the type provided as the value for
3681 // a type parameter outlives the moment of instantiation.
3682 let substs = self.tables.borrow().node_substs(expr.hir_id);
3683 self.add_wf_bounds(substs, expr);
3687 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3688 for output in outputs {
3689 self.check_expr(output);
3691 for input in inputs {
3692 self.check_expr(input);
3696 hir::ExprBreak(destination, ref expr_opt) => {
3697 if let Some(target_id) = destination.target_id.opt_id() {
3698 let (e_ty, e_diverges, cause);
3699 if let Some(ref e) = *expr_opt {
3700 // If this is a break with a value, we need to type-check
3701 // the expression. Get an expected type from the loop context.
3702 let opt_coerce_to = {
3703 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3704 enclosing_breakables.find_breakable(target_id)
3707 .map(|coerce| coerce.expected_ty())
3710 // If the loop context is not a `loop { }`, then break with
3711 // a value is illegal, and `opt_coerce_to` will be `None`.
3712 // Just set expectation to error in that case.
3713 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3715 // Recurse without `enclosing_breakables` borrowed.
3716 e_ty = self.check_expr_with_hint(e, coerce_to);
3717 e_diverges = self.diverges.get();
3718 cause = self.misc(e.span);
3720 // Otherwise, this is a break *without* a value. That's
3721 // always legal, and is equivalent to `break ()`.
3722 e_ty = tcx.mk_nil();
3723 e_diverges = Diverges::Maybe;
3724 cause = self.misc(expr.span);
3727 // Now that we have type-checked `expr_opt`, borrow
3728 // the `enclosing_loops` field and let's coerce the
3729 // type of `expr_opt` into what is expected.
3730 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3731 let ctxt = enclosing_breakables.find_breakable(target_id);
3732 if let Some(ref mut coerce) = ctxt.coerce {
3733 if let Some(ref e) = *expr_opt {
3734 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3736 assert!(e_ty.is_nil());
3737 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3740 // If `ctxt.coerce` is `None`, we can just ignore
3741 // the type of the expresison. This is because
3742 // either this was a break *without* a value, in
3743 // which case it is always a legal type (`()`), or
3744 // else an error would have been flagged by the
3745 // `loops` pass for using break with an expression
3746 // where you are not supposed to.
3747 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3750 ctxt.may_break = true;
3752 // Otherwise, we failed to find the enclosing loop;
3753 // this can only happen if the `break` was not
3754 // inside a loop at all, which is caught by the
3755 // loop-checking pass.
3756 assert!(self.tcx.sess.err_count() > 0);
3758 // We still need to assign a type to the inner expression to
3759 // prevent the ICE in #43162.
3760 if let Some(ref e) = *expr_opt {
3761 self.check_expr_with_hint(e, tcx.types.err);
3763 // ... except when we try to 'break rust;'.
3764 // ICE this expression in particular (see #43162).
3765 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3766 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3767 fatally_break_rust(self.tcx.sess);
3773 // the type of a `break` is always `!`, since it diverges
3776 hir::ExprAgain(_) => { tcx.types.never }
3777 hir::ExprRet(ref expr_opt) => {
3778 if self.ret_coercion.is_none() {
3779 struct_span_err!(self.tcx.sess, expr.span, E0572,
3780 "return statement outside of function body").emit();
3781 } else if let Some(ref e) = *expr_opt {
3782 self.check_return_expr(e);
3784 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3785 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3786 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3790 hir::ExprAssign(ref lhs, ref rhs) => {
3791 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3793 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3796 ExpectIfCondition => {
3797 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3798 expected error elsehwere");
3801 // Only check this if not in an `if` condition, as the
3802 // mistyped comparison help is more appropriate.
3803 if !self.tcx.expr_is_lval(&lhs) {
3804 struct_span_err!(self.tcx.sess, expr.span, E0070,
3805 "invalid left-hand side expression")
3806 .span_label(expr.span, "left-hand of expression not valid")
3812 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3814 if lhs_ty.references_error() || rhs_ty.references_error() {
3820 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3821 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3822 expr.span, expected)
3824 hir::ExprWhile(ref cond, ref body, _) => {
3825 let ctxt = BreakableCtxt {
3826 // cannot use break with a value from a while loop
3831 self.with_breakable_ctxt(expr.id, ctxt, || {
3832 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3833 let cond_diverging = self.diverges.get();
3834 self.check_block_no_value(&body);
3836 // We may never reach the body so it diverging means nothing.
3837 self.diverges.set(cond_diverging);
3842 hir::ExprLoop(ref body, _, source) => {
3843 let coerce = match source {
3844 // you can only use break with a value from a normal `loop { }`
3845 hir::LoopSource::Loop => {
3846 let coerce_to = expected.coercion_target_type(self, body.span);
3847 Some(CoerceMany::new(coerce_to))
3850 hir::LoopSource::WhileLet |
3851 hir::LoopSource::ForLoop => {
3856 let ctxt = BreakableCtxt {
3858 may_break: false, // will get updated if/when we find a `break`
3861 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3862 self.check_block_no_value(&body);
3866 // No way to know whether it's diverging because
3867 // of a `break` or an outer `break` or `return.
3868 self.diverges.set(Diverges::Maybe);
3871 // If we permit break with a value, then result type is
3872 // the LUB of the breaks (possibly ! if none); else, it
3873 // is nil. This makes sense because infinite loops
3874 // (which would have type !) are only possible iff we
3875 // permit break with a value [1].
3876 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3877 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3879 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3880 self.check_match(expr, &discrim, arms, expected, match_src)
3882 hir::ExprClosure(capture, ref decl, body_id, _, _) => {
3883 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3885 hir::ExprBlock(ref body) => {
3886 self.check_block_with_expected(&body, expected)
3888 hir::ExprCall(ref callee, ref args) => {
3889 self.check_call(expr, &callee, args, expected)
3891 hir::ExprMethodCall(ref segment, span, ref args) => {
3892 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3894 hir::ExprCast(ref e, ref t) => {
3895 // Find the type of `e`. Supply hints based on the type we are casting to,
3897 let t_cast = self.to_ty(t);
3898 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3899 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3900 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3901 let diverges = self.diverges.get();
3903 // Eagerly check for some obvious errors.
3904 if t_expr.references_error() || t_cast.references_error() {
3907 // Defer other checks until we're done type checking.
3908 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3909 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3911 deferred_cast_checks.push(cast_check);
3914 Err(ErrorReported) => {
3920 hir::ExprType(ref e, ref t) => {
3921 let typ = self.to_ty(&t);
3922 self.check_expr_eq_type(&e, typ);
3925 hir::ExprArray(ref args) => {
3926 let uty = expected.to_option(self).and_then(|uty| {
3928 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3933 let element_ty = if !args.is_empty() {
3934 let coerce_to = uty.unwrap_or_else(
3935 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3936 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3937 assert_eq!(self.diverges.get(), Diverges::Maybe);
3939 let e_ty = self.check_expr_with_hint(e, coerce_to);
3940 let cause = self.misc(e.span);
3941 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3943 coerce.complete(self)
3945 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3947 tcx.mk_array(element_ty, args.len() as u64)
3949 hir::ExprRepeat(ref element, count) => {
3950 let count_def_id = tcx.hir.body_owner_def_id(count);
3951 let param_env = ty::ParamEnv::empty(traits::Reveal::UserFacing);
3952 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
3953 let count = tcx.const_eval(param_env.and((count_def_id, substs)));
3955 if let Err(ref err) = count {
3956 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
3959 let uty = match expected {
3960 ExpectHasType(uty) => {
3962 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3969 let (element_ty, t) = match uty {
3971 self.check_expr_coercable_to_type(&element, uty);
3975 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3976 let element_ty = self.check_expr_has_type_or_error(&element, t);
3981 if let Ok(count) = count {
3982 let zero_or_one = count.val.to_const_int().and_then(|count| {
3983 count.to_u64().map(|count| count <= 1)
3984 }).unwrap_or(false);
3986 // For [foo, ..n] where n > 1, `foo` must have
3988 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3989 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3993 if element_ty.references_error() {
3995 } else if let Ok(count) = count {
3996 tcx.mk_ty(ty::TyArray(t, count))
4001 hir::ExprTup(ref elts) => {
4002 let flds = expected.only_has_type(self).and_then(|ty| {
4003 let ty = self.resolve_type_vars_with_obligations(ty);
4005 ty::TyTuple(ref flds, _) => Some(&flds[..]),
4010 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4011 let t = match flds {
4012 Some(ref fs) if i < fs.len() => {
4014 self.check_expr_coercable_to_type(&e, ety);
4018 self.check_expr_with_expectation(&e, NoExpectation)
4023 let tuple = tcx.mk_tup(elt_ts_iter, false);
4024 if tuple.references_error() {
4027 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4031 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4032 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4034 hir::ExprField(ref base, ref field) => {
4035 self.check_field(expr, lvalue_pref, &base, field)
4037 hir::ExprTupField(ref base, idx) => {
4038 self.check_tup_field(expr, lvalue_pref, &base, idx)
4040 hir::ExprIndex(ref base, ref idx) => {
4041 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
4042 let idx_t = self.check_expr(&idx);
4044 if base_t.references_error() {
4046 } else if idx_t.references_error() {
4049 let base_t = self.structurally_resolved_type(expr.span, base_t);
4050 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
4051 Some((index_ty, element_ty)) => {
4052 self.demand_coerce(idx, idx_t, index_ty);
4056 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4057 "cannot index into a value of type `{}`",
4059 // Try to give some advice about indexing tuples.
4060 if let ty::TyTuple(..) = base_t.sty {
4061 let mut needs_note = true;
4062 // If the index is an integer, we can show the actual
4063 // fixed expression:
4064 if let hir::ExprLit(ref lit) = idx.node {
4065 if let ast::LitKind::Int(i,
4066 ast::LitIntType::Unsuffixed) = lit.node {
4067 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4068 if let Ok(snip) = snip {
4069 err.span_suggestion(expr.span,
4070 "to access tuple elements, use",
4071 format!("{}.{}", snip, i));
4077 err.help("to access tuple elements, use tuple indexing \
4078 syntax (e.g. `tuple.0`)");
4087 hir::ExprYield(ref value) => {
4088 match self.yield_ty {
4090 self.check_expr_coercable_to_type(&value, ty);
4093 struct_span_err!(self.tcx.sess, expr.span, E0627,
4094 "yield statement outside of generator literal").emit();
4102 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4103 // The newly resolved definition is written into `type_dependent_defs`.
4104 fn finish_resolving_struct_path(&self,
4107 node_id: ast::NodeId)
4111 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4112 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4113 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4116 hir::QPath::TypeRelative(ref qself, ref segment) => {
4117 let ty = self.to_ty(qself);
4119 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4124 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4127 // Write back the new resolution.
4128 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4129 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4136 // Resolve associated value path into a base type and associated constant or method definition.
4137 // The newly resolved definition is written into `type_dependent_defs`.
4138 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4139 qpath: &'b hir::QPath,
4140 node_id: ast::NodeId,
4142 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4144 let (ty, item_segment) = match *qpath {
4145 hir::QPath::Resolved(ref opt_qself, ref path) => {
4147 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4148 &path.segments[..]);
4150 hir::QPath::TypeRelative(ref qself, ref segment) => {
4151 (self.to_ty(qself), segment)
4154 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4155 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4156 // Return directly on cache hit. This is useful to avoid doubly reporting
4157 // errors with default match binding modes. See #44614.
4158 return (*cached_def, Some(ty), slice::ref_slice(&**item_segment))
4160 let item_name = item_segment.name;
4161 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4164 let def = match error {
4165 method::MethodError::PrivateMatch(def, _) => def,
4168 if item_name != keywords::Invalid.name() {
4169 self.report_method_error(span, ty, item_name, None, error, None);
4175 // Write back the new resolution.
4176 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4177 (def, Some(ty), slice::ref_slice(&**item_segment))
4180 pub fn check_decl_initializer(&self,
4181 local: &'gcx hir::Local,
4182 init: &'gcx hir::Expr) -> Ty<'tcx>
4184 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4185 // for #42640 (default match binding modes).
4188 let ref_bindings = local.pat.contains_explicit_ref_binding();
4190 let local_ty = self.local_ty(init.span, local.id);
4191 if let Some(m) = ref_bindings {
4192 // Somewhat subtle: if we have a `ref` binding in the pattern,
4193 // we want to avoid introducing coercions for the RHS. This is
4194 // both because it helps preserve sanity and, in the case of
4195 // ref mut, for soundness (issue #23116). In particular, in
4196 // the latter case, we need to be clear that the type of the
4197 // referent for the reference that results is *equal to* the
4198 // type of the lvalue it is referencing, and not some
4199 // supertype thereof.
4200 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4201 self.demand_eqtype(init.span, init_ty, local_ty);
4204 self.check_expr_coercable_to_type(init, local_ty)
4208 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4209 let t = self.local_ty(local.span, local.id);
4210 self.write_ty(local.hir_id, t);
4212 if let Some(ref init) = local.init {
4213 let init_ty = self.check_decl_initializer(local, &init);
4214 if init_ty.references_error() {
4215 self.write_ty(local.hir_id, init_ty);
4219 self.check_pat_walk(&local.pat, t,
4220 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4222 let pat_ty = self.node_ty(local.pat.hir_id);
4223 if pat_ty.references_error() {
4224 self.write_ty(local.hir_id, pat_ty);
4228 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4229 // Don't do all the complex logic below for DeclItem.
4231 hir::StmtDecl(ref decl, _) => {
4233 hir::DeclLocal(_) => {}
4234 hir::DeclItem(_) => {
4239 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4242 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4244 // Hide the outer diverging and has_errors flags.
4245 let old_diverges = self.diverges.get();
4246 let old_has_errors = self.has_errors.get();
4247 self.diverges.set(Diverges::Maybe);
4248 self.has_errors.set(false);
4251 hir::StmtDecl(ref decl, _) => {
4253 hir::DeclLocal(ref l) => {
4254 self.check_decl_local(&l);
4256 hir::DeclItem(_) => {/* ignore for now */}
4259 hir::StmtExpr(ref expr, _) => {
4260 // Check with expected type of ()
4261 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4263 hir::StmtSemi(ref expr, _) => {
4264 self.check_expr(&expr);
4268 // Combine the diverging and has_error flags.
4269 self.diverges.set(self.diverges.get() | old_diverges);
4270 self.has_errors.set(self.has_errors.get() | old_has_errors);
4273 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4274 let unit = self.tcx.mk_nil();
4275 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4277 // if the block produces a `!` value, that can always be
4278 // (effectively) coerced to unit.
4280 self.demand_suptype(blk.span, unit, ty);
4284 fn check_block_with_expected(&self,
4285 blk: &'gcx hir::Block,
4286 expected: Expectation<'tcx>) -> Ty<'tcx> {
4288 let mut fcx_ps = self.ps.borrow_mut();
4289 let unsafety_state = fcx_ps.recurse(blk);
4290 replace(&mut *fcx_ps, unsafety_state)
4293 // In some cases, blocks have just one exit, but other blocks
4294 // can be targeted by multiple breaks. This cannot happen in
4295 // normal Rust syntax today, but it can happen when we desugar
4296 // a `do catch { ... }` expression.
4300 // 'a: { if true { break 'a Err(()); } Ok(()) }
4302 // Here we would wind up with two coercions, one from
4303 // `Err(())` and the other from the tail expression
4304 // `Ok(())`. If the tail expression is omitted, that's a
4305 // "forced unit" -- unless the block diverges, in which
4306 // case we can ignore the tail expression (e.g., `'a: {
4307 // break 'a 22; }` would not force the type of the block
4309 let tail_expr = blk.expr.as_ref();
4310 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4311 let coerce = if blk.targeted_by_break {
4312 CoerceMany::new(coerce_to_ty)
4314 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4315 Some(e) => ref_slice(e),
4318 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4321 let prev_diverges = self.diverges.get();
4322 let ctxt = BreakableCtxt {
4323 coerce: Some(coerce),
4327 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4328 for s in &blk.stmts {
4332 // check the tail expression **without** holding the
4333 // `enclosing_breakables` lock below.
4334 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4336 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4337 let ctxt = enclosing_breakables.find_breakable(blk.id);
4338 let coerce = ctxt.coerce.as_mut().unwrap();
4339 if let Some(tail_expr_ty) = tail_expr_ty {
4340 let tail_expr = tail_expr.unwrap();
4341 let cause = self.cause(tail_expr.span,
4342 ObligationCauseCode::BlockTailExpression(blk.id));
4347 self.diverges.get());
4349 // Subtle: if there is no explicit tail expression,
4350 // that is typically equivalent to a tail expression
4351 // of `()` -- except if the block diverges. In that
4352 // case, there is no value supplied from the tail
4353 // expression (assuming there are no other breaks,
4354 // this implies that the type of the block will be
4357 // #41425 -- label the implicit `()` as being the
4358 // "found type" here, rather than the "expected type".
4359 if !self.diverges.get().always() {
4360 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4361 if let Some(expected_ty) = expected.only_has_type(self) {
4362 self.consider_hint_about_removing_semicolon(blk,
4372 // If we can break from the block, then the block's exit is always reachable
4373 // (... as long as the entry is reachable) - regardless of the tail of the block.
4374 self.diverges.set(prev_diverges);
4377 let mut ty = ctxt.coerce.unwrap().complete(self);
4379 if self.has_errors.get() || ty.references_error() {
4380 ty = self.tcx.types.err
4383 self.write_ty(blk.hir_id, ty);
4385 *self.ps.borrow_mut() = prev;
4389 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4390 /// suggestion can be made, `None` otherwise.
4391 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4392 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4393 // `while` before reaching it, as block tail returns are not available in them.
4394 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4395 let parent = self.tcx.hir.get(fn_id);
4397 if let Node::NodeItem(&hir::Item {
4398 name, node: hir::ItemFn(ref decl, ..), ..
4400 decl.clone().and_then(|decl| {
4401 // This is less than ideal, it will not suggest a return type span on any
4402 // method called `main`, regardless of whether it is actually the entry point,
4403 // but it will still present it as the reason for the expected type.
4404 Some((decl, name != Symbol::intern("main")))
4406 } else if let Node::NodeTraitItem(&hir::TraitItem {
4407 node: hir::TraitItemKind::Method(hir::MethodSig {
4411 decl.clone().and_then(|decl| {
4414 } else if let Node::NodeImplItem(&hir::ImplItem {
4415 node: hir::ImplItemKind::Method(hir::MethodSig {
4419 decl.clone().and_then(|decl| {
4430 /// On implicit return expressions with mismatched types, provide the following suggestions:
4432 /// - Point out the method's return type as the reason for the expected type
4433 /// - Possible missing semicolon
4434 /// - Possible missing return type if the return type is the default, and not `fn main()`
4435 pub fn suggest_mismatched_types_on_tail(&self,
4436 err: &mut DiagnosticBuilder<'tcx>,
4437 expression: &'gcx hir::Expr,
4441 blk_id: ast::NodeId) {
4442 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4444 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4445 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4449 /// A common error is to forget to add a semicolon at the end of a block:
4453 /// bar_that_returns_u32()
4457 /// This routine checks if the return expression in a block would make sense on its own as a
4458 /// statement and the return type has been left as default or has been specified as `()`. If so,
4459 /// it suggests adding a semicolon.
4460 fn suggest_missing_semicolon(&self,
4461 err: &mut DiagnosticBuilder<'tcx>,
4462 expression: &'gcx hir::Expr,
4465 if expected.is_nil() {
4466 // `BlockTailExpression` only relevant if the tail expr would be
4467 // useful on its own.
4468 match expression.node {
4470 hir::ExprMethodCall(..) |
4472 hir::ExprWhile(..) |
4474 hir::ExprMatch(..) |
4475 hir::ExprBlock(..) => {
4476 let sp = cause_span.next_point();
4477 err.span_suggestion(sp,
4478 "try adding a semicolon",
4487 /// A possible error is to forget to add a return type that is needed:
4491 /// bar_that_returns_u32()
4495 /// This routine checks if the return type is left as default, the method is not part of an
4496 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4498 fn suggest_missing_return_type(&self,
4499 err: &mut DiagnosticBuilder<'tcx>,
4500 fn_decl: &hir::FnDecl,
4503 can_suggest: bool) {
4504 // Only suggest changing the return type for methods that
4505 // haven't set a return type at all (and aren't `fn main()` or an impl).
4506 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4507 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4508 err.span_suggestion(span,
4509 "try adding a return type",
4510 format!("-> {} ", found));
4512 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4513 err.span_label(span, "possibly return type missing here?");
4515 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4516 // `fn main()` must return `()`, do not suggest changing return type
4517 err.span_label(span, "expected `()` because of default return type");
4519 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4520 // Only point to return type if the expected type is the return type, as if they
4521 // are not, the expectation must have been caused by something else.
4522 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4524 let ty = AstConv::ast_ty_to_ty(self, ty);
4525 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4526 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4527 if ty.sty == expected.sty {
4528 err.span_label(sp, format!("expected `{}` because of return type",
4536 /// A common error is to add an extra semicolon:
4539 /// fn foo() -> usize {
4544 /// This routine checks if the final statement in a block is an
4545 /// expression with an explicit semicolon whose type is compatible
4546 /// with `expected_ty`. If so, it suggests removing the semicolon.
4547 fn consider_hint_about_removing_semicolon(&self,
4548 blk: &'gcx hir::Block,
4549 expected_ty: Ty<'tcx>,
4550 err: &mut DiagnosticBuilder) {
4551 // Be helpful when the user wrote `{... expr;}` and
4552 // taking the `;` off is enough to fix the error.
4553 let last_stmt = match blk.stmts.last() {
4557 let last_expr = match last_stmt.node {
4558 hir::StmtSemi(ref e, _) => e,
4561 let last_expr_ty = self.node_ty(last_expr.hir_id);
4562 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4565 let original_span = original_sp(last_stmt.span, blk.span);
4566 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4567 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4570 // Instantiates the given path, which must refer to an item with the given
4571 // number of type parameters and type.
4572 pub fn instantiate_value_path(&self,
4573 segments: &[hir::PathSegment],
4574 opt_self_ty: Option<Ty<'tcx>>,
4577 node_id: ast::NodeId)
4579 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4584 // We need to extract the type parameters supplied by the user in
4585 // the path `path`. Due to the current setup, this is a bit of a
4586 // tricky-process; the problem is that resolve only tells us the
4587 // end-point of the path resolution, and not the intermediate steps.
4588 // Luckily, we can (at least for now) deduce the intermediate steps
4589 // just from the end-point.
4591 // There are basically four cases to consider:
4593 // 1. Reference to a constructor of enum variant or struct:
4595 // struct Foo<T>(...)
4596 // enum E<T> { Foo(...) }
4598 // In these cases, the parameters are declared in the type
4601 // 2. Reference to a fn item or a free constant:
4605 // In this case, the path will again always have the form
4606 // `a::b::foo::<T>` where only the final segment should have
4607 // type parameters. However, in this case, those parameters are
4608 // declared on a value, and hence are in the `FnSpace`.
4610 // 3. Reference to a method or an associated constant:
4612 // impl<A> SomeStruct<A> {
4616 // Here we can have a path like
4617 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4618 // may appear in two places. The penultimate segment,
4619 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4620 // final segment, `foo::<B>` contains parameters in fn space.
4622 // 4. Reference to a local variable
4624 // Local variables can't have any type parameters.
4626 // The first step then is to categorize the segments appropriately.
4628 assert!(!segments.is_empty());
4630 let mut ufcs_associated = None;
4631 let mut type_segment = None;
4632 let mut fn_segment = None;
4634 // Case 1. Reference to a struct/variant constructor.
4635 Def::StructCtor(def_id, ..) |
4636 Def::VariantCtor(def_id, ..) => {
4637 // Everything but the final segment should have no
4638 // parameters at all.
4639 let mut generics = self.tcx.generics_of(def_id);
4640 if let Some(def_id) = generics.parent {
4641 // Variant and struct constructors use the
4642 // generics of their parent type definition.
4643 generics = self.tcx.generics_of(def_id);
4645 type_segment = Some((segments.last().unwrap(), generics));
4648 // Case 2. Reference to a top-level value.
4650 Def::Const(def_id) |
4651 Def::Static(def_id, _) => {
4652 fn_segment = Some((segments.last().unwrap(),
4653 self.tcx.generics_of(def_id)));
4656 // Case 3. Reference to a method or associated const.
4657 Def::Method(def_id) |
4658 Def::AssociatedConst(def_id) => {
4659 let container = self.tcx.associated_item(def_id).container;
4661 ty::TraitContainer(trait_did) => {
4662 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4664 ty::ImplContainer(_) => {}
4667 let generics = self.tcx.generics_of(def_id);
4668 if segments.len() >= 2 {
4669 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4670 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4672 // `<T>::assoc` will end up here, and so can `T::assoc`.
4673 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4674 ufcs_associated = Some((container, self_ty));
4676 fn_segment = Some((segments.last().unwrap(), generics));
4679 // Case 4. Local variable, no generics.
4680 Def::Local(..) | Def::Upvar(..) => {}
4682 _ => bug!("unexpected definition: {:?}", def),
4685 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4687 // Now that we have categorized what space the parameters for each
4688 // segment belong to, let's sort out the parameters that the user
4689 // provided (if any) into their appropriate spaces. We'll also report
4690 // errors if type parameters are provided in an inappropriate place.
4691 let poly_segments = type_segment.is_some() as usize +
4692 fn_segment.is_some() as usize;
4693 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4696 Def::Local(nid) | Def::Upvar(nid, ..) => {
4697 let ty = self.local_ty(span, nid);
4698 let ty = self.normalize_associated_types_in(span, &ty);
4699 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4705 // Now we have to compare the types that the user *actually*
4706 // provided against the types that were *expected*. If the user
4707 // did not provide any types, then we want to substitute inference
4708 // variables. If the user provided some types, we may still need
4709 // to add defaults. If the user provided *too many* types, that's
4711 self.check_path_parameter_count(span, &mut type_segment, false);
4712 self.check_path_parameter_count(span, &mut fn_segment, false);
4713 self.check_impl_trait(span, &mut fn_segment);
4715 let (fn_start, has_self) = match (type_segment, fn_segment) {
4716 (_, Some((_, generics))) => {
4717 (generics.parent_count(), generics.has_self)
4719 (Some((_, generics)), None) => {
4720 (generics.own_count(), generics.has_self)
4722 (None, None) => (0, false)
4724 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4725 let mut i = def.index as usize;
4727 let segment = if i < fn_start {
4728 i -= has_self as usize;
4734 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4735 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4738 if let Some(lifetime) = lifetimes.get(i) {
4739 AstConv::ast_region_to_region(self, lifetime, Some(def))
4741 self.re_infer(span, Some(def)).unwrap()
4744 let mut i = def.index as usize;
4746 let segment = if i < fn_start {
4747 // Handle Self first, so we can adjust the index to match the AST.
4748 if has_self && i == 0 {
4749 return opt_self_ty.unwrap_or_else(|| {
4750 self.type_var_for_def(span, def, substs)
4753 i -= has_self as usize;
4759 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4760 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4763 // Skip over the lifetimes in the same segment.
4764 if let Some((_, generics)) = segment {
4765 i -= generics.regions.len();
4768 if let Some(ast_ty) = types.get(i) {
4769 // A provided type parameter.
4771 } else if !infer_types && def.has_default {
4772 // No type parameter provided, but a default exists.
4773 let default = self.tcx.type_of(def.def_id);
4776 default.subst_spanned(self.tcx, substs, Some(span))
4779 // No type parameters were provided, we can infer all.
4780 // This can also be reached in some error cases:
4781 // We prefer to use inference variables instead of
4782 // TyError to let type inference recover somewhat.
4783 self.type_var_for_def(span, def, substs)
4787 // The things we are substituting into the type should not contain
4788 // escaping late-bound regions, and nor should the base type scheme.
4789 let ty = self.tcx.type_of(def.def_id());
4790 assert!(!substs.has_escaping_regions());
4791 assert!(!ty.has_escaping_regions());
4793 // Add all the obligations that are required, substituting and
4794 // normalized appropriately.
4795 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4796 self.add_obligations_for_parameters(
4797 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4800 // Substitute the values for the type parameters into the type of
4801 // the referenced item.
4802 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4804 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4805 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4806 // is inherent, there is no `Self` parameter, instead, the impl needs
4807 // type parameters, which we can infer by unifying the provided `Self`
4808 // with the substituted impl type.
4809 let ty = self.tcx.type_of(impl_def_id);
4811 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4812 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4813 Ok(ok) => self.register_infer_ok_obligations(ok),
4816 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4823 debug!("instantiate_value_path: type of {:?} is {:?}",
4826 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4830 /// Report errors if the provided parameters are too few or too many.
4831 fn check_path_parameter_count(&self,
4833 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4834 is_method_call: bool) {
4835 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4836 (&[][..], &[][..], true, &[][..]),
4837 |(s, _)| s.parameters.as_ref().map_or(
4838 (&[][..], &[][..], s.infer_types, &[][..]),
4839 |p| (&p.lifetimes[..], &p.types[..],
4840 s.infer_types, &p.bindings[..])));
4841 let infer_lifetimes = lifetimes.len() == 0;
4843 let count_lifetime_params = |n| {
4844 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4846 let count_type_params = |n| {
4847 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4850 // Check provided type parameters.
4851 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4852 if generics.parent.is_none() {
4853 &generics.types[generics.has_self as usize..]
4858 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4859 if types.len() > type_defs.len() {
4860 let span = types[type_defs.len()].span;
4861 let expected_text = count_type_params(type_defs.len());
4862 let actual_text = count_type_params(types.len());
4863 struct_span_err!(self.tcx.sess, span, E0087,
4864 "too many type parameters provided: \
4865 expected at most {}, found {}",
4866 expected_text, actual_text)
4867 .span_label(span, format!("expected {}", expected_text))
4870 // To prevent derived errors to accumulate due to extra
4871 // type parameters, we force instantiate_value_path to
4872 // use inference variables instead of the provided types.
4874 } else if types.len() < required_len && !infer_types {
4875 let expected_text = count_type_params(required_len);
4876 let actual_text = count_type_params(types.len());
4877 struct_span_err!(self.tcx.sess, span, E0089,
4878 "too few type parameters provided: \
4879 expected {}, found {}",
4880 expected_text, actual_text)
4881 .span_label(span, format!("expected {}", expected_text))
4885 if !bindings.is_empty() {
4886 AstConv::prohibit_projection(self, bindings[0].span);
4889 // Check provided lifetime parameters.
4890 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4891 let required_len = lifetime_defs.len();
4893 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4894 let has_late_bound_lifetime_defs =
4895 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4896 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4897 // Report this as a lint only if no error was reported previously.
4898 let primary_msg = "cannot specify lifetime arguments explicitly \
4899 if late bound lifetime parameters are present";
4900 let note_msg = "the late bound lifetime parameter is introduced here";
4901 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4902 lifetimes.len() < required_len && !infer_lifetimes) {
4903 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4904 err.span_note(span_late, note_msg);
4908 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4909 multispan.push_span_label(span_late, note_msg.to_string());
4910 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4911 lifetimes[0].id, multispan, primary_msg);
4916 if lifetimes.len() > lifetime_defs.len() {
4917 let span = lifetimes[lifetime_defs.len()].span;
4918 let expected_text = count_lifetime_params(lifetime_defs.len());
4919 let actual_text = count_lifetime_params(lifetimes.len());
4920 struct_span_err!(self.tcx.sess, span, E0088,
4921 "too many lifetime parameters provided: \
4922 expected at most {}, found {}",
4923 expected_text, actual_text)
4924 .span_label(span, format!("expected {}", expected_text))
4926 } else if lifetimes.len() < required_len && !infer_lifetimes {
4927 let expected_text = count_lifetime_params(lifetime_defs.len());
4928 let actual_text = count_lifetime_params(lifetimes.len());
4929 struct_span_err!(self.tcx.sess, span, E0090,
4930 "too few lifetime parameters provided: \
4931 expected {}, found {}",
4932 expected_text, actual_text)
4933 .span_label(span, format!("expected {}", expected_text))
4938 /// Report error if there is an explicit type parameter when using `impl Trait`.
4939 fn check_impl_trait(&self,
4941 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
4942 use hir::SyntheticTyParamKind::*;
4944 segment.map(|(path_segment, generics)| {
4945 let explicit = !path_segment.infer_types;
4946 let impl_trait = generics.types.iter()
4948 match ty_param.synthetic {
4949 Some(ImplTrait) => true,
4954 if explicit && impl_trait {
4955 let mut err = struct_span_err! {
4959 "cannot provide explicit type parameters when `impl Trait` is \
4960 used in argument position."
4968 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4970 where F: Fn() -> Ty<'tcx>
4972 let mut ty = self.resolve_type_vars_with_obligations(ty);
4975 let alternative = f();
4978 if alternative.is_ty_var() || alternative.references_error() {
4979 if !self.is_tainted_by_errors() {
4980 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4981 "the type of this value must be known in this context")
4984 self.demand_suptype(sp, self.tcx.types.err, ty);
4985 ty = self.tcx.types.err;
4987 self.demand_suptype(sp, alternative, ty);
4995 // Resolves `typ` by a single level if `typ` is a type variable. If no
4996 // resolution is possible, then an error is reported.
4997 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4998 self.structurally_resolve_type_or_else(sp, ty, || {
5003 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5004 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5005 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5008 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5009 index = enclosing_breakables.stack.len();
5010 enclosing_breakables.by_id.insert(id, index);
5011 enclosing_breakables.stack.push(ctxt);
5015 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5016 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5017 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5018 enclosing_breakables.stack.pop().expect("missing breakable context")
5024 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5025 generics: &hir::Generics,
5027 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5028 generics.ty_params.len(), ty);
5030 // make a vector of booleans initially false, set to true when used
5031 if generics.ty_params.is_empty() { return; }
5032 let mut tps_used = vec![false; generics.ty_params.len()];
5034 for leaf_ty in ty.walk() {
5035 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
5036 debug!("Found use of ty param num {}", idx);
5037 tps_used[idx as usize - generics.lifetimes.len()] = true;
5041 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
5043 struct_span_err!(tcx.sess, param.span, E0091,
5044 "type parameter `{}` is unused",
5046 .span_label(param.span, "unused type parameter")
5052 fn fatally_break_rust(sess: &Session) {
5053 let handler = sess.diagnostic();
5054 handler.span_bug_no_panic(
5056 "It looks like you're trying to break rust; would you like some ICE?",
5058 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5059 handler.note_without_error(
5060 "we would appreciate a joke overview: \
5061 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5063 handler.note_without_error(&format!("rustc {} running on {}",
5064 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5065 ::session::config::host_triple(),