5 Within the check phase of type check, we check each item one at a time
6 (bodies of function expressions are checked as part of the containing
7 function). Inference is used to supply types wherever they are unknown.
9 By far the most complex case is checking the body of a function. This
10 can be broken down into several distinct phases:
12 - gather: creates type variables to represent the type of each local
13 variable and pattern binding.
15 - main: the main pass does the lion's share of the work: it
16 determines the types of all expressions, resolves
17 methods, checks for most invalid conditions, and so forth. In
18 some cases, where a type is unknown, it may create a type or region
19 variable and use that as the type of an expression.
21 In the process of checking, various constraints will be placed on
22 these type variables through the subtyping relationships requested
23 through the `demand` module. The `infer` module is in charge
24 of resolving those constraints.
26 - regionck: after main is complete, the regionck pass goes over all
27 types looking for regions and making sure that they did not escape
28 into places they are not in scope. This may also influence the
29 final assignments of the various region variables if there is some
32 - vtable: find and records the impls to use for each trait bound that
33 appears on a type parameter.
35 - writeback: writes the final types within a function body, replacing
36 type variables with their final inferred types. These final types
37 are written into the `tcx.node_types` table, which should *never* contain
38 any reference to a type variable.
42 While type checking a function, the intermediate types for the
43 expressions, blocks, and so forth contained within the function are
44 stored in `fcx.node_types` and `fcx.node_substs`. These types
45 may contain unresolved type variables. After type checking is
46 complete, the functions in the writeback module are used to take the
47 types from this table, resolve them, and then write them into their
48 permanent home in the type context `tcx`.
50 This means that during inferencing you should use `fcx.write_ty()`
51 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
52 nodes within the function.
54 The types of top-level items, which never contain unbound type
55 variables, are stored directly into the `tcx` tables.
57 N.B., a type variable is not the same thing as a type parameter. A
58 type variable is rather an "instance" of a type parameter: that is,
59 given a generic function `fn foo<T>(t: T)`: while checking the
60 function `foo`, the type `ty_param(0)` refers to the type `T`, which
61 is treated in abstract. When `foo()` is called, however, `T` will be
62 substituted for a fresh type variable `N`. This variable will
63 eventually be resolved to some concrete type (which might itself be
82 mod generator_interior;
86 use crate::astconv::{AstConv, PathSeg};
87 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
88 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
89 use rustc::hir::def::{CtorOf, CtorKind, Def};
90 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
92 use rustc::hir::itemlikevisit::ItemLikeVisitor;
93 use crate::middle::lang_items;
94 use crate::namespace::Namespace;
95 use rustc::infer::{self, InferCtxt, InferOk, InferResult, RegionVariableOrigin};
96 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
97 use rustc_data_structures::indexed_vec::Idx;
98 use rustc_data_structures::sync::Lrc;
99 use rustc_target::spec::abi::Abi;
100 use rustc::infer::opaque_types::OpaqueTypeDecl;
101 use rustc::infer::type_variable::{TypeVariableOrigin};
102 use rustc::middle::region;
103 use rustc::mir::interpret::{ConstValue, GlobalId};
104 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
106 self, AdtKind, CanonicalUserType, Ty, TyCtxt, GenericParamDefKind, Visibility,
107 ToPolyTraitRef, ToPredicate, RegionKind, UserType
109 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
110 use rustc::ty::fold::TypeFoldable;
111 use rustc::ty::query::Providers;
112 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
113 use rustc::ty::util::{Representability, IntTypeExt, Discr};
114 use rustc::ty::layout::VariantIdx;
115 use syntax_pos::{self, BytePos, Span, MultiSpan};
118 use syntax::feature_gate::{GateIssue, emit_feature_err};
120 use syntax::source_map::{DUMMY_SP, original_sp};
121 use syntax::symbol::{Symbol, LocalInternedString, keywords};
122 use syntax::util::lev_distance::find_best_match_for_name;
124 use std::cell::{Cell, RefCell, Ref, RefMut};
125 use std::collections::hash_map::Entry;
127 use std::fmt::Display;
129 use std::mem::replace;
130 use std::ops::{self, Deref};
133 use crate::require_c_abi_if_c_variadic;
134 use crate::session::Session;
135 use crate::session::config::EntryFnType;
136 use crate::TypeAndSubsts;
138 use crate::util::captures::Captures;
139 use crate::util::common::{ErrorReported, indenter};
140 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap};
142 pub use self::Expectation::*;
143 use self::autoderef::Autoderef;
144 use self::callee::DeferredCallResolution;
145 use self::coercion::{CoerceMany, DynamicCoerceMany};
146 pub use self::compare_method::{compare_impl_method, compare_const_impl};
147 use self::method::{MethodCallee, SelfSource};
148 use self::TupleArgumentsFlag::*;
150 /// The type of a local binding, including the revealed type for anon types.
151 #[derive(Copy, Clone)]
152 pub struct LocalTy<'tcx> {
154 revealed_ty: Ty<'tcx>
157 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
158 #[derive(Copy, Clone)]
159 struct MaybeInProgressTables<'a, 'tcx: 'a> {
160 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
163 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
164 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
165 match self.maybe_tables {
166 Some(tables) => tables.borrow(),
168 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
173 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
174 match self.maybe_tables {
175 Some(tables) => tables.borrow_mut(),
177 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
183 /// Closures defined within the function. For example:
186 /// bar(move|| { ... })
189 /// Here, the function `foo()` and the closure passed to
190 /// `bar()` will each have their own `FnCtxt`, but they will
191 /// share the inherited fields.
192 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
193 infcx: InferCtxt<'a, 'gcx, 'tcx>,
195 tables: MaybeInProgressTables<'a, 'tcx>,
197 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
199 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
201 // Some additional `Sized` obligations badly affect type inference.
202 // These obligations are added in a later stage of typeck.
203 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
205 // When we process a call like `c()` where `c` is a closure type,
206 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
207 // `FnOnce` closure. In that case, we defer full resolution of the
208 // call until upvar inference can kick in and make the
209 // decision. We keep these deferred resolutions grouped by the
210 // def-id of the closure, so that once we decide, we can easily go
211 // back and process them.
212 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
214 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
216 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
218 // Opaque types found in explicit return types and their
219 // associated fresh inference variable. Writeback resolves these
220 // variables to get the concrete type, which can be used to
221 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
222 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
224 /// Each type parameter has an implicit region bound that
225 /// indicates it must outlive at least the function body (the user
226 /// may specify stronger requirements). This field indicates the
227 /// region of the callee. If it is `None`, then the parameter
228 /// environment is for an item or something where the "callee" is
230 implicit_region_bound: Option<ty::Region<'tcx>>,
232 body_id: Option<hir::BodyId>,
235 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
236 type Target = InferCtxt<'a, 'gcx, 'tcx>;
237 fn deref(&self) -> &Self::Target {
242 /// When type-checking an expression, we propagate downward
243 /// whatever type hint we are able in the form of an `Expectation`.
244 #[derive(Copy, Clone, Debug)]
245 pub enum Expectation<'tcx> {
246 /// We know nothing about what type this expression should have.
249 /// This expression is an `if` condition, it must resolve to `bool`.
252 /// This expression should have the type given (or some subtype).
253 ExpectHasType(Ty<'tcx>),
255 /// This expression will be cast to the `Ty`.
256 ExpectCastableToType(Ty<'tcx>),
258 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
259 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
260 ExpectRvalueLikeUnsized(Ty<'tcx>),
263 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
264 // Disregard "castable to" expectations because they
265 // can lead us astray. Consider for example `if cond
266 // {22} else {c} as u8` -- if we propagate the
267 // "castable to u8" constraint to 22, it will pick the
268 // type 22u8, which is overly constrained (c might not
269 // be a u8). In effect, the problem is that the
270 // "castable to" expectation is not the tightest thing
271 // we can say, so we want to drop it in this case.
272 // The tightest thing we can say is "must unify with
273 // else branch". Note that in the case of a "has type"
274 // constraint, this limitation does not hold.
276 // If the expected type is just a type variable, then don't use
277 // an expected type. Otherwise, we might write parts of the type
278 // when checking the 'then' block which are incompatible with the
280 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
282 ExpectHasType(ety) => {
283 let ety = fcx.shallow_resolve(ety);
284 if !ety.is_ty_var() {
290 ExpectRvalueLikeUnsized(ety) => {
291 ExpectRvalueLikeUnsized(ety)
297 /// Provides an expectation for an rvalue expression given an *optional*
298 /// hint, which is not required for type safety (the resulting type might
299 /// be checked higher up, as is the case with `&expr` and `box expr`), but
300 /// is useful in determining the concrete type.
302 /// The primary use case is where the expected type is a fat pointer,
303 /// like `&[isize]`. For example, consider the following statement:
305 /// let x: &[isize] = &[1, 2, 3];
307 /// In this case, the expected type for the `&[1, 2, 3]` expression is
308 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
309 /// expectation `ExpectHasType([isize])`, that would be too strong --
310 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
311 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
312 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
313 /// which still is useful, because it informs integer literals and the like.
314 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
315 /// for examples of where this comes up,.
316 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
317 match fcx.tcx.struct_tail(ty).sty {
318 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
319 ExpectRvalueLikeUnsized(ty)
321 _ => ExpectHasType(ty)
325 // Resolves `expected` by a single level if it is a variable. If
326 // there is no expected type or resolution is not possible (e.g.,
327 // no constraints yet present), just returns `None`.
328 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
330 NoExpectation => NoExpectation,
331 ExpectIfCondition => ExpectIfCondition,
332 ExpectCastableToType(t) => {
333 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
335 ExpectHasType(t) => {
336 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
338 ExpectRvalueLikeUnsized(t) => {
339 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
344 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
345 match self.resolve(fcx) {
346 NoExpectation => None,
347 ExpectIfCondition => Some(fcx.tcx.types.bool),
348 ExpectCastableToType(ty) |
350 ExpectRvalueLikeUnsized(ty) => Some(ty),
354 /// It sometimes happens that we want to turn an expectation into
355 /// a **hard constraint** (i.e., something that must be satisfied
356 /// for the program to type-check). `only_has_type` will return
357 /// such a constraint, if it exists.
358 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
359 match self.resolve(fcx) {
360 ExpectHasType(ty) => Some(ty),
361 ExpectIfCondition => Some(fcx.tcx.types.bool),
362 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
366 /// Like `only_has_type`, but instead of returning `None` if no
367 /// hard constraint exists, creates a fresh type variable.
368 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
369 self.only_has_type(fcx)
370 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
374 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
381 fn maybe_mut_place(m: hir::Mutability) -> Self {
383 hir::MutMutable => Needs::MutPlace,
384 hir::MutImmutable => Needs::None,
389 #[derive(Copy, Clone)]
390 pub struct UnsafetyState {
392 pub unsafety: hir::Unsafety,
393 pub unsafe_push_count: u32,
398 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
399 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
402 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
403 match self.unsafety {
404 // If this unsafe, then if the outer function was already marked as
405 // unsafe we shouldn't attribute the unsafe'ness to the block. This
406 // way the block can be warned about instead of ignoring this
407 // extraneous block (functions are never warned about).
408 hir::Unsafety::Unsafe if self.from_fn => *self,
411 let (unsafety, def, count) = match blk.rules {
412 hir::PushUnsafeBlock(..) =>
413 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
414 hir::PopUnsafeBlock(..) =>
415 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
416 hir::UnsafeBlock(..) =>
417 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
419 (unsafety, self.def, self.unsafe_push_count),
423 unsafe_push_count: count,
430 #[derive(Debug, Copy, Clone)]
436 /// Tracks whether executing a node may exit normally (versus
437 /// return/break/panic, which "diverge", leaving dead code in their
438 /// wake). Tracked semi-automatically (through type variables marked
439 /// as diverging), with some manual adjustments for control-flow
440 /// primitives (approximating a CFG).
441 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
443 /// Potentially unknown, some cases converge,
444 /// others require a CFG to determine them.
447 /// Definitely known to diverge and therefore
448 /// not reach the next sibling or its parent.
451 /// Same as `Always` but with a reachability
452 /// warning already emitted.
456 // Convenience impls for combinig `Diverges`.
458 impl ops::BitAnd for Diverges {
460 fn bitand(self, other: Self) -> Self {
461 cmp::min(self, other)
465 impl ops::BitOr for Diverges {
467 fn bitor(self, other: Self) -> Self {
468 cmp::max(self, other)
472 impl ops::BitAndAssign for Diverges {
473 fn bitand_assign(&mut self, other: Self) {
474 *self = *self & other;
478 impl ops::BitOrAssign for Diverges {
479 fn bitor_assign(&mut self, other: Self) {
480 *self = *self | other;
485 fn always(self) -> bool {
486 self >= Diverges::Always
490 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
493 // this is `null` for loops where break with a value is illegal,
494 // such as `while`, `for`, and `while let`
495 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
498 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
499 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
500 by_id: HirIdMap<usize>,
503 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
504 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'gcx, 'tcx> {
505 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
506 bug!("could not find enclosing breakable with id {}", target_id);
512 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
515 /// The parameter environment used for proving trait obligations
516 /// in this function. This can change when we descend into
517 /// closures (as they bring new things into scope), hence it is
518 /// not part of `Inherited` (as of the time of this writing,
519 /// closures do not yet change the environment, but they will
521 param_env: ty::ParamEnv<'tcx>,
523 // Number of errors that had been reported when we started
524 // checking this function. On exit, if we find that *more* errors
525 // have been reported, we will skip regionck and other work that
526 // expects the types within the function to be consistent.
527 err_count_on_creation: usize,
529 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
530 ret_coercion_span: RefCell<Option<Span>>,
532 yield_ty: Option<Ty<'tcx>>,
534 ps: RefCell<UnsafetyState>,
536 /// Whether the last checked node generates a divergence (e.g.,
537 /// `return` will set this to `Always`). In general, when entering
538 /// an expression or other node in the tree, the initial value
539 /// indicates whether prior parts of the containing expression may
540 /// have diverged. It is then typically set to `Maybe` (and the
541 /// old value remembered) for processing the subparts of the
542 /// current expression. As each subpart is processed, they may set
543 /// the flag to `Always`, etc. Finally, at the end, we take the
544 /// result and "union" it with the original value, so that when we
545 /// return the flag indicates if any subpart of the parent
546 /// expression (up to and including this part) has diverged. So,
547 /// if you read it after evaluating a subexpression `X`, the value
548 /// you get indicates whether any subexpression that was
549 /// evaluating up to and including `X` diverged.
551 /// We currently use this flag only for diagnostic purposes:
553 /// - To warn about unreachable code: if, after processing a
554 /// sub-expression but before we have applied the effects of the
555 /// current node, we see that the flag is set to `Always`, we
556 /// can issue a warning. This corresponds to something like
557 /// `foo(return)`; we warn on the `foo()` expression. (We then
558 /// update the flag to `WarnedAlways` to suppress duplicate
559 /// reports.) Similarly, if we traverse to a fresh statement (or
560 /// tail expression) from a `Always` setting, we will issue a
561 /// warning. This corresponds to something like `{return;
562 /// foo();}` or `{return; 22}`, where we would warn on the
565 /// An expression represents dead code if, after checking it,
566 /// the diverges flag is set to something other than `Maybe`.
567 diverges: Cell<Diverges>,
569 /// Whether any child nodes have any type errors.
570 has_errors: Cell<bool>,
572 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
574 inh: &'a Inherited<'a, 'gcx, 'tcx>,
577 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
578 type Target = Inherited<'a, 'gcx, 'tcx>;
579 fn deref(&self) -> &Self::Target {
584 /// Helper type of a temporary returned by `Inherited::build(...)`.
585 /// Necessary because we can't write the following bound:
586 /// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>)`.
587 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
588 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
592 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
593 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
594 -> InheritedBuilder<'a, 'gcx, 'tcx> {
595 let hir_id_root = if def_id.is_local() {
596 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
597 DefId::local(hir_id.owner)
603 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
609 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
610 fn enter<F, R>(&'tcx mut self, f: F) -> R
611 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
613 let def_id = self.def_id;
614 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
618 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
619 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
621 let item_id = tcx.hir().as_local_hir_id(def_id);
622 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by_by_hir_id(id));
623 let implicit_region_bound = body_id.map(|body_id| {
624 let body = tcx.hir().body(body_id);
625 tcx.mk_region(ty::ReScope(region::Scope {
626 id: body.value.hir_id.local_id,
627 data: region::ScopeData::CallSite
632 tables: MaybeInProgressTables {
633 maybe_tables: infcx.in_progress_tables,
636 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
637 locals: RefCell::new(Default::default()),
638 deferred_sized_obligations: RefCell::new(Vec::new()),
639 deferred_call_resolutions: RefCell::new(Default::default()),
640 deferred_cast_checks: RefCell::new(Vec::new()),
641 deferred_generator_interiors: RefCell::new(Vec::new()),
642 opaque_types: RefCell::new(Default::default()),
643 implicit_region_bound,
648 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
649 debug!("register_predicate({:?})", obligation);
650 if obligation.has_escaping_bound_vars() {
651 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
656 .register_predicate_obligation(self, obligation);
659 fn register_predicates<I>(&self, obligations: I)
660 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
662 for obligation in obligations {
663 self.register_predicate(obligation);
667 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
668 self.register_predicates(infer_ok.obligations);
672 fn normalize_associated_types_in<T>(&self,
675 param_env: ty::ParamEnv<'tcx>,
677 where T : TypeFoldable<'tcx>
679 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
680 self.register_infer_ok_obligations(ok)
684 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
686 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
687 fn visit_item(&mut self, i: &'tcx hir::Item) {
688 check_item_type(self.tcx, i);
690 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
691 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
694 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
695 tcx.sess.track_errors(|| {
696 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
697 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
701 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
702 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
705 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) {
706 debug_assert!(crate_num == LOCAL_CRATE);
707 tcx.par_body_owners(|body_owner_def_id| {
708 tcx.ensure().typeck_tables_of(body_owner_def_id);
712 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
713 wfcheck::check_item_well_formed(tcx, def_id);
716 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
717 wfcheck::check_trait_item(tcx, def_id);
720 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
721 wfcheck::check_impl_item(tcx, def_id);
724 pub fn provide(providers: &mut Providers<'_>) {
725 method::provide(providers);
726 *providers = Providers {
732 check_item_well_formed,
733 check_trait_item_well_formed,
734 check_impl_item_well_formed,
735 check_mod_item_types,
740 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
742 -> Option<ty::Destructor> {
743 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
746 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
747 /// with information about it's body-id and fn-decl (if any). Otherwise,
750 /// If this function returns "some", then `typeck_tables(def_id)` will
751 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
752 /// may not succeed. In some cases where this function returns `None`
753 /// (notably closures), `typeck_tables(def_id)` would wind up
754 /// redirecting to the owning function.
755 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
757 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
759 match tcx.hir().get_by_hir_id(id) {
760 Node::Item(item) => {
762 hir::ItemKind::Const(_, body) |
763 hir::ItemKind::Static(_, _, body) =>
765 hir::ItemKind::Fn(ref decl, .., body) =>
766 Some((body, Some(decl))),
771 Node::TraitItem(item) => {
773 hir::TraitItemKind::Const(_, Some(body)) =>
775 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
776 Some((body, Some(&sig.decl))),
781 Node::ImplItem(item) => {
783 hir::ImplItemKind::Const(_, body) =>
785 hir::ImplItemKind::Method(ref sig, body) =>
786 Some((body, Some(&sig.decl))),
791 Node::AnonConst(constant) => Some((constant.body, None)),
796 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
799 // Closures' tables come from their outermost function,
800 // as they are part of the same "inference environment".
801 let outer_def_id = tcx.closure_base_def_id(def_id);
802 if outer_def_id != def_id {
803 return tcx.has_typeck_tables(outer_def_id);
806 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
807 primary_body_of(tcx, id).is_some()
810 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
813 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
816 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
818 -> &'tcx ty::TypeckTables<'tcx> {
819 // Closures' tables come from their outermost function,
820 // as they are part of the same "inference environment".
821 let outer_def_id = tcx.closure_base_def_id(def_id);
822 if outer_def_id != def_id {
823 return tcx.typeck_tables_of(outer_def_id);
826 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
827 let span = tcx.hir().span_by_hir_id(id);
829 // Figure out what primary body this item has.
830 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
831 span_bug!(span, "can't type-check body of {:?}", def_id);
833 let body = tcx.hir().body(body_id);
835 let tables = Inherited::build(tcx, def_id).enter(|inh| {
836 let param_env = tcx.param_env(def_id);
837 let fcx = if let Some(decl) = fn_decl {
838 let fn_sig = tcx.fn_sig(def_id);
840 check_abi(tcx, span, fn_sig.abi());
842 // Compute the fty from point of view of inside the fn.
844 tcx.liberate_late_bound_regions(def_id, &fn_sig);
846 inh.normalize_associated_types_in(body.value.span,
851 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
854 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
855 let expected_type = tcx.type_of(def_id);
856 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
857 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
859 let revealed_ty = if tcx.features().impl_trait_in_bindings {
860 fcx.instantiate_opaque_types_from_value(
868 // Gather locals in statics (because of block expressions).
869 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
871 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
876 // All type checking constraints were added, try to fallback unsolved variables.
877 fcx.select_obligations_where_possible(false);
878 let mut fallback_has_occurred = false;
879 for ty in &fcx.unsolved_variables() {
880 fallback_has_occurred |= fcx.fallback_if_possible(ty);
882 fcx.select_obligations_where_possible(fallback_has_occurred);
884 // Even though coercion casts provide type hints, we check casts after fallback for
885 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
888 // Closure and generator analysis may run after fallback
889 // because they don't constrain other type variables.
890 fcx.closure_analyze(body);
891 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
892 fcx.resolve_generator_interiors(def_id);
894 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
895 let ty = fcx.normalize_ty(span, ty);
896 fcx.require_type_is_sized(ty, span, code);
898 fcx.select_all_obligations_or_error();
900 if fn_decl.is_some() {
901 fcx.regionck_fn(id, body);
903 fcx.regionck_expr(body);
906 fcx.resolve_type_vars_in_body(body)
909 // Consistency check our TypeckTables instance can hold all ItemLocalIds
910 // it will need to hold.
911 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
916 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
917 if !tcx.sess.target.target.is_abi_supported(abi) {
918 struct_span_err!(tcx.sess, span, E0570,
919 "The ABI `{}` is not supported for the current target", abi).emit()
923 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
924 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
925 parent_id: hir::HirId,
928 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
929 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
932 // infer the variable's type
933 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
934 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
941 // take type that the user specified
942 self.fcx.locals.borrow_mut().insert(nid, typ);
949 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
950 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
951 NestedVisitorMap::None
954 // Add explicitly-declared locals.
955 fn visit_local(&mut self, local: &'gcx hir::Local) {
956 let local_ty = match local.ty {
958 let o_ty = self.fcx.to_ty(&ty);
960 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
961 self.fcx.instantiate_opaque_types_from_value(
969 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
970 &UserType::Ty(revealed_ty)
972 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
973 ty.hir_id, o_ty, revealed_ty, c_ty);
974 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
976 Some(LocalTy { decl_ty: o_ty, revealed_ty })
980 self.assign(local.span, local.hir_id, local_ty);
982 debug!("Local variable {:?} is assigned type {}",
984 self.fcx.ty_to_string(
985 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
986 intravisit::walk_local(self, local);
989 // Add pattern bindings.
990 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
991 if let PatKind::Binding(_, _, ident, _) = p.node {
992 let var_ty = self.assign(p.span, p.hir_id, None);
994 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
995 if !self.fcx.tcx.features().unsized_locals {
996 self.fcx.require_type_is_sized(var_ty, p.span,
997 traits::VariableType(node_id));
1000 debug!("Pattern binding {} is assigned to {} with type {:?}",
1002 self.fcx.ty_to_string(
1003 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1006 intravisit::walk_pat(self, p);
1009 // Don't descend into the bodies of nested closures
1010 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1011 _: hir::BodyId, _: Span, _: hir::HirId) { }
1014 /// When `check_fn` is invoked on a generator (i.e., a body that
1015 /// includes yield), it returns back some information about the yield
1017 struct GeneratorTypes<'tcx> {
1018 /// Type of value that is yielded.
1019 yield_ty: ty::Ty<'tcx>,
1021 /// Types that are captured (see `GeneratorInterior` for more).
1022 interior: ty::Ty<'tcx>,
1024 /// Indicates if the generator is movable or static (immovable).
1025 movability: hir::GeneratorMovability,
1028 /// Helper used for fns and closures. Does the grungy work of checking a function
1029 /// body and returns the function context used for that purpose, since in the case of a fn item
1030 /// there is still a bit more to do.
1033 /// * inherited: other fields inherited from the enclosing fn (if any)
1034 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1035 param_env: ty::ParamEnv<'tcx>,
1036 fn_sig: ty::FnSig<'tcx>,
1037 decl: &'gcx hir::FnDecl,
1039 body: &'gcx hir::Body,
1040 can_be_generator: Option<hir::GeneratorMovability>)
1041 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1043 let mut fn_sig = fn_sig.clone();
1045 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1047 // Create the function context. This is either derived from scratch or,
1048 // in the case of closures, based on the outer context.
1049 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1050 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1052 let declared_ret_ty = fn_sig.output();
1053 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1054 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1055 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1056 fn_sig = fcx.tcx.mk_fn_sig(
1057 fn_sig.inputs().iter().cloned(),
1064 let span = body.value.span;
1066 if body.is_generator && can_be_generator.is_some() {
1067 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1068 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1069 fcx.yield_ty = Some(yield_ty);
1072 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1073 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1074 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1076 // Add formal parameters.
1077 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1078 // Check the pattern.
1082 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
1086 // Check that argument is Sized.
1087 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1088 // for simple cases like `fn foo(x: Trait)`,
1089 // where we would error once on the parameter as a whole, and once on the binding `x`.
1090 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1091 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1094 fcx.write_ty(arg.hir_id, arg_ty);
1097 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1099 fcx.check_return_expr(&body.value);
1101 // We insert the deferred_generator_interiors entry after visiting the body.
1102 // This ensures that all nested generators appear before the entry of this generator.
1103 // resolve_generator_interiors relies on this property.
1104 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1105 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1106 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1107 Some(GeneratorTypes {
1108 yield_ty: fcx.yield_ty.unwrap(),
1110 movability: can_be_generator.unwrap(),
1116 // Finalize the return check by taking the LUB of the return types
1117 // we saw and assigning it to the expected return type. This isn't
1118 // really expected to fail, since the coercions would have failed
1119 // earlier when trying to find a LUB.
1121 // However, the behavior around `!` is sort of complex. In the
1122 // event that the `actual_return_ty` comes back as `!`, that
1123 // indicates that the fn either does not return or "returns" only
1124 // values of type `!`. In this case, if there is an expected
1125 // return type that is *not* `!`, that should be ok. But if the
1126 // return type is being inferred, we want to "fallback" to `!`:
1128 // let x = move || panic!();
1130 // To allow for that, I am creating a type variable with diverging
1131 // fallback. This was deemed ever so slightly better than unifying
1132 // the return value with `!` because it allows for the caller to
1133 // make more assumptions about the return type (e.g., they could do
1135 // let y: Option<u32> = Some(x());
1137 // which would then cause this return type to become `u32`, not
1139 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1140 let mut actual_return_ty = coercion.complete(&fcx);
1141 if actual_return_ty.is_never() {
1142 actual_return_ty = fcx.next_diverging_ty_var(
1143 TypeVariableOrigin::DivergingFn(span));
1145 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1147 // Check that the main return type implements the termination trait.
1148 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1149 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1150 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1151 if main_id == fn_id {
1152 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1153 let trait_ref = ty::TraitRef::new(term_id, substs);
1154 let return_ty_span = decl.output.span();
1155 let cause = traits::ObligationCause::new(
1156 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1158 inherited.register_predicate(
1159 traits::Obligation::new(
1160 cause, param_env, trait_ref.to_predicate()));
1165 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1166 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1167 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1168 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1169 // at this point we don't care if there are duplicate handlers or if the handler has
1170 // the wrong signature as this value we'll be used when writing metadata and that
1171 // only happens if compilation succeeded
1172 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1174 if declared_ret_ty.sty != ty::Never {
1175 fcx.tcx.sess.span_err(
1177 "return type should be `!`",
1181 let inputs = fn_sig.inputs();
1182 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1183 if inputs.len() == 1 {
1184 let arg_is_panic_info = match inputs[0].sty {
1185 ty::Ref(region, ty, mutbl) => match ty.sty {
1186 ty::Adt(ref adt, _) => {
1187 adt.did == panic_info_did &&
1188 mutbl == hir::Mutability::MutImmutable &&
1189 *region != RegionKind::ReStatic
1196 if !arg_is_panic_info {
1197 fcx.tcx.sess.span_err(
1198 decl.inputs[0].span,
1199 "argument should be `&PanicInfo`",
1203 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1204 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1205 if !generics.params.is_empty() {
1206 fcx.tcx.sess.span_err(
1208 "should have no type parameters",
1214 let span = fcx.tcx.sess.source_map().def_span(span);
1215 fcx.tcx.sess.span_err(span, "function should have one argument");
1218 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1223 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1224 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1225 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1226 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1227 if declared_ret_ty.sty != ty::Never {
1228 fcx.tcx.sess.span_err(
1230 "return type should be `!`",
1234 let inputs = fn_sig.inputs();
1235 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1236 if inputs.len() == 1 {
1237 let arg_is_alloc_layout = match inputs[0].sty {
1238 ty::Adt(ref adt, _) => {
1239 adt.did == alloc_layout_did
1244 if !arg_is_alloc_layout {
1245 fcx.tcx.sess.span_err(
1246 decl.inputs[0].span,
1247 "argument should be `Layout`",
1251 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1252 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1253 if !generics.params.is_empty() {
1254 fcx.tcx.sess.span_err(
1256 "`#[alloc_error_handler]` function should have no type \
1263 let span = fcx.tcx.sess.source_map().def_span(span);
1264 fcx.tcx.sess.span_err(span, "function should have one argument");
1267 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1275 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1278 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1279 let def = tcx.adt_def(def_id);
1280 def.destructor(tcx); // force the destructor to be evaluated
1281 check_representable(tcx, span, def_id);
1283 if def.repr.simd() {
1284 check_simd(tcx, span, def_id);
1287 check_transparent(tcx, span, def_id);
1288 check_packed(tcx, span, def_id);
1291 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1294 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1295 let def = tcx.adt_def(def_id);
1296 def.destructor(tcx); // force the destructor to be evaluated
1297 check_representable(tcx, span, def_id);
1299 check_packed(tcx, span, def_id);
1302 fn check_opaque<'a, 'tcx>(
1303 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1305 substs: SubstsRef<'tcx>,
1308 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1309 let mut err = struct_span_err!(
1310 tcx.sess, span, E0720,
1311 "opaque type expands to a recursive type",
1313 err.span_label(span, "expands to self-referential type");
1314 if let ty::Opaque(..) = partially_expanded_type.sty {
1315 err.note("type resolves to itself");
1317 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1323 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1325 "check_item_type(it.hir_id={}, it.name={})",
1327 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1329 let _indenter = indenter();
1331 // Consts can play a role in type-checking, so they are included here.
1332 hir::ItemKind::Static(..) => {
1333 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1334 tcx.typeck_tables_of(def_id);
1335 maybe_check_static_with_link_section(tcx, def_id, it.span);
1337 hir::ItemKind::Const(..) => {
1338 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1340 hir::ItemKind::Enum(ref enum_definition, _) => {
1341 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1343 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1344 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1345 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1346 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1347 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1348 check_impl_items_against_trait(
1355 let trait_def_id = impl_trait_ref.def_id;
1356 check_on_unimplemented(tcx, trait_def_id, it);
1359 hir::ItemKind::Trait(..) => {
1360 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1361 check_on_unimplemented(tcx, def_id, it);
1363 hir::ItemKind::Struct(..) => {
1364 check_struct(tcx, it.hir_id, it.span);
1366 hir::ItemKind::Union(..) => {
1367 check_union(tcx, it.hir_id, it.span);
1369 hir::ItemKind::Existential(..) => {
1370 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1372 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1373 check_opaque(tcx, def_id, substs, it.span);
1375 hir::ItemKind::Ty(..) => {
1376 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1377 let pty_ty = tcx.type_of(def_id);
1378 let generics = tcx.generics_of(def_id);
1379 check_bounds_are_used(tcx, &generics, pty_ty);
1381 hir::ItemKind::ForeignMod(ref m) => {
1382 check_abi(tcx, it.span, m.abi);
1384 if m.abi == Abi::RustIntrinsic {
1385 for item in &m.items {
1386 intrinsic::check_intrinsic_type(tcx, item);
1388 } else if m.abi == Abi::PlatformIntrinsic {
1389 for item in &m.items {
1390 intrinsic::check_platform_intrinsic_type(tcx, item);
1393 for item in &m.items {
1394 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1395 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1396 let mut err = struct_span_err!(
1400 "foreign items may not have type parameters"
1402 err.span_label(item.span, "can't have type parameters");
1403 // FIXME: once we start storing spans for type arguments, turn this into a
1406 "use specialization instead of type parameters by replacing them \
1407 with concrete types like `u32`",
1412 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1413 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1418 _ => { /* nothing to do */ }
1422 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_, '_>, id: DefId, span: Span) {
1423 // Only restricted on wasm32 target for now
1424 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1428 // If `#[link_section]` is missing, then nothing to verify
1429 let attrs = tcx.codegen_fn_attrs(id);
1430 if attrs.link_section.is_none() {
1434 // For the wasm32 target statics with #[link_section] are placed into custom
1435 // sections of the final output file, but this isn't link custom sections of
1436 // other executable formats. Namely we can only embed a list of bytes,
1437 // nothing with pointers to anything else or relocations. If any relocation
1438 // show up, reject them here.
1439 let instance = ty::Instance::mono(tcx, id);
1440 let cid = GlobalId {
1444 let param_env = ty::ParamEnv::reveal_all();
1445 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1446 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1449 bug!("Matching on non-ByRef static")
1451 if alloc.relocations.len() != 0 {
1452 let msg = "statics with a custom `#[link_section]` must be a \
1453 simple list of bytes on the wasm target with no \
1454 extra levels of indirection such as references";
1455 tcx.sess.span_err(span, msg);
1460 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1461 trait_def_id: DefId,
1463 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1464 // an error would be reported if this fails.
1465 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1468 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1469 impl_item: &hir::ImplItem,
1472 let mut err = struct_span_err!(
1473 tcx.sess, impl_item.span, E0520,
1474 "`{}` specializes an item from a parent `impl`, but \
1475 that item is not marked `default`",
1477 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1480 match tcx.span_of_impl(parent_impl) {
1482 err.span_label(span, "parent `impl` is here");
1483 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1487 err.note(&format!("parent implementation is in crate `{}`", cname));
1494 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1495 trait_def: &ty::TraitDef,
1496 trait_item: &ty::AssociatedItem,
1498 impl_item: &hir::ImplItem)
1500 let ancestors = trait_def.ancestors(tcx, impl_id);
1502 let kind = match impl_item.node {
1503 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1504 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1505 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1506 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1509 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1510 .map(|node_item| node_item.map(|parent| parent.defaultness));
1512 if let Some(parent) = parent {
1513 if tcx.impl_item_is_final(&parent) {
1514 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1520 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1523 impl_trait_ref: ty::TraitRef<'tcx>,
1524 impl_item_refs: &[hir::ImplItemRef]) {
1525 let impl_span = tcx.sess.source_map().def_span(impl_span);
1527 // If the trait reference itself is erroneous (so the compilation is going
1528 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1529 // isn't populated for such impls.
1530 if impl_trait_ref.references_error() { return; }
1532 // Locate trait definition and items
1533 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1534 let mut overridden_associated_type = None;
1536 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1538 // Check existing impl methods to see if they are both present in trait
1539 // and compatible with trait signature
1540 for impl_item in impl_items() {
1541 let ty_impl_item = tcx.associated_item(
1542 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1543 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1544 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1545 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1547 // Not compatible, but needed for the error message
1548 tcx.associated_items(impl_trait_ref.def_id)
1549 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1552 // Check that impl definition matches trait definition
1553 if let Some(ty_trait_item) = ty_trait_item {
1554 match impl_item.node {
1555 hir::ImplItemKind::Const(..) => {
1556 // Find associated const definition.
1557 if ty_trait_item.kind == ty::AssociatedKind::Const {
1558 compare_const_impl(tcx,
1564 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1565 "item `{}` is an associated const, \
1566 which doesn't match its trait `{}`",
1569 err.span_label(impl_item.span, "does not match trait");
1570 // We can only get the spans from local trait definition
1571 // Same for E0324 and E0325
1572 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1573 err.span_label(trait_span, "item in trait");
1578 hir::ImplItemKind::Method(..) => {
1579 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1580 if ty_trait_item.kind == ty::AssociatedKind::Method {
1581 compare_impl_method(tcx,
1588 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1589 "item `{}` is an associated method, \
1590 which doesn't match its trait `{}`",
1593 err.span_label(impl_item.span, "does not match trait");
1594 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1595 err.span_label(trait_span, "item in trait");
1600 hir::ImplItemKind::Existential(..) |
1601 hir::ImplItemKind::Type(_) => {
1602 if ty_trait_item.kind == ty::AssociatedKind::Type {
1603 if ty_trait_item.defaultness.has_value() {
1604 overridden_associated_type = Some(impl_item);
1607 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1608 "item `{}` is an associated type, \
1609 which doesn't match its trait `{}`",
1612 err.span_label(impl_item.span, "does not match trait");
1613 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1614 err.span_label(trait_span, "item in trait");
1621 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1625 // Check for missing items from trait
1626 let mut missing_items = Vec::new();
1627 let mut invalidated_items = Vec::new();
1628 let associated_type_overridden = overridden_associated_type.is_some();
1629 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1630 let is_implemented = trait_def.ancestors(tcx, impl_id)
1631 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1633 .map(|node_item| !node_item.node.is_from_trait())
1636 if !is_implemented && !tcx.impl_is_default(impl_id) {
1637 if !trait_item.defaultness.has_value() {
1638 missing_items.push(trait_item);
1639 } else if associated_type_overridden {
1640 invalidated_items.push(trait_item.ident);
1645 if !missing_items.is_empty() {
1646 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1647 "not all trait items implemented, missing: `{}`",
1648 missing_items.iter()
1649 .map(|trait_item| trait_item.ident.to_string())
1650 .collect::<Vec<_>>().join("`, `"));
1651 err.span_label(impl_span, format!("missing `{}` in implementation",
1652 missing_items.iter()
1653 .map(|trait_item| trait_item.ident.to_string())
1654 .collect::<Vec<_>>().join("`, `")));
1655 for trait_item in missing_items {
1656 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1657 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1659 err.note_trait_signature(trait_item.ident.to_string(),
1660 trait_item.signature(&tcx));
1666 if !invalidated_items.is_empty() {
1667 let invalidator = overridden_associated_type.unwrap();
1668 span_err!(tcx.sess, invalidator.span, E0399,
1669 "the following trait items need to be reimplemented \
1670 as `{}` was overridden: `{}`",
1672 invalidated_items.iter()
1673 .map(|name| name.to_string())
1674 .collect::<Vec<_>>().join("`, `"))
1678 /// Checks whether a type can be represented in memory. In particular, it
1679 /// identifies types that contain themselves without indirection through a
1680 /// pointer, which would mean their size is unbounded.
1681 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1685 let rty = tcx.type_of(item_def_id);
1687 // Check that it is possible to represent this type. This call identifies
1688 // (1) types that contain themselves and (2) types that contain a different
1689 // recursive type. It is only necessary to throw an error on those that
1690 // contain themselves. For case 2, there must be an inner type that will be
1691 // caught by case 1.
1692 match rty.is_representable(tcx, sp) {
1693 Representability::SelfRecursive(spans) => {
1694 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1696 err.span_label(span, "recursive without indirection");
1701 Representability::Representable | Representability::ContainsRecursive => (),
1706 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1707 let t = tcx.type_of(def_id);
1708 if let ty::Adt(def, substs) = t.sty {
1709 if def.is_struct() {
1710 let fields = &def.non_enum_variant().fields;
1711 if fields.is_empty() {
1712 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1715 let e = fields[0].ty(tcx, substs);
1716 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1717 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1718 .span_label(sp, "SIMD elements must have the same type")
1723 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1724 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1726 span_err!(tcx.sess, sp, E0077,
1727 "SIMD vector element type should be machine type");
1735 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1736 let repr = tcx.adt_def(def_id).repr;
1738 for attr in tcx.get_attrs(def_id).iter() {
1739 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1740 if let attr::ReprPacked(pack) = r {
1741 if pack != repr.pack {
1742 struct_span_err!(tcx.sess, sp, E0634,
1743 "type has conflicting packed representation hints").emit();
1749 struct_span_err!(tcx.sess, sp, E0587,
1750 "type has conflicting packed and align representation hints").emit();
1752 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1753 struct_span_err!(tcx.sess, sp, E0588,
1754 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1759 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1761 stack: &mut Vec<DefId>) -> bool {
1762 let t = tcx.type_of(def_id);
1763 if stack.contains(&def_id) {
1764 debug!("check_packed_inner: {:?} is recursive", t);
1767 if let ty::Adt(def, substs) = t.sty {
1768 if def.is_struct() || def.is_union() {
1769 if tcx.adt_def(def.did).repr.align > 0 {
1772 // push struct def_id before checking fields
1774 for field in &def.non_enum_variant().fields {
1775 let f = field.ty(tcx, substs);
1776 if let ty::Adt(def, _) = f.sty {
1777 if check_packed_inner(tcx, def.did, stack) {
1782 // only need to pop if not early out
1789 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1790 let adt = tcx.adt_def(def_id);
1791 if !adt.repr.transparent() {
1795 // For each field, figure out if it's known to be a ZST and align(1)
1796 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1797 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1798 let param_env = tcx.param_env(field.did);
1799 let layout = tcx.layout_of(param_env.and(ty));
1800 // We are currently checking the type this field came from, so it must be local
1801 let span = tcx.hir().span_if_local(field.did).unwrap();
1802 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1803 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1807 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1808 let non_zst_count = non_zst_fields.clone().count();
1809 if non_zst_count != 1 {
1810 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1811 struct_span_err!(tcx.sess, sp, E0690,
1812 "transparent struct needs exactly one non-zero-sized field, but has {}",
1814 .span_note(field_spans, "non-zero-sized field")
1817 for (span, zst, align1) in field_infos {
1819 span_err!(tcx.sess, span, E0691,
1820 "zero-sized field in transparent struct has alignment larger than 1");
1825 #[allow(trivial_numeric_casts)]
1826 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1828 vs: &'tcx [hir::Variant],
1830 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1831 let def = tcx.adt_def(def_id);
1832 def.destructor(tcx); // force the destructor to be evaluated
1835 let attributes = tcx.get_attrs(def_id);
1836 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1838 tcx.sess, attr.span, E0084,
1839 "unsupported representation for zero-variant enum")
1840 .span_label(sp, "zero-variant enum")
1845 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1846 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1847 if !tcx.features().repr128 {
1848 emit_feature_err(&tcx.sess.parse_sess,
1851 GateIssue::Language,
1852 "repr with 128-bit type is unstable");
1857 if let Some(ref e) = v.node.disr_expr {
1858 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1862 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1863 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1864 // Check for duplicate discriminant values
1865 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1866 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1867 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1868 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1869 let i_span = match variant_i.node.disr_expr {
1870 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1871 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1873 let span = match v.node.disr_expr {
1874 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1877 struct_span_err!(tcx.sess, span, E0081,
1878 "discriminant value `{}` already exists", disr_vals[i])
1879 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1880 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1883 disr_vals.push(discr);
1886 check_representable(tcx, sp, def_id);
1889 fn report_unexpected_variant_def<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1893 span_err!(tcx.sess, span, E0533,
1894 "expected unit struct/variant or constant, found {} `{}`",
1896 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1899 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1900 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1902 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1903 -> Lrc<ty::GenericPredicates<'tcx>>
1906 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1907 let item_id = tcx.hir().ty_param_owner(hir_id);
1908 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1909 let generics = tcx.generics_of(item_def_id);
1910 let index = generics.param_def_id_to_index[&def_id];
1911 Lrc::new(ty::GenericPredicates {
1913 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1915 ty::Predicate::Trait(ref data)
1916 if data.skip_binder().self_ty().is_param(index) => {
1917 // HACK(eddyb) should get the original `Span`.
1918 let span = tcx.def_span(def_id);
1919 Some((predicate, span))
1927 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1928 -> Option<ty::Region<'tcx>> {
1930 Some(def) => infer::EarlyBoundRegion(span, def.name),
1931 None => infer::MiscVariable(span)
1933 Some(self.next_region_var(v))
1936 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1937 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1940 fn ty_infer_for_def(&self,
1941 ty_param_def: &ty::GenericParamDef,
1942 span: Span) -> Ty<'tcx> {
1943 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1949 fn projected_ty_from_poly_trait_ref(&self,
1952 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1955 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1957 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1961 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1964 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1965 if ty.has_escaping_bound_vars() {
1966 ty // FIXME: normalization and escaping regions
1968 self.normalize_associated_types_in(span, &ty)
1972 fn set_tainted_by_errors(&self) {
1973 self.infcx.set_tainted_by_errors()
1976 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1977 self.write_ty(hir_id, ty)
1981 /// Controls whether the arguments are tupled. This is used for the call
1984 /// Tupling means that all call-side arguments are packed into a tuple and
1985 /// passed as a single parameter. For example, if tupling is enabled, this
1988 /// fn f(x: (isize, isize))
1990 /// Can be called as:
1997 #[derive(Clone, Eq, PartialEq)]
1998 enum TupleArgumentsFlag {
2003 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2004 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2005 param_env: ty::ParamEnv<'tcx>,
2006 body_id: hir::HirId)
2007 -> FnCtxt<'a, 'gcx, 'tcx> {
2011 err_count_on_creation: inh.tcx.sess.err_count(),
2013 ret_coercion_span: RefCell::new(None),
2015 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2016 hir::CRATE_HIR_ID)),
2017 diverges: Cell::new(Diverges::Maybe),
2018 has_errors: Cell::new(false),
2019 enclosing_breakables: RefCell::new(EnclosingBreakables {
2021 by_id: Default::default(),
2027 pub fn sess(&self) -> &Session {
2031 pub fn err_count_since_creation(&self) -> usize {
2032 self.tcx.sess.err_count() - self.err_count_on_creation
2035 /// Produces warning on the given node, if the current point in the
2036 /// function is unreachable, and there hasn't been another warning.
2037 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2038 if self.diverges.get() == Diverges::Always {
2039 self.diverges.set(Diverges::WarnedAlways);
2041 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2043 self.tcx().lint_hir(
2044 lint::builtin::UNREACHABLE_CODE,
2046 &format!("unreachable {}", kind));
2052 code: ObligationCauseCode<'tcx>)
2053 -> ObligationCause<'tcx> {
2054 ObligationCause::new(span, self.body_id, code)
2057 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2058 self.cause(span, ObligationCauseCode::MiscObligation)
2061 /// Resolves type variables in `ty` if possible. Unlike the infcx
2062 /// version (resolve_type_vars_if_possible), this version will
2063 /// also select obligations if it seems useful, in an effort
2064 /// to get more type information.
2065 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2066 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2068 // No Infer()? Nothing needs doing.
2069 if !ty.has_infer_types() {
2070 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2074 // If `ty` is a type variable, see whether we already know what it is.
2075 ty = self.resolve_type_vars_if_possible(&ty);
2076 if !ty.has_infer_types() {
2077 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2081 // If not, try resolving pending obligations as much as
2082 // possible. This can help substantially when there are
2083 // indirect dependencies that don't seem worth tracking
2085 self.select_obligations_where_possible(false);
2086 ty = self.resolve_type_vars_if_possible(&ty);
2088 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2092 fn record_deferred_call_resolution(&self,
2093 closure_def_id: DefId,
2094 r: DeferredCallResolution<'gcx, 'tcx>) {
2095 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2096 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2099 fn remove_deferred_call_resolutions(&self,
2100 closure_def_id: DefId)
2101 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2103 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2104 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2107 pub fn tag(&self) -> String {
2108 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2109 format!("{:?}", self_ptr)
2112 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2113 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2114 span_bug!(span, "no type for local variable {}",
2115 self.tcx.hir().hir_to_string(nid))
2120 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2121 debug!("write_ty({:?}, {:?}) in fcx {}",
2122 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2123 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2125 if ty.references_error() {
2126 self.has_errors.set(true);
2127 self.set_tainted_by_errors();
2131 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2132 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2135 pub fn write_method_call(&self,
2137 method: MethodCallee<'tcx>) {
2138 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2141 .type_dependent_defs_mut()
2142 .insert(hir_id, Def::Method(method.def_id));
2144 self.write_substs(hir_id, method.substs);
2146 // When the method is confirmed, the `method.substs` includes
2147 // parameters from not just the method, but also the impl of
2148 // the method -- in particular, the `Self` type will be fully
2149 // resolved. However, those are not something that the "user
2150 // specified" -- i.e., those types come from the inferred type
2151 // of the receiver, not something the user wrote. So when we
2152 // create the user-substs, we want to replace those earlier
2153 // types with just the types that the user actually wrote --
2154 // that is, those that appear on the *method itself*.
2156 // As an example, if the user wrote something like
2157 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2158 // type of `foo` (possibly adjusted), but we don't want to
2159 // include that. We want just the `[_, u32]` part.
2160 if !method.substs.is_noop() {
2161 let method_generics = self.tcx.generics_of(method.def_id);
2162 if !method_generics.params.is_empty() {
2163 let user_type_annotation = self.infcx.probe(|_| {
2164 let user_substs = UserSubsts {
2165 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2166 let i = param.index as usize;
2167 if i < method_generics.parent_count {
2168 self.infcx.var_for_def(DUMMY_SP, param)
2173 user_self_ty: None, // not relevant here
2176 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2182 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2183 self.write_user_type_annotation(hir_id, user_type_annotation);
2188 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2189 if !substs.is_noop() {
2190 debug!("write_substs({:?}, {:?}) in fcx {}",
2195 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2199 /// Given the substs that we just converted from the HIR, try to
2200 /// canonicalize them and store them as user-given substitutions
2201 /// (i.e., substitutions that must be respected by the NLL check).
2203 /// This should be invoked **before any unifications have
2204 /// occurred**, so that annotations like `Vec<_>` are preserved
2206 pub fn write_user_type_annotation_from_substs(
2210 substs: SubstsRef<'tcx>,
2211 user_self_ty: Option<UserSelfTy<'tcx>>,
2214 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2215 user_self_ty={:?} in fcx {}",
2216 hir_id, def_id, substs, user_self_ty, self.tag(),
2219 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2220 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2221 &UserType::TypeOf(def_id, UserSubsts {
2226 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2227 self.write_user_type_annotation(hir_id, canonicalized);
2231 pub fn write_user_type_annotation(
2234 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2237 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2238 hir_id, canonical_user_type_annotation, self.tag(),
2241 if !canonical_user_type_annotation.is_identity() {
2242 self.tables.borrow_mut().user_provided_types_mut().insert(
2243 hir_id, canonical_user_type_annotation
2246 debug!("write_user_type_annotation: skipping identity substs");
2250 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2251 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2257 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2258 Entry::Vacant(entry) => { entry.insert(adj); },
2259 Entry::Occupied(mut entry) => {
2260 debug!(" - composing on top of {:?}", entry.get());
2261 match (&entry.get()[..], &adj[..]) {
2262 // Applying any adjustment on top of a NeverToAny
2263 // is a valid NeverToAny adjustment, because it can't
2265 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2267 Adjustment { kind: Adjust::Deref(_), .. },
2268 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2270 Adjustment { kind: Adjust::Deref(_), .. },
2271 .. // Any following adjustments are allowed.
2273 // A reborrow has no effect before a dereference.
2275 // FIXME: currently we never try to compose autoderefs
2276 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2278 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2279 expr, entry.get(), adj)
2281 *entry.get_mut() = adj;
2286 /// Basically whenever we are converting from a type scheme into
2287 /// the fn body space, we always want to normalize associated
2288 /// types as well. This function combines the two.
2289 fn instantiate_type_scheme<T>(&self,
2291 substs: SubstsRef<'tcx>,
2294 where T : TypeFoldable<'tcx>
2296 let value = value.subst(self.tcx, substs);
2297 let result = self.normalize_associated_types_in(span, &value);
2298 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2305 /// As `instantiate_type_scheme`, but for the bounds found in a
2306 /// generic type scheme.
2307 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2308 -> ty::InstantiatedPredicates<'tcx> {
2309 let bounds = self.tcx.predicates_of(def_id);
2310 let result = bounds.instantiate(self.tcx, substs);
2311 let result = self.normalize_associated_types_in(span, &result);
2312 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2319 /// Replaces the opaque types from the given value with type variables,
2320 /// and records the `OpaqueTypeMap` for later use during writeback. See
2321 /// `InferCtxt::instantiate_opaque_types` for more details.
2322 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2324 parent_id: hir::HirId,
2327 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2328 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2332 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2333 self.instantiate_opaque_types(
2341 let mut opaque_types = self.opaque_types.borrow_mut();
2342 for (ty, decl) in opaque_type_map {
2343 let old_value = opaque_types.insert(ty, decl);
2344 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2350 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2351 where T : TypeFoldable<'tcx>
2353 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2356 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2358 where T : TypeFoldable<'tcx>
2360 self.inh.partially_normalize_associated_types_in(span,
2366 pub fn require_type_meets(&self,
2369 code: traits::ObligationCauseCode<'tcx>,
2372 self.register_bound(
2375 traits::ObligationCause::new(span, self.body_id, code));
2378 pub fn require_type_is_sized(&self,
2381 code: traits::ObligationCauseCode<'tcx>)
2383 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2384 self.require_type_meets(ty, span, code, lang_item);
2387 pub fn require_type_is_sized_deferred(&self,
2390 code: traits::ObligationCauseCode<'tcx>)
2392 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2395 pub fn register_bound(&self,
2398 cause: traits::ObligationCause<'tcx>)
2400 self.fulfillment_cx.borrow_mut()
2401 .register_bound(self, self.param_env, ty, def_id, cause);
2404 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2405 let t = AstConv::ast_ty_to_ty(self, ast_t);
2406 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2410 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2411 let ty = self.to_ty(ast_ty);
2412 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2414 if Self::can_contain_user_lifetime_bounds(ty) {
2415 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2416 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2417 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2423 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2424 AstConv::ast_const_to_const(self, ast_c, ty)
2427 // If the type given by the user has free regions, save it for later, since
2428 // NLL would like to enforce those. Also pass in types that involve
2429 // projections, since those can resolve to `'static` bounds (modulo #54940,
2430 // which hopefully will be fixed by the time you see this comment, dear
2431 // reader, although I have my doubts). Also pass in types with inference
2432 // types, because they may be repeated. Other sorts of things are already
2433 // sufficiently enforced with erased regions. =)
2434 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2436 T: TypeFoldable<'tcx>
2438 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2441 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2442 match self.tables.borrow().node_types().get(id) {
2444 None if self.is_tainted_by_errors() => self.tcx.types.err,
2446 let node_id = self.tcx.hir().hir_to_node_id(id);
2447 bug!("no type for node {}: {} in fcx {}",
2448 node_id, self.tcx.hir().node_to_string(node_id),
2454 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2455 /// outlive the region `r`.
2456 pub fn register_wf_obligation(&self,
2459 code: traits::ObligationCauseCode<'tcx>)
2461 // WF obligations never themselves fail, so no real need to give a detailed cause:
2462 let cause = traits::ObligationCause::new(span, self.body_id, code);
2463 self.register_predicate(traits::Obligation::new(cause,
2465 ty::Predicate::WellFormed(ty)));
2468 /// Registers obligations that all types appearing in `substs` are well-formed.
2469 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2470 for ty in substs.types() {
2471 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2475 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2476 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2477 /// trait/region obligations.
2479 /// For example, if there is a function:
2482 /// fn foo<'a,T:'a>(...)
2485 /// and a reference:
2491 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2492 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2493 pub fn add_obligations_for_parameters(&self,
2494 cause: traits::ObligationCause<'tcx>,
2495 predicates: &ty::InstantiatedPredicates<'tcx>)
2497 assert!(!predicates.has_escaping_bound_vars());
2499 debug!("add_obligations_for_parameters(predicates={:?})",
2502 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2503 self.register_predicate(obligation);
2507 // FIXME(arielb1): use this instead of field.ty everywhere
2508 // Only for fields! Returns <none> for methods>
2509 // Indifferent to privacy flags
2510 pub fn field_ty(&self,
2512 field: &'tcx ty::FieldDef,
2513 substs: SubstsRef<'tcx>)
2516 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2519 fn check_casts(&self) {
2520 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2521 for cast in deferred_cast_checks.drain(..) {
2526 fn resolve_generator_interiors(&self, def_id: DefId) {
2527 let mut generators = self.deferred_generator_interiors.borrow_mut();
2528 for (body_id, interior) in generators.drain(..) {
2529 self.select_obligations_where_possible(false);
2530 generator_interior::resolve_interior(self, def_id, body_id, interior);
2534 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2535 // Non-numerics get replaced with ! or () (depending on whether
2536 // feature(never_type) is enabled, unconstrained ints with i32,
2537 // unconstrained floats with f64.
2538 // Fallback becomes very dubious if we have encountered type-checking errors.
2539 // In that case, fallback to Error.
2540 // The return value indicates whether fallback has occurred.
2541 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2542 use rustc::ty::error::UnconstrainedNumeric::Neither;
2543 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2545 assert!(ty.is_ty_infer());
2546 let fallback = match self.type_is_unconstrained_numeric(ty) {
2547 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2548 UnconstrainedInt => self.tcx.types.i32,
2549 UnconstrainedFloat => self.tcx.types.f64,
2550 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2551 Neither => return false,
2553 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2554 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2558 fn select_all_obligations_or_error(&self) {
2559 debug!("select_all_obligations_or_error");
2560 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2561 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2565 /// Select as many obligations as we can at present.
2566 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2567 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2568 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2572 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2573 /// returns a type of `&T`, but the actual type we assign to the
2574 /// *expression* is `T`. So this function just peels off the return
2575 /// type by one layer to yield `T`.
2576 fn make_overloaded_place_return_type(&self,
2577 method: MethodCallee<'tcx>)
2578 -> ty::TypeAndMut<'tcx>
2580 // extract method return type, which will be &T;
2581 let ret_ty = method.sig.output();
2583 // method returns &T, but the type as visible to user is T, so deref
2584 ret_ty.builtin_deref(true).unwrap()
2587 fn lookup_indexing(&self,
2589 base_expr: &'gcx hir::Expr,
2593 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2595 // FIXME(#18741) -- this is almost but not quite the same as the
2596 // autoderef that normal method probing does. They could likely be
2599 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2600 let mut result = None;
2601 while result.is_none() && autoderef.next().is_some() {
2602 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2604 autoderef.finalize(self);
2608 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2609 /// (and otherwise adjust) `base_expr`, looking for a type which either
2610 /// supports builtin indexing or overloaded indexing.
2611 /// This loop implements one step in that search; the autoderef loop
2612 /// is implemented by `lookup_indexing`.
2613 fn try_index_step(&self,
2615 base_expr: &hir::Expr,
2616 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2619 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2621 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2622 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2629 for &unsize in &[false, true] {
2630 let mut self_ty = adjusted_ty;
2632 // We only unsize arrays here.
2633 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2634 self_ty = self.tcx.mk_slice(element_ty);
2640 // If some lookup succeeds, write callee into table and extract index/element
2641 // type from the method signature.
2642 // If some lookup succeeded, install method in table
2643 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2644 let method = self.try_overloaded_place_op(
2645 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2647 let result = method.map(|ok| {
2648 debug!("try_index_step: success, using overloaded indexing");
2649 let method = self.register_infer_ok_obligations(ok);
2651 let mut adjustments = autoderef.adjust_steps(self, needs);
2652 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2653 let mutbl = match r_mutbl {
2654 hir::MutImmutable => AutoBorrowMutability::Immutable,
2655 hir::MutMutable => AutoBorrowMutability::Mutable {
2656 // Indexing can be desugared to a method call,
2657 // so maybe we could use two-phase here.
2658 // See the documentation of AllowTwoPhase for why that's
2659 // not the case today.
2660 allow_two_phase_borrow: AllowTwoPhase::No,
2663 adjustments.push(Adjustment {
2664 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2665 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2672 adjustments.push(Adjustment {
2673 kind: Adjust::Unsize,
2674 target: method.sig.inputs()[0]
2677 self.apply_adjustments(base_expr, adjustments);
2679 self.write_method_call(expr.hir_id, method);
2680 (input_ty, self.make_overloaded_place_return_type(method).ty)
2682 if result.is_some() {
2690 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2691 let (tr, name) = match (op, is_mut) {
2692 (PlaceOp::Deref, false) =>
2693 (self.tcx.lang_items().deref_trait(), "deref"),
2694 (PlaceOp::Deref, true) =>
2695 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2696 (PlaceOp::Index, false) =>
2697 (self.tcx.lang_items().index_trait(), "index"),
2698 (PlaceOp::Index, true) =>
2699 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2701 (tr, ast::Ident::from_str(name))
2704 fn try_overloaded_place_op(&self,
2707 arg_tys: &[Ty<'tcx>],
2710 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2712 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2718 // Try Mut first, if needed.
2719 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2720 let method = match (needs, mut_tr) {
2721 (Needs::MutPlace, Some(trait_did)) => {
2722 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2727 // Otherwise, fall back to the immutable version.
2728 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2729 let method = match (method, imm_tr) {
2730 (None, Some(trait_did)) => {
2731 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2733 (method, _) => method,
2739 fn check_method_argument_types(&self,
2742 method: Result<MethodCallee<'tcx>, ()>,
2743 args_no_rcvr: &'gcx [hir::Expr],
2744 tuple_arguments: TupleArgumentsFlag,
2745 expected: Expectation<'tcx>)
2747 let has_error = match method {
2749 method.substs.references_error() || method.sig.references_error()
2754 let err_inputs = self.err_args(args_no_rcvr.len());
2756 let err_inputs = match tuple_arguments {
2757 DontTupleArguments => err_inputs,
2758 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2761 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2762 false, tuple_arguments, None);
2763 return self.tcx.types.err;
2766 let method = method.unwrap();
2767 // HACK(eddyb) ignore self in the definition (see above).
2768 let expected_arg_tys = self.expected_inputs_for_expected_output(
2771 method.sig.output(),
2772 &method.sig.inputs()[1..]
2774 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2775 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2776 self.tcx.hir().span_if_local(method.def_id));
2780 fn self_type_matches_expected_vid(
2782 trait_ref: ty::PolyTraitRef<'tcx>,
2783 expected_vid: ty::TyVid,
2785 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2787 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2788 trait_ref, self_ty, expected_vid
2791 ty::Infer(ty::TyVar(found_vid)) => {
2792 // FIXME: consider using `sub_root_var` here so we
2793 // can see through subtyping.
2794 let found_vid = self.root_var(found_vid);
2795 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2796 expected_vid == found_vid
2802 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2803 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2804 + Captures<'gcx> + 'b
2806 // FIXME: consider using `sub_root_var` here so we
2807 // can see through subtyping.
2808 let ty_var_root = self.root_var(self_ty);
2809 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2810 self_ty, ty_var_root,
2811 self.fulfillment_cx.borrow().pending_obligations());
2815 .pending_obligations()
2817 .filter_map(move |obligation| match obligation.predicate {
2818 ty::Predicate::Projection(ref data) =>
2819 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2820 ty::Predicate::Trait(ref data) =>
2821 Some((data.to_poly_trait_ref(), obligation)),
2822 ty::Predicate::Subtype(..) => None,
2823 ty::Predicate::RegionOutlives(..) => None,
2824 ty::Predicate::TypeOutlives(..) => None,
2825 ty::Predicate::WellFormed(..) => None,
2826 ty::Predicate::ObjectSafe(..) => None,
2827 ty::Predicate::ConstEvaluatable(..) => None,
2828 // N.B., this predicate is created by breaking down a
2829 // `ClosureType: FnFoo()` predicate, where
2830 // `ClosureType` represents some `Closure`. It can't
2831 // possibly be referring to the current closure,
2832 // because we haven't produced the `Closure` for
2833 // this closure yet; this is exactly why the other
2834 // code is looking for a self type of a unresolved
2835 // inference variable.
2836 ty::Predicate::ClosureKind(..) => None,
2837 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2840 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2841 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2842 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2846 /// Generic function that factors out common logic from function calls,
2847 /// method calls and overloaded operators.
2848 fn check_argument_types(&self,
2851 fn_inputs: &[Ty<'tcx>],
2852 mut expected_arg_tys: &[Ty<'tcx>],
2853 args: &'gcx [hir::Expr],
2855 tuple_arguments: TupleArgumentsFlag,
2856 def_span: Option<Span>) {
2859 // Grab the argument types, supplying fresh type variables
2860 // if the wrong number of arguments were supplied
2861 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2867 // All the input types from the fn signature must outlive the call
2868 // so as to validate implied bounds.
2869 for &fn_input_ty in fn_inputs {
2870 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2873 let expected_arg_count = fn_inputs.len();
2875 let param_count_error = |expected_count: usize,
2880 let mut err = tcx.sess.struct_span_err_with_code(sp,
2881 &format!("this function takes {}{} but {} {} supplied",
2882 if c_variadic { "at least " } else { "" },
2883 potentially_plural_count(expected_count, "parameter"),
2884 potentially_plural_count(arg_count, "parameter"),
2885 if arg_count == 1 {"was"} else {"were"}),
2886 DiagnosticId::Error(error_code.to_owned()));
2888 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2889 err.span_label(def_s, "defined here");
2892 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2893 // remove closing `)` from the span
2894 let sugg_span = sugg_span.shrink_to_lo();
2895 err.span_suggestion(
2897 "expected the unit value `()`; create it with empty parentheses",
2899 Applicability::MachineApplicable);
2901 err.span_label(sp, format!("expected {}{}",
2902 if c_variadic { "at least " } else { "" },
2903 potentially_plural_count(expected_count, "parameter")));
2908 let formal_tys = if tuple_arguments == TupleArguments {
2909 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2910 match tuple_type.sty {
2911 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2912 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2913 expected_arg_tys = &[];
2914 self.err_args(args.len())
2916 ty::Tuple(arg_types) => {
2917 expected_arg_tys = match expected_arg_tys.get(0) {
2918 Some(&ty) => match ty.sty {
2919 ty::Tuple(ref tys) => &tys,
2927 span_err!(tcx.sess, sp, E0059,
2928 "cannot use call notation; the first type parameter \
2929 for the function trait is neither a tuple nor unit");
2930 expected_arg_tys = &[];
2931 self.err_args(args.len())
2934 } else if expected_arg_count == supplied_arg_count {
2936 } else if c_variadic {
2937 if supplied_arg_count >= expected_arg_count {
2940 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2941 expected_arg_tys = &[];
2942 self.err_args(supplied_arg_count)
2945 // is the missing argument of type `()`?
2946 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2947 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2948 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2949 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2953 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2955 expected_arg_tys = &[];
2956 self.err_args(supplied_arg_count)
2958 // If there is no expectation, expect formal_tys.
2959 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2965 debug!("check_argument_types: formal_tys={:?}",
2966 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2968 // Check the arguments.
2969 // We do this in a pretty awful way: first we type-check any arguments
2970 // that are not closures, then we type-check the closures. This is so
2971 // that we have more information about the types of arguments when we
2972 // type-check the functions. This isn't really the right way to do this.
2973 for &check_closures in &[false, true] {
2974 debug!("check_closures={}", check_closures);
2976 // More awful hacks: before we check argument types, try to do
2977 // an "opportunistic" vtable resolution of any trait bounds on
2978 // the call. This helps coercions.
2980 self.select_obligations_where_possible(false);
2983 // For C-variadic functions, we don't have a declared type for all of
2984 // the arguments hence we only do our usual type checking with
2985 // the arguments who's types we do know.
2986 let t = if c_variadic {
2988 } else if tuple_arguments == TupleArguments {
2993 for (i, arg) in args.iter().take(t).enumerate() {
2994 // Warn only for the first loop (the "no closures" one).
2995 // Closure arguments themselves can't be diverging, but
2996 // a previous argument can, e.g., `foo(panic!(), || {})`.
2997 if !check_closures {
2998 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3001 let is_closure = match arg.node {
3002 ExprKind::Closure(..) => true,
3006 if is_closure != check_closures {
3010 debug!("checking the argument");
3011 let formal_ty = formal_tys[i];
3013 // The special-cased logic below has three functions:
3014 // 1. Provide as good of an expected type as possible.
3015 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3017 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3019 // 2. Coerce to the most detailed type that could be coerced
3020 // to, which is `expected_ty` if `rvalue_hint` returns an
3021 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3022 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3023 // We're processing function arguments so we definitely want to use
3024 // two-phase borrows.
3025 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3027 // 3. Relate the expected type and the formal one,
3028 // if the expected type was used for the coercion.
3029 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3033 // We also need to make sure we at least write the ty of the other
3034 // arguments which we skipped above.
3036 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3037 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3038 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3041 for arg in args.iter().skip(expected_arg_count) {
3042 let arg_ty = self.check_expr(&arg);
3044 // There are a few types which get autopromoted when passed via varargs
3045 // in C but we just error out instead and require explicit casts.
3046 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3048 ty::Float(ast::FloatTy::F32) => {
3049 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3051 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3052 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3054 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3055 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3058 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3059 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3060 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3068 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3069 vec![self.tcx.types.err; len]
3072 // AST fragment checking
3075 expected: Expectation<'tcx>)
3081 ast::LitKind::Str(..) => tcx.mk_static_str(),
3082 ast::LitKind::ByteStr(ref v) => {
3083 tcx.mk_imm_ref(tcx.types.re_static,
3084 tcx.mk_array(tcx.types.u8, v.len() as u64))
3086 ast::LitKind::Byte(_) => tcx.types.u8,
3087 ast::LitKind::Char(_) => tcx.types.char,
3088 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3089 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3090 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3091 let opt_ty = expected.to_option(self).and_then(|ty| {
3093 ty::Int(_) | ty::Uint(_) => Some(ty),
3094 ty::Char => Some(tcx.types.u8),
3095 ty::RawPtr(..) => Some(tcx.types.usize),
3096 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3100 opt_ty.unwrap_or_else(
3101 || tcx.mk_int_var(self.next_int_var_id()))
3103 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3104 ast::LitKind::FloatUnsuffixed(_) => {
3105 let opt_ty = expected.to_option(self).and_then(|ty| {
3107 ty::Float(_) => Some(ty),
3111 opt_ty.unwrap_or_else(
3112 || tcx.mk_float_var(self.next_float_var_id()))
3114 ast::LitKind::Bool(_) => tcx.types.bool,
3115 ast::LitKind::Err(_) => tcx.types.err,
3119 fn check_expr_eq_type(&self,
3120 expr: &'gcx hir::Expr,
3121 expected: Ty<'tcx>) {
3122 let ty = self.check_expr_with_hint(expr, expected);
3123 self.demand_eqtype(expr.span, expected, ty);
3126 pub fn check_expr_has_type_or_error(&self,
3127 expr: &'gcx hir::Expr,
3128 expected: Ty<'tcx>) -> Ty<'tcx> {
3129 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3132 fn check_expr_meets_expectation_or_error(&self,
3133 expr: &'gcx hir::Expr,
3134 expected: Expectation<'tcx>) -> Ty<'tcx> {
3135 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3136 let mut ty = self.check_expr_with_expectation(expr, expected);
3138 // While we don't allow *arbitrary* coercions here, we *do* allow
3139 // coercions from ! to `expected`.
3141 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3142 "expression with never type wound up being adjusted");
3143 let adj_ty = self.next_diverging_ty_var(
3144 TypeVariableOrigin::AdjustmentType(expr.span));
3145 self.apply_adjustments(expr, vec![Adjustment {
3146 kind: Adjust::NeverToAny,
3152 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3153 // Add help to type error if this is an `if` condition with an assignment.
3154 if let (ExpectIfCondition, &ExprKind::Assign(ref lhs, ref rhs))
3155 = (expected, &expr.node)
3157 let msg = "try comparing for equality";
3158 if let (Ok(left), Ok(right)) = (
3159 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3160 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3162 err.span_suggestion(
3165 format!("{} == {}", left, right),
3166 Applicability::MaybeIncorrect);
3176 fn check_expr_coercable_to_type(&self,
3177 expr: &'gcx hir::Expr,
3178 expected: Ty<'tcx>) -> Ty<'tcx> {
3179 let ty = self.check_expr_with_hint(expr, expected);
3180 // checks don't need two phase
3181 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3184 fn check_expr_with_hint(&self,
3185 expr: &'gcx hir::Expr,
3186 expected: Ty<'tcx>) -> Ty<'tcx> {
3187 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3190 fn check_expr_with_expectation(&self,
3191 expr: &'gcx hir::Expr,
3192 expected: Expectation<'tcx>) -> Ty<'tcx> {
3193 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3196 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3197 self.check_expr_with_expectation(expr, NoExpectation)
3200 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3201 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3204 // Determine the `Self` type, using fresh variables for all variables
3205 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3206 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3208 pub fn impl_self_ty(&self,
3209 span: Span, // (potential) receiver for this impl
3211 -> TypeAndSubsts<'tcx> {
3212 let ity = self.tcx.type_of(did);
3213 debug!("impl_self_ty: ity={:?}", ity);
3215 let substs = self.fresh_substs_for_item(span, did);
3216 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3218 TypeAndSubsts { substs: substs, ty: substd_ty }
3221 /// Unifies the output type with the expected type early, for more coercions
3222 /// and forward type information on the input expressions.
3223 fn expected_inputs_for_expected_output(&self,
3225 expected_ret: Expectation<'tcx>,
3226 formal_ret: Ty<'tcx>,
3227 formal_args: &[Ty<'tcx>])
3229 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3230 let ret_ty = match expected_ret.only_has_type(self) {
3232 None => return Vec::new()
3234 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3235 // Attempt to apply a subtyping relationship between the formal
3236 // return type (likely containing type variables if the function
3237 // is polymorphic) and the expected return type.
3238 // No argument expectations are produced if unification fails.
3239 let origin = self.misc(call_span);
3240 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3242 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3243 // to identity so the resulting type is not constrained.
3246 // Process any obligations locally as much as
3247 // we can. We don't care if some things turn
3248 // out unconstrained or ambiguous, as we're
3249 // just trying to get hints here.
3250 self.save_and_restore_in_snapshot_flag(|_| {
3251 let mut fulfill = TraitEngine::new(self.tcx);
3252 for obligation in ok.obligations {
3253 fulfill.register_predicate_obligation(self, obligation);
3255 fulfill.select_where_possible(self)
3256 }).map_err(|_| ())?;
3258 Err(_) => return Err(()),
3261 // Record all the argument types, with the substitutions
3262 // produced from the above subtyping unification.
3263 Ok(formal_args.iter().map(|ty| {
3264 self.resolve_type_vars_if_possible(ty)
3266 }).unwrap_or_default();
3267 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3268 formal_args, formal_ret,
3269 expect_args, expected_ret);
3273 // Checks a method call.
3274 fn check_method_call(&self,
3275 expr: &'gcx hir::Expr,
3276 segment: &hir::PathSegment,
3278 args: &'gcx [hir::Expr],
3279 expected: Expectation<'tcx>,
3280 needs: Needs) -> Ty<'tcx> {
3281 let rcvr = &args[0];
3282 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3283 // no need to check for bot/err -- callee does that
3284 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3286 let method = match self.lookup_method(rcvr_t,
3292 self.write_method_call(expr.hir_id, method);
3296 if segment.ident.name != keywords::Invalid.name() {
3297 self.report_method_error(span,
3300 SelfSource::MethodCall(rcvr),
3308 // Call the generic checker.
3309 self.check_method_argument_types(span,
3317 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3321 .unwrap_or_else(|| span_bug!(return_expr.span,
3322 "check_return_expr called outside fn body"));
3324 let ret_ty = ret_coercion.borrow().expected_ty();
3325 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3326 ret_coercion.borrow_mut()
3328 &self.cause(return_expr.span,
3329 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3334 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3335 // or 'if-else' expression.
3336 fn check_then_else(&self,
3337 cond_expr: &'gcx hir::Expr,
3338 then_expr: &'gcx hir::Expr,
3339 opt_else_expr: Option<&'gcx hir::Expr>,
3341 expected: Expectation<'tcx>) -> Ty<'tcx> {
3342 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3343 let cond_diverges = self.diverges.get();
3344 self.diverges.set(Diverges::Maybe);
3346 let expected = expected.adjust_for_branches(self);
3347 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3348 let then_diverges = self.diverges.get();
3349 self.diverges.set(Diverges::Maybe);
3351 // We've already taken the expected type's preferences
3352 // into account when typing the `then` branch. To figure
3353 // out the initial shot at a LUB, we thus only consider
3354 // `expected` if it represents a *hard* constraint
3355 // (`only_has_type`); otherwise, we just go with a
3356 // fresh type variable.
3357 let coerce_to_ty = expected.coercion_target_type(self, sp);
3358 let mut coerce: DynamicCoerceMany<'_, '_> = CoerceMany::new(coerce_to_ty);
3360 coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
3362 if let Some(else_expr) = opt_else_expr {
3363 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3364 let else_diverges = self.diverges.get();
3366 let mut outer_sp = if self.tcx.sess.source_map().is_multiline(sp) {
3367 // The `if`/`else` isn't in one line in the output, include some context to make it
3368 // clear it is an if/else expression:
3370 // LL | let x = if true {
3373 // || ----- expected because of this
3376 // || ^^^^^ expected i32, found u32
3378 // ||_____- if and else have incompatible types
3382 // The entire expression is in one line, only point at the arms
3384 // LL | let x = if true { 10i32 } else { 10u32 };
3385 // | ----- ^^^^^ expected i32, found u32
3387 // | expected because of this
3391 let mut remove_semicolon = None;
3392 let error_sp = if let ExprKind::Block(block, _) = &else_expr.node {
3393 if let Some(expr) = &block.expr {
3395 } else if let Some(stmt) = block.stmts.last() {
3396 // possibly incorrect trailing `;` in the else arm
3397 remove_semicolon = self.could_remove_semicolon(block, then_ty);
3399 } else { // empty block, point at its entirety
3400 // Avoid overlapping spans that aren't as readable:
3402 // 2 | let x = if true {
3405 // | | - expected because of this
3412 // | |______if and else have incompatible types
3413 // | expected integer, found ()
3415 // by not pointing at the entire expression:
3417 // 2 | let x = if true {
3418 // | ------- if and else have incompatible types
3420 // | - expected because of this
3425 // | |_____^ expected integer, found ()
3427 if outer_sp.is_some() {
3428 outer_sp = Some(self.tcx.sess.source_map().def_span(sp));
3432 } else { // shouldn't happen unless the parser has done something weird
3435 let then_sp = if let ExprKind::Block(block, _) = &then_expr.node {
3436 if let Some(expr) = &block.expr {
3438 } else if let Some(stmt) = block.stmts.last() {
3439 // possibly incorrect trailing `;` in the else arm
3440 remove_semicolon = remove_semicolon.or(
3441 self.could_remove_semicolon(block, else_ty));
3443 } else { // empty block, point at its entirety
3444 outer_sp = None; // same as in `error_sp`, cleanup output
3447 } else { // shouldn't happen unless the parser has done something weird
3451 let if_cause = self.cause(error_sp, ObligationCauseCode::IfExpression {
3454 semicolon: remove_semicolon,
3457 coerce.coerce(self, &if_cause, else_expr, else_ty);
3459 // We won't diverge unless both branches do (or the condition does).
3460 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3462 // If this `if` expr is the parent's function return expr, the cause of the type
3463 // coercion is the return type, point at it. (#25228)
3464 let ret_reason = self.maybe_get_coercion_reason(then_expr.hir_id, sp);
3466 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3467 coerce.coerce_forced_unit(self, &else_cause, &mut |err| {
3468 if let Some((sp, msg)) = &ret_reason {
3469 err.span_label(*sp, msg.as_str());
3470 } else if let ExprKind::Block(block, _) = &then_expr.node {
3471 if let Some(expr) = &block.expr {
3472 err.span_label(expr.span, "found here".to_string());
3475 err.note("`if` expressions without `else` evaluate to `()`");
3476 err.help("consider adding an `else` block that evaluates to the expected type");
3477 }, ret_reason.is_none());
3479 // If the condition is false we can't diverge.
3480 self.diverges.set(cond_diverges);
3483 let result_ty = coerce.complete(self);
3484 if cond_ty.references_error() {
3491 fn maybe_get_coercion_reason(&self, hir_id: hir::HirId, sp: Span) -> Option<(Span, String)> {
3492 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(
3493 self.tcx.hir().get_parent_node_by_hir_id(hir_id),
3495 if let Node::Block(block) = node {
3496 // check that the body's parent is an fn
3497 let parent = self.tcx.hir().get_by_hir_id(
3498 self.tcx.hir().get_parent_node_by_hir_id(
3499 self.tcx.hir().get_parent_node_by_hir_id(block.hir_id),
3502 if let (Some(expr), Node::Item(hir::Item {
3503 node: hir::ItemKind::Fn(..), ..
3504 })) = (&block.expr, parent) {
3505 // check that the `if` expr without `else` is the fn body's expr
3506 if expr.span == sp {
3507 return self.get_fn_decl(hir_id).map(|(fn_decl, _)| (
3508 fn_decl.output.span(),
3509 format!("expected `{}` because of this return type", fn_decl.output),
3514 if let Node::Local(hir::Local {
3515 ty: Some(_), pat, ..
3517 return Some((pat.span, "expected because of this assignment".to_string()));
3522 // Check field access expressions
3523 fn check_field(&self,
3524 expr: &'gcx hir::Expr,
3526 base: &'gcx hir::Expr,
3527 field: ast::Ident) -> Ty<'tcx> {
3528 let expr_t = self.check_expr_with_needs(base, needs);
3529 let expr_t = self.structurally_resolved_type(base.span,
3531 let mut private_candidate = None;
3532 let mut autoderef = self.autoderef(expr.span, expr_t);
3533 while let Some((base_t, _)) = autoderef.next() {
3535 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3536 debug!("struct named {:?}", base_t);
3537 let (ident, def_scope) =
3538 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3539 let fields = &base_def.non_enum_variant().fields;
3540 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3541 let field = &fields[index];
3542 let field_ty = self.field_ty(expr.span, field, substs);
3543 // Save the index of all fields regardless of their visibility in case
3544 // of error recovery.
3545 self.write_field_index(expr.hir_id, index);
3546 if field.vis.is_accessible_from(def_scope, self.tcx) {
3547 let adjustments = autoderef.adjust_steps(self, needs);
3548 self.apply_adjustments(base, adjustments);
3549 autoderef.finalize(self);
3551 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3554 private_candidate = Some((base_def.did, field_ty));
3557 ty::Tuple(ref tys) => {
3558 let fstr = field.as_str();
3559 if let Ok(index) = fstr.parse::<usize>() {
3560 if fstr == index.to_string() {
3561 if let Some(field_ty) = tys.get(index) {
3562 let adjustments = autoderef.adjust_steps(self, needs);
3563 self.apply_adjustments(base, adjustments);
3564 autoderef.finalize(self);
3566 self.write_field_index(expr.hir_id, index);
3575 autoderef.unambiguous_final_ty(self);
3577 if let Some((did, field_ty)) = private_candidate {
3578 let struct_path = self.tcx().def_path_str(did);
3579 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3580 "field `{}` of struct `{}` is private",
3581 field, struct_path);
3582 // Also check if an accessible method exists, which is often what is meant.
3583 if self.method_exists(field, expr_t, expr.hir_id, false)
3584 && !self.expr_in_place(expr.hir_id)
3586 self.suggest_method_call(
3588 &format!("a method `{}` also exists, call it with parentheses", field),
3596 } else if field.name == keywords::Invalid.name() {
3597 self.tcx().types.err
3598 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3599 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3600 "attempted to take value of method `{}` on type `{}`",
3603 if !self.expr_in_place(expr.hir_id) {
3604 self.suggest_method_call(
3606 "use parentheses to call the method",
3612 err.help("methods are immutable and cannot be assigned to");
3616 self.tcx().types.err
3618 if !expr_t.is_primitive_ty() {
3619 let mut err = self.no_such_field_err(field.span, field, expr_t);
3622 ty::Adt(def, _) if !def.is_enum() => {
3623 if let Some(suggested_field_name) =
3624 Self::suggest_field_name(def.non_enum_variant(),
3625 &field.as_str(), vec![]) {
3626 err.span_suggestion(
3628 "a field with a similar name exists",
3629 suggested_field_name.to_string(),
3630 Applicability::MaybeIncorrect,
3633 err.span_label(field.span, "unknown field");
3634 let struct_variant_def = def.non_enum_variant();
3635 let field_names = self.available_field_names(struct_variant_def);
3636 if !field_names.is_empty() {
3637 err.note(&format!("available fields are: {}",
3638 self.name_series_display(field_names)));
3642 ty::Array(_, len) => {
3643 if let (Some(len), Ok(user_index)) = (
3644 len.assert_usize(self.tcx),
3645 field.as_str().parse::<u64>()
3647 let base = self.tcx.sess.source_map()
3648 .span_to_snippet(base.span)
3650 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3651 let help = "instead of using tuple indexing, use array indexing";
3652 let suggestion = format!("{}[{}]", base, field);
3653 let applicability = if len < user_index {
3654 Applicability::MachineApplicable
3656 Applicability::MaybeIncorrect
3658 err.span_suggestion(
3659 expr.span, help, suggestion, applicability
3664 let base = self.tcx.sess.source_map()
3665 .span_to_snippet(base.span)
3666 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3667 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3668 let suggestion = format!("(*{}).{}", base, field);
3669 err.span_suggestion(
3673 Applicability::MaybeIncorrect,
3680 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3681 "`{}` is a primitive type and therefore doesn't have fields",
3684 self.tcx().types.err
3688 // Return an hint about the closest match in field names
3689 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3691 skip: Vec<LocalInternedString>)
3693 let names = variant.fields.iter().filter_map(|field| {
3694 // ignore already set fields and private fields from non-local crates
3695 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3696 (!variant.def_id.is_local() && field.vis != Visibility::Public)
3700 Some(&field.ident.name)
3704 find_best_match_for_name(names, field, None)
3707 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3708 variant.fields.iter().filter(|field| {
3709 let def_scope = self.tcx.adjust_ident(field.ident, variant.def_id, self.body_id).1;
3710 field.vis.is_accessible_from(def_scope, self.tcx)
3712 .map(|field| field.ident.name)
3716 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3717 // dynamic limit, to never omit just one field
3718 let limit = if names.len() == 6 { 6 } else { 5 };
3719 let mut display = names.iter().take(limit)
3720 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3721 if names.len() > limit {
3722 display = format!("{} ... and {} others", display, names.len() - limit);
3727 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3728 -> DiagnosticBuilder<'_> {
3729 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3730 "no field `{}` on type `{}`",
3734 fn report_unknown_field(
3737 variant: &'tcx ty::VariantDef,
3739 skip_fields: &[hir::Field],
3742 if variant.recovered {
3745 let mut err = self.type_error_struct_with_diag(
3747 |actual| match ty.sty {
3748 ty::Adt(adt, ..) if adt.is_enum() => {
3749 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3750 "{} `{}::{}` has no field named `{}`",
3751 kind_name, actual, variant.ident, field.ident)
3754 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3755 "{} `{}` has no field named `{}`",
3756 kind_name, actual, field.ident)
3760 // prevent all specified fields from being suggested
3761 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3762 if let Some(field_name) = Self::suggest_field_name(variant,
3763 &field.ident.as_str(),
3764 skip_fields.collect()) {
3765 err.span_suggestion(
3767 "a field with a similar name exists",
3768 field_name.to_string(),
3769 Applicability::MaybeIncorrect,
3773 ty::Adt(adt, ..) => {
3775 err.span_label(field.ident.span,
3776 format!("`{}::{}` does not have this field",
3777 ty, variant.ident));
3779 err.span_label(field.ident.span,
3780 format!("`{}` does not have this field", ty));
3782 let available_field_names = self.available_field_names(variant);
3783 if !available_field_names.is_empty() {
3784 err.note(&format!("available fields are: {}",
3785 self.name_series_display(available_field_names)));
3788 _ => bug!("non-ADT passed to report_unknown_field")
3794 fn check_expr_struct_fields(&self,
3796 expected: Expectation<'tcx>,
3797 expr_id: hir::HirId,
3799 variant: &'tcx ty::VariantDef,
3800 ast_fields: &'gcx [hir::Field],
3801 check_completeness: bool) -> bool {
3805 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3806 .get(0).cloned().unwrap_or(adt_ty);
3807 // re-link the regions that EIfEO can erase.
3808 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3810 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3811 &ty::Adt(adt, substs) => {
3812 (substs, adt.adt_kind(), adt.variant_descr())
3814 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3817 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3818 (field.ident.modern(), (i, field))
3819 ).collect::<FxHashMap<_, _>>();
3821 let mut seen_fields = FxHashMap::default();
3823 let mut error_happened = false;
3825 // Type-check each field.
3826 for field in ast_fields {
3827 let ident = tcx.adjust_ident(field.ident, variant.def_id, self.body_id).0;
3828 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3829 seen_fields.insert(ident, field.span);
3830 self.write_field_index(field.hir_id, i);
3832 // We don't look at stability attributes on
3833 // struct-like enums (yet...), but it's definitely not
3834 // a bug to have constructed one.
3835 if adt_kind != AdtKind::Enum {
3836 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3839 self.field_ty(field.span, v_field, substs)
3841 error_happened = true;
3842 if let Some(prev_span) = seen_fields.get(&ident) {
3843 let mut err = struct_span_err!(self.tcx.sess,
3846 "field `{}` specified more than once",
3849 err.span_label(field.ident.span, "used more than once");
3850 err.span_label(*prev_span, format!("first use of `{}`", ident));
3854 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3860 // Make sure to give a type to the field even if there's
3861 // an error, so we can continue type-checking.
3862 self.check_expr_coercable_to_type(&field.expr, field_type);
3865 // Make sure the programmer specified correct number of fields.
3866 if kind_name == "union" {
3867 if ast_fields.len() != 1 {
3868 tcx.sess.span_err(span, "union expressions should have exactly one field");
3870 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3871 let len = remaining_fields.len();
3873 let mut displayable_field_names = remaining_fields
3875 .map(|ident| ident.as_str())
3876 .collect::<Vec<_>>();
3878 displayable_field_names.sort();
3880 let truncated_fields_error = if len <= 3 {
3883 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3886 let remaining_fields_names = displayable_field_names.iter().take(3)
3887 .map(|n| format!("`{}`", n))
3888 .collect::<Vec<_>>()
3891 struct_span_err!(tcx.sess, span, E0063,
3892 "missing field{} {}{} in initializer of `{}`",
3893 if remaining_fields.len() == 1 { "" } else { "s" },
3894 remaining_fields_names,
3895 truncated_fields_error,
3897 .span_label(span, format!("missing {}{}",
3898 remaining_fields_names,
3899 truncated_fields_error))
3905 fn check_struct_fields_on_error(&self,
3906 fields: &'gcx [hir::Field],
3907 base_expr: &'gcx Option<P<hir::Expr>>) {
3908 for field in fields {
3909 self.check_expr(&field.expr);
3911 if let Some(ref base) = *base_expr {
3912 self.check_expr(&base);
3916 pub fn check_struct_path(&self,
3919 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3920 let path_span = match *qpath {
3921 QPath::Resolved(_, ref path) => path.span,
3922 QPath::TypeRelative(ref qself, _) => qself.span
3924 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3925 let variant = match def {
3927 self.set_tainted_by_errors();
3930 Def::Variant(..) => {
3932 ty::Adt(adt, substs) => {
3933 Some((adt.variant_of_def(def), adt.did, substs))
3935 _ => bug!("unexpected type: {:?}", ty)
3938 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3939 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3941 ty::Adt(adt, substs) if !adt.is_enum() => {
3942 Some((adt.non_enum_variant(), adt.did, substs))
3947 _ => bug!("unexpected definition: {:?}", def)
3950 if let Some((variant, did, substs)) = variant {
3951 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3952 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3954 // Check bounds on type arguments used in the path.
3955 let bounds = self.instantiate_bounds(path_span, did, substs);
3956 let cause = traits::ObligationCause::new(path_span, self.body_id,
3957 traits::ItemObligation(did));
3958 self.add_obligations_for_parameters(cause, &bounds);
3962 struct_span_err!(self.tcx.sess, path_span, E0071,
3963 "expected struct, variant or union type, found {}",
3964 ty.sort_string(self.tcx))
3965 .span_label(path_span, "not a struct")
3971 fn check_expr_struct(&self,
3973 expected: Expectation<'tcx>,
3975 fields: &'gcx [hir::Field],
3976 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3978 // Find the relevant variant
3979 let (variant, adt_ty) =
3980 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3983 self.check_struct_fields_on_error(fields, base_expr);
3984 return self.tcx.types.err;
3987 let path_span = match *qpath {
3988 QPath::Resolved(_, ref path) => path.span,
3989 QPath::TypeRelative(ref qself, _) => qself.span
3992 // Prohibit struct expressions when non-exhaustive flag is set.
3993 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3994 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3995 span_err!(self.tcx.sess, expr.span, E0639,
3996 "cannot create non-exhaustive {} using struct expression",
3997 adt.variant_descr());
4000 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
4001 variant, fields, base_expr.is_none());
4002 if let &Some(ref base_expr) = base_expr {
4003 // If check_expr_struct_fields hit an error, do not attempt to populate
4004 // the fields with the base_expr. This could cause us to hit errors later
4005 // when certain fields are assumed to exist that in fact do not.
4006 if !error_happened {
4007 self.check_expr_has_type_or_error(base_expr, adt_ty);
4009 ty::Adt(adt, substs) if adt.is_struct() => {
4010 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
4011 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
4016 .fru_field_types_mut()
4017 .insert(expr.hir_id, fru_field_types);
4020 span_err!(self.tcx.sess, base_expr.span, E0436,
4021 "functional record update syntax requires a struct");
4026 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
4032 /// If an expression has any sub-expressions that result in a type error,
4033 /// inspecting that expression's type with `ty.references_error()` will return
4034 /// true. Likewise, if an expression is known to diverge, inspecting its
4035 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
4036 /// strict, _|_ can appear in the type of an expression that does not,
4037 /// itself, diverge: for example, fn() -> _|_.)
4038 /// Note that inspecting a type's structure *directly* may expose the fact
4039 /// that there are actually multiple representations for `Error`, so avoid
4040 /// that when err needs to be handled differently.
4041 fn check_expr_with_expectation_and_needs(&self,
4042 expr: &'gcx hir::Expr,
4043 expected: Expectation<'tcx>,
4044 needs: Needs) -> Ty<'tcx> {
4045 debug!(">> type-checking: expr={:?} expected={:?}",
4048 // Warn for expressions after diverging siblings.
4049 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
4051 // Hide the outer diverging and has_errors flags.
4052 let old_diverges = self.diverges.get();
4053 let old_has_errors = self.has_errors.get();
4054 self.diverges.set(Diverges::Maybe);
4055 self.has_errors.set(false);
4057 let ty = self.check_expr_kind(expr, expected, needs);
4059 // Warn for non-block expressions with diverging children.
4061 ExprKind::Block(..) |
4062 ExprKind::Loop(..) | ExprKind::While(..) |
4063 ExprKind::If(..) | ExprKind::Match(..) => {}
4065 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
4068 // Any expression that produces a value of type `!` must have diverged
4070 self.diverges.set(self.diverges.get() | Diverges::Always);
4073 // Record the type, which applies it effects.
4074 // We need to do this after the warning above, so that
4075 // we don't warn for the diverging expression itself.
4076 self.write_ty(expr.hir_id, ty);
4078 // Combine the diverging and has_error flags.
4079 self.diverges.set(self.diverges.get() | old_diverges);
4080 self.has_errors.set(self.has_errors.get() | old_has_errors);
4082 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
4083 debug!("... {:?}, expected is {:?}", ty, expected);
4090 expr: &'gcx hir::Expr,
4091 expected: Expectation<'tcx>,
4095 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
4102 let id = expr.hir_id;
4104 ExprKind::Box(ref subexpr) => {
4105 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
4107 ty::Adt(def, _) if def.is_box()
4108 => Expectation::rvalue_hint(self, ty.boxed_ty()),
4112 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
4113 tcx.mk_box(referent_ty)
4116 ExprKind::Lit(ref lit) => {
4117 self.check_lit(&lit, expected)
4119 ExprKind::Binary(op, ref lhs, ref rhs) => {
4120 self.check_binop(expr, op, lhs, rhs)
4122 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
4123 self.check_binop_assign(expr, op, lhs, rhs)
4125 ExprKind::Unary(unop, ref oprnd) => {
4126 let expected_inner = match unop {
4127 hir::UnNot | hir::UnNeg => {
4134 let needs = match unop {
4135 hir::UnDeref => needs,
4138 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
4142 if !oprnd_t.references_error() {
4143 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
4146 if let Some(mt) = oprnd_t.builtin_deref(true) {
4148 } else if let Some(ok) = self.try_overloaded_deref(
4149 expr.span, oprnd_t, needs) {
4150 let method = self.register_infer_ok_obligations(ok);
4151 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
4152 let mutbl = match mutbl {
4153 hir::MutImmutable => AutoBorrowMutability::Immutable,
4154 hir::MutMutable => AutoBorrowMutability::Mutable {
4155 // (It shouldn't actually matter for unary ops whether
4156 // we enable two-phase borrows or not, since a unary
4157 // op has no additional operands.)
4158 allow_two_phase_borrow: AllowTwoPhase::No,
4161 self.apply_adjustments(oprnd, vec![Adjustment {
4162 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
4163 target: method.sig.inputs()[0]
4166 oprnd_t = self.make_overloaded_place_return_type(method).ty;
4167 self.write_method_call(expr.hir_id, method);
4169 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
4170 "type `{}` cannot be dereferenced",
4172 oprnd_t = tcx.types.err;
4176 let result = self.check_user_unop(expr, oprnd_t, unop);
4177 // If it's builtin, we can reuse the type, this helps inference.
4178 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4183 let result = self.check_user_unop(expr, oprnd_t, unop);
4184 // If it's builtin, we can reuse the type, this helps inference.
4185 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4193 ExprKind::AddrOf(mutbl, ref oprnd) => {
4194 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4196 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4197 if oprnd.is_place_expr() {
4198 // Places may legitimately have unsized types.
4199 // For example, dereferences of a fat pointer and
4200 // the last field of a struct can be unsized.
4203 Expectation::rvalue_hint(self, ty)
4209 let needs = Needs::maybe_mut_place(mutbl);
4210 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4212 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4213 if tm.ty.references_error() {
4216 // Note: at this point, we cannot say what the best lifetime
4217 // is to use for resulting pointer. We want to use the
4218 // shortest lifetime possible so as to avoid spurious borrowck
4219 // errors. Moreover, the longest lifetime will depend on the
4220 // precise details of the value whose address is being taken
4221 // (and how long it is valid), which we don't know yet until type
4222 // inference is complete.
4224 // Therefore, here we simply generate a region variable. The
4225 // region inferencer will then select the ultimate value.
4226 // Finally, borrowck is charged with guaranteeing that the
4227 // value whose address was taken can actually be made to live
4228 // as long as it needs to live.
4229 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4230 tcx.mk_ref(region, tm)
4233 ExprKind::Path(ref qpath) => {
4234 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.hir_id,
4236 let ty = match def {
4238 self.set_tainted_by_errors();
4241 Def::Ctor(_, _, CtorKind::Fictive) => {
4242 report_unexpected_variant_def(tcx, &def, expr.span, qpath);
4245 _ => self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0,
4248 if let ty::FnDef(..) = ty.sty {
4249 let fn_sig = ty.fn_sig(tcx);
4250 if !tcx.features().unsized_locals {
4251 // We want to remove some Sized bounds from std functions,
4252 // but don't want to expose the removal to stable Rust.
4253 // i.e., we don't want to allow
4259 // to work in stable even if the Sized bound on `drop` is relaxed.
4260 for i in 0..fn_sig.inputs().skip_binder().len() {
4261 // We just want to check sizedness, so instead of introducing
4262 // placeholder lifetimes with probing, we just replace higher lifetimes
4264 let input = self.replace_bound_vars_with_fresh_vars(
4266 infer::LateBoundRegionConversionTime::FnCall,
4267 &fn_sig.input(i)).0;
4268 self.require_type_is_sized_deferred(input, expr.span,
4269 traits::SizedArgumentType);
4272 // Here we want to prevent struct constructors from returning unsized types.
4273 // There were two cases this happened: fn pointer coercion in stable
4274 // and usual function call in presense of unsized_locals.
4275 // Also, as we just want to check sizedness, instead of introducing
4276 // placeholder lifetimes with probing, we just replace higher lifetimes
4278 let output = self.replace_bound_vars_with_fresh_vars(
4280 infer::LateBoundRegionConversionTime::FnCall,
4281 &fn_sig.output()).0;
4282 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4285 // We always require that the type provided as the value for
4286 // a type parameter outlives the moment of instantiation.
4287 let substs = self.tables.borrow().node_substs(expr.hir_id);
4288 self.add_wf_bounds(substs, expr);
4292 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4293 for expr in outputs.iter().chain(inputs.iter()) {
4294 self.check_expr(expr);
4298 ExprKind::Break(destination, ref expr_opt) => {
4299 if let Ok(target_id) = destination.target_id {
4301 if let Some(ref e) = *expr_opt {
4302 // If this is a break with a value, we need to type-check
4303 // the expression. Get an expected type from the loop context.
4304 let opt_coerce_to = {
4305 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4306 enclosing_breakables.find_breakable(target_id)
4309 .map(|coerce| coerce.expected_ty())
4312 // If the loop context is not a `loop { }`, then break with
4313 // a value is illegal, and `opt_coerce_to` will be `None`.
4314 // Just set expectation to error in that case.
4315 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4317 // Recurse without `enclosing_breakables` borrowed.
4318 e_ty = self.check_expr_with_hint(e, coerce_to);
4319 cause = self.misc(e.span);
4321 // Otherwise, this is a break *without* a value. That's
4322 // always legal, and is equivalent to `break ()`.
4323 e_ty = tcx.mk_unit();
4324 cause = self.misc(expr.span);
4327 // Now that we have type-checked `expr_opt`, borrow
4328 // the `enclosing_loops` field and let's coerce the
4329 // type of `expr_opt` into what is expected.
4330 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4331 let ctxt = enclosing_breakables.find_breakable(target_id);
4332 if let Some(ref mut coerce) = ctxt.coerce {
4333 if let Some(ref e) = *expr_opt {
4334 coerce.coerce(self, &cause, e, e_ty);
4336 assert!(e_ty.is_unit());
4337 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4340 // If `ctxt.coerce` is `None`, we can just ignore
4341 // the type of the expresison. This is because
4342 // either this was a break *without* a value, in
4343 // which case it is always a legal type (`()`), or
4344 // else an error would have been flagged by the
4345 // `loops` pass for using break with an expression
4346 // where you are not supposed to.
4347 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4350 ctxt.may_break = true;
4352 // the type of a `break` is always `!`, since it diverges
4355 // Otherwise, we failed to find the enclosing loop;
4356 // this can only happen if the `break` was not
4357 // inside a loop at all, which is caught by the
4358 // loop-checking pass.
4359 if self.tcx.sess.err_count() == 0 {
4360 self.tcx.sess.delay_span_bug(expr.span,
4361 "break was outside loop, but no error was emitted");
4364 // We still need to assign a type to the inner expression to
4365 // prevent the ICE in #43162.
4366 if let Some(ref e) = *expr_opt {
4367 self.check_expr_with_hint(e, tcx.types.err);
4369 // ... except when we try to 'break rust;'.
4370 // ICE this expression in particular (see #43162).
4371 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4372 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4373 fatally_break_rust(self.tcx.sess);
4377 // There was an error; make type-check fail.
4382 ExprKind::Continue(destination) => {
4383 if destination.target_id.is_ok() {
4386 // There was an error; make type-check fail.
4390 ExprKind::Ret(ref expr_opt) => {
4391 if self.ret_coercion.is_none() {
4392 struct_span_err!(self.tcx.sess, expr.span, E0572,
4393 "return statement outside of function body").emit();
4394 } else if let Some(ref e) = *expr_opt {
4395 if self.ret_coercion_span.borrow().is_none() {
4396 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4398 self.check_return_expr(e);
4400 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4401 if self.ret_coercion_span.borrow().is_none() {
4402 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4404 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4405 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4406 coercion.coerce_forced_unit(
4411 fn_decl.output.span(),
4413 "expected `{}` because of this return type",
4421 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4426 ExprKind::Assign(ref lhs, ref rhs) => {
4427 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4429 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4432 ExpectIfCondition => {
4433 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4434 expected error elsehwere");
4437 // Only check this if not in an `if` condition, as the
4438 // mistyped comparison help is more appropriate.
4439 if !lhs.is_place_expr() {
4440 struct_span_err!(self.tcx.sess, expr.span, E0070,
4441 "invalid left-hand side expression")
4442 .span_label(expr.span, "left-hand of expression not valid")
4448 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4450 if lhs_ty.references_error() || rhs_ty.references_error() {
4456 ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4457 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4458 expr.span, expected)
4460 ExprKind::While(ref cond, ref body, _) => {
4461 let ctxt = BreakableCtxt {
4462 // cannot use break with a value from a while loop
4464 may_break: false, // Will get updated if/when we find a `break`.
4467 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4468 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4469 let cond_diverging = self.diverges.get();
4470 self.check_block_no_value(&body);
4472 // We may never reach the body so it diverging means nothing.
4473 self.diverges.set(cond_diverging);
4477 // No way to know whether it's diverging because
4478 // of a `break` or an outer `break` or `return`.
4479 self.diverges.set(Diverges::Maybe);
4484 ExprKind::Loop(ref body, _, source) => {
4485 let coerce = match source {
4486 // you can only use break with a value from a normal `loop { }`
4487 hir::LoopSource::Loop => {
4488 let coerce_to = expected.coercion_target_type(self, body.span);
4489 Some(CoerceMany::new(coerce_to))
4492 hir::LoopSource::WhileLet |
4493 hir::LoopSource::ForLoop => {
4498 let ctxt = BreakableCtxt {
4500 may_break: false, // Will get updated if/when we find a `break`.
4503 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4504 self.check_block_no_value(&body);
4508 // No way to know whether it's diverging because
4509 // of a `break` or an outer `break` or `return`.
4510 self.diverges.set(Diverges::Maybe);
4513 // If we permit break with a value, then result type is
4514 // the LUB of the breaks (possibly ! if none); else, it
4515 // is nil. This makes sense because infinite loops
4516 // (which would have type !) are only possible iff we
4517 // permit break with a value [1].
4518 if ctxt.coerce.is_none() && !ctxt.may_break {
4520 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4522 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4524 ExprKind::Match(ref discrim, ref arms, match_src) => {
4525 self.check_match(expr, &discrim, arms, expected, match_src)
4527 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4528 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4530 ExprKind::Block(ref body, _) => {
4531 self.check_block_with_expected(&body, expected)
4533 ExprKind::Call(ref callee, ref args) => {
4534 self.check_call(expr, &callee, args, expected)
4536 ExprKind::MethodCall(ref segment, span, ref args) => {
4537 self.check_method_call(expr, segment, span, args, expected, needs)
4539 ExprKind::Cast(ref e, ref t) => {
4540 // Find the type of `e`. Supply hints based on the type we are casting to,
4542 let t_cast = self.to_ty_saving_user_provided_ty(t);
4543 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4544 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4545 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4547 // Eagerly check for some obvious errors.
4548 if t_expr.references_error() || t_cast.references_error() {
4551 // Defer other checks until we're done type checking.
4552 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4553 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4555 deferred_cast_checks.push(cast_check);
4558 Err(ErrorReported) => {
4564 ExprKind::Type(ref e, ref t) => {
4565 let ty = self.to_ty_saving_user_provided_ty(&t);
4566 self.check_expr_eq_type(&e, ty);
4569 ExprKind::Array(ref args) => {
4570 let uty = expected.to_option(self).and_then(|uty| {
4572 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4577 let element_ty = if !args.is_empty() {
4578 let coerce_to = uty.unwrap_or_else(
4579 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4580 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4581 assert_eq!(self.diverges.get(), Diverges::Maybe);
4583 let e_ty = self.check_expr_with_hint(e, coerce_to);
4584 let cause = self.misc(e.span);
4585 coerce.coerce(self, &cause, e, e_ty);
4587 coerce.complete(self)
4589 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4591 tcx.mk_array(element_ty, args.len() as u64)
4593 ExprKind::Repeat(ref element, ref count) => {
4594 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4595 let param_env = ty::ParamEnv::empty();
4596 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4597 let instance = ty::Instance::resolve(
4603 let global_id = GlobalId {
4607 let count = tcx.const_eval(param_env.and(global_id));
4609 let uty = match expected {
4610 ExpectHasType(uty) => {
4612 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4619 let (element_ty, t) = match uty {
4621 self.check_expr_coercable_to_type(&element, uty);
4625 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4626 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4631 if let Ok(count) = count {
4632 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4634 // For [foo, ..n] where n > 1, `foo` must have
4636 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4637 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4641 if element_ty.references_error() {
4643 } else if let Ok(count) = count {
4644 tcx.mk_ty(ty::Array(t, tcx.mk_const(count)))
4649 ExprKind::Tup(ref elts) => {
4650 let flds = expected.only_has_type(self).and_then(|ty| {
4651 let ty = self.resolve_type_vars_with_obligations(ty);
4653 ty::Tuple(ref flds) => Some(&flds[..]),
4658 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4659 let t = match flds {
4660 Some(ref fs) if i < fs.len() => {
4662 self.check_expr_coercable_to_type(&e, ety);
4666 self.check_expr_with_expectation(&e, NoExpectation)
4671 let tuple = tcx.mk_tup(elt_ts_iter);
4672 if tuple.references_error() {
4675 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4679 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4680 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4682 ExprKind::Field(ref base, field) => {
4683 self.check_field(expr, needs, &base, field)
4685 ExprKind::Index(ref base, ref idx) => {
4686 let base_t = self.check_expr_with_needs(&base, needs);
4687 let idx_t = self.check_expr(&idx);
4689 if base_t.references_error() {
4691 } else if idx_t.references_error() {
4694 let base_t = self.structurally_resolved_type(base.span, base_t);
4695 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4696 Some((index_ty, element_ty)) => {
4697 // two-phase not needed because index_ty is never mutable
4698 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4703 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4704 "cannot index into a value of type `{}`",
4706 // Try to give some advice about indexing tuples.
4707 if let ty::Tuple(..) = base_t.sty {
4708 let mut needs_note = true;
4709 // If the index is an integer, we can show the actual
4710 // fixed expression:
4711 if let ExprKind::Lit(ref lit) = idx.node {
4712 if let ast::LitKind::Int(i,
4713 ast::LitIntType::Unsuffixed) = lit.node {
4714 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4715 if let Ok(snip) = snip {
4716 err.span_suggestion(
4718 "to access tuple elements, use",
4719 format!("{}.{}", snip, i),
4720 Applicability::MachineApplicable,
4727 err.help("to access tuple elements, use tuple indexing \
4728 syntax (e.g., `tuple.0`)");
4737 ExprKind::Yield(ref value) => {
4738 match self.yield_ty {
4740 self.check_expr_coercable_to_type(&value, ty);
4743 struct_span_err!(self.tcx.sess, expr.span, E0627,
4744 "yield statement outside of generator literal").emit();
4749 hir::ExprKind::Err => {
4755 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4756 // The newly resolved definition is written into `type_dependent_defs`.
4757 fn finish_resolving_struct_path(&self,
4764 QPath::Resolved(ref maybe_qself, ref path) => {
4765 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4766 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4769 QPath::TypeRelative(ref qself, ref segment) => {
4770 let ty = self.to_ty(qself);
4772 let def = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4777 let (ty, def) = AstConv::associated_path_to_ty(self, hir_id, path_span,
4778 ty, def, segment, true);
4780 // Write back the new resolution.
4781 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4788 /// Resolves associated value path into a base type and associated constant or method
4789 /// definition. The newly resolved definition is written into `type_dependent_defs`.
4790 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4794 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4796 debug!("resolve_ty_and_def_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4797 let (ty, qself, item_segment) = match *qpath {
4798 QPath::Resolved(ref opt_qself, ref path) => {
4800 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4801 &path.segments[..]);
4803 QPath::TypeRelative(ref qself, ref segment) => {
4804 (self.to_ty(qself), qself, segment)
4807 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4808 // Return directly on cache hit. This is useful to avoid doubly reporting
4809 // errors with default match binding modes. See #44614.
4810 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4812 let item_name = item_segment.ident;
4813 let def = match self.resolve_ufcs(span, item_name, ty, hir_id) {
4816 let def = match error {
4817 method::MethodError::PrivateMatch(def, _) => def,
4820 if item_name.name != keywords::Invalid.name() {
4821 self.report_method_error(span,
4824 SelfSource::QPath(qself),
4832 // Write back the new resolution.
4833 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4834 (def, Some(ty), slice::from_ref(&**item_segment))
4837 pub fn check_decl_initializer(&self,
4838 local: &'gcx hir::Local,
4839 init: &'gcx hir::Expr) -> Ty<'tcx>
4841 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4842 // for #42640 (default match binding modes).
4845 let ref_bindings = local.pat.contains_explicit_ref_binding();
4847 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4848 if let Some(m) = ref_bindings {
4849 // Somewhat subtle: if we have a `ref` binding in the pattern,
4850 // we want to avoid introducing coercions for the RHS. This is
4851 // both because it helps preserve sanity and, in the case of
4852 // ref mut, for soundness (issue #23116). In particular, in
4853 // the latter case, we need to be clear that the type of the
4854 // referent for the reference that results is *equal to* the
4855 // type of the place it is referencing, and not some
4856 // supertype thereof.
4857 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4858 self.demand_eqtype(init.span, local_ty, init_ty);
4861 self.check_expr_coercable_to_type(init, local_ty)
4865 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4866 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4867 self.write_ty(local.hir_id, t);
4869 if let Some(ref init) = local.init {
4870 let init_ty = self.check_decl_initializer(local, &init);
4871 if init_ty.references_error() {
4872 self.write_ty(local.hir_id, init_ty);
4876 self.check_pat_walk(
4879 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4882 let pat_ty = self.node_ty(local.pat.hir_id);
4883 if pat_ty.references_error() {
4884 self.write_ty(local.hir_id, pat_ty);
4888 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4889 // Don't do all the complex logic below for `DeclItem`.
4891 hir::StmtKind::Item(..) => return,
4892 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4895 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4897 // Hide the outer diverging and `has_errors` flags.
4898 let old_diverges = self.diverges.get();
4899 let old_has_errors = self.has_errors.get();
4900 self.diverges.set(Diverges::Maybe);
4901 self.has_errors.set(false);
4904 hir::StmtKind::Local(ref l) => {
4905 self.check_decl_local(&l);
4908 hir::StmtKind::Item(_) => {}
4909 hir::StmtKind::Expr(ref expr) => {
4910 // Check with expected type of `()`.
4911 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4913 hir::StmtKind::Semi(ref expr) => {
4914 self.check_expr(&expr);
4918 // Combine the diverging and `has_error` flags.
4919 self.diverges.set(self.diverges.get() | old_diverges);
4920 self.has_errors.set(self.has_errors.get() | old_has_errors);
4923 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4924 let unit = self.tcx.mk_unit();
4925 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4927 // if the block produces a `!` value, that can always be
4928 // (effectively) coerced to unit.
4930 self.demand_suptype(blk.span, unit, ty);
4934 fn check_block_with_expected(&self,
4935 blk: &'gcx hir::Block,
4936 expected: Expectation<'tcx>) -> Ty<'tcx> {
4938 let mut fcx_ps = self.ps.borrow_mut();
4939 let unsafety_state = fcx_ps.recurse(blk);
4940 replace(&mut *fcx_ps, unsafety_state)
4943 // In some cases, blocks have just one exit, but other blocks
4944 // can be targeted by multiple breaks. This can happen both
4945 // with labeled blocks as well as when we desugar
4946 // a `try { ... }` expression.
4950 // 'a: { if true { break 'a Err(()); } Ok(()) }
4952 // Here we would wind up with two coercions, one from
4953 // `Err(())` and the other from the tail expression
4954 // `Ok(())`. If the tail expression is omitted, that's a
4955 // "forced unit" -- unless the block diverges, in which
4956 // case we can ignore the tail expression (e.g., `'a: {
4957 // break 'a 22; }` would not force the type of the block
4959 let tail_expr = blk.expr.as_ref();
4960 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4961 let coerce = if blk.targeted_by_break {
4962 CoerceMany::new(coerce_to_ty)
4964 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4965 Some(e) => slice::from_ref(e),
4968 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4971 let prev_diverges = self.diverges.get();
4972 let ctxt = BreakableCtxt {
4973 coerce: Some(coerce),
4977 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4978 for s in &blk.stmts {
4982 // check the tail expression **without** holding the
4983 // `enclosing_breakables` lock below.
4984 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4986 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4987 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4988 let coerce = ctxt.coerce.as_mut().unwrap();
4989 if let Some(tail_expr_ty) = tail_expr_ty {
4990 let tail_expr = tail_expr.unwrap();
4991 let cause = self.cause(tail_expr.span,
4992 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4998 // Subtle: if there is no explicit tail expression,
4999 // that is typically equivalent to a tail expression
5000 // of `()` -- except if the block diverges. In that
5001 // case, there is no value supplied from the tail
5002 // expression (assuming there are no other breaks,
5003 // this implies that the type of the block will be
5006 // #41425 -- label the implicit `()` as being the
5007 // "found type" here, rather than the "expected type".
5008 if !self.diverges.get().always() {
5009 // #50009 -- Do not point at the entire fn block span, point at the return type
5010 // span, as it is the cause of the requirement, and
5011 // `consider_hint_about_removing_semicolon` will point at the last expression
5012 // if it were a relevant part of the error. This improves usability in editors
5013 // that highlight errors inline.
5014 let mut sp = blk.span;
5015 let mut fn_span = None;
5016 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
5017 let ret_sp = decl.output.span();
5018 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
5019 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
5020 // output would otherwise be incorrect and even misleading. Make sure
5021 // the span we're aiming at correspond to a `fn` body.
5022 if block_sp == blk.span {
5024 fn_span = Some(ident.span);
5028 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
5029 if let Some(expected_ty) = expected.only_has_type(self) {
5030 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
5032 if let Some(fn_span) = fn_span {
5033 err.span_label(fn_span, "this function's body doesn't return");
5041 // If we can break from the block, then the block's exit is always reachable
5042 // (... as long as the entry is reachable) - regardless of the tail of the block.
5043 self.diverges.set(prev_diverges);
5046 let mut ty = ctxt.coerce.unwrap().complete(self);
5048 if self.has_errors.get() || ty.references_error() {
5049 ty = self.tcx.types.err
5052 self.write_ty(blk.hir_id, ty);
5054 *self.ps.borrow_mut() = prev;
5058 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
5059 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
5061 Node::Item(&hir::Item {
5062 node: hir::ItemKind::Fn(_, _, _, body_id), ..
5064 Node::ImplItem(&hir::ImplItem {
5065 node: hir::ImplItemKind::Method(_, body_id), ..
5067 let body = self.tcx.hir().body(body_id);
5068 if let ExprKind::Block(block, _) = &body.value.node {
5069 return Some(block.span);
5077 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
5078 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
5079 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
5080 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
5083 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
5084 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
5086 Node::Item(&hir::Item {
5087 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
5088 }) => decl.clone().and_then(|decl| {
5089 // This is less than ideal, it will not suggest a return type span on any
5090 // method called `main`, regardless of whether it is actually the entry point,
5091 // but it will still present it as the reason for the expected type.
5092 Some((decl, ident, ident.name != Symbol::intern("main")))
5094 Node::TraitItem(&hir::TraitItem {
5095 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
5098 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
5099 Node::ImplItem(&hir::ImplItem {
5100 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
5103 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
5108 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
5109 /// suggestion can be made, `None` otherwise.
5110 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
5111 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
5112 // `while` before reaching it, as block tail returns are not available in them.
5113 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
5114 let parent = self.tcx.hir().get_by_hir_id(blk_id);
5115 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
5119 /// On implicit return expressions with mismatched types, provides the following suggestions:
5121 /// - Points out the method's return type as the reason for the expected type.
5122 /// - Possible missing semicolon.
5123 /// - Possible missing return type if the return type is the default, and not `fn main()`.
5124 pub fn suggest_mismatched_types_on_tail(
5126 err: &mut DiagnosticBuilder<'tcx>,
5127 expression: &'gcx hir::Expr,
5133 self.suggest_missing_semicolon(err, expression, expected, cause_span);
5134 let mut pointing_at_return_type = false;
5135 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
5136 pointing_at_return_type = self.suggest_missing_return_type(
5137 err, &fn_decl, expected, found, can_suggest);
5139 self.suggest_ref_or_into(err, expression, expected, found);
5140 pointing_at_return_type
5143 pub fn suggest_ref_or_into(
5145 err: &mut DiagnosticBuilder<'tcx>,
5150 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5151 err.span_suggestion(
5155 Applicability::MachineApplicable,
5157 } else if !self.check_for_cast(err, expr, found, expected) {
5158 let methods = self.get_conversion_methods(expr.span, expected, found);
5159 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5160 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5161 .filter_map(|(receiver, method)| {
5162 let method_call = format!(".{}()", method.ident);
5163 if receiver.ends_with(&method_call) {
5164 None // do not suggest code that is already there (#53348)
5166 let method_call_list = [".to_vec()", ".to_string()"];
5167 if receiver.ends_with(".clone()")
5168 && method_call_list.contains(&method_call.as_str()) {
5169 let max_len = receiver.rfind(".").unwrap();
5170 Some(format!("{}{}", &receiver[..max_len], method_call))
5173 Some(format!("{}{}", receiver, method_call))
5177 if suggestions.peek().is_some() {
5178 err.span_suggestions(
5180 "try using a conversion method",
5182 Applicability::MaybeIncorrect,
5189 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5193 /// bar_that_returns_u32()
5197 /// This routine checks if the return expression in a block would make sense on its own as a
5198 /// statement and the return type has been left as default or has been specified as `()`. If so,
5199 /// it suggests adding a semicolon.
5200 fn suggest_missing_semicolon(&self,
5201 err: &mut DiagnosticBuilder<'tcx>,
5202 expression: &'gcx hir::Expr,
5205 if expected.is_unit() {
5206 // `BlockTailExpression` only relevant if the tail expr would be
5207 // useful on its own.
5208 match expression.node {
5209 ExprKind::Call(..) |
5210 ExprKind::MethodCall(..) |
5212 ExprKind::While(..) |
5213 ExprKind::Loop(..) |
5214 ExprKind::Match(..) |
5215 ExprKind::Block(..) => {
5216 let sp = self.tcx.sess.source_map().next_point(cause_span);
5217 err.span_suggestion(
5219 "try adding a semicolon",
5221 Applicability::MachineApplicable);
5228 /// A possible error is to forget to add a return type that is needed:
5232 /// bar_that_returns_u32()
5236 /// This routine checks if the return type is left as default, the method is not part of an
5237 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5239 fn suggest_missing_return_type(
5241 err: &mut DiagnosticBuilder<'tcx>,
5242 fn_decl: &hir::FnDecl,
5247 // Only suggest changing the return type for methods that
5248 // haven't set a return type at all (and aren't `fn main()` or an impl).
5249 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5250 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5251 err.span_suggestion(
5253 "try adding a return type",
5254 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5255 Applicability::MachineApplicable);
5258 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5259 err.span_label(span, "possibly return type missing here?");
5262 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5263 // `fn main()` must return `()`, do not suggest changing return type
5264 err.span_label(span, "expected `()` because of default return type");
5267 // expectation was caused by something else, not the default return
5268 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5269 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5270 // Only point to return type if the expected type is the return type, as if they
5271 // are not, the expectation must have been caused by something else.
5272 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5274 let ty = AstConv::ast_ty_to_ty(self, ty);
5275 debug!("suggest_missing_return_type: return type {:?}", ty);
5276 debug!("suggest_missing_return_type: expected type {:?}", ty);
5277 if ty.sty == expected.sty {
5278 err.span_label(sp, format!("expected `{}` because of return type",
5287 /// A common error is to add an extra semicolon:
5290 /// fn foo() -> usize {
5295 /// This routine checks if the final statement in a block is an
5296 /// expression with an explicit semicolon whose type is compatible
5297 /// with `expected_ty`. If so, it suggests removing the semicolon.
5298 fn consider_hint_about_removing_semicolon(
5300 blk: &'gcx hir::Block,
5301 expected_ty: Ty<'tcx>,
5302 err: &mut DiagnosticBuilder<'_>,
5304 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5305 err.span_suggestion(
5307 "consider removing this semicolon",
5309 Applicability::MachineApplicable,
5314 fn could_remove_semicolon(
5316 blk: &'gcx hir::Block,
5317 expected_ty: Ty<'tcx>,
5319 // Be helpful when the user wrote `{... expr;}` and
5320 // taking the `;` off is enough to fix the error.
5321 let last_stmt = blk.stmts.last()?;
5322 let last_expr = match last_stmt.node {
5323 hir::StmtKind::Semi(ref e) => e,
5326 let last_expr_ty = self.node_ty(last_expr.hir_id);
5327 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5330 let original_span = original_sp(last_stmt.span, blk.span);
5331 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5334 // Rewrite `SelfCtor` to `Ctor`
5335 pub fn rewrite_self_ctor(&self, def: Def, span: Span) -> (Def, DefId, Ty<'tcx>) {
5337 if let Def::SelfCtor(impl_def_id) = def {
5338 let ty = self.impl_self_ty(span, impl_def_id).ty;
5339 let adt_def = ty.ty_adt_def();
5342 Some(adt_def) if adt_def.has_ctor() => {
5343 let variant = adt_def.non_enum_variant();
5344 let ctor_def_id = variant.ctor_def_id.unwrap();
5345 let def = Def::Ctor(ctor_def_id, CtorOf::Struct, variant.ctor_kind);
5346 (def, ctor_def_id, tcx.type_of(ctor_def_id))
5349 let mut err = tcx.sess.struct_span_err(span,
5350 "the `Self` constructor can only be used with tuple or unit structs");
5351 if let Some(adt_def) = adt_def {
5352 match adt_def.adt_kind() {
5354 err.help("did you mean to use one of the enum's variants?");
5358 err.span_suggestion(
5360 "use curly brackets",
5361 String::from("Self { /* fields */ }"),
5362 Applicability::HasPlaceholders,
5369 (def, impl_def_id, tcx.types.err)
5373 let def_id = def.def_id();
5375 // The things we are substituting into the type should not contain
5376 // escaping late-bound regions, and nor should the base type scheme.
5377 let ty = tcx.type_of(def_id);
5382 // Instantiates the given path, which must refer to an item with the given
5383 // number of type parameters and type.
5384 pub fn instantiate_value_path(&self,
5385 segments: &[hir::PathSegment],
5386 self_ty: Option<Ty<'tcx>>,
5390 -> (Ty<'tcx>, Def) {
5392 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, hir_id={})",
5402 Def::Local(nid) | Def::Upvar(nid, ..) => {
5403 let hid = self.tcx.hir().node_to_hir_id(nid);
5404 let ty = self.local_ty(span, hid).decl_ty;
5405 let ty = self.normalize_associated_types_in(span, &ty);
5406 self.write_ty(hir_id, ty);
5412 let (def, def_id, ty) = self.rewrite_self_ctor(def, span);
5413 let path_segs = AstConv::def_ids_for_path_segments(self, segments, self_ty, def);
5415 let mut user_self_ty = None;
5416 let mut is_alias_variant_ctor = false;
5418 Def::Ctor(_, CtorOf::Variant, _) => {
5419 if let Some(self_ty) = self_ty {
5420 let adt_def = self_ty.ty_adt_def().unwrap();
5421 user_self_ty = Some(UserSelfTy {
5422 impl_def_id: adt_def.did,
5425 is_alias_variant_ctor = true;
5428 Def::Method(def_id) |
5429 Def::AssociatedConst(def_id) => {
5430 let container = tcx.associated_item(def_id).container;
5431 debug!("instantiate_value_path: def={:?} container={:?}", def, container);
5433 ty::TraitContainer(trait_did) => {
5434 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5436 ty::ImplContainer(impl_def_id) => {
5437 if segments.len() == 1 {
5438 // `<T>::assoc` will end up here, and so
5439 // can `T::assoc`. It this came from an
5440 // inherent impl, we need to record the
5441 // `T` for posterity (see `UserSelfTy` for
5443 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5444 user_self_ty = Some(UserSelfTy {
5455 // Now that we have categorized what space the parameters for each
5456 // segment belong to, let's sort out the parameters that the user
5457 // provided (if any) into their appropriate spaces. We'll also report
5458 // errors if type parameters are provided in an inappropriate place.
5460 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5461 let generics_has_err = AstConv::prohibit_generics(
5462 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5463 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5469 if generics_has_err {
5470 // Don't try to infer type parameters when prohibited generic arguments were given.
5471 user_self_ty = None;
5474 // Now we have to compare the types that the user *actually*
5475 // provided against the types that were *expected*. If the user
5476 // did not provide any types, then we want to substitute inference
5477 // variables. If the user provided some types, we may still need
5478 // to add defaults. If the user provided *too many* types, that's
5481 let mut infer_args_for_err = FxHashSet::default();
5482 for &PathSeg(def_id, index) in &path_segs {
5483 let seg = &segments[index];
5484 let generics = tcx.generics_of(def_id);
5485 // Argument-position `impl Trait` is treated as a normal generic
5486 // parameter internally, but we don't allow users to specify the
5487 // parameter's value explicitly, so we have to do some error-
5489 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5494 false, // `is_method_call`
5496 if suppress_errors {
5497 infer_args_for_err.insert(index);
5498 self.set_tainted_by_errors(); // See issue #53251.
5502 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5503 tcx.generics_of(*def_id).has_self
5504 }).unwrap_or(false);
5506 let substs = AstConv::create_substs_for_generic_args(
5512 // Provide the generic args, and whether types should be inferred.
5514 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5517 // If we've encountered an `impl Trait`-related error, we're just
5518 // going to infer the arguments for better error messages.
5519 if !infer_args_for_err.contains(&index) {
5520 // Check whether the user has provided generic arguments.
5521 if let Some(ref data) = segments[index].args {
5522 return (Some(data), segments[index].infer_types);
5525 return (None, segments[index].infer_types);
5530 // Provide substitutions for parameters for which (valid) arguments have been provided.
5532 match (¶m.kind, arg) {
5533 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5534 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5536 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5537 self.to_ty(ty).into()
5539 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5540 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5542 _ => unreachable!(),
5545 // Provide substitutions for parameters for which arguments are inferred.
5546 |substs, param, infer_types| {
5548 GenericParamDefKind::Lifetime => {
5549 self.re_infer(span, Some(param)).unwrap().into()
5551 GenericParamDefKind::Type { has_default, .. } => {
5552 if !infer_types && has_default {
5553 // If we have a default, then we it doesn't matter that we're not
5554 // inferring the type arguments: we provide the default where any
5556 let default = tcx.type_of(param.def_id);
5559 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5562 // If no type arguments were provided, we have to infer them.
5563 // This case also occurs as a result of some malformed input, e.g.
5564 // a lifetime argument being given instead of a type parameter.
5565 // Using inference instead of `Error` gives better error messages.
5566 self.var_for_def(span, param)
5569 GenericParamDefKind::Const => {
5570 // FIXME(const_generics:defaults)
5571 // No const parameters were provided, we have to infer them.
5572 self.var_for_def(span, param)
5577 assert!(!substs.has_escaping_bound_vars());
5578 assert!(!ty.has_escaping_bound_vars());
5580 // First, store the "user substs" for later.
5581 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5583 // Add all the obligations that are required, substituting and
5584 // normalized appropriately.
5585 let bounds = self.instantiate_bounds(span, def_id, &substs);
5586 self.add_obligations_for_parameters(
5587 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5590 // Substitute the values for the type parameters into the type of
5591 // the referenced item.
5592 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5594 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5595 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5596 // is inherent, there is no `Self` parameter; instead, the impl needs
5597 // type parameters, which we can infer by unifying the provided `Self`
5598 // with the substituted impl type.
5599 // This also occurs for an enum variant on a type alias.
5600 let ty = tcx.type_of(impl_def_id);
5602 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5603 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5604 Ok(ok) => self.register_infer_ok_obligations(ok),
5607 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5614 self.check_rustc_args_require_const(def_id, hir_id, span);
5616 debug!("instantiate_value_path: type of {:?} is {:?}",
5619 self.write_substs(hir_id, substs);
5621 (ty_substituted, def)
5624 fn check_rustc_args_require_const(&self,
5628 // We're only interested in functions tagged with
5629 // #[rustc_args_required_const], so ignore anything that's not.
5630 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5634 // If our calling expression is indeed the function itself, we're good!
5635 // If not, generate an error that this can only be called directly.
5636 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5637 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5639 if let ExprKind::Call(ref callee, ..) = expr.node {
5640 if callee.hir_id == hir_id {
5646 self.tcx.sess.span_err(span, "this function can only be invoked \
5647 directly, not through a function pointer");
5650 // Resolves `typ` by a single level if `typ` is a type variable.
5651 // If no resolution is possible, then an error is reported.
5652 // Numeric inference variables may be left unresolved.
5653 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5654 let ty = self.resolve_type_vars_with_obligations(ty);
5655 if !ty.is_ty_var() {
5658 if !self.is_tainted_by_errors() {
5659 self.need_type_info_err((**self).body_id, sp, ty)
5660 .note("type must be known at this point")
5663 self.demand_suptype(sp, self.tcx.types.err, ty);
5668 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5669 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5670 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5673 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5674 index = enclosing_breakables.stack.len();
5675 enclosing_breakables.by_id.insert(id, index);
5676 enclosing_breakables.stack.push(ctxt);
5680 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5681 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5682 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5683 enclosing_breakables.stack.pop().expect("missing breakable context")
5688 /// Instantiate a QueryResponse in a probe context, without a
5689 /// good ObligationCause.
5690 fn probe_instantiate_query_response(
5693 original_values: &OriginalQueryValues<'tcx>,
5694 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5695 ) -> InferResult<'tcx, Ty<'tcx>>
5697 self.instantiate_query_response_and_region_obligations(
5698 &traits::ObligationCause::misc(span, self.body_id),
5704 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5705 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5706 let mut contained_in_place = false;
5708 while let hir::Node::Expr(parent_expr) =
5709 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5711 match &parent_expr.node {
5712 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5713 if lhs.hir_id == expr_id {
5714 contained_in_place = true;
5720 expr_id = parent_expr.hir_id;
5727 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5728 generics: &ty::Generics,
5730 let own_counts = generics.own_counts();
5732 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5738 // FIXME(const_generics): we probably want to check the bounds for const parameters too.
5740 if own_counts.types == 0 {
5744 // Make a vector of booleans initially false, set to true when used.
5745 let mut types_used = vec![false; own_counts.types];
5747 for leaf_ty in ty.walk() {
5748 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5749 debug!("Found use of ty param num {}", idx);
5750 types_used[idx as usize - own_counts.lifetimes] = true;
5751 } else if let ty::Error = leaf_ty.sty {
5752 // If there is already another error, do not emit
5753 // an error for not using a type Parameter.
5754 assert!(tcx.sess.err_count() > 0);
5759 let types = generics.params.iter().filter(|param| match param.kind {
5760 ty::GenericParamDefKind::Type { .. } => true,
5763 for (&used, param) in types_used.iter().zip(types) {
5765 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5766 let span = tcx.hir().span_by_hir_id(id);
5767 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5768 .span_label(span, "unused type parameter")
5774 fn fatally_break_rust(sess: &Session) {
5775 let handler = sess.diagnostic();
5776 handler.span_bug_no_panic(
5778 "It looks like you're trying to break rust; would you like some ICE?",
5780 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5781 handler.note_without_error(
5782 "we would appreciate a joke overview: \
5783 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5785 handler.note_without_error(&format!("rustc {} running on {}",
5786 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5787 crate::session::config::host_triple(),
5791 fn potentially_plural_count(count: usize, word: &str) -> String {
5792 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })