1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 n.b.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
88 use hir::def::{Def, CtorKind};
89 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use namespace::Namespace;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::anon_types::AnonTypeDecl;
94 use rustc::infer::type_variable::{TypeVariableOrigin};
95 use rustc::middle::region;
96 use rustc::ty::subst::{Kind, Subst, Substs};
97 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
98 use rustc::ty::{self, Ty, TyCtxt, Visibility, ToPredicate};
99 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
100 use rustc::ty::fold::TypeFoldable;
101 use rustc::ty::maps::Providers;
102 use rustc::ty::util::{Representability, IntTypeExt};
103 use errors::{DiagnosticBuilder, DiagnosticId};
105 use require_c_abi_if_variadic;
106 use session::{CompileIncomplete, config, Session};
109 use util::common::{ErrorReported, indenter};
110 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
112 use std::cell::{Cell, RefCell, Ref, RefMut};
114 use std::collections::hash_map::Entry;
116 use std::fmt::Display;
117 use std::mem::replace;
119 use std::ops::{self, Deref};
120 use syntax::abi::Abi;
123 use syntax::codemap::{self, original_sp, Spanned};
124 use syntax::feature_gate::{GateIssue, emit_feature_err};
126 use syntax::symbol::{Symbol, InternedString, keywords};
127 use syntax::util::lev_distance::find_best_match_for_name;
128 use syntax_pos::{self, BytePos, Span, MultiSpan};
130 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
131 use rustc::hir::itemlikevisit::ItemLikeVisitor;
132 use rustc::hir::map::Node;
133 use rustc::hir::{self, PatKind};
134 use rustc::middle::lang_items;
135 use rustc_const_math::ConstInt;
151 mod generator_interior;
155 /// A wrapper for InferCtxt's `in_progress_tables` field.
156 #[derive(Copy, Clone)]
157 struct MaybeInProgressTables<'a, 'tcx: 'a> {
158 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
161 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
162 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
163 match self.maybe_tables {
164 Some(tables) => tables.borrow(),
166 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
171 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
172 match self.maybe_tables {
173 Some(tables) => tables.borrow_mut(),
175 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
182 /// closures defined within the function. For example:
185 /// bar(move|| { ... })
188 /// Here, the function `foo()` and the closure passed to
189 /// `bar()` will each have their own `FnCtxt`, but they will
190 /// share the inherited fields.
191 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
192 infcx: InferCtxt<'a, 'gcx, 'tcx>,
194 tables: MaybeInProgressTables<'a, 'tcx>,
196 locals: RefCell<NodeMap<Ty<'tcx>>>,
198 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
200 // When we process a call like `c()` where `c` is a closure type,
201 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
202 // `FnOnce` closure. In that case, we defer full resolution of the
203 // call until upvar inference can kick in and make the
204 // decision. We keep these deferred resolutions grouped by the
205 // def-id of the closure, so that once we decide, we can easily go
206 // back and process them.
207 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
209 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
211 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, ty::GeneratorInterior<'tcx>)>>,
213 // Anonymized types found in explicit return types and their
214 // associated fresh inference variable. Writeback resolves these
215 // variables to get the concrete type, which can be used to
216 // deanonymize TyAnon, after typeck is done with all functions.
217 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
219 /// Each type parameter has an implicit region bound that
220 /// indicates it must outlive at least the function body (the user
221 /// may specify stronger requirements). This field indicates the
222 /// region of the callee. If it is `None`, then the parameter
223 /// environment is for an item or something where the "callee" is
225 implicit_region_bound: Option<ty::Region<'tcx>>,
227 body_id: Option<hir::BodyId>,
230 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
231 type Target = InferCtxt<'a, 'gcx, 'tcx>;
232 fn deref(&self) -> &Self::Target {
237 /// When type-checking an expression, we propagate downward
238 /// whatever type hint we are able in the form of an `Expectation`.
239 #[derive(Copy, Clone, Debug)]
240 pub enum Expectation<'tcx> {
241 /// We know nothing about what type this expression should have.
244 /// This expression is an `if` condition, it must resolve to `bool`.
247 /// This expression should have the type given (or some subtype)
248 ExpectHasType(Ty<'tcx>),
250 /// This expression will be cast to the `Ty`
251 ExpectCastableToType(Ty<'tcx>),
253 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
254 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
255 ExpectRvalueLikeUnsized(Ty<'tcx>),
258 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
259 // Disregard "castable to" expectations because they
260 // can lead us astray. Consider for example `if cond
261 // {22} else {c} as u8` -- if we propagate the
262 // "castable to u8" constraint to 22, it will pick the
263 // type 22u8, which is overly constrained (c might not
264 // be a u8). In effect, the problem is that the
265 // "castable to" expectation is not the tightest thing
266 // we can say, so we want to drop it in this case.
267 // The tightest thing we can say is "must unify with
268 // else branch". Note that in the case of a "has type"
269 // constraint, this limitation does not hold.
271 // If the expected type is just a type variable, then don't use
272 // an expected type. Otherwise, we might write parts of the type
273 // when checking the 'then' block which are incompatible with the
275 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
277 ExpectHasType(ety) => {
278 let ety = fcx.shallow_resolve(ety);
279 if !ety.is_ty_var() {
285 ExpectRvalueLikeUnsized(ety) => {
286 ExpectRvalueLikeUnsized(ety)
292 /// Provide an expectation for an rvalue expression given an *optional*
293 /// hint, which is not required for type safety (the resulting type might
294 /// be checked higher up, as is the case with `&expr` and `box expr`), but
295 /// is useful in determining the concrete type.
297 /// The primary use case is where the expected type is a fat pointer,
298 /// like `&[isize]`. For example, consider the following statement:
300 /// let x: &[isize] = &[1, 2, 3];
302 /// In this case, the expected type for the `&[1, 2, 3]` expression is
303 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
304 /// expectation `ExpectHasType([isize])`, that would be too strong --
305 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
306 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
307 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
308 /// which still is useful, because it informs integer literals and the like.
309 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
310 /// for examples of where this comes up,.
311 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
312 match fcx.tcx.struct_tail(ty).sty {
313 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
314 ExpectRvalueLikeUnsized(ty)
316 _ => ExpectHasType(ty)
320 // Resolves `expected` by a single level if it is a variable. If
321 // there is no expected type or resolution is not possible (e.g.,
322 // no constraints yet present), just returns `None`.
323 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
325 NoExpectation => NoExpectation,
326 ExpectIfCondition => ExpectIfCondition,
327 ExpectCastableToType(t) => {
328 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
330 ExpectHasType(t) => {
331 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
333 ExpectRvalueLikeUnsized(t) => {
334 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
339 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
340 match self.resolve(fcx) {
341 NoExpectation => None,
342 ExpectIfCondition => Some(fcx.tcx.types.bool),
343 ExpectCastableToType(ty) |
345 ExpectRvalueLikeUnsized(ty) => Some(ty),
349 /// It sometimes happens that we want to turn an expectation into
350 /// a **hard constraint** (i.e., something that must be satisfied
351 /// for the program to type-check). `only_has_type` will return
352 /// such a constraint, if it exists.
353 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
354 match self.resolve(fcx) {
355 ExpectHasType(ty) => Some(ty),
356 ExpectIfCondition => Some(fcx.tcx.types.bool),
357 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
361 /// Like `only_has_type`, but instead of returning `None` if no
362 /// hard constraint exists, creates a fresh type variable.
363 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
364 self.only_has_type(fcx)
365 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
369 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
376 fn maybe_mut_place(m: hir::Mutability) -> Self {
378 hir::MutMutable => Needs::MutPlace,
379 hir::MutImmutable => Needs::None,
384 #[derive(Copy, Clone)]
385 pub struct UnsafetyState {
386 pub def: ast::NodeId,
387 pub unsafety: hir::Unsafety,
388 pub unsafe_push_count: u32,
393 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
394 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
397 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
398 match self.unsafety {
399 // If this unsafe, then if the outer function was already marked as
400 // unsafe we shouldn't attribute the unsafe'ness to the block. This
401 // way the block can be warned about instead of ignoring this
402 // extraneous block (functions are never warned about).
403 hir::Unsafety::Unsafe if self.from_fn => *self,
406 let (unsafety, def, count) = match blk.rules {
407 hir::PushUnsafeBlock(..) =>
408 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
409 hir::PopUnsafeBlock(..) =>
410 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
411 hir::UnsafeBlock(..) =>
412 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
414 (unsafety, self.def, self.unsafe_push_count),
418 unsafe_push_count: count,
425 #[derive(Debug, Copy, Clone)]
431 /// Tracks whether executing a node may exit normally (versus
432 /// return/break/panic, which "diverge", leaving dead code in their
433 /// wake). Tracked semi-automatically (through type variables marked
434 /// as diverging), with some manual adjustments for control-flow
435 /// primitives (approximating a CFG).
436 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
438 /// Potentially unknown, some cases converge,
439 /// others require a CFG to determine them.
442 /// Definitely known to diverge and therefore
443 /// not reach the next sibling or its parent.
446 /// Same as `Always` but with a reachability
447 /// warning already emitted
451 // Convenience impls for combinig `Diverges`.
453 impl ops::BitAnd for Diverges {
455 fn bitand(self, other: Self) -> Self {
456 cmp::min(self, other)
460 impl ops::BitOr for Diverges {
462 fn bitor(self, other: Self) -> Self {
463 cmp::max(self, other)
467 impl ops::BitAndAssign for Diverges {
468 fn bitand_assign(&mut self, other: Self) {
469 *self = *self & other;
473 impl ops::BitOrAssign for Diverges {
474 fn bitor_assign(&mut self, other: Self) {
475 *self = *self | other;
480 fn always(self) -> bool {
481 self >= Diverges::Always
485 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
488 // this is `null` for loops where break with a value is illegal,
489 // such as `while`, `for`, and `while let`
490 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
493 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
494 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
495 by_id: NodeMap<usize>,
498 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
499 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
500 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
501 bug!("could not find enclosing breakable with id {}", target_id);
507 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
508 body_id: ast::NodeId,
510 /// The parameter environment used for proving trait obligations
511 /// in this function. This can change when we descend into
512 /// closures (as they bring new things into scope), hence it is
513 /// not part of `Inherited` (as of the time of this writing,
514 /// closures do not yet change the environment, but they will
516 param_env: ty::ParamEnv<'tcx>,
518 // Number of errors that had been reported when we started
519 // checking this function. On exit, if we find that *more* errors
520 // have been reported, we will skip regionck and other work that
521 // expects the types within the function to be consistent.
522 err_count_on_creation: usize,
524 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
526 yield_ty: Option<Ty<'tcx>>,
528 ps: RefCell<UnsafetyState>,
530 /// Whether the last checked node generates a divergence (e.g.,
531 /// `return` will set this to Always). In general, when entering
532 /// an expression or other node in the tree, the initial value
533 /// indicates whether prior parts of the containing expression may
534 /// have diverged. It is then typically set to `Maybe` (and the
535 /// old value remembered) for processing the subparts of the
536 /// current expression. As each subpart is processed, they may set
537 /// the flag to `Always` etc. Finally, at the end, we take the
538 /// result and "union" it with the original value, so that when we
539 /// return the flag indicates if any subpart of the the parent
540 /// expression (up to and including this part) has diverged. So,
541 /// if you read it after evaluating a subexpression `X`, the value
542 /// you get indicates whether any subexpression that was
543 /// evaluating up to and including `X` diverged.
545 /// We use this flag for two purposes:
547 /// - To warn about unreachable code: if, after processing a
548 /// sub-expression but before we have applied the effects of the
549 /// current node, we see that the flag is set to `Always`, we
550 /// can issue a warning. This corresponds to something like
551 /// `foo(return)`; we warn on the `foo()` expression. (We then
552 /// update the flag to `WarnedAlways` to suppress duplicate
553 /// reports.) Similarly, if we traverse to a fresh statement (or
554 /// tail expression) from a `Always` setting, we will issue a
555 /// warning. This corresponds to something like `{return;
556 /// foo();}` or `{return; 22}`, where we would warn on the
559 /// - To permit assignment into a local variable or other place
560 /// (including the "return slot") of type `!`. This is allowed
561 /// if **either** the type of value being assigned is `!`, which
562 /// means the current code is dead, **or** the expression's
563 /// diverging flag is true, which means that a diverging value was
564 /// wrapped (e.g., `let x: ! = foo(return)`).
566 /// To repeat the last point: an expression represents dead-code
567 /// if, after checking it, **either** its type is `!` OR the
568 /// diverges flag is set to something other than `Maybe`.
569 diverges: Cell<Diverges>,
571 /// Whether any child nodes have any type errors.
572 has_errors: Cell<bool>,
574 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
576 inh: &'a Inherited<'a, 'gcx, 'tcx>,
579 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
580 type Target = Inherited<'a, 'gcx, 'tcx>;
581 fn deref(&self) -> &Self::Target {
586 /// Helper type of a temporary returned by Inherited::build(...).
587 /// Necessary because we can't write the following bound:
588 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
589 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
590 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
594 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
595 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
596 -> InheritedBuilder<'a, 'gcx, 'tcx> {
597 let hir_id_root = if def_id.is_local() {
598 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
599 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
600 DefId::local(hir_id.owner)
606 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
612 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
613 fn enter<F, R>(&'tcx mut self, f: F) -> R
614 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
616 let def_id = self.def_id;
617 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
621 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
622 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
624 let item_id = tcx.hir.as_local_node_id(def_id);
625 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
626 let implicit_region_bound = body_id.map(|body_id| {
627 let body = tcx.hir.body(body_id);
628 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
632 tables: MaybeInProgressTables {
633 maybe_tables: infcx.in_progress_tables,
636 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
637 locals: RefCell::new(NodeMap()),
638 deferred_call_resolutions: RefCell::new(DefIdMap()),
639 deferred_cast_checks: RefCell::new(Vec::new()),
640 deferred_generator_interiors: RefCell::new(Vec::new()),
641 anon_types: RefCell::new(DefIdMap()),
642 implicit_region_bound,
647 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
648 debug!("register_predicate({:?})", obligation);
649 if obligation.has_escaping_regions() {
650 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
655 .register_predicate_obligation(self, obligation);
658 fn register_predicates<I>(&self, obligations: I)
659 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
660 for obligation in obligations {
661 self.register_predicate(obligation);
665 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
666 self.register_predicates(infer_ok.obligations);
670 fn normalize_associated_types_in<T>(&self,
672 body_id: ast::NodeId,
673 param_env: ty::ParamEnv<'tcx>,
675 where T : TypeFoldable<'tcx>
677 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
678 self.register_infer_ok_obligations(ok)
682 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
684 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
685 fn visit_item(&mut self, i: &'tcx hir::Item) {
686 check_item_type(self.tcx, i);
688 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
689 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
692 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
693 tcx.sess.track_errors(|| {
694 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
695 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
699 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
700 tcx.sess.track_errors(|| {
701 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
705 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
706 tcx.typeck_item_bodies(LOCAL_CRATE)
709 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
710 -> Result<(), CompileIncomplete>
712 debug_assert!(crate_num == LOCAL_CRATE);
713 Ok(tcx.sess.track_errors(|| {
714 for body_owner_def_id in tcx.body_owners() {
715 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
720 pub fn provide(providers: &mut Providers) {
721 *providers = Providers {
731 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
733 -> Option<ty::Destructor> {
734 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
737 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
738 /// with information about it's body-id and fn-decl (if any). Otherwise,
741 /// If this function returns "some", then `typeck_tables(def_id)` will
742 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
743 /// may not succeed. In some cases where this function returns `None`
744 /// (notably closures), `typeck_tables(def_id)` would wind up
745 /// redirecting to the owning function.
746 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
748 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
750 match tcx.hir.get(id) {
751 hir::map::NodeItem(item) => {
753 hir::ItemConst(_, body) |
754 hir::ItemStatic(_, _, body) =>
756 hir::ItemFn(ref decl, .., body) =>
757 Some((body, Some(decl))),
762 hir::map::NodeTraitItem(item) => {
764 hir::TraitItemKind::Const(_, Some(body)) =>
766 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
767 Some((body, Some(&sig.decl))),
772 hir::map::NodeImplItem(item) => {
774 hir::ImplItemKind::Const(_, body) =>
776 hir::ImplItemKind::Method(ref sig, body) =>
777 Some((body, Some(&sig.decl))),
782 hir::map::NodeExpr(expr) => {
783 // FIXME(eddyb) Closures should have separate
784 // function definition IDs and expression IDs.
785 // Type-checking should not let closures get
786 // this far in a constant position.
787 // Assume that everything other than closures
788 // is a constant "initializer" expression.
790 hir::ExprClosure(..) =>
793 Some((hir::BodyId { node_id: expr.id }, None)),
800 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
803 // Closures' tables come from their outermost function,
804 // as they are part of the same "inference environment".
805 let outer_def_id = tcx.closure_base_def_id(def_id);
806 if outer_def_id != def_id {
807 return tcx.has_typeck_tables(outer_def_id);
810 let id = tcx.hir.as_local_node_id(def_id).unwrap();
811 primary_body_of(tcx, id).is_some()
814 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
817 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
820 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
822 -> &'tcx ty::TypeckTables<'tcx> {
823 // Closures' tables come from their outermost function,
824 // as they are part of the same "inference environment".
825 let outer_def_id = tcx.closure_base_def_id(def_id);
826 if outer_def_id != def_id {
827 return tcx.typeck_tables_of(outer_def_id);
830 let id = tcx.hir.as_local_node_id(def_id).unwrap();
831 let span = tcx.hir.span(id);
833 // Figure out what primary body this item has.
834 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
835 span_bug!(span, "can't type-check body of {:?}", def_id);
837 let body = tcx.hir.body(body_id);
839 let tables = Inherited::build(tcx, def_id).enter(|inh| {
840 let param_env = tcx.param_env(def_id);
841 let fcx = if let Some(decl) = fn_decl {
842 let fn_sig = tcx.fn_sig(def_id);
844 check_abi(tcx, span, fn_sig.abi());
846 // Compute the fty from point of view of inside fn.
848 tcx.liberate_late_bound_regions(def_id, &fn_sig);
850 inh.normalize_associated_types_in(body.value.span,
855 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
858 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
859 let expected_type = tcx.type_of(def_id);
860 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
861 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
863 // Gather locals in statics (because of block expressions).
864 // This is technically unnecessary because locals in static items are forbidden,
865 // but prevents type checking from blowing up before const checking can properly
867 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
869 fcx.check_expr_coercable_to_type(&body.value, expected_type);
874 // All type checking constraints were added, try to fallback unsolved variables.
875 fcx.select_obligations_where_possible();
876 for ty in &fcx.unsolved_variables() {
877 fcx.fallback_if_possible(ty);
879 fcx.select_obligations_where_possible();
881 // Even though coercion casts provide type hints, we check casts after fallback for
882 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
885 // Closure and generater analysis may run after fallback
886 // because they don't constrain other type variables.
887 fcx.closure_analyze(body);
888 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
889 fcx.resolve_generator_interiors(def_id);
890 fcx.select_all_obligations_or_error();
892 if fn_decl.is_some() {
893 fcx.regionck_fn(id, body);
895 fcx.regionck_expr(body);
898 fcx.resolve_type_vars_in_body(body)
901 // Consistency check our TypeckTables instance can hold all ItemLocalIds
902 // it will need to hold.
903 assert_eq!(tables.local_id_root,
904 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
908 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
909 if !tcx.sess.target.target.is_abi_supported(abi) {
910 struct_span_err!(tcx.sess, span, E0570,
911 "The ABI `{}` is not supported for the current target", abi).emit()
915 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
916 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
919 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
920 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
923 // infer the variable's type
924 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
925 self.fcx.locals.borrow_mut().insert(nid, var_ty);
929 // take type that the user specified
930 self.fcx.locals.borrow_mut().insert(nid, typ);
937 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
938 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
939 NestedVisitorMap::None
942 // Add explicitly-declared locals.
943 fn visit_local(&mut self, local: &'gcx hir::Local) {
944 let o_ty = match local.ty {
945 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
948 self.assign(local.span, local.id, o_ty);
949 debug!("Local variable {:?} is assigned type {}",
951 self.fcx.ty_to_string(
952 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
953 intravisit::walk_local(self, local);
956 // Add pattern bindings.
957 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
958 if let PatKind::Binding(_, _, ref path1, _) = p.node {
959 let var_ty = self.assign(p.span, p.id, None);
961 self.fcx.require_type_is_sized(var_ty, p.span,
962 traits::VariableType(p.id));
964 debug!("Pattern binding {} is assigned to {} with type {:?}",
966 self.fcx.ty_to_string(
967 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
970 intravisit::walk_pat(self, p);
973 // Don't descend into the bodies of nested closures
974 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
975 _: hir::BodyId, _: Span, _: ast::NodeId) { }
978 /// When `check_fn` is invoked on a generator (i.e., a body that
979 /// includes yield), it returns back some information about the yield
981 struct GeneratorTypes<'tcx> {
982 /// Type of value that is yielded.
983 yield_ty: ty::Ty<'tcx>,
985 /// Types that are captured (see `GeneratorInterior` for more).
986 interior: ty::GeneratorInterior<'tcx>
989 /// Helper used for fns and closures. Does the grungy work of checking a function
990 /// body and returns the function context used for that purpose, since in the case of a fn item
991 /// there is still a bit more to do.
994 /// * inherited: other fields inherited from the enclosing fn (if any)
995 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
996 param_env: ty::ParamEnv<'tcx>,
997 fn_sig: ty::FnSig<'tcx>,
998 decl: &'gcx hir::FnDecl,
1000 body: &'gcx hir::Body,
1001 can_be_generator: Option<hir::GeneratorMovability>)
1002 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1004 let mut fn_sig = fn_sig.clone();
1006 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1008 // Create the function context. This is either derived from scratch or,
1009 // in the case of function expressions, based on the outer context.
1010 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1011 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1013 let ret_ty = fn_sig.output();
1014 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1015 let ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &ret_ty);
1016 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1017 fn_sig = fcx.tcx.mk_fn_sig(
1018 fn_sig.inputs().iter().cloned(),
1025 let span = body.value.span;
1027 if body.is_generator && can_be_generator.is_some() {
1028 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1029 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1030 fcx.yield_ty = Some(yield_ty);
1033 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1035 // Add formal parameters.
1036 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1037 // Check the pattern.
1038 fcx.check_pat_walk(&arg.pat, arg_ty,
1039 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1041 // Check that argument is Sized.
1042 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1043 // for simple cases like `fn foo(x: Trait)`,
1044 // where we would error once on the parameter as a whole, and once on the binding `x`.
1045 if arg.pat.simple_name().is_none() {
1046 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1049 fcx.write_ty(arg.hir_id, arg_ty);
1052 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1053 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1055 fcx.check_return_expr(&body.value);
1057 // We insert the deferred_generator_interiors entry after visiting the body.
1058 // This ensures that all nested generators appear before the entry of this generator.
1059 // resolve_generator_interiors relies on this property.
1060 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1061 let witness = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1062 let interior = ty::GeneratorInterior {
1064 movable: can_be_generator.unwrap() == hir::GeneratorMovability::Movable,
1066 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1067 Some(GeneratorTypes { yield_ty: fcx.yield_ty.unwrap(), interior: interior })
1072 // Finalize the return check by taking the LUB of the return types
1073 // we saw and assigning it to the expected return type. This isn't
1074 // really expected to fail, since the coercions would have failed
1075 // earlier when trying to find a LUB.
1077 // However, the behavior around `!` is sort of complex. In the
1078 // event that the `actual_return_ty` comes back as `!`, that
1079 // indicates that the fn either does not return or "returns" only
1080 // values of type `!`. In this case, if there is an expected
1081 // return type that is *not* `!`, that should be ok. But if the
1082 // return type is being inferred, we want to "fallback" to `!`:
1084 // let x = move || panic!();
1086 // To allow for that, I am creating a type variable with diverging
1087 // fallback. This was deemed ever so slightly better than unifying
1088 // the return value with `!` because it allows for the caller to
1089 // make more assumptions about the return type (e.g., they could do
1091 // let y: Option<u32> = Some(x());
1093 // which would then cause this return type to become `u32`, not
1095 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1096 let mut actual_return_ty = coercion.complete(&fcx);
1097 if actual_return_ty.is_never() {
1098 actual_return_ty = fcx.next_diverging_ty_var(
1099 TypeVariableOrigin::DivergingFn(span));
1101 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1103 if fcx.tcx.sess.features.borrow().termination_trait {
1104 // If the termination trait language item is activated, check that the main return type
1105 // implements the termination trait.
1106 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1107 if let Some((id, _)) = *fcx.tcx.sess.entry_fn.borrow() {
1109 match fcx.sess().entry_type.get() {
1110 Some(config::EntryMain) => {
1111 let substs = fcx.tcx.mk_substs(iter::once(Kind::from(ret_ty)));
1112 let trait_ref = ty::TraitRef::new(term_id, substs);
1113 let cause = traits::ObligationCause::new(
1114 span, fn_id, ObligationCauseCode::MainFunctionType);
1116 inherited.register_predicate(
1117 traits::Obligation::new(
1118 cause, param_env, trait_ref.to_predicate()));
1130 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1133 let def_id = tcx.hir.local_def_id(id);
1134 let def = tcx.adt_def(def_id);
1135 def.destructor(tcx); // force the destructor to be evaluated
1136 check_representable(tcx, span, def_id);
1138 if def.repr.simd() {
1139 check_simd(tcx, span, def_id);
1142 check_transparent(tcx, span, def_id);
1143 check_packed(tcx, span, def_id);
1146 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1149 let def_id = tcx.hir.local_def_id(id);
1150 let def = tcx.adt_def(def_id);
1151 def.destructor(tcx); // force the destructor to be evaluated
1152 check_representable(tcx, span, def_id);
1154 check_packed(tcx, span, def_id);
1157 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1158 debug!("check_item_type(it.id={}, it.name={})",
1160 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1161 let _indenter = indenter();
1163 // Consts can play a role in type-checking, so they are included here.
1164 hir::ItemStatic(..) |
1165 hir::ItemConst(..) => {
1166 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1168 hir::ItemEnum(ref enum_definition, _) => {
1171 &enum_definition.variants,
1174 hir::ItemFn(..) => {} // entirely within check_item_body
1175 hir::ItemImpl(.., ref impl_item_refs) => {
1176 debug!("ItemImpl {} with id {}", it.name, it.id);
1177 let impl_def_id = tcx.hir.local_def_id(it.id);
1178 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1179 check_impl_items_against_trait(tcx,
1184 let trait_def_id = impl_trait_ref.def_id;
1185 check_on_unimplemented(tcx, trait_def_id, it);
1188 hir::ItemTrait(..) => {
1189 let def_id = tcx.hir.local_def_id(it.id);
1190 check_on_unimplemented(tcx, def_id, it);
1192 hir::ItemStruct(..) => {
1193 check_struct(tcx, it.id, it.span);
1195 hir::ItemUnion(..) => {
1196 check_union(tcx, it.id, it.span);
1198 hir::ItemTy(_, ref generics) => {
1199 let def_id = tcx.hir.local_def_id(it.id);
1200 let pty_ty = tcx.type_of(def_id);
1201 check_bounds_are_used(tcx, generics, pty_ty);
1203 hir::ItemForeignMod(ref m) => {
1204 check_abi(tcx, it.span, m.abi);
1206 if m.abi == Abi::RustIntrinsic {
1207 for item in &m.items {
1208 intrinsic::check_intrinsic_type(tcx, item);
1210 } else if m.abi == Abi::PlatformIntrinsic {
1211 for item in &m.items {
1212 intrinsic::check_platform_intrinsic_type(tcx, item);
1215 for item in &m.items {
1216 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1217 if !generics.types.is_empty() {
1218 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1219 "foreign items may not have type parameters");
1220 span_help!(&mut err, item.span,
1221 "consider using specialization instead of \
1226 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1227 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1232 _ => {/* nothing to do */ }
1236 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1237 trait_def_id: DefId,
1239 let item_def_id = tcx.hir.local_def_id(item.id);
1240 // an error would be reported if this fails.
1241 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1244 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1245 impl_item: &hir::ImplItem,
1248 let mut err = struct_span_err!(
1249 tcx.sess, impl_item.span, E0520,
1250 "`{}` specializes an item from a parent `impl`, but \
1251 that item is not marked `default`",
1253 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1256 match tcx.span_of_impl(parent_impl) {
1258 err.span_label(span, "parent `impl` is here");
1259 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1263 err.note(&format!("parent implementation is in crate `{}`", cname));
1270 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1271 trait_def: &ty::TraitDef,
1272 trait_item: &ty::AssociatedItem,
1274 impl_item: &hir::ImplItem)
1276 let ancestors = trait_def.ancestors(tcx, impl_id);
1278 let kind = match impl_item.node {
1279 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1280 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1281 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1284 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1285 .map(|node_item| node_item.map(|parent| parent.defaultness));
1287 if let Some(parent) = parent {
1288 if tcx.impl_item_is_final(&parent) {
1289 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1295 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1298 impl_trait_ref: ty::TraitRef<'tcx>,
1299 impl_item_refs: &[hir::ImplItemRef]) {
1300 let impl_span = tcx.sess.codemap().def_span(impl_span);
1302 // If the trait reference itself is erroneous (so the compilation is going
1303 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1304 // isn't populated for such impls.
1305 if impl_trait_ref.references_error() { return; }
1307 // Locate trait definition and items
1308 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1309 let mut overridden_associated_type = None;
1311 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1313 // Check existing impl methods to see if they are both present in trait
1314 // and compatible with trait signature
1315 for impl_item in impl_items() {
1316 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1317 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1318 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1319 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1321 // Not compatible, but needed for the error message
1322 tcx.associated_items(impl_trait_ref.def_id)
1323 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1326 // Check that impl definition matches trait definition
1327 if let Some(ty_trait_item) = ty_trait_item {
1328 match impl_item.node {
1329 hir::ImplItemKind::Const(..) => {
1330 // Find associated const definition.
1331 if ty_trait_item.kind == ty::AssociatedKind::Const {
1332 compare_const_impl(tcx,
1338 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1339 "item `{}` is an associated const, \
1340 which doesn't match its trait `{}`",
1343 err.span_label(impl_item.span, "does not match trait");
1344 // We can only get the spans from local trait definition
1345 // Same for E0324 and E0325
1346 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1347 err.span_label(trait_span, "item in trait");
1352 hir::ImplItemKind::Method(..) => {
1353 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1354 if ty_trait_item.kind == ty::AssociatedKind::Method {
1355 compare_impl_method(tcx,
1362 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1363 "item `{}` is an associated method, \
1364 which doesn't match its trait `{}`",
1367 err.span_label(impl_item.span, "does not match trait");
1368 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1369 err.span_label(trait_span, "item in trait");
1374 hir::ImplItemKind::Type(_) => {
1375 if ty_trait_item.kind == ty::AssociatedKind::Type {
1376 if ty_trait_item.defaultness.has_value() {
1377 overridden_associated_type = Some(impl_item);
1380 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1381 "item `{}` is an associated type, \
1382 which doesn't match its trait `{}`",
1385 err.span_label(impl_item.span, "does not match trait");
1386 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1387 err.span_label(trait_span, "item in trait");
1394 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1398 // Check for missing items from trait
1399 let mut missing_items = Vec::new();
1400 let mut invalidated_items = Vec::new();
1401 let associated_type_overridden = overridden_associated_type.is_some();
1402 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1403 let is_implemented = trait_def.ancestors(tcx, impl_id)
1404 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1406 .map(|node_item| !node_item.node.is_from_trait())
1409 if !is_implemented && !tcx.impl_is_default(impl_id) {
1410 if !trait_item.defaultness.has_value() {
1411 missing_items.push(trait_item);
1412 } else if associated_type_overridden {
1413 invalidated_items.push(trait_item.name);
1418 if !missing_items.is_empty() {
1419 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1420 "not all trait items implemented, missing: `{}`",
1421 missing_items.iter()
1422 .map(|trait_item| trait_item.name.to_string())
1423 .collect::<Vec<_>>().join("`, `"));
1424 err.span_label(impl_span, format!("missing `{}` in implementation",
1425 missing_items.iter()
1426 .map(|trait_item| trait_item.name.to_string())
1427 .collect::<Vec<_>>().join("`, `")));
1428 for trait_item in missing_items {
1429 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1430 err.span_label(span, format!("`{}` from trait", trait_item.name));
1432 err.note_trait_signature(trait_item.name.to_string(),
1433 trait_item.signature(&tcx));
1439 if !invalidated_items.is_empty() {
1440 let invalidator = overridden_associated_type.unwrap();
1441 span_err!(tcx.sess, invalidator.span, E0399,
1442 "the following trait items need to be reimplemented \
1443 as `{}` was overridden: `{}`",
1445 invalidated_items.iter()
1446 .map(|name| name.to_string())
1447 .collect::<Vec<_>>().join("`, `"))
1451 /// Checks whether a type can be represented in memory. In particular, it
1452 /// identifies types that contain themselves without indirection through a
1453 /// pointer, which would mean their size is unbounded.
1454 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1458 let rty = tcx.type_of(item_def_id);
1460 // Check that it is possible to represent this type. This call identifies
1461 // (1) types that contain themselves and (2) types that contain a different
1462 // recursive type. It is only necessary to throw an error on those that
1463 // contain themselves. For case 2, there must be an inner type that will be
1464 // caught by case 1.
1465 match rty.is_representable(tcx, sp) {
1466 Representability::SelfRecursive(spans) => {
1467 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1469 err.span_label(span, "recursive without indirection");
1474 Representability::Representable | Representability::ContainsRecursive => (),
1479 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1480 let t = tcx.type_of(def_id);
1482 ty::TyAdt(def, substs) if def.is_struct() => {
1483 let fields = &def.non_enum_variant().fields;
1484 if fields.is_empty() {
1485 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1488 let e = fields[0].ty(tcx, substs);
1489 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1490 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1491 .span_label(sp, "SIMD elements must have the same type")
1496 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1497 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1499 span_err!(tcx.sess, sp, E0077,
1500 "SIMD vector element type should be machine type");
1509 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1510 if tcx.adt_def(def_id).repr.packed() {
1511 if tcx.adt_def(def_id).repr.align > 0 {
1512 struct_span_err!(tcx.sess, sp, E0587,
1513 "type has conflicting packed and align representation hints").emit();
1515 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1516 struct_span_err!(tcx.sess, sp, E0588,
1517 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1522 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1524 stack: &mut Vec<DefId>) -> bool {
1525 let t = tcx.type_of(def_id);
1526 if stack.contains(&def_id) {
1527 debug!("check_packed_inner: {:?} is recursive", t);
1531 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1532 if tcx.adt_def(def.did).repr.align > 0 {
1535 // push struct def_id before checking fields
1537 for field in &def.non_enum_variant().fields {
1538 let f = field.ty(tcx, substs);
1540 ty::TyAdt(def, _) => {
1541 if check_packed_inner(tcx, def.did, stack) {
1548 // only need to pop if not early out
1556 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1557 let adt = tcx.adt_def(def_id);
1558 if !adt.repr.transparent() {
1562 // For each field, figure out if it's known to be a ZST and align(1)
1563 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1564 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1565 let param_env = tcx.param_env(field.did);
1566 let layout = tcx.layout_of(param_env.and(ty));
1567 // We are currently checking the type this field came from, so it must be local
1568 let span = tcx.hir.span_if_local(field.did).unwrap();
1569 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1570 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1574 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1575 let non_zst_count = non_zst_fields.clone().count();
1576 if non_zst_count != 1 {
1577 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1578 struct_span_err!(tcx.sess, sp, E0690,
1579 "transparent struct needs exactly one non-zero-sized field, but has {}",
1581 .span_note(field_spans, "non-zero-sized field")
1584 for &(span, zst, align1) in &field_infos {
1586 span_err!(tcx.sess, span, E0691,
1587 "zero-sized field in transparent struct has alignment larger than 1");
1592 #[allow(trivial_numeric_casts)]
1593 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1595 vs: &'tcx [hir::Variant],
1597 let def_id = tcx.hir.local_def_id(id);
1598 let def = tcx.adt_def(def_id);
1599 def.destructor(tcx); // force the destructor to be evaluated
1602 let attributes = tcx.get_attrs(def_id);
1603 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1605 tcx.sess, attr.span, E0084,
1606 "unsupported representation for zero-variant enum")
1607 .span_label(sp, "zero-variant enum")
1612 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1613 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1614 if !tcx.sess.features.borrow().repr128 {
1615 emit_feature_err(&tcx.sess.parse_sess,
1618 GateIssue::Language,
1619 "repr with 128-bit type is unstable");
1624 if let Some(e) = v.node.disr_expr {
1625 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1629 let mut disr_vals: Vec<ConstInt> = Vec::new();
1630 for (discr, v) in def.discriminants(tcx).zip(vs) {
1631 // Check for duplicate discriminant values
1632 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1633 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1634 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1635 let i_span = match variant_i.node.disr_expr {
1636 Some(expr) => tcx.hir.span(expr.node_id),
1637 None => tcx.hir.span(variant_i_node_id)
1639 let span = match v.node.disr_expr {
1640 Some(expr) => tcx.hir.span(expr.node_id),
1643 struct_span_err!(tcx.sess, span, E0081,
1644 "discriminant value `{}` already exists", disr_vals[i])
1645 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1646 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1649 disr_vals.push(discr);
1652 check_representable(tcx, sp, def_id);
1655 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1656 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1658 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1659 -> ty::GenericPredicates<'tcx>
1662 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1663 let item_id = tcx.hir.ty_param_owner(node_id);
1664 let item_def_id = tcx.hir.local_def_id(item_id);
1665 let generics = tcx.generics_of(item_def_id);
1666 let index = generics.type_param_to_index[&def_id];
1667 ty::GenericPredicates {
1669 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1671 ty::Predicate::Trait(ref data) => {
1672 data.0.self_ty().is_param(index)
1676 }).cloned().collect()
1680 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1681 -> Option<ty::Region<'tcx>> {
1683 Some(def) => infer::EarlyBoundRegion(span, def.name),
1684 None => infer::MiscVariable(span)
1686 Some(self.next_region_var(v))
1689 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1690 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1693 fn ty_infer_for_def(&self,
1694 ty_param_def: &ty::TypeParameterDef,
1695 substs: &[Kind<'tcx>],
1696 span: Span) -> Ty<'tcx> {
1697 self.type_var_for_def(span, ty_param_def, substs)
1700 fn projected_ty_from_poly_trait_ref(&self,
1703 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1706 let (trait_ref, _) =
1707 self.replace_late_bound_regions_with_fresh_var(
1709 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1712 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1715 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1716 if ty.has_escaping_regions() {
1717 ty // FIXME: normalization and escaping regions
1719 self.normalize_associated_types_in(span, &ty)
1723 fn set_tainted_by_errors(&self) {
1724 self.infcx.set_tainted_by_errors()
1727 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1728 self.write_ty(hir_id, ty)
1732 /// Controls whether the arguments are tupled. This is used for the call
1735 /// Tupling means that all call-side arguments are packed into a tuple and
1736 /// passed as a single parameter. For example, if tupling is enabled, this
1739 /// fn f(x: (isize, isize))
1741 /// Can be called as:
1748 #[derive(Clone, Eq, PartialEq)]
1749 enum TupleArgumentsFlag {
1754 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1755 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1756 param_env: ty::ParamEnv<'tcx>,
1757 body_id: ast::NodeId)
1758 -> FnCtxt<'a, 'gcx, 'tcx> {
1762 err_count_on_creation: inh.tcx.sess.err_count(),
1765 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1766 ast::CRATE_NODE_ID)),
1767 diverges: Cell::new(Diverges::Maybe),
1768 has_errors: Cell::new(false),
1769 enclosing_breakables: RefCell::new(EnclosingBreakables {
1777 pub fn sess(&self) -> &Session {
1781 pub fn err_count_since_creation(&self) -> usize {
1782 self.tcx.sess.err_count() - self.err_count_on_creation
1785 /// Produce warning on the given node, if the current point in the
1786 /// function is unreachable, and there hasn't been another warning.
1787 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1788 if self.diverges.get() == Diverges::Always {
1789 self.diverges.set(Diverges::WarnedAlways);
1791 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1793 self.tcx().lint_node(
1794 lint::builtin::UNREACHABLE_CODE,
1796 &format!("unreachable {}", kind));
1802 code: ObligationCauseCode<'tcx>)
1803 -> ObligationCause<'tcx> {
1804 ObligationCause::new(span, self.body_id, code)
1807 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1808 self.cause(span, ObligationCauseCode::MiscObligation)
1811 /// Resolves type variables in `ty` if possible. Unlike the infcx
1812 /// version (resolve_type_vars_if_possible), this version will
1813 /// also select obligations if it seems useful, in an effort
1814 /// to get more type information.
1815 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1816 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1818 // No TyInfer()? Nothing needs doing.
1819 if !ty.has_infer_types() {
1820 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1824 // If `ty` is a type variable, see whether we already know what it is.
1825 ty = self.resolve_type_vars_if_possible(&ty);
1826 if !ty.has_infer_types() {
1827 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1831 // If not, try resolving pending obligations as much as
1832 // possible. This can help substantially when there are
1833 // indirect dependencies that don't seem worth tracking
1835 self.select_obligations_where_possible();
1836 ty = self.resolve_type_vars_if_possible(&ty);
1838 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1842 fn record_deferred_call_resolution(&self,
1843 closure_def_id: DefId,
1844 r: DeferredCallResolution<'gcx, 'tcx>) {
1845 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1846 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1849 fn remove_deferred_call_resolutions(&self,
1850 closure_def_id: DefId)
1851 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1853 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1854 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1857 pub fn tag(&self) -> String {
1858 let self_ptr: *const FnCtxt = self;
1859 format!("{:?}", self_ptr)
1862 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1863 match self.locals.borrow().get(&nid) {
1866 span_bug!(span, "no type for local variable {}",
1867 self.tcx.hir.node_to_string(nid));
1873 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1874 debug!("write_ty({:?}, {:?}) in fcx {}",
1875 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1876 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1878 if ty.references_error() {
1879 self.has_errors.set(true);
1880 self.set_tainted_by_errors();
1884 // The NodeId and the ItemLocalId must identify the same item. We just pass
1885 // both of them for consistency checking.
1886 pub fn write_method_call(&self,
1888 method: MethodCallee<'tcx>) {
1891 .type_dependent_defs_mut()
1892 .insert(hir_id, Def::Method(method.def_id));
1893 self.write_substs(hir_id, method.substs);
1896 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1897 if !substs.is_noop() {
1898 debug!("write_substs({:?}, {:?}) in fcx {}",
1903 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1907 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1908 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1914 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1915 Entry::Vacant(entry) => { entry.insert(adj); },
1916 Entry::Occupied(mut entry) => {
1917 debug!(" - composing on top of {:?}", entry.get());
1918 match (&entry.get()[..], &adj[..]) {
1919 // Applying any adjustment on top of a NeverToAny
1920 // is a valid NeverToAny adjustment, because it can't
1922 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1924 Adjustment { kind: Adjust::Deref(_), .. },
1925 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1927 Adjustment { kind: Adjust::Deref(_), .. },
1928 .. // Any following adjustments are allowed.
1930 // A reborrow has no effect before a dereference.
1932 // FIXME: currently we never try to compose autoderefs
1933 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1935 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1936 expr, entry.get(), adj)
1938 *entry.get_mut() = adj;
1943 /// Basically whenever we are converting from a type scheme into
1944 /// the fn body space, we always want to normalize associated
1945 /// types as well. This function combines the two.
1946 fn instantiate_type_scheme<T>(&self,
1948 substs: &Substs<'tcx>,
1951 where T : TypeFoldable<'tcx>
1953 let value = value.subst(self.tcx, substs);
1954 let result = self.normalize_associated_types_in(span, &value);
1955 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1962 /// As `instantiate_type_scheme`, but for the bounds found in a
1963 /// generic type scheme.
1964 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1965 -> ty::InstantiatedPredicates<'tcx> {
1966 let bounds = self.tcx.predicates_of(def_id);
1967 let result = bounds.instantiate(self.tcx, substs);
1968 let result = self.normalize_associated_types_in(span, &result);
1969 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1976 /// Replace the anonymized types from the return value of the
1977 /// function with type variables and records the `AnonTypeMap` for
1978 /// later use during writeback. See
1979 /// `InferCtxt::instantiate_anon_types` for more details.
1980 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
1985 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
1987 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
1992 let (value, anon_type_map) = self.register_infer_ok_obligations(
1993 self.instantiate_anon_types(
2001 let mut anon_types = self.anon_types.borrow_mut();
2002 for (ty, decl) in anon_type_map {
2003 let old_value = anon_types.insert(ty, decl);
2004 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2010 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2011 where T : TypeFoldable<'tcx>
2013 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2016 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2018 where T : TypeFoldable<'tcx>
2020 self.inh.partially_normalize_associated_types_in(span,
2026 pub fn require_type_meets(&self,
2029 code: traits::ObligationCauseCode<'tcx>,
2032 self.register_bound(
2035 traits::ObligationCause::new(span, self.body_id, code));
2038 pub fn require_type_is_sized(&self,
2041 code: traits::ObligationCauseCode<'tcx>)
2043 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2044 self.require_type_meets(ty, span, code, lang_item);
2047 pub fn register_bound(&self,
2050 cause: traits::ObligationCause<'tcx>)
2052 self.fulfillment_cx.borrow_mut()
2053 .register_bound(self, self.param_env, ty, def_id, cause);
2056 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2057 let t = AstConv::ast_ty_to_ty(self, ast_t);
2058 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2062 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2063 match self.tables.borrow().node_types().get(id) {
2065 None if self.is_tainted_by_errors() => self.tcx.types.err,
2067 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2068 bug!("no type for node {}: {} in fcx {}",
2069 node_id, self.tcx.hir.node_to_string(node_id),
2075 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2076 /// outlive the region `r`.
2077 pub fn register_wf_obligation(&self,
2080 code: traits::ObligationCauseCode<'tcx>)
2082 // WF obligations never themselves fail, so no real need to give a detailed cause:
2083 let cause = traits::ObligationCause::new(span, self.body_id, code);
2084 self.register_predicate(traits::Obligation::new(cause,
2086 ty::Predicate::WellFormed(ty)));
2089 /// Registers obligations that all types appearing in `substs` are well-formed.
2090 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2092 for ty in substs.types() {
2093 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2097 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2098 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2099 /// trait/region obligations.
2101 /// For example, if there is a function:
2104 /// fn foo<'a,T:'a>(...)
2107 /// and a reference:
2113 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2114 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2115 pub fn add_obligations_for_parameters(&self,
2116 cause: traits::ObligationCause<'tcx>,
2117 predicates: &ty::InstantiatedPredicates<'tcx>)
2119 assert!(!predicates.has_escaping_regions());
2121 debug!("add_obligations_for_parameters(predicates={:?})",
2124 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2125 self.register_predicate(obligation);
2129 // FIXME(arielb1): use this instead of field.ty everywhere
2130 // Only for fields! Returns <none> for methods>
2131 // Indifferent to privacy flags
2132 pub fn field_ty(&self,
2134 field: &'tcx ty::FieldDef,
2135 substs: &Substs<'tcx>)
2138 self.normalize_associated_types_in(span,
2139 &field.ty(self.tcx, substs))
2142 fn check_casts(&self) {
2143 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2144 for cast in deferred_cast_checks.drain(..) {
2149 fn resolve_generator_interiors(&self, def_id: DefId) {
2150 let mut generators = self.deferred_generator_interiors.borrow_mut();
2151 for (body_id, interior) in generators.drain(..) {
2152 self.select_obligations_where_possible();
2153 generator_interior::resolve_interior(self, def_id, body_id, interior);
2157 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2158 // Non-numerics get replaced with ! or () (depending on whether
2159 // feature(never_type) is enabled), unconstrained ints with i32,
2160 // unconstrained floats with f64.
2161 // Fallback becomes very dubious if we have encountered type-checking errors.
2162 // In that case, fallback to TyError.
2163 fn fallback_if_possible(&self, ty: Ty<'tcx>) {
2164 use rustc::ty::error::UnconstrainedNumeric::Neither;
2165 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2167 assert!(ty.is_ty_infer());
2168 let fallback = match self.type_is_unconstrained_numeric(ty) {
2169 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2170 UnconstrainedInt => self.tcx.types.i32,
2171 UnconstrainedFloat => self.tcx.types.f64,
2172 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2175 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2176 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2179 fn select_all_obligations_or_error(&self) {
2180 debug!("select_all_obligations_or_error");
2181 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2182 self.report_fulfillment_errors(&errors, self.inh.body_id);
2186 /// Select as many obligations as we can at present.
2187 fn select_obligations_where_possible(&self) {
2188 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2190 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2194 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2196 hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
2198 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2203 hir::ExprType(ref e, _) => {
2204 self.is_place_expr(e)
2207 hir::ExprUnary(hir::UnDeref, _) |
2208 hir::ExprField(..) |
2209 hir::ExprTupField(..) |
2210 hir::ExprIndex(..) => {
2214 // Partially qualified paths in expressions can only legally
2215 // refer to associated items which are always rvalues.
2216 hir::ExprPath(hir::QPath::TypeRelative(..)) |
2219 hir::ExprMethodCall(..) |
2220 hir::ExprStruct(..) |
2223 hir::ExprMatch(..) |
2224 hir::ExprClosure(..) |
2225 hir::ExprBlock(..) |
2226 hir::ExprRepeat(..) |
2227 hir::ExprArray(..) |
2228 hir::ExprBreak(..) |
2229 hir::ExprAgain(..) |
2231 hir::ExprWhile(..) |
2233 hir::ExprAssign(..) |
2234 hir::ExprInlineAsm(..) |
2235 hir::ExprAssignOp(..) |
2237 hir::ExprUnary(..) |
2239 hir::ExprAddrOf(..) |
2240 hir::ExprBinary(..) |
2241 hir::ExprYield(..) |
2242 hir::ExprCast(..) => {
2248 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2249 /// returns a type of `&T`, but the actual type we assign to the
2250 /// *expression* is `T`. So this function just peels off the return
2251 /// type by one layer to yield `T`.
2252 fn make_overloaded_place_return_type(&self,
2253 method: MethodCallee<'tcx>)
2254 -> ty::TypeAndMut<'tcx>
2256 // extract method return type, which will be &T;
2257 let ret_ty = method.sig.output();
2259 // method returns &T, but the type as visible to user is T, so deref
2260 ret_ty.builtin_deref(true).unwrap()
2263 fn lookup_indexing(&self,
2265 base_expr: &'gcx hir::Expr,
2269 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2271 // FIXME(#18741) -- this is almost but not quite the same as the
2272 // autoderef that normal method probing does. They could likely be
2275 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2276 let mut result = None;
2277 while result.is_none() && autoderef.next().is_some() {
2278 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2280 autoderef.finalize();
2284 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2285 /// (and otherwise adjust) `base_expr`, looking for a type which either
2286 /// supports builtin indexing or overloaded indexing.
2287 /// This loop implements one step in that search; the autoderef loop
2288 /// is implemented by `lookup_indexing`.
2289 fn try_index_step(&self,
2291 base_expr: &hir::Expr,
2292 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2295 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2297 let adjusted_ty = autoderef.unambiguous_final_ty();
2298 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2305 for &unsize in &[false, true] {
2306 let mut self_ty = adjusted_ty;
2308 // We only unsize arrays here.
2309 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2310 self_ty = self.tcx.mk_slice(element_ty);
2316 // If some lookup succeeds, write callee into table and extract index/element
2317 // type from the method signature.
2318 // If some lookup succeeded, install method in table
2319 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2320 let method = self.try_overloaded_place_op(
2321 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2323 let result = method.map(|ok| {
2324 debug!("try_index_step: success, using overloaded indexing");
2325 let method = self.register_infer_ok_obligations(ok);
2327 let mut adjustments = autoderef.adjust_steps(needs);
2328 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2329 let mutbl = match mt.mutbl {
2330 hir::MutImmutable => AutoBorrowMutability::Immutable,
2331 hir::MutMutable => AutoBorrowMutability::Mutable {
2332 // FIXME (#46747): arguably indexing is
2333 // "just another kind of call"; perhaps it
2334 // would be more consistent to allow
2335 // two-phase borrows for .index()
2337 allow_two_phase_borrow: false,
2340 adjustments.push(Adjustment {
2341 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2342 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2349 adjustments.push(Adjustment {
2350 kind: Adjust::Unsize,
2351 target: method.sig.inputs()[0]
2354 self.apply_adjustments(base_expr, adjustments);
2356 self.write_method_call(expr.hir_id, method);
2357 (input_ty, self.make_overloaded_place_return_type(method).ty)
2359 if result.is_some() {
2367 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2368 let (tr, name) = match (op, is_mut) {
2369 (PlaceOp::Deref, false) =>
2370 (self.tcx.lang_items().deref_trait(), "deref"),
2371 (PlaceOp::Deref, true) =>
2372 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2373 (PlaceOp::Index, false) =>
2374 (self.tcx.lang_items().index_trait(), "index"),
2375 (PlaceOp::Index, true) =>
2376 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2378 (tr, Symbol::intern(name))
2381 fn try_overloaded_place_op(&self,
2384 arg_tys: &[Ty<'tcx>],
2387 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2389 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2395 // Try Mut first, if needed.
2396 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2397 let method = match (needs, mut_tr) {
2398 (Needs::MutPlace, Some(trait_did)) => {
2399 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2404 // Otherwise, fall back to the immutable version.
2405 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2406 let method = match (method, imm_tr) {
2407 (None, Some(trait_did)) => {
2408 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2410 (method, _) => method,
2416 fn check_method_argument_types(&self,
2419 method: Result<MethodCallee<'tcx>, ()>,
2420 args_no_rcvr: &'gcx [hir::Expr],
2421 tuple_arguments: TupleArgumentsFlag,
2422 expected: Expectation<'tcx>)
2424 let has_error = match method {
2426 method.substs.references_error() || method.sig.references_error()
2431 let err_inputs = self.err_args(args_no_rcvr.len());
2433 let err_inputs = match tuple_arguments {
2434 DontTupleArguments => err_inputs,
2435 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2438 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2439 false, tuple_arguments, None);
2440 return self.tcx.types.err;
2443 let method = method.unwrap();
2444 // HACK(eddyb) ignore self in the definition (see above).
2445 let expected_arg_tys = self.expected_inputs_for_expected_output(
2448 method.sig.output(),
2449 &method.sig.inputs()[1..]
2451 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2452 args_no_rcvr, method.sig.variadic, tuple_arguments,
2453 self.tcx.hir.span_if_local(method.def_id));
2457 /// Generic function that factors out common logic from function calls,
2458 /// method calls and overloaded operators.
2459 fn check_argument_types(&self,
2462 fn_inputs: &[Ty<'tcx>],
2463 expected_arg_tys: &[Ty<'tcx>],
2464 args: &'gcx [hir::Expr],
2466 tuple_arguments: TupleArgumentsFlag,
2467 def_span: Option<Span>) {
2470 // Grab the argument types, supplying fresh type variables
2471 // if the wrong number of arguments were supplied
2472 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2478 // All the input types from the fn signature must outlive the call
2479 // so as to validate implied bounds.
2480 for &fn_input_ty in fn_inputs {
2481 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2484 let mut expected_arg_tys = expected_arg_tys;
2485 let expected_arg_count = fn_inputs.len();
2487 fn parameter_count_error<'tcx>(sess: &Session,
2490 expected_count: usize,
2494 def_span: Option<Span>,
2496 let mut err = sess.struct_span_err_with_code(sp,
2497 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2498 if variadic {"at least "} else {""},
2500 if expected_count == 1 {""} else {"s"},
2502 if arg_count == 1 {" was"} else {"s were"}),
2503 DiagnosticId::Error(error_code.to_owned()));
2505 if let Some(def_s) = def_span.map(|sp| sess.codemap().def_span(sp)) {
2506 err.span_label(def_s, "defined here");
2509 let sugg_span = sess.codemap().end_point(expr_sp);
2510 // remove closing `)` from the span
2511 let sugg_span = sugg_span.with_hi(sugg_span.lo());
2512 err.span_suggestion(
2514 "expected the unit value `()`; create it with empty parentheses",
2515 String::from("()"));
2517 err.span_label(sp, format!("expected {}{} parameter{}",
2518 if variadic {"at least "} else {""},
2520 if expected_count == 1 {""} else {"s"}));
2525 let formal_tys = if tuple_arguments == TupleArguments {
2526 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2527 match tuple_type.sty {
2528 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2529 parameter_count_error(tcx.sess, sp, expr_sp, arg_types.len(), args.len(),
2530 "E0057", false, def_span, false);
2531 expected_arg_tys = &[];
2532 self.err_args(args.len())
2534 ty::TyTuple(arg_types, _) => {
2535 expected_arg_tys = match expected_arg_tys.get(0) {
2536 Some(&ty) => match ty.sty {
2537 ty::TyTuple(ref tys, _) => &tys,
2545 span_err!(tcx.sess, sp, E0059,
2546 "cannot use call notation; the first type parameter \
2547 for the function trait is neither a tuple nor unit");
2548 expected_arg_tys = &[];
2549 self.err_args(args.len())
2552 } else if expected_arg_count == supplied_arg_count {
2554 } else if variadic {
2555 if supplied_arg_count >= expected_arg_count {
2558 parameter_count_error(tcx.sess, sp, expr_sp, expected_arg_count,
2559 supplied_arg_count, "E0060", true, def_span, false);
2560 expected_arg_tys = &[];
2561 self.err_args(supplied_arg_count)
2564 // is the missing argument of type `()`?
2565 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2566 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2567 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2568 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2572 parameter_count_error(tcx.sess, sp, expr_sp, expected_arg_count,
2573 supplied_arg_count, "E0061", false, def_span, sugg_unit);
2574 expected_arg_tys = &[];
2575 self.err_args(supplied_arg_count)
2578 debug!("check_argument_types: formal_tys={:?}",
2579 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2581 // Check the arguments.
2582 // We do this in a pretty awful way: first we typecheck any arguments
2583 // that are not closures, then we typecheck the closures. This is so
2584 // that we have more information about the types of arguments when we
2585 // typecheck the functions. This isn't really the right way to do this.
2586 for &check_closures in &[false, true] {
2587 debug!("check_closures={}", check_closures);
2589 // More awful hacks: before we check argument types, try to do
2590 // an "opportunistic" vtable resolution of any trait bounds on
2591 // the call. This helps coercions.
2593 self.select_obligations_where_possible();
2596 // For variadic functions, we don't have a declared type for all of
2597 // the arguments hence we only do our usual type checking with
2598 // the arguments who's types we do know.
2599 let t = if variadic {
2601 } else if tuple_arguments == TupleArguments {
2606 for (i, arg) in args.iter().take(t).enumerate() {
2607 // Warn only for the first loop (the "no closures" one).
2608 // Closure arguments themselves can't be diverging, but
2609 // a previous argument can, e.g. `foo(panic!(), || {})`.
2610 if !check_closures {
2611 self.warn_if_unreachable(arg.id, arg.span, "expression");
2614 let is_closure = match arg.node {
2615 hir::ExprClosure(..) => true,
2619 if is_closure != check_closures {
2623 debug!("checking the argument");
2624 let formal_ty = formal_tys[i];
2626 // The special-cased logic below has three functions:
2627 // 1. Provide as good of an expected type as possible.
2628 let expected = expected_arg_tys.get(i).map(|&ty| {
2629 Expectation::rvalue_hint(self, ty)
2632 let checked_ty = self.check_expr_with_expectation(
2634 expected.unwrap_or(ExpectHasType(formal_ty)));
2636 // 2. Coerce to the most detailed type that could be coerced
2637 // to, which is `expected_ty` if `rvalue_hint` returns an
2638 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2639 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2640 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2642 // 3. Relate the expected type and the formal one,
2643 // if the expected type was used for the coercion.
2644 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2648 // We also need to make sure we at least write the ty of the other
2649 // arguments which we skipped above.
2651 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2652 use structured_errors::{VariadicError, StructuredDiagnostic};
2653 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2656 for arg in args.iter().skip(expected_arg_count) {
2657 let arg_ty = self.check_expr(&arg);
2659 // There are a few types which get autopromoted when passed via varargs
2660 // in C but we just error out instead and require explicit casts.
2661 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2663 ty::TyFloat(ast::FloatTy::F32) => {
2664 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2666 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2667 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2669 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2670 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2672 ty::TyFnDef(..) => {
2673 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2674 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2675 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2683 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2684 (0..len).map(|_| self.tcx.types.err).collect()
2687 // AST fragment checking
2690 expected: Expectation<'tcx>)
2696 ast::LitKind::Str(..) => tcx.mk_static_str(),
2697 ast::LitKind::ByteStr(ref v) => {
2698 tcx.mk_imm_ref(tcx.types.re_static,
2699 tcx.mk_array(tcx.types.u8, v.len() as u64))
2701 ast::LitKind::Byte(_) => tcx.types.u8,
2702 ast::LitKind::Char(_) => tcx.types.char,
2703 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2704 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2705 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2706 let opt_ty = expected.to_option(self).and_then(|ty| {
2708 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2709 ty::TyChar => Some(tcx.types.u8),
2710 ty::TyRawPtr(..) => Some(tcx.types.usize),
2711 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2715 opt_ty.unwrap_or_else(
2716 || tcx.mk_int_var(self.next_int_var_id()))
2718 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2719 ast::LitKind::FloatUnsuffixed(_) => {
2720 let opt_ty = expected.to_option(self).and_then(|ty| {
2722 ty::TyFloat(_) => Some(ty),
2726 opt_ty.unwrap_or_else(
2727 || tcx.mk_float_var(self.next_float_var_id()))
2729 ast::LitKind::Bool(_) => tcx.types.bool
2733 fn check_expr_eq_type(&self,
2734 expr: &'gcx hir::Expr,
2735 expected: Ty<'tcx>) {
2736 let ty = self.check_expr_with_hint(expr, expected);
2737 self.demand_eqtype(expr.span, expected, ty);
2740 pub fn check_expr_has_type_or_error(&self,
2741 expr: &'gcx hir::Expr,
2742 expected: Ty<'tcx>) -> Ty<'tcx> {
2743 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2746 fn check_expr_meets_expectation_or_error(&self,
2747 expr: &'gcx hir::Expr,
2748 expected: Expectation<'tcx>) -> Ty<'tcx> {
2749 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2750 let mut ty = self.check_expr_with_expectation(expr, expected);
2752 // While we don't allow *arbitrary* coercions here, we *do* allow
2753 // coercions from ! to `expected`.
2755 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2756 "expression with never type wound up being adjusted");
2757 let adj_ty = self.next_diverging_ty_var(
2758 TypeVariableOrigin::AdjustmentType(expr.span));
2759 self.apply_adjustments(expr, vec![Adjustment {
2760 kind: Adjust::NeverToAny,
2766 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2767 // Add help to type error if this is an `if` condition with an assignment
2768 match (expected, &expr.node) {
2769 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2770 let msg = "try comparing for equality";
2771 if let (Ok(left), Ok(right)) = (
2772 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2773 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2775 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2787 fn check_expr_coercable_to_type(&self,
2788 expr: &'gcx hir::Expr,
2789 expected: Ty<'tcx>) -> Ty<'tcx> {
2790 self.check_expr_coercable_to_type_with_needs(expr, expected, Needs::None)
2793 fn check_expr_coercable_to_type_with_needs(&self,
2794 expr: &'gcx hir::Expr,
2798 let ty = self.check_expr_with_expectation_and_needs(
2800 ExpectHasType(expected),
2802 self.demand_coerce(expr, ty, expected)
2805 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2806 expected: Ty<'tcx>) -> Ty<'tcx> {
2807 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2810 fn check_expr_with_expectation(&self,
2811 expr: &'gcx hir::Expr,
2812 expected: Expectation<'tcx>) -> Ty<'tcx> {
2813 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2816 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2817 self.check_expr_with_expectation(expr, NoExpectation)
2820 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2821 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2824 // determine the `self` type, using fresh variables for all variables
2825 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2826 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2828 pub fn impl_self_ty(&self,
2829 span: Span, // (potential) receiver for this impl
2831 -> TypeAndSubsts<'tcx> {
2832 let ity = self.tcx.type_of(did);
2833 debug!("impl_self_ty: ity={:?}", ity);
2835 let substs = self.fresh_substs_for_item(span, did);
2836 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2838 TypeAndSubsts { substs: substs, ty: substd_ty }
2841 /// Unifies the output type with the expected type early, for more coercions
2842 /// and forward type information on the input expressions.
2843 fn expected_inputs_for_expected_output(&self,
2845 expected_ret: Expectation<'tcx>,
2846 formal_ret: Ty<'tcx>,
2847 formal_args: &[Ty<'tcx>])
2849 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2850 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2851 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2852 // Attempt to apply a subtyping relationship between the formal
2853 // return type (likely containing type variables if the function
2854 // is polymorphic) and the expected return type.
2855 // No argument expectations are produced if unification fails.
2856 let origin = self.misc(call_span);
2857 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2859 // FIXME(#15760) can't use try! here, FromError doesn't default
2860 // to identity so the resulting type is not constrained.
2863 // Process any obligations locally as much as
2864 // we can. We don't care if some things turn
2865 // out unconstrained or ambiguous, as we're
2866 // just trying to get hints here.
2867 let result = self.save_and_restore_in_snapshot_flag(|_| {
2868 let mut fulfill = FulfillmentContext::new();
2869 let ok = ok; // FIXME(#30046)
2870 for obligation in ok.obligations {
2871 fulfill.register_predicate_obligation(self, obligation);
2873 fulfill.select_where_possible(self)
2878 Err(_) => return Err(()),
2881 Err(_) => return Err(()),
2884 // Record all the argument types, with the substitutions
2885 // produced from the above subtyping unification.
2886 Ok(formal_args.iter().map(|ty| {
2887 self.resolve_type_vars_if_possible(ty)
2890 }).unwrap_or(vec![]);
2891 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2892 formal_args, formal_ret,
2893 expected_args, expected_ret);
2897 // Checks a method call.
2898 fn check_method_call(&self,
2899 expr: &'gcx hir::Expr,
2900 segment: &hir::PathSegment,
2902 args: &'gcx [hir::Expr],
2903 expected: Expectation<'tcx>,
2904 needs: Needs) -> Ty<'tcx> {
2905 let rcvr = &args[0];
2906 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
2907 // no need to check for bot/err -- callee does that
2908 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
2910 let method = match self.lookup_method(rcvr_t,
2916 self.write_method_call(expr.hir_id, method);
2920 if segment.name != keywords::Invalid.name() {
2921 self.report_method_error(span,
2932 // Call the generic checker.
2933 self.check_method_argument_types(span,
2941 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2945 .unwrap_or_else(|| span_bug!(return_expr.span,
2946 "check_return_expr called outside fn body"));
2948 let ret_ty = ret_coercion.borrow().expected_ty();
2949 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2950 ret_coercion.borrow_mut()
2952 &self.cause(return_expr.span,
2953 ObligationCauseCode::ReturnType(return_expr.id)),
2956 self.diverges.get());
2960 // A generic function for checking the then and else in an if
2962 fn check_then_else(&self,
2963 cond_expr: &'gcx hir::Expr,
2964 then_expr: &'gcx hir::Expr,
2965 opt_else_expr: Option<&'gcx hir::Expr>,
2967 expected: Expectation<'tcx>) -> Ty<'tcx> {
2968 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2969 let cond_diverges = self.diverges.get();
2970 self.diverges.set(Diverges::Maybe);
2972 let expected = expected.adjust_for_branches(self);
2973 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2974 let then_diverges = self.diverges.get();
2975 self.diverges.set(Diverges::Maybe);
2977 // We've already taken the expected type's preferences
2978 // into account when typing the `then` branch. To figure
2979 // out the initial shot at a LUB, we thus only consider
2980 // `expected` if it represents a *hard* constraint
2981 // (`only_has_type`); otherwise, we just go with a
2982 // fresh type variable.
2983 let coerce_to_ty = expected.coercion_target_type(self, sp);
2984 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2986 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2987 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2989 if let Some(else_expr) = opt_else_expr {
2990 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2991 let else_diverges = self.diverges.get();
2993 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2995 // We won't diverge unless both branches do (or the condition does).
2996 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2998 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2999 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3001 // If the condition is false we can't diverge.
3002 self.diverges.set(cond_diverges);
3005 let result_ty = coerce.complete(self);
3006 if cond_ty.references_error() {
3013 // Check field access expressions
3014 fn check_field(&self,
3015 expr: &'gcx hir::Expr,
3017 base: &'gcx hir::Expr,
3018 field: &Spanned<ast::Name>) -> Ty<'tcx> {
3019 let expr_t = self.check_expr_with_needs(base, needs);
3020 let expr_t = self.structurally_resolved_type(expr.span,
3022 let mut private_candidate = None;
3023 let mut autoderef = self.autoderef(expr.span, expr_t);
3024 while let Some((base_t, _)) = autoderef.next() {
3026 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3027 debug!("struct named {:?}", base_t);
3028 let (ident, def_scope) =
3029 self.tcx.adjust(field.node, base_def.did, self.body_id);
3030 let fields = &base_def.non_enum_variant().fields;
3031 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3032 let field_ty = self.field_ty(expr.span, field, substs);
3033 if field.vis.is_accessible_from(def_scope, self.tcx) {
3034 let adjustments = autoderef.adjust_steps(needs);
3035 self.apply_adjustments(base, adjustments);
3036 autoderef.finalize();
3038 self.tcx.check_stability(field.did, expr.id, expr.span);
3042 private_candidate = Some((base_def.did, field_ty));
3048 autoderef.unambiguous_final_ty();
3050 if let Some((did, field_ty)) = private_candidate {
3051 let struct_path = self.tcx().item_path_str(did);
3052 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3053 "field `{}` of struct `{}` is private",
3054 field.node, struct_path);
3055 // Also check if an accessible method exists, which is often what is meant.
3056 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3057 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3062 } else if field.node == keywords::Invalid.name() {
3063 self.tcx().types.err
3064 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3065 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3066 "attempted to take value of method `{}` on type `{}`",
3068 .help("maybe a `()` to call it is missing?")
3070 self.tcx().types.err
3072 if !expr_t.is_primitive_ty() {
3073 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3076 ty::TyAdt(def, _) if !def.is_enum() => {
3077 if let Some(suggested_field_name) =
3078 Self::suggest_field_name(def.non_enum_variant(), field, vec![]) {
3079 err.span_label(field.span,
3080 format!("did you mean `{}`?", suggested_field_name));
3082 err.span_label(field.span, "unknown field");
3083 let struct_variant_def = def.non_enum_variant();
3084 let field_names = self.available_field_names(struct_variant_def);
3085 if !field_names.is_empty() {
3086 err.note(&format!("available fields are: {}",
3087 self.name_series_display(field_names)));
3091 ty::TyRawPtr(..) => {
3092 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
3094 self.tcx.hir.node_to_pretty_string(base.id),
3101 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3102 "`{}` is a primitive type and therefore doesn't have fields",
3105 self.tcx().types.err
3109 // Return an hint about the closest match in field names
3110 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3111 field: &Spanned<ast::Name>,
3112 skip: Vec<InternedString>)
3114 let name = field.node.as_str();
3115 let names = variant.fields.iter().filter_map(|field| {
3116 // ignore already set fields and private fields from non-local crates
3117 if skip.iter().any(|x| *x == field.name.as_str()) ||
3118 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3125 find_best_match_for_name(names, &name, None)
3128 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3129 let mut available = Vec::new();
3130 for field in variant.fields.iter() {
3131 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3132 if field.vis.is_accessible_from(def_scope, self.tcx) {
3133 available.push(field.name);
3139 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3140 // dynamic limit, to never omit just one field
3141 let limit = if names.len() == 6 { 6 } else { 5 };
3142 let mut display = names.iter().take(limit)
3143 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3144 if names.len() > limit {
3145 display = format!("{} ... and {} others", display, names.len() - limit);
3150 // Check tuple index expressions
3151 fn check_tup_field(&self,
3152 expr: &'gcx hir::Expr,
3154 base: &'gcx hir::Expr,
3155 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3156 let expr_t = self.check_expr_with_needs(base, needs);
3157 let expr_t = self.structurally_resolved_type(expr.span,
3159 let mut private_candidate = None;
3160 let mut tuple_like = false;
3161 let mut autoderef = self.autoderef(expr.span, expr_t);
3162 while let Some((base_t, _)) = autoderef.next() {
3163 let field = match base_t.sty {
3164 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3165 tuple_like = base_def.non_enum_variant().ctor_kind == CtorKind::Fn;
3166 if !tuple_like { continue }
3168 debug!("tuple struct named {:?}", base_t);
3169 let ident = ast::Ident {
3170 name: Symbol::intern(&idx.node.to_string()),
3171 ctxt: idx.span.ctxt().modern(),
3173 let (ident, def_scope) =
3174 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3175 let fields = &base_def.non_enum_variant().fields;
3176 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3177 let field_ty = self.field_ty(expr.span, field, substs);
3178 if field.vis.is_accessible_from(def_scope, self.tcx) {
3179 self.tcx.check_stability(field.did, expr.id, expr.span);
3182 private_candidate = Some((base_def.did, field_ty));
3189 ty::TyTuple(ref v, _) => {
3191 v.get(idx.node).cloned()
3196 if let Some(field_ty) = field {
3197 let adjustments = autoderef.adjust_steps(needs);
3198 self.apply_adjustments(base, adjustments);
3199 autoderef.finalize();
3203 autoderef.unambiguous_final_ty();
3205 if let Some((did, field_ty)) = private_candidate {
3206 let struct_path = self.tcx().item_path_str(did);
3207 struct_span_err!(self.tcx().sess, expr.span, E0611,
3208 "field `{}` of tuple-struct `{}` is private",
3209 idx.node, struct_path).emit();
3214 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3215 "attempted out-of-bounds tuple index `{}` on type `{}`",
3216 idx.node, expr_t).emit();
3218 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3221 self.tcx().types.err
3224 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3225 -> DiagnosticBuilder {
3226 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3227 "no field `{}` on type `{}`",
3231 fn report_unknown_field(&self,
3233 variant: &'tcx ty::VariantDef,
3235 skip_fields: &[hir::Field],
3237 let mut err = self.type_error_struct_with_diag(
3239 |actual| match ty.sty {
3240 ty::TyAdt(adt, ..) if adt.is_enum() => {
3241 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3242 "{} `{}::{}` has no field named `{}`",
3243 kind_name, actual, variant.name, field.name.node)
3246 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3247 "{} `{}` has no field named `{}`",
3248 kind_name, actual, field.name.node)
3252 // prevent all specified fields from being suggested
3253 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3254 if let Some(field_name) = Self::suggest_field_name(variant,
3256 skip_fields.collect()) {
3257 err.span_label(field.name.span,
3258 format!("field does not exist - did you mean `{}`?", field_name));
3261 ty::TyAdt(adt, ..) => {
3263 err.span_label(field.name.span,
3264 format!("`{}::{}` does not have this field",
3267 err.span_label(field.name.span,
3268 format!("`{}` does not have this field", ty));
3270 let available_field_names = self.available_field_names(variant);
3271 if !available_field_names.is_empty() {
3272 err.note(&format!("available fields are: {}",
3273 self.name_series_display(available_field_names)));
3276 _ => bug!("non-ADT passed to report_unknown_field")
3282 fn check_expr_struct_fields(&self,
3284 expected: Expectation<'tcx>,
3285 expr_id: ast::NodeId,
3287 variant: &'tcx ty::VariantDef,
3288 ast_fields: &'gcx [hir::Field],
3289 check_completeness: bool) {
3293 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3294 .get(0).cloned().unwrap_or(adt_ty);
3295 // re-link the regions that EIfEO can erase.
3296 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3298 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3299 &ty::TyAdt(adt, substs) => {
3300 (substs, adt.adt_kind(), adt.variant_descr())
3302 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3305 let mut remaining_fields = FxHashMap();
3306 for field in &variant.fields {
3307 remaining_fields.insert(field.name.to_ident(), field);
3310 let mut seen_fields = FxHashMap();
3312 let mut error_happened = false;
3314 // Typecheck each field.
3315 for field in ast_fields {
3316 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3317 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3318 seen_fields.insert(field.name.node, field.span);
3320 // we don't look at stability attributes on
3321 // struct-like enums (yet...), but it's definitely not
3322 // a bug to have construct one.
3323 if adt_kind != ty::AdtKind::Enum {
3324 tcx.check_stability(v_field.did, expr_id, field.span);
3327 self.field_ty(field.span, v_field, substs)
3329 error_happened = true;
3330 if let Some(_) = variant.find_field_named(field.name.node) {
3331 let mut err = struct_span_err!(self.tcx.sess,
3334 "field `{}` specified more than once",
3337 err.span_label(field.name.span, "used more than once");
3339 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3340 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3345 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3351 // Make sure to give a type to the field even if there's
3352 // an error, so we can continue typechecking
3353 self.check_expr_coercable_to_type(&field.expr, field_type);
3356 // Make sure the programmer specified correct number of fields.
3357 if kind_name == "union" {
3358 if ast_fields.len() != 1 {
3359 tcx.sess.span_err(span, "union expressions should have exactly one field");
3361 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3362 let len = remaining_fields.len();
3364 let mut displayable_field_names = remaining_fields
3366 .map(|ident| ident.name.as_str())
3367 .collect::<Vec<_>>();
3369 displayable_field_names.sort();
3371 let truncated_fields_error = if len <= 3 {
3374 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3377 let remaining_fields_names = displayable_field_names.iter().take(3)
3378 .map(|n| format!("`{}`", n))
3379 .collect::<Vec<_>>()
3382 struct_span_err!(tcx.sess, span, E0063,
3383 "missing field{} {}{} in initializer of `{}`",
3384 if remaining_fields.len() == 1 { "" } else { "s" },
3385 remaining_fields_names,
3386 truncated_fields_error,
3388 .span_label(span, format!("missing {}{}",
3389 remaining_fields_names,
3390 truncated_fields_error))
3395 fn check_struct_fields_on_error(&self,
3396 fields: &'gcx [hir::Field],
3397 base_expr: &'gcx Option<P<hir::Expr>>) {
3398 for field in fields {
3399 self.check_expr(&field.expr);
3403 self.check_expr(&base);
3409 pub fn check_struct_path(&self,
3411 node_id: ast::NodeId)
3412 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3413 let path_span = match *qpath {
3414 hir::QPath::Resolved(_, ref path) => path.span,
3415 hir::QPath::TypeRelative(ref qself, _) => qself.span
3417 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3418 let variant = match def {
3420 self.set_tainted_by_errors();
3423 Def::Variant(..) => {
3425 ty::TyAdt(adt, substs) => {
3426 Some((adt.variant_of_def(def), adt.did, substs))
3428 _ => bug!("unexpected type: {:?}", ty.sty)
3431 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3432 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3434 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3435 Some((adt.non_enum_variant(), adt.did, substs))
3440 _ => bug!("unexpected definition: {:?}", def)
3443 if let Some((variant, did, substs)) = variant {
3444 // Check bounds on type arguments used in the path.
3445 let bounds = self.instantiate_bounds(path_span, did, substs);
3446 let cause = traits::ObligationCause::new(path_span, self.body_id,
3447 traits::ItemObligation(did));
3448 self.add_obligations_for_parameters(cause, &bounds);
3452 struct_span_err!(self.tcx.sess, path_span, E0071,
3453 "expected struct, variant or union type, found {}",
3454 ty.sort_string(self.tcx))
3455 .span_label(path_span, "not a struct")
3461 fn check_expr_struct(&self,
3463 expected: Expectation<'tcx>,
3465 fields: &'gcx [hir::Field],
3466 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3468 // Find the relevant variant
3469 let (variant, struct_ty) =
3470 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3473 self.check_struct_fields_on_error(fields, base_expr);
3474 return self.tcx.types.err;
3477 let path_span = match *qpath {
3478 hir::QPath::Resolved(_, ref path) => path.span,
3479 hir::QPath::TypeRelative(ref qself, _) => qself.span
3482 // Prohibit struct expressions when non exhaustive flag is set.
3483 if let ty::TyAdt(adt, _) = struct_ty.sty {
3484 if !adt.did.is_local() && adt.is_non_exhaustive() {
3485 span_err!(self.tcx.sess, expr.span, E0639,
3486 "cannot create non-exhaustive {} using struct expression",
3487 adt.variant_descr());
3491 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3492 base_expr.is_none());
3493 if let &Some(ref base_expr) = base_expr {
3494 self.check_expr_has_type_or_error(base_expr, struct_ty);
3495 match struct_ty.sty {
3496 ty::TyAdt(adt, substs) if adt.is_struct() => {
3497 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3498 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3503 .fru_field_types_mut()
3504 .insert(expr.hir_id, fru_field_types);
3507 span_err!(self.tcx.sess, base_expr.span, E0436,
3508 "functional record update syntax requires a struct");
3512 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3518 /// If an expression has any sub-expressions that result in a type error,
3519 /// inspecting that expression's type with `ty.references_error()` will return
3520 /// true. Likewise, if an expression is known to diverge, inspecting its
3521 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3522 /// strict, _|_ can appear in the type of an expression that does not,
3523 /// itself, diverge: for example, fn() -> _|_.)
3524 /// Note that inspecting a type's structure *directly* may expose the fact
3525 /// that there are actually multiple representations for `TyError`, so avoid
3526 /// that when err needs to be handled differently.
3527 fn check_expr_with_expectation_and_needs(&self,
3528 expr: &'gcx hir::Expr,
3529 expected: Expectation<'tcx>,
3530 needs: Needs) -> Ty<'tcx> {
3531 debug!(">> typechecking: expr={:?} expected={:?}",
3534 // Warn for expressions after diverging siblings.
3535 self.warn_if_unreachable(expr.id, expr.span, "expression");
3537 // Hide the outer diverging and has_errors flags.
3538 let old_diverges = self.diverges.get();
3539 let old_has_errors = self.has_errors.get();
3540 self.diverges.set(Diverges::Maybe);
3541 self.has_errors.set(false);
3543 let ty = self.check_expr_kind(expr, expected, needs);
3545 // Warn for non-block expressions with diverging children.
3548 hir::ExprLoop(..) | hir::ExprWhile(..) |
3549 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3551 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3554 // Any expression that produces a value of type `!` must have diverged
3556 self.diverges.set(self.diverges.get() | Diverges::Always);
3559 // Record the type, which applies it effects.
3560 // We need to do this after the warning above, so that
3561 // we don't warn for the diverging expression itself.
3562 self.write_ty(expr.hir_id, ty);
3564 // Combine the diverging and has_error flags.
3565 self.diverges.set(self.diverges.get() | old_diverges);
3566 self.has_errors.set(self.has_errors.get() | old_has_errors);
3568 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3569 debug!("... {:?}, expected is {:?}", ty, expected);
3574 fn check_expr_kind(&self,
3575 expr: &'gcx hir::Expr,
3576 expected: Expectation<'tcx>,
3577 needs: Needs) -> Ty<'tcx> {
3581 hir::ExprBox(ref subexpr) => {
3582 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3584 ty::TyAdt(def, _) if def.is_box()
3585 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3589 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3590 tcx.mk_box(referent_ty)
3593 hir::ExprLit(ref lit) => {
3594 self.check_lit(&lit, expected)
3596 hir::ExprBinary(op, ref lhs, ref rhs) => {
3597 self.check_binop(expr, op, lhs, rhs)
3599 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3600 self.check_binop_assign(expr, op, lhs, rhs)
3602 hir::ExprUnary(unop, ref oprnd) => {
3603 let expected_inner = match unop {
3604 hir::UnNot | hir::UnNeg => {
3611 let needs = match unop {
3612 hir::UnDeref => needs,
3615 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3619 if !oprnd_t.references_error() {
3620 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3623 if let Some(mt) = oprnd_t.builtin_deref(true) {
3625 } else if let Some(ok) = self.try_overloaded_deref(
3626 expr.span, oprnd_t, needs) {
3627 let method = self.register_infer_ok_obligations(ok);
3628 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3629 let mutbl = match mt.mutbl {
3630 hir::MutImmutable => AutoBorrowMutability::Immutable,
3631 hir::MutMutable => AutoBorrowMutability::Mutable {
3632 // (It shouldn't actually matter for unary ops whether
3633 // we enable two-phase borrows or not, since a unary
3634 // op has no additional operands.)
3635 allow_two_phase_borrow: false,
3638 self.apply_adjustments(oprnd, vec![Adjustment {
3639 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3640 target: method.sig.inputs()[0]
3643 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3644 self.write_method_call(expr.hir_id, method);
3646 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3647 "type `{}` cannot be dereferenced",
3649 oprnd_t = tcx.types.err;
3653 let result = self.check_user_unop(expr, oprnd_t, unop);
3654 // If it's builtin, we can reuse the type, this helps inference.
3655 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3660 let result = self.check_user_unop(expr, oprnd_t, unop);
3661 // If it's builtin, we can reuse the type, this helps inference.
3662 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3670 hir::ExprAddrOf(mutbl, ref oprnd) => {
3671 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3673 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3674 if self.is_place_expr(&oprnd) {
3675 // Places may legitimately have unsized types.
3676 // For example, dereferences of a fat pointer and
3677 // the last field of a struct can be unsized.
3678 ExpectHasType(mt.ty)
3680 Expectation::rvalue_hint(self, mt.ty)
3686 let needs = Needs::maybe_mut_place(mutbl);
3687 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3689 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3690 if tm.ty.references_error() {
3693 // Note: at this point, we cannot say what the best lifetime
3694 // is to use for resulting pointer. We want to use the
3695 // shortest lifetime possible so as to avoid spurious borrowck
3696 // errors. Moreover, the longest lifetime will depend on the
3697 // precise details of the value whose address is being taken
3698 // (and how long it is valid), which we don't know yet until type
3699 // inference is complete.
3701 // Therefore, here we simply generate a region variable. The
3702 // region inferencer will then select the ultimate value.
3703 // Finally, borrowck is charged with guaranteeing that the
3704 // value whose address was taken can actually be made to live
3705 // as long as it needs to live.
3706 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3707 tcx.mk_ref(region, tm)
3710 hir::ExprPath(ref qpath) => {
3711 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3712 expr.id, expr.span);
3713 let ty = if def != Def::Err {
3714 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3716 self.set_tainted_by_errors();
3720 // We always require that the type provided as the value for
3721 // a type parameter outlives the moment of instantiation.
3722 let substs = self.tables.borrow().node_substs(expr.hir_id);
3723 self.add_wf_bounds(substs, expr);
3727 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3728 for output in outputs {
3729 self.check_expr(output);
3731 for input in inputs {
3732 self.check_expr(input);
3736 hir::ExprBreak(destination, ref expr_opt) => {
3737 if let Some(target_id) = destination.target_id.opt_id() {
3738 let (e_ty, e_diverges, cause);
3739 if let Some(ref e) = *expr_opt {
3740 // If this is a break with a value, we need to type-check
3741 // the expression. Get an expected type from the loop context.
3742 let opt_coerce_to = {
3743 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3744 enclosing_breakables.find_breakable(target_id)
3747 .map(|coerce| coerce.expected_ty())
3750 // If the loop context is not a `loop { }`, then break with
3751 // a value is illegal, and `opt_coerce_to` will be `None`.
3752 // Just set expectation to error in that case.
3753 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3755 // Recurse without `enclosing_breakables` borrowed.
3756 e_ty = self.check_expr_with_hint(e, coerce_to);
3757 e_diverges = self.diverges.get();
3758 cause = self.misc(e.span);
3760 // Otherwise, this is a break *without* a value. That's
3761 // always legal, and is equivalent to `break ()`.
3762 e_ty = tcx.mk_nil();
3763 e_diverges = Diverges::Maybe;
3764 cause = self.misc(expr.span);
3767 // Now that we have type-checked `expr_opt`, borrow
3768 // the `enclosing_loops` field and let's coerce the
3769 // type of `expr_opt` into what is expected.
3770 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3771 let ctxt = enclosing_breakables.find_breakable(target_id);
3772 if let Some(ref mut coerce) = ctxt.coerce {
3773 if let Some(ref e) = *expr_opt {
3774 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3776 assert!(e_ty.is_nil());
3777 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3780 // If `ctxt.coerce` is `None`, we can just ignore
3781 // the type of the expresison. This is because
3782 // either this was a break *without* a value, in
3783 // which case it is always a legal type (`()`), or
3784 // else an error would have been flagged by the
3785 // `loops` pass for using break with an expression
3786 // where you are not supposed to.
3787 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3790 ctxt.may_break = true;
3792 // Otherwise, we failed to find the enclosing loop;
3793 // this can only happen if the `break` was not
3794 // inside a loop at all, which is caught by the
3795 // loop-checking pass.
3796 assert!(self.tcx.sess.err_count() > 0);
3798 // We still need to assign a type to the inner expression to
3799 // prevent the ICE in #43162.
3800 if let Some(ref e) = *expr_opt {
3801 self.check_expr_with_hint(e, tcx.types.err);
3803 // ... except when we try to 'break rust;'.
3804 // ICE this expression in particular (see #43162).
3805 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3806 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3807 fatally_break_rust(self.tcx.sess);
3813 // the type of a `break` is always `!`, since it diverges
3816 hir::ExprAgain(_) => { tcx.types.never }
3817 hir::ExprRet(ref expr_opt) => {
3818 if self.ret_coercion.is_none() {
3819 struct_span_err!(self.tcx.sess, expr.span, E0572,
3820 "return statement outside of function body").emit();
3821 } else if let Some(ref e) = *expr_opt {
3822 self.check_return_expr(e);
3824 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3825 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3826 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3830 hir::ExprAssign(ref lhs, ref rhs) => {
3831 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3833 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3836 ExpectIfCondition => {
3837 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3838 expected error elsehwere");
3841 // Only check this if not in an `if` condition, as the
3842 // mistyped comparison help is more appropriate.
3843 if !self.is_place_expr(&lhs) {
3844 struct_span_err!(self.tcx.sess, expr.span, E0070,
3845 "invalid left-hand side expression")
3846 .span_label(expr.span, "left-hand of expression not valid")
3852 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3854 if lhs_ty.references_error() || rhs_ty.references_error() {
3860 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3861 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3862 expr.span, expected)
3864 hir::ExprWhile(ref cond, ref body, _) => {
3865 let ctxt = BreakableCtxt {
3866 // cannot use break with a value from a while loop
3871 self.with_breakable_ctxt(expr.id, ctxt, || {
3872 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3873 let cond_diverging = self.diverges.get();
3874 self.check_block_no_value(&body);
3876 // We may never reach the body so it diverging means nothing.
3877 self.diverges.set(cond_diverging);
3882 hir::ExprLoop(ref body, _, source) => {
3883 let coerce = match source {
3884 // you can only use break with a value from a normal `loop { }`
3885 hir::LoopSource::Loop => {
3886 let coerce_to = expected.coercion_target_type(self, body.span);
3887 Some(CoerceMany::new(coerce_to))
3890 hir::LoopSource::WhileLet |
3891 hir::LoopSource::ForLoop => {
3896 let ctxt = BreakableCtxt {
3898 may_break: false, // will get updated if/when we find a `break`
3901 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3902 self.check_block_no_value(&body);
3906 // No way to know whether it's diverging because
3907 // of a `break` or an outer `break` or `return.
3908 self.diverges.set(Diverges::Maybe);
3911 // If we permit break with a value, then result type is
3912 // the LUB of the breaks (possibly ! if none); else, it
3913 // is nil. This makes sense because infinite loops
3914 // (which would have type !) are only possible iff we
3915 // permit break with a value [1].
3916 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3917 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3919 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3920 self.check_match(expr, &discrim, arms, expected, match_src)
3922 hir::ExprClosure(capture, ref decl, body_id, _, gen) => {
3923 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
3925 hir::ExprBlock(ref body) => {
3926 self.check_block_with_expected(&body, expected)
3928 hir::ExprCall(ref callee, ref args) => {
3929 self.check_call(expr, &callee, args, expected)
3931 hir::ExprMethodCall(ref segment, span, ref args) => {
3932 self.check_method_call(expr, segment, span, args, expected, needs)
3934 hir::ExprCast(ref e, ref t) => {
3935 // Find the type of `e`. Supply hints based on the type we are casting to,
3937 let t_cast = self.to_ty(t);
3938 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3939 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3940 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3941 let diverges = self.diverges.get();
3943 // Eagerly check for some obvious errors.
3944 if t_expr.references_error() || t_cast.references_error() {
3947 // Defer other checks until we're done type checking.
3948 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3949 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3951 deferred_cast_checks.push(cast_check);
3954 Err(ErrorReported) => {
3960 hir::ExprType(ref e, ref t) => {
3961 let typ = self.to_ty(&t);
3962 self.check_expr_eq_type(&e, typ);
3965 hir::ExprArray(ref args) => {
3966 let uty = expected.to_option(self).and_then(|uty| {
3968 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3973 let element_ty = if !args.is_empty() {
3974 let coerce_to = uty.unwrap_or_else(
3975 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3976 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3977 assert_eq!(self.diverges.get(), Diverges::Maybe);
3979 let e_ty = self.check_expr_with_hint(e, coerce_to);
3980 let cause = self.misc(e.span);
3981 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3983 coerce.complete(self)
3985 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3987 tcx.mk_array(element_ty, args.len() as u64)
3989 hir::ExprRepeat(ref element, count) => {
3990 let count_def_id = tcx.hir.body_owner_def_id(count);
3991 let param_env = ty::ParamEnv::empty(traits::Reveal::UserFacing);
3992 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
3993 let count = tcx.const_eval(param_env.and((count_def_id, substs)));
3995 if let Err(ref err) = count {
3996 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
3999 let uty = match expected {
4000 ExpectHasType(uty) => {
4002 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4009 let (element_ty, t) = match uty {
4011 self.check_expr_coercable_to_type(&element, uty);
4015 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4016 let element_ty = self.check_expr_has_type_or_error(&element, t);
4021 if let Ok(count) = count {
4022 let zero_or_one = count.val.to_const_int().and_then(|count| {
4023 count.to_u64().map(|count| count <= 1)
4024 }).unwrap_or(false);
4026 // For [foo, ..n] where n > 1, `foo` must have
4028 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4029 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4033 if element_ty.references_error() {
4035 } else if let Ok(count) = count {
4036 tcx.mk_ty(ty::TyArray(t, count))
4041 hir::ExprTup(ref elts) => {
4042 let flds = expected.only_has_type(self).and_then(|ty| {
4043 let ty = self.resolve_type_vars_with_obligations(ty);
4045 ty::TyTuple(ref flds, _) => Some(&flds[..]),
4050 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4051 let t = match flds {
4052 Some(ref fs) if i < fs.len() => {
4054 self.check_expr_coercable_to_type(&e, ety);
4058 self.check_expr_with_expectation(&e, NoExpectation)
4063 let tuple = tcx.mk_tup(elt_ts_iter, false);
4064 if tuple.references_error() {
4067 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4071 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4072 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4074 hir::ExprField(ref base, ref field) => {
4075 self.check_field(expr, needs, &base, field)
4077 hir::ExprTupField(ref base, idx) => {
4078 self.check_tup_field(expr, needs, &base, idx)
4080 hir::ExprIndex(ref base, ref idx) => {
4081 let base_t = self.check_expr_with_needs(&base, needs);
4082 let idx_t = self.check_expr(&idx);
4084 if base_t.references_error() {
4086 } else if idx_t.references_error() {
4089 let base_t = self.structurally_resolved_type(expr.span, base_t);
4090 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4091 Some((index_ty, element_ty)) => {
4092 self.demand_coerce(idx, idx_t, index_ty);
4096 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4097 "cannot index into a value of type `{}`",
4099 // Try to give some advice about indexing tuples.
4100 if let ty::TyTuple(..) = base_t.sty {
4101 let mut needs_note = true;
4102 // If the index is an integer, we can show the actual
4103 // fixed expression:
4104 if let hir::ExprLit(ref lit) = idx.node {
4105 if let ast::LitKind::Int(i,
4106 ast::LitIntType::Unsuffixed) = lit.node {
4107 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4108 if let Ok(snip) = snip {
4109 err.span_suggestion(expr.span,
4110 "to access tuple elements, use",
4111 format!("{}.{}", snip, i));
4117 err.help("to access tuple elements, use tuple indexing \
4118 syntax (e.g. `tuple.0`)");
4127 hir::ExprYield(ref value) => {
4128 match self.yield_ty {
4130 self.check_expr_coercable_to_type(&value, ty);
4133 struct_span_err!(self.tcx.sess, expr.span, E0627,
4134 "yield statement outside of generator literal").emit();
4142 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4143 // The newly resolved definition is written into `type_dependent_defs`.
4144 fn finish_resolving_struct_path(&self,
4147 node_id: ast::NodeId)
4151 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4152 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4153 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4156 hir::QPath::TypeRelative(ref qself, ref segment) => {
4157 let ty = self.to_ty(qself);
4159 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4164 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4167 // Write back the new resolution.
4168 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4169 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4176 // Resolve associated value path into a base type and associated constant or method definition.
4177 // The newly resolved definition is written into `type_dependent_defs`.
4178 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4179 qpath: &'b hir::QPath,
4180 node_id: ast::NodeId,
4182 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4184 let (ty, item_segment) = match *qpath {
4185 hir::QPath::Resolved(ref opt_qself, ref path) => {
4187 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4188 &path.segments[..]);
4190 hir::QPath::TypeRelative(ref qself, ref segment) => {
4191 (self.to_ty(qself), segment)
4194 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4195 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4196 // Return directly on cache hit. This is useful to avoid doubly reporting
4197 // errors with default match binding modes. See #44614.
4198 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4200 let item_name = item_segment.name;
4201 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4204 let def = match error {
4205 method::MethodError::PrivateMatch(def, _) => def,
4208 if item_name != keywords::Invalid.name() {
4209 self.report_method_error(span, ty, item_name, None, error, None);
4215 // Write back the new resolution.
4216 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4217 (def, Some(ty), slice::from_ref(&**item_segment))
4220 pub fn check_decl_initializer(&self,
4221 local: &'gcx hir::Local,
4222 init: &'gcx hir::Expr) -> Ty<'tcx>
4224 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4225 // for #42640 (default match binding modes).
4228 let ref_bindings = local.pat.contains_explicit_ref_binding();
4230 let local_ty = self.local_ty(init.span, local.id);
4231 if let Some(m) = ref_bindings {
4232 // Somewhat subtle: if we have a `ref` binding in the pattern,
4233 // we want to avoid introducing coercions for the RHS. This is
4234 // both because it helps preserve sanity and, in the case of
4235 // ref mut, for soundness (issue #23116). In particular, in
4236 // the latter case, we need to be clear that the type of the
4237 // referent for the reference that results is *equal to* the
4238 // type of the place it is referencing, and not some
4239 // supertype thereof.
4240 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4241 self.demand_eqtype(init.span, local_ty, init_ty);
4244 self.check_expr_coercable_to_type(init, local_ty)
4248 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4249 let t = self.local_ty(local.span, local.id);
4250 self.write_ty(local.hir_id, t);
4252 if let Some(ref init) = local.init {
4253 let init_ty = self.check_decl_initializer(local, &init);
4254 if init_ty.references_error() {
4255 self.write_ty(local.hir_id, init_ty);
4259 self.check_pat_walk(&local.pat, t,
4260 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4262 let pat_ty = self.node_ty(local.pat.hir_id);
4263 if pat_ty.references_error() {
4264 self.write_ty(local.hir_id, pat_ty);
4268 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4269 // Don't do all the complex logic below for DeclItem.
4271 hir::StmtDecl(ref decl, _) => {
4273 hir::DeclLocal(_) => {}
4274 hir::DeclItem(_) => {
4279 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4282 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4284 // Hide the outer diverging and has_errors flags.
4285 let old_diverges = self.diverges.get();
4286 let old_has_errors = self.has_errors.get();
4287 self.diverges.set(Diverges::Maybe);
4288 self.has_errors.set(false);
4291 hir::StmtDecl(ref decl, _) => {
4293 hir::DeclLocal(ref l) => {
4294 self.check_decl_local(&l);
4296 hir::DeclItem(_) => {/* ignore for now */}
4299 hir::StmtExpr(ref expr, _) => {
4300 // Check with expected type of ()
4301 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4303 hir::StmtSemi(ref expr, _) => {
4304 self.check_expr(&expr);
4308 // Combine the diverging and has_error flags.
4309 self.diverges.set(self.diverges.get() | old_diverges);
4310 self.has_errors.set(self.has_errors.get() | old_has_errors);
4313 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4314 let unit = self.tcx.mk_nil();
4315 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4317 // if the block produces a `!` value, that can always be
4318 // (effectively) coerced to unit.
4320 self.demand_suptype(blk.span, unit, ty);
4324 fn check_block_with_expected(&self,
4325 blk: &'gcx hir::Block,
4326 expected: Expectation<'tcx>) -> Ty<'tcx> {
4328 let mut fcx_ps = self.ps.borrow_mut();
4329 let unsafety_state = fcx_ps.recurse(blk);
4330 replace(&mut *fcx_ps, unsafety_state)
4333 // In some cases, blocks have just one exit, but other blocks
4334 // can be targeted by multiple breaks. This cannot happen in
4335 // normal Rust syntax today, but it can happen when we desugar
4336 // a `do catch { ... }` expression.
4340 // 'a: { if true { break 'a Err(()); } Ok(()) }
4342 // Here we would wind up with two coercions, one from
4343 // `Err(())` and the other from the tail expression
4344 // `Ok(())`. If the tail expression is omitted, that's a
4345 // "forced unit" -- unless the block diverges, in which
4346 // case we can ignore the tail expression (e.g., `'a: {
4347 // break 'a 22; }` would not force the type of the block
4349 let tail_expr = blk.expr.as_ref();
4350 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4351 let coerce = if blk.targeted_by_break {
4352 CoerceMany::new(coerce_to_ty)
4354 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4355 Some(e) => slice::from_ref(e),
4358 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4361 let prev_diverges = self.diverges.get();
4362 let ctxt = BreakableCtxt {
4363 coerce: Some(coerce),
4367 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4368 for s in &blk.stmts {
4372 // check the tail expression **without** holding the
4373 // `enclosing_breakables` lock below.
4374 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4376 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4377 let ctxt = enclosing_breakables.find_breakable(blk.id);
4378 let coerce = ctxt.coerce.as_mut().unwrap();
4379 if let Some(tail_expr_ty) = tail_expr_ty {
4380 let tail_expr = tail_expr.unwrap();
4381 let cause = self.cause(tail_expr.span,
4382 ObligationCauseCode::BlockTailExpression(blk.id));
4387 self.diverges.get());
4389 // Subtle: if there is no explicit tail expression,
4390 // that is typically equivalent to a tail expression
4391 // of `()` -- except if the block diverges. In that
4392 // case, there is no value supplied from the tail
4393 // expression (assuming there are no other breaks,
4394 // this implies that the type of the block will be
4397 // #41425 -- label the implicit `()` as being the
4398 // "found type" here, rather than the "expected type".
4400 // #44579 -- if the block was recovered during parsing,
4401 // the type would be nonsensical and it is not worth it
4402 // to perform the type check, so we avoid generating the
4403 // diagnostic output.
4404 if !self.diverges.get().always() && !blk.recovered {
4405 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4406 if let Some(expected_ty) = expected.only_has_type(self) {
4407 self.consider_hint_about_removing_semicolon(blk,
4417 // If we can break from the block, then the block's exit is always reachable
4418 // (... as long as the entry is reachable) - regardless of the tail of the block.
4419 self.diverges.set(prev_diverges);
4422 let mut ty = ctxt.coerce.unwrap().complete(self);
4424 if self.has_errors.get() || ty.references_error() {
4425 ty = self.tcx.types.err
4428 self.write_ty(blk.hir_id, ty);
4430 *self.ps.borrow_mut() = prev;
4434 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4435 /// suggestion can be made, `None` otherwise.
4436 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4437 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4438 // `while` before reaching it, as block tail returns are not available in them.
4439 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4440 let parent = self.tcx.hir.get(fn_id);
4442 if let Node::NodeItem(&hir::Item {
4443 name, node: hir::ItemFn(ref decl, ..), ..
4445 decl.clone().and_then(|decl| {
4446 // This is less than ideal, it will not suggest a return type span on any
4447 // method called `main`, regardless of whether it is actually the entry point,
4448 // but it will still present it as the reason for the expected type.
4449 Some((decl, name != Symbol::intern("main")))
4451 } else if let Node::NodeTraitItem(&hir::TraitItem {
4452 node: hir::TraitItemKind::Method(hir::MethodSig {
4456 decl.clone().and_then(|decl| {
4459 } else if let Node::NodeImplItem(&hir::ImplItem {
4460 node: hir::ImplItemKind::Method(hir::MethodSig {
4464 decl.clone().and_then(|decl| {
4475 /// On implicit return expressions with mismatched types, provide the following suggestions:
4477 /// - Point out the method's return type as the reason for the expected type
4478 /// - Possible missing semicolon
4479 /// - Possible missing return type if the return type is the default, and not `fn main()`
4480 pub fn suggest_mismatched_types_on_tail(&self,
4481 err: &mut DiagnosticBuilder<'tcx>,
4482 expression: &'gcx hir::Expr,
4486 blk_id: ast::NodeId) {
4487 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4489 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4490 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4494 /// A common error is to forget to add a semicolon at the end of a block:
4498 /// bar_that_returns_u32()
4502 /// This routine checks if the return expression in a block would make sense on its own as a
4503 /// statement and the return type has been left as default or has been specified as `()`. If so,
4504 /// it suggests adding a semicolon.
4505 fn suggest_missing_semicolon(&self,
4506 err: &mut DiagnosticBuilder<'tcx>,
4507 expression: &'gcx hir::Expr,
4510 if expected.is_nil() {
4511 // `BlockTailExpression` only relevant if the tail expr would be
4512 // useful on its own.
4513 match expression.node {
4515 hir::ExprMethodCall(..) |
4517 hir::ExprWhile(..) |
4519 hir::ExprMatch(..) |
4520 hir::ExprBlock(..) => {
4521 let sp = self.tcx.sess.codemap().next_point(cause_span);
4522 err.span_suggestion(sp,
4523 "try adding a semicolon",
4532 /// A possible error is to forget to add a return type that is needed:
4536 /// bar_that_returns_u32()
4540 /// This routine checks if the return type is left as default, the method is not part of an
4541 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4543 fn suggest_missing_return_type(&self,
4544 err: &mut DiagnosticBuilder<'tcx>,
4545 fn_decl: &hir::FnDecl,
4548 can_suggest: bool) {
4549 // Only suggest changing the return type for methods that
4550 // haven't set a return type at all (and aren't `fn main()` or an impl).
4551 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4552 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4553 err.span_suggestion(span,
4554 "try adding a return type",
4556 self.resolve_type_vars_with_obligations(found)));
4558 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4559 err.span_label(span, "possibly return type missing here?");
4561 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4562 // `fn main()` must return `()`, do not suggest changing return type
4563 err.span_label(span, "expected `()` because of default return type");
4565 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4566 // Only point to return type if the expected type is the return type, as if they
4567 // are not, the expectation must have been caused by something else.
4568 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4570 let ty = AstConv::ast_ty_to_ty(self, ty);
4571 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4572 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4573 if ty.sty == expected.sty {
4574 err.span_label(sp, format!("expected `{}` because of return type",
4582 /// A common error is to add an extra semicolon:
4585 /// fn foo() -> usize {
4590 /// This routine checks if the final statement in a block is an
4591 /// expression with an explicit semicolon whose type is compatible
4592 /// with `expected_ty`. If so, it suggests removing the semicolon.
4593 fn consider_hint_about_removing_semicolon(&self,
4594 blk: &'gcx hir::Block,
4595 expected_ty: Ty<'tcx>,
4596 err: &mut DiagnosticBuilder) {
4597 // Be helpful when the user wrote `{... expr;}` and
4598 // taking the `;` off is enough to fix the error.
4599 let last_stmt = match blk.stmts.last() {
4603 let last_expr = match last_stmt.node {
4604 hir::StmtSemi(ref e, _) => e,
4607 let last_expr_ty = self.node_ty(last_expr.hir_id);
4608 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4611 let original_span = original_sp(last_stmt.span, blk.span);
4612 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4613 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4616 // Instantiates the given path, which must refer to an item with the given
4617 // number of type parameters and type.
4618 pub fn instantiate_value_path(&self,
4619 segments: &[hir::PathSegment],
4620 opt_self_ty: Option<Ty<'tcx>>,
4623 node_id: ast::NodeId)
4625 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4630 // We need to extract the type parameters supplied by the user in
4631 // the path `path`. Due to the current setup, this is a bit of a
4632 // tricky-process; the problem is that resolve only tells us the
4633 // end-point of the path resolution, and not the intermediate steps.
4634 // Luckily, we can (at least for now) deduce the intermediate steps
4635 // just from the end-point.
4637 // There are basically four cases to consider:
4639 // 1. Reference to a constructor of enum variant or struct:
4641 // struct Foo<T>(...)
4642 // enum E<T> { Foo(...) }
4644 // In these cases, the parameters are declared in the type
4647 // 2. Reference to a fn item or a free constant:
4651 // In this case, the path will again always have the form
4652 // `a::b::foo::<T>` where only the final segment should have
4653 // type parameters. However, in this case, those parameters are
4654 // declared on a value, and hence are in the `FnSpace`.
4656 // 3. Reference to a method or an associated constant:
4658 // impl<A> SomeStruct<A> {
4662 // Here we can have a path like
4663 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4664 // may appear in two places. The penultimate segment,
4665 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4666 // final segment, `foo::<B>` contains parameters in fn space.
4668 // 4. Reference to a local variable
4670 // Local variables can't have any type parameters.
4672 // The first step then is to categorize the segments appropriately.
4674 assert!(!segments.is_empty());
4676 let mut ufcs_associated = None;
4677 let mut type_segment = None;
4678 let mut fn_segment = None;
4680 // Case 1. Reference to a struct/variant constructor.
4681 Def::StructCtor(def_id, ..) |
4682 Def::VariantCtor(def_id, ..) => {
4683 // Everything but the final segment should have no
4684 // parameters at all.
4685 let mut generics = self.tcx.generics_of(def_id);
4686 if let Some(def_id) = generics.parent {
4687 // Variant and struct constructors use the
4688 // generics of their parent type definition.
4689 generics = self.tcx.generics_of(def_id);
4691 type_segment = Some((segments.last().unwrap(), generics));
4694 // Case 2. Reference to a top-level value.
4696 Def::Const(def_id) |
4697 Def::Static(def_id, _) => {
4698 fn_segment = Some((segments.last().unwrap(),
4699 self.tcx.generics_of(def_id)));
4702 // Case 3. Reference to a method or associated const.
4703 Def::Method(def_id) |
4704 Def::AssociatedConst(def_id) => {
4705 let container = self.tcx.associated_item(def_id).container;
4707 ty::TraitContainer(trait_did) => {
4708 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4710 ty::ImplContainer(_) => {}
4713 let generics = self.tcx.generics_of(def_id);
4714 if segments.len() >= 2 {
4715 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4716 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4718 // `<T>::assoc` will end up here, and so can `T::assoc`.
4719 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4720 ufcs_associated = Some((container, self_ty));
4722 fn_segment = Some((segments.last().unwrap(), generics));
4725 // Case 4. Local variable, no generics.
4726 Def::Local(..) | Def::Upvar(..) => {}
4728 _ => bug!("unexpected definition: {:?}", def),
4731 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4733 // Now that we have categorized what space the parameters for each
4734 // segment belong to, let's sort out the parameters that the user
4735 // provided (if any) into their appropriate spaces. We'll also report
4736 // errors if type parameters are provided in an inappropriate place.
4737 let poly_segments = type_segment.is_some() as usize +
4738 fn_segment.is_some() as usize;
4739 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4742 Def::Local(nid) | Def::Upvar(nid, ..) => {
4743 let ty = self.local_ty(span, nid);
4744 let ty = self.normalize_associated_types_in(span, &ty);
4745 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4751 // Now we have to compare the types that the user *actually*
4752 // provided against the types that were *expected*. If the user
4753 // did not provide any types, then we want to substitute inference
4754 // variables. If the user provided some types, we may still need
4755 // to add defaults. If the user provided *too many* types, that's
4757 self.check_path_parameter_count(span, &mut type_segment, false);
4758 self.check_path_parameter_count(span, &mut fn_segment, false);
4759 self.check_impl_trait(span, &mut fn_segment);
4761 let (fn_start, has_self) = match (type_segment, fn_segment) {
4762 (_, Some((_, generics))) => {
4763 (generics.parent_count(), generics.has_self)
4765 (Some((_, generics)), None) => {
4766 (generics.own_count(), generics.has_self)
4768 (None, None) => (0, false)
4770 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4771 let mut i = def.index as usize;
4773 let segment = if i < fn_start {
4774 i -= has_self as usize;
4780 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4781 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4784 if let Some(lifetime) = lifetimes.get(i) {
4785 AstConv::ast_region_to_region(self, lifetime, Some(def))
4787 self.re_infer(span, Some(def)).unwrap()
4790 let mut i = def.index as usize;
4792 let segment = if i < fn_start {
4793 // Handle Self first, so we can adjust the index to match the AST.
4794 if has_self && i == 0 {
4795 return opt_self_ty.unwrap_or_else(|| {
4796 self.type_var_for_def(span, def, substs)
4799 i -= has_self as usize;
4805 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4806 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4809 // Skip over the lifetimes in the same segment.
4810 if let Some((_, generics)) = segment {
4811 i -= generics.regions.len();
4814 if let Some(ast_ty) = types.get(i) {
4815 // A provided type parameter.
4817 } else if !infer_types && def.has_default {
4818 // No type parameter provided, but a default exists.
4819 let default = self.tcx.type_of(def.def_id);
4822 default.subst_spanned(self.tcx, substs, Some(span))
4825 // No type parameters were provided, we can infer all.
4826 // This can also be reached in some error cases:
4827 // We prefer to use inference variables instead of
4828 // TyError to let type inference recover somewhat.
4829 self.type_var_for_def(span, def, substs)
4833 // The things we are substituting into the type should not contain
4834 // escaping late-bound regions, and nor should the base type scheme.
4835 let ty = self.tcx.type_of(def.def_id());
4836 assert!(!substs.has_escaping_regions());
4837 assert!(!ty.has_escaping_regions());
4839 // Add all the obligations that are required, substituting and
4840 // normalized appropriately.
4841 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4842 self.add_obligations_for_parameters(
4843 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4846 // Substitute the values for the type parameters into the type of
4847 // the referenced item.
4848 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4850 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4851 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4852 // is inherent, there is no `Self` parameter, instead, the impl needs
4853 // type parameters, which we can infer by unifying the provided `Self`
4854 // with the substituted impl type.
4855 let ty = self.tcx.type_of(impl_def_id);
4857 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4858 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4859 Ok(ok) => self.register_infer_ok_obligations(ok),
4862 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4869 self.check_rustc_args_require_const(def.def_id(), node_id, span);
4871 debug!("instantiate_value_path: type of {:?} is {:?}",
4874 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4878 fn check_rustc_args_require_const(&self,
4880 node_id: ast::NodeId,
4882 // We're only interested in functions tagged with
4883 // #[rustc_args_required_const], so ignore anything that's not.
4884 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
4888 // If our calling expression is indeed the function itself, we're good!
4889 // If not, generate an error that this can only be called directly.
4890 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
4891 Node::NodeExpr(expr) => {
4893 hir::ExprCall(ref callee, ..) => {
4894 if callee.id == node_id {
4904 self.tcx.sess.span_err(span, "this function can only be invoked \
4905 directly, not through a function pointer");
4908 /// Report errors if the provided parameters are too few or too many.
4909 fn check_path_parameter_count(&self,
4911 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4912 is_method_call: bool) {
4913 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4914 (&[][..], &[][..], true, &[][..]),
4915 |(s, _)| s.parameters.as_ref().map_or(
4916 (&[][..], &[][..], s.infer_types, &[][..]),
4917 |p| (&p.lifetimes[..], &p.types[..],
4918 s.infer_types, &p.bindings[..])));
4919 let infer_lifetimes = lifetimes.len() == 0;
4921 let count_lifetime_params = |n| {
4922 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4924 let count_type_params = |n| {
4925 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4928 // Check provided type parameters.
4929 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4930 if generics.parent.is_none() {
4931 &generics.types[generics.has_self as usize..]
4936 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4937 if types.len() > type_defs.len() {
4938 let span = types[type_defs.len()].span;
4939 let expected_text = count_type_params(type_defs.len());
4940 let actual_text = count_type_params(types.len());
4941 struct_span_err!(self.tcx.sess, span, E0087,
4942 "too many type parameters provided: \
4943 expected at most {}, found {}",
4944 expected_text, actual_text)
4945 .span_label(span, format!("expected {}", expected_text))
4948 // To prevent derived errors to accumulate due to extra
4949 // type parameters, we force instantiate_value_path to
4950 // use inference variables instead of the provided types.
4952 } else if types.len() < required_len && !infer_types {
4953 let expected_text = count_type_params(required_len);
4954 let actual_text = count_type_params(types.len());
4955 struct_span_err!(self.tcx.sess, span, E0089,
4956 "too few type parameters provided: \
4957 expected {}, found {}",
4958 expected_text, actual_text)
4959 .span_label(span, format!("expected {}", expected_text))
4963 if !bindings.is_empty() {
4964 AstConv::prohibit_projection(self, bindings[0].span);
4967 // Check provided lifetime parameters.
4968 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4969 let required_len = lifetime_defs.len();
4971 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4972 let has_late_bound_lifetime_defs =
4973 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4974 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4975 // Report this as a lint only if no error was reported previously.
4976 let primary_msg = "cannot specify lifetime arguments explicitly \
4977 if late bound lifetime parameters are present";
4978 let note_msg = "the late bound lifetime parameter is introduced here";
4979 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4980 lifetimes.len() < required_len && !infer_lifetimes) {
4981 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4982 err.span_note(span_late, note_msg);
4986 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4987 multispan.push_span_label(span_late, note_msg.to_string());
4988 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4989 lifetimes[0].id, multispan, primary_msg);
4994 if lifetimes.len() > lifetime_defs.len() {
4995 let span = lifetimes[lifetime_defs.len()].span;
4996 let expected_text = count_lifetime_params(lifetime_defs.len());
4997 let actual_text = count_lifetime_params(lifetimes.len());
4998 struct_span_err!(self.tcx.sess, span, E0088,
4999 "too many lifetime parameters provided: \
5000 expected at most {}, found {}",
5001 expected_text, actual_text)
5002 .span_label(span, format!("expected {}", expected_text))
5004 } else if lifetimes.len() < required_len && !infer_lifetimes {
5005 let expected_text = count_lifetime_params(lifetime_defs.len());
5006 let actual_text = count_lifetime_params(lifetimes.len());
5007 struct_span_err!(self.tcx.sess, span, E0090,
5008 "too few lifetime parameters provided: \
5009 expected {}, found {}",
5010 expected_text, actual_text)
5011 .span_label(span, format!("expected {}", expected_text))
5016 /// Report error if there is an explicit type parameter when using `impl Trait`.
5017 fn check_impl_trait(&self,
5019 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
5020 use hir::SyntheticTyParamKind::*;
5022 segment.map(|(path_segment, generics)| {
5023 let explicit = !path_segment.infer_types;
5024 let impl_trait = generics.types.iter()
5026 match ty_param.synthetic {
5027 Some(ImplTrait) => true,
5032 if explicit && impl_trait {
5033 let mut err = struct_span_err! {
5037 "cannot provide explicit type parameters when `impl Trait` is \
5038 used in argument position."
5046 // Resolves `typ` by a single level if `typ` is a type variable.
5047 // If no resolution is possible, then an error is reported.
5048 // Numeric inference variables may be left unresolved.
5049 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5050 let ty = self.resolve_type_vars_with_obligations(ty);
5051 if !ty.is_ty_var() {
5054 if !self.is_tainted_by_errors() {
5055 type_error_struct!(self.tcx.sess, sp, ty, E0619,
5056 "the type of this value must be known in this context")
5059 self.demand_suptype(sp, self.tcx.types.err, ty);
5064 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5065 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5066 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5069 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5070 index = enclosing_breakables.stack.len();
5071 enclosing_breakables.by_id.insert(id, index);
5072 enclosing_breakables.stack.push(ctxt);
5076 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5077 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5078 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5079 enclosing_breakables.stack.pop().expect("missing breakable context")
5085 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5086 generics: &hir::Generics,
5088 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5089 generics.ty_params().count(), ty);
5091 // make a vector of booleans initially false, set to true when used
5092 if generics.ty_params().next().is_none() { return; }
5093 let mut tps_used = vec![false; generics.ty_params().count()];
5095 let lifetime_count = generics.lifetimes().count();
5097 for leaf_ty in ty.walk() {
5098 if let ty::TyParam(ty::ParamTy {idx, ..}) = leaf_ty.sty {
5099 debug!("Found use of ty param num {}", idx);
5100 tps_used[idx as usize - lifetime_count] = true;
5101 } else if let ty::TyError = leaf_ty.sty {
5102 // If there already another error, do not emit an error for not using a type Parameter
5103 assert!(tcx.sess.err_count() > 0);
5108 for (&used, param) in tps_used.iter().zip(generics.ty_params()) {
5110 struct_span_err!(tcx.sess, param.span, E0091,
5111 "type parameter `{}` is unused",
5113 .span_label(param.span, "unused type parameter")
5119 fn fatally_break_rust(sess: &Session) {
5120 let handler = sess.diagnostic();
5121 handler.span_bug_no_panic(
5123 "It looks like you're trying to break rust; would you like some ICE?",
5125 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5126 handler.note_without_error(
5127 "we would appreciate a joke overview: \
5128 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5130 handler.note_without_error(&format!("rustc {} running on {}",
5131 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5132 ::session::config::host_triple(),