1 // ignore-tidy-filelength
7 Within the check phase of type check, we check each item one at a time
8 (bodies of function expressions are checked as part of the containing
9 function). Inference is used to supply types wherever they are unknown.
11 By far the most complex case is checking the body of a function. This
12 can be broken down into several distinct phases:
14 - gather: creates type variables to represent the type of each local
15 variable and pattern binding.
17 - main: the main pass does the lion's share of the work: it
18 determines the types of all expressions, resolves
19 methods, checks for most invalid conditions, and so forth. In
20 some cases, where a type is unknown, it may create a type or region
21 variable and use that as the type of an expression.
23 In the process of checking, various constraints will be placed on
24 these type variables through the subtyping relationships requested
25 through the `demand` module. The `infer` module is in charge
26 of resolving those constraints.
28 - regionck: after main is complete, the regionck pass goes over all
29 types looking for regions and making sure that they did not escape
30 into places they are not in scope. This may also influence the
31 final assignments of the various region variables if there is some
34 - vtable: find and records the impls to use for each trait bound that
35 appears on a type parameter.
37 - writeback: writes the final types within a function body, replacing
38 type variables with their final inferred types. These final types
39 are written into the `tcx.node_types` table, which should *never* contain
40 any reference to a type variable.
44 While type checking a function, the intermediate types for the
45 expressions, blocks, and so forth contained within the function are
46 stored in `fcx.node_types` and `fcx.node_substs`. These types
47 may contain unresolved type variables. After type checking is
48 complete, the functions in the writeback module are used to take the
49 types from this table, resolve them, and then write them into their
50 permanent home in the type context `tcx`.
52 This means that during inferencing you should use `fcx.write_ty()`
53 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
54 nodes within the function.
56 The types of top-level items, which never contain unbound type
57 variables, are stored directly into the `tcx` tables.
59 N.B., a type variable is not the same thing as a type parameter. A
60 type variable is rather an "instance" of a type parameter: that is,
61 given a generic function `fn foo<T>(t: T)`: while checking the
62 function `foo`, the type `ty_param(0)` refers to the type `T`, which
63 is treated in abstract. When `foo()` is called, however, `T` will be
64 substituted for a fresh type variable `N`. This variable will
65 eventually be resolved to some concrete type (which might itself be
85 mod generator_interior;
89 use crate::astconv::{AstConv, PathSeg};
90 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
91 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
92 use rustc::hir::def::{CtorOf, Res, DefKind};
93 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
94 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
95 use rustc::hir::itemlikevisit::ItemLikeVisitor;
96 use rustc::hir::ptr::P;
97 use crate::middle::lang_items;
98 use crate::namespace::Namespace;
99 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
100 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
101 use rustc_data_structures::indexed_vec::Idx;
102 use rustc_target::spec::abi::Abi;
103 use rustc::infer::opaque_types::OpaqueTypeDecl;
104 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
105 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
106 use rustc::middle::region;
107 use rustc::mir::interpret::{ConstValue, GlobalId};
108 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
110 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
111 ToPolyTraitRef, ToPredicate, RegionKind, UserType
113 use rustc::ty::adjustment::{
114 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
116 use rustc::ty::fold::TypeFoldable;
117 use rustc::ty::query::Providers;
118 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
119 use rustc::ty::util::{Representability, IntTypeExt, Discr};
120 use rustc::ty::layout::VariantIdx;
121 use syntax_pos::{self, BytePos, Span, MultiSpan};
122 use syntax_pos::hygiene::DesugaringKind;
125 use syntax::feature_gate::{GateIssue, emit_feature_err};
126 use syntax::source_map::{DUMMY_SP, original_sp};
127 use syntax::symbol::{kw, sym};
129 use std::cell::{Cell, RefCell, Ref, RefMut};
130 use std::collections::hash_map::Entry;
133 use std::mem::replace;
134 use std::ops::{self, Deref};
137 use crate::require_c_abi_if_c_variadic;
138 use crate::session::Session;
139 use crate::session::config::EntryFnType;
140 use crate::TypeAndSubsts;
142 use crate::util::captures::Captures;
143 use crate::util::common::{ErrorReported, indenter};
144 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashSet, HirIdMap};
146 pub use self::Expectation::*;
147 use self::autoderef::Autoderef;
148 use self::callee::DeferredCallResolution;
149 use self::coercion::{CoerceMany, DynamicCoerceMany};
150 pub use self::compare_method::{compare_impl_method, compare_const_impl};
151 use self::method::{MethodCallee, SelfSource};
152 use self::TupleArgumentsFlag::*;
154 /// The type of a local binding, including the revealed type for anon types.
155 #[derive(Copy, Clone)]
156 pub struct LocalTy<'tcx> {
158 revealed_ty: Ty<'tcx>
161 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
162 #[derive(Copy, Clone)]
163 struct MaybeInProgressTables<'a, 'tcx> {
164 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
167 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
168 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
169 match self.maybe_tables {
170 Some(tables) => tables.borrow(),
172 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
177 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
178 match self.maybe_tables {
179 Some(tables) => tables.borrow_mut(),
181 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
187 /// Closures defined within the function. For example:
190 /// bar(move|| { ... })
193 /// Here, the function `foo()` and the closure passed to
194 /// `bar()` will each have their own `FnCtxt`, but they will
195 /// share the inherited fields.
196 pub struct Inherited<'a, 'tcx> {
197 infcx: InferCtxt<'a, 'tcx>,
199 tables: MaybeInProgressTables<'a, 'tcx>,
201 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
203 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
205 // Some additional `Sized` obligations badly affect type inference.
206 // These obligations are added in a later stage of typeck.
207 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
209 // When we process a call like `c()` where `c` is a closure type,
210 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
211 // `FnOnce` closure. In that case, we defer full resolution of the
212 // call until upvar inference can kick in and make the
213 // decision. We keep these deferred resolutions grouped by the
214 // def-id of the closure, so that once we decide, we can easily go
215 // back and process them.
216 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
218 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
220 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
222 // Opaque types found in explicit return types and their
223 // associated fresh inference variable. Writeback resolves these
224 // variables to get the concrete type, which can be used to
225 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
226 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
228 /// Each type parameter has an implicit region bound that
229 /// indicates it must outlive at least the function body (the user
230 /// may specify stronger requirements). This field indicates the
231 /// region of the callee. If it is `None`, then the parameter
232 /// environment is for an item or something where the "callee" is
234 implicit_region_bound: Option<ty::Region<'tcx>>,
236 body_id: Option<hir::BodyId>,
239 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
240 type Target = InferCtxt<'a, 'tcx>;
241 fn deref(&self) -> &Self::Target {
246 /// When type-checking an expression, we propagate downward
247 /// whatever type hint we are able in the form of an `Expectation`.
248 #[derive(Copy, Clone, Debug)]
249 pub enum Expectation<'tcx> {
250 /// We know nothing about what type this expression should have.
253 /// This expression should have the type given (or some subtype).
254 ExpectHasType(Ty<'tcx>),
256 /// This expression will be cast to the `Ty`.
257 ExpectCastableToType(Ty<'tcx>),
259 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
260 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
261 ExpectRvalueLikeUnsized(Ty<'tcx>),
264 impl<'a, 'tcx> Expectation<'tcx> {
265 // Disregard "castable to" expectations because they
266 // can lead us astray. Consider for example `if cond
267 // {22} else {c} as u8` -- if we propagate the
268 // "castable to u8" constraint to 22, it will pick the
269 // type 22u8, which is overly constrained (c might not
270 // be a u8). In effect, the problem is that the
271 // "castable to" expectation is not the tightest thing
272 // we can say, so we want to drop it in this case.
273 // The tightest thing we can say is "must unify with
274 // else branch". Note that in the case of a "has type"
275 // constraint, this limitation does not hold.
277 // If the expected type is just a type variable, then don't use
278 // an expected type. Otherwise, we might write parts of the type
279 // when checking the 'then' block which are incompatible with the
281 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
283 ExpectHasType(ety) => {
284 let ety = fcx.shallow_resolve(ety);
285 if !ety.is_ty_var() {
291 ExpectRvalueLikeUnsized(ety) => {
292 ExpectRvalueLikeUnsized(ety)
298 /// Provides an expectation for an rvalue expression given an *optional*
299 /// hint, which is not required for type safety (the resulting type might
300 /// be checked higher up, as is the case with `&expr` and `box expr`), but
301 /// is useful in determining the concrete type.
303 /// The primary use case is where the expected type is a fat pointer,
304 /// like `&[isize]`. For example, consider the following statement:
306 /// let x: &[isize] = &[1, 2, 3];
308 /// In this case, the expected type for the `&[1, 2, 3]` expression is
309 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
310 /// expectation `ExpectHasType([isize])`, that would be too strong --
311 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
312 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
313 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
314 /// which still is useful, because it informs integer literals and the like.
315 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
316 /// for examples of where this comes up,.
317 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
318 match fcx.tcx.struct_tail_without_normalization(ty).sty {
319 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
320 ExpectRvalueLikeUnsized(ty)
322 _ => ExpectHasType(ty)
326 // Resolves `expected` by a single level if it is a variable. If
327 // there is no expected type or resolution is not possible (e.g.,
328 // no constraints yet present), just returns `None`.
329 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
331 NoExpectation => NoExpectation,
332 ExpectCastableToType(t) => {
333 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
335 ExpectHasType(t) => {
336 ExpectHasType(fcx.resolve_vars_if_possible(&t))
338 ExpectRvalueLikeUnsized(t) => {
339 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
344 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
345 match self.resolve(fcx) {
346 NoExpectation => None,
347 ExpectCastableToType(ty) |
349 ExpectRvalueLikeUnsized(ty) => Some(ty),
353 /// It sometimes happens that we want to turn an expectation into
354 /// a **hard constraint** (i.e., something that must be satisfied
355 /// for the program to type-check). `only_has_type` will return
356 /// such a constraint, if it exists.
357 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
358 match self.resolve(fcx) {
359 ExpectHasType(ty) => Some(ty),
360 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
364 /// Like `only_has_type`, but instead of returning `None` if no
365 /// hard constraint exists, creates a fresh type variable.
366 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
367 self.only_has_type(fcx)
369 fcx.next_ty_var(TypeVariableOrigin {
370 kind: TypeVariableOriginKind::MiscVariable,
377 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
384 fn maybe_mut_place(m: hir::Mutability) -> Self {
386 hir::MutMutable => Needs::MutPlace,
387 hir::MutImmutable => Needs::None,
392 #[derive(Copy, Clone)]
393 pub struct UnsafetyState {
395 pub unsafety: hir::Unsafety,
396 pub unsafe_push_count: u32,
401 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
402 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
405 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
406 match self.unsafety {
407 // If this unsafe, then if the outer function was already marked as
408 // unsafe we shouldn't attribute the unsafe'ness to the block. This
409 // way the block can be warned about instead of ignoring this
410 // extraneous block (functions are never warned about).
411 hir::Unsafety::Unsafe if self.from_fn => *self,
414 let (unsafety, def, count) = match blk.rules {
415 hir::PushUnsafeBlock(..) =>
416 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
417 hir::PopUnsafeBlock(..) =>
418 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
419 hir::UnsafeBlock(..) =>
420 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
422 (unsafety, self.def, self.unsafe_push_count),
426 unsafe_push_count: count,
433 #[derive(Debug, Copy, Clone)]
439 /// Tracks whether executing a node may exit normally (versus
440 /// return/break/panic, which "diverge", leaving dead code in their
441 /// wake). Tracked semi-automatically (through type variables marked
442 /// as diverging), with some manual adjustments for control-flow
443 /// primitives (approximating a CFG).
444 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
446 /// Potentially unknown, some cases converge,
447 /// others require a CFG to determine them.
450 /// Definitely known to diverge and therefore
451 /// not reach the next sibling or its parent.
454 /// Same as `Always` but with a reachability
455 /// warning already emitted.
459 // Convenience impls for combinig `Diverges`.
461 impl ops::BitAnd for Diverges {
463 fn bitand(self, other: Self) -> Self {
464 cmp::min(self, other)
468 impl ops::BitOr for Diverges {
470 fn bitor(self, other: Self) -> Self {
471 cmp::max(self, other)
475 impl ops::BitAndAssign for Diverges {
476 fn bitand_assign(&mut self, other: Self) {
477 *self = *self & other;
481 impl ops::BitOrAssign for Diverges {
482 fn bitor_assign(&mut self, other: Self) {
483 *self = *self | other;
488 fn always(self) -> bool {
489 self >= Diverges::Always
493 pub struct BreakableCtxt<'tcx> {
496 // this is `null` for loops where break with a value is illegal,
497 // such as `while`, `for`, and `while let`
498 coerce: Option<DynamicCoerceMany<'tcx>>,
501 pub struct EnclosingBreakables<'tcx> {
502 stack: Vec<BreakableCtxt<'tcx>>,
503 by_id: HirIdMap<usize>,
506 impl<'tcx> EnclosingBreakables<'tcx> {
507 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
508 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
509 bug!("could not find enclosing breakable with id {}", target_id);
515 pub struct FnCtxt<'a, 'tcx> {
518 /// The parameter environment used for proving trait obligations
519 /// in this function. This can change when we descend into
520 /// closures (as they bring new things into scope), hence it is
521 /// not part of `Inherited` (as of the time of this writing,
522 /// closures do not yet change the environment, but they will
524 param_env: ty::ParamEnv<'tcx>,
526 /// Number of errors that had been reported when we started
527 /// checking this function. On exit, if we find that *more* errors
528 /// have been reported, we will skip regionck and other work that
529 /// expects the types within the function to be consistent.
530 // FIXME(matthewjasper) This should not exist, and it's not correct
531 // if type checking is run in parallel.
532 err_count_on_creation: usize,
534 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
535 ret_coercion_span: RefCell<Option<Span>>,
537 yield_ty: Option<Ty<'tcx>>,
539 ps: RefCell<UnsafetyState>,
541 /// Whether the last checked node generates a divergence (e.g.,
542 /// `return` will set this to `Always`). In general, when entering
543 /// an expression or other node in the tree, the initial value
544 /// indicates whether prior parts of the containing expression may
545 /// have diverged. It is then typically set to `Maybe` (and the
546 /// old value remembered) for processing the subparts of the
547 /// current expression. As each subpart is processed, they may set
548 /// the flag to `Always`, etc. Finally, at the end, we take the
549 /// result and "union" it with the original value, so that when we
550 /// return the flag indicates if any subpart of the parent
551 /// expression (up to and including this part) has diverged. So,
552 /// if you read it after evaluating a subexpression `X`, the value
553 /// you get indicates whether any subexpression that was
554 /// evaluating up to and including `X` diverged.
556 /// We currently use this flag only for diagnostic purposes:
558 /// - To warn about unreachable code: if, after processing a
559 /// sub-expression but before we have applied the effects of the
560 /// current node, we see that the flag is set to `Always`, we
561 /// can issue a warning. This corresponds to something like
562 /// `foo(return)`; we warn on the `foo()` expression. (We then
563 /// update the flag to `WarnedAlways` to suppress duplicate
564 /// reports.) Similarly, if we traverse to a fresh statement (or
565 /// tail expression) from a `Always` setting, we will issue a
566 /// warning. This corresponds to something like `{return;
567 /// foo();}` or `{return; 22}`, where we would warn on the
570 /// An expression represents dead code if, after checking it,
571 /// the diverges flag is set to something other than `Maybe`.
572 diverges: Cell<Diverges>,
574 /// Whether any child nodes have any type errors.
575 has_errors: Cell<bool>,
577 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
579 inh: &'a Inherited<'a, 'tcx>,
582 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
583 type Target = Inherited<'a, 'tcx>;
584 fn deref(&self) -> &Self::Target {
589 /// Helper type of a temporary returned by `Inherited::build(...)`.
590 /// Necessary because we can't write the following bound:
591 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
592 pub struct InheritedBuilder<'tcx> {
593 infcx: infer::InferCtxtBuilder<'tcx>,
597 impl Inherited<'_, 'tcx> {
598 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
599 let hir_id_root = if def_id.is_local() {
600 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
601 DefId::local(hir_id.owner)
607 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
613 impl<'tcx> InheritedBuilder<'tcx> {
614 fn enter<F, R>(&mut self, f: F) -> R
616 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
618 let def_id = self.def_id;
619 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
623 impl Inherited<'a, 'tcx> {
624 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
626 let item_id = tcx.hir().as_local_hir_id(def_id);
627 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
628 let implicit_region_bound = body_id.map(|body_id| {
629 let body = tcx.hir().body(body_id);
630 tcx.mk_region(ty::ReScope(region::Scope {
631 id: body.value.hir_id.local_id,
632 data: region::ScopeData::CallSite
637 tables: MaybeInProgressTables {
638 maybe_tables: infcx.in_progress_tables,
641 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
642 locals: RefCell::new(Default::default()),
643 deferred_sized_obligations: RefCell::new(Vec::new()),
644 deferred_call_resolutions: RefCell::new(Default::default()),
645 deferred_cast_checks: RefCell::new(Vec::new()),
646 deferred_generator_interiors: RefCell::new(Vec::new()),
647 opaque_types: RefCell::new(Default::default()),
648 implicit_region_bound,
653 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
654 debug!("register_predicate({:?})", obligation);
655 if obligation.has_escaping_bound_vars() {
656 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
661 .register_predicate_obligation(self, obligation);
664 fn register_predicates<I>(&self, obligations: I)
665 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
667 for obligation in obligations {
668 self.register_predicate(obligation);
672 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
673 self.register_predicates(infer_ok.obligations);
677 fn normalize_associated_types_in<T>(&self,
680 param_env: ty::ParamEnv<'tcx>,
682 where T : TypeFoldable<'tcx>
684 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
685 self.register_infer_ok_obligations(ok)
689 struct CheckItemTypesVisitor<'tcx> {
693 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
694 fn visit_item(&mut self, i: &'tcx hir::Item) {
695 check_item_type(self.tcx, i);
697 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
698 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
701 pub fn check_wf_new(tcx: TyCtxt<'_>) {
702 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
703 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
706 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
707 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
710 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
711 debug_assert!(crate_num == LOCAL_CRATE);
712 tcx.par_body_owners(|body_owner_def_id| {
713 tcx.ensure().typeck_tables_of(body_owner_def_id);
717 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
718 wfcheck::check_item_well_formed(tcx, def_id);
721 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
722 wfcheck::check_trait_item(tcx, def_id);
725 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
726 wfcheck::check_impl_item(tcx, def_id);
729 pub fn provide(providers: &mut Providers<'_>) {
730 method::provide(providers);
731 *providers = Providers {
737 check_item_well_formed,
738 check_trait_item_well_formed,
739 check_impl_item_well_formed,
740 check_mod_item_types,
745 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
746 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
749 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
750 /// with information about it's body-id and fn-decl (if any). Otherwise,
753 /// If this function returns "some", then `typeck_tables(def_id)` will
754 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
755 /// may not succeed. In some cases where this function returns `None`
756 /// (notably closures), `typeck_tables(def_id)` would wind up
757 /// redirecting to the owning function.
761 ) -> Option<(hir::BodyId, Option<&hir::FnDecl>)> {
762 match tcx.hir().get(id) {
763 Node::Item(item) => {
765 hir::ItemKind::Const(_, body) |
766 hir::ItemKind::Static(_, _, body) =>
768 hir::ItemKind::Fn(ref decl, .., body) =>
769 Some((body, Some(decl))),
774 Node::TraitItem(item) => {
776 hir::TraitItemKind::Const(_, Some(body)) =>
778 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
779 Some((body, Some(&sig.decl))),
784 Node::ImplItem(item) => {
786 hir::ImplItemKind::Const(_, body) =>
788 hir::ImplItemKind::Method(ref sig, body) =>
789 Some((body, Some(&sig.decl))),
794 Node::AnonConst(constant) => Some((constant.body, None)),
799 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
800 // Closures' tables come from their outermost function,
801 // as they are part of the same "inference environment".
802 let outer_def_id = tcx.closure_base_def_id(def_id);
803 if outer_def_id != def_id {
804 return tcx.has_typeck_tables(outer_def_id);
807 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
808 primary_body_of(tcx, id).is_some()
811 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
812 &*tcx.typeck_tables_of(def_id).used_trait_imports
815 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
816 // Closures' tables come from their outermost function,
817 // as they are part of the same "inference environment".
818 let outer_def_id = tcx.closure_base_def_id(def_id);
819 if outer_def_id != def_id {
820 return tcx.typeck_tables_of(outer_def_id);
823 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
824 let span = tcx.hir().span(id);
826 // Figure out what primary body this item has.
827 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
828 span_bug!(span, "can't type-check body of {:?}", def_id);
830 let body = tcx.hir().body(body_id);
832 let tables = Inherited::build(tcx, def_id).enter(|inh| {
833 let param_env = tcx.param_env(def_id);
834 let fcx = if let Some(decl) = fn_decl {
835 let fn_sig = tcx.fn_sig(def_id);
837 check_abi(tcx, span, fn_sig.abi());
839 // Compute the fty from point of view of inside the fn.
841 tcx.liberate_late_bound_regions(def_id, &fn_sig);
843 inh.normalize_associated_types_in(body.value.span,
848 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
851 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
852 let expected_type = tcx.type_of(def_id);
853 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
854 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
856 let revealed_ty = if tcx.features().impl_trait_in_bindings {
857 fcx.instantiate_opaque_types_from_value(
866 // Gather locals in statics (because of block expressions).
867 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
869 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
871 fcx.write_ty(id, 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(tcx: TyCtxt<'_>, 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, 'tcx> {
924 fcx: &'a FnCtxt<'a, 'tcx>,
925 parent_id: hir::HirId,
928 impl<'a, 'tcx> GatherLocalsVisitor<'a, '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 {
934 kind: TypeVariableOriginKind::TypeInference,
937 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
944 // take type that the user specified
945 self.fcx.locals.borrow_mut().insert(nid, typ);
952 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
953 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
954 NestedVisitorMap::None
957 // Add explicitly-declared locals.
958 fn visit_local(&mut self, local: &'tcx hir::Local) {
959 let local_ty = match local.ty {
961 let o_ty = self.fcx.to_ty(&ty);
963 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
964 self.fcx.instantiate_opaque_types_from_value(
973 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
974 &UserType::Ty(revealed_ty)
976 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
977 ty.hir_id, o_ty, revealed_ty, c_ty);
978 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
980 Some(LocalTy { decl_ty: o_ty, revealed_ty })
984 self.assign(local.span, local.hir_id, local_ty);
986 debug!("local variable {:?} is assigned type {}",
988 self.fcx.ty_to_string(
989 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
990 intravisit::walk_local(self, local);
993 // Add pattern bindings.
994 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
995 if let PatKind::Binding(_, _, ident, _) = p.node {
996 let var_ty = self.assign(p.span, p.hir_id, None);
998 if !self.fcx.tcx.features().unsized_locals {
999 self.fcx.require_type_is_sized(var_ty, p.span,
1000 traits::VariableType(p.hir_id));
1003 debug!("pattern binding {} is assigned to {} with type {:?}",
1005 self.fcx.ty_to_string(
1006 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1009 intravisit::walk_pat(self, p);
1012 // Don't descend into the bodies of nested closures
1015 _: intravisit::FnKind<'tcx>,
1016 _: &'tcx hir::FnDecl,
1023 /// When `check_fn` is invoked on a generator (i.e., a body that
1024 /// includes yield), it returns back some information about the yield
1026 struct GeneratorTypes<'tcx> {
1027 /// Type of value that is yielded.
1030 /// Types that are captured (see `GeneratorInterior` for more).
1033 /// Indicates if the generator is movable or static (immovable).
1034 movability: hir::GeneratorMovability,
1037 /// Helper used for fns and closures. Does the grungy work of checking a function
1038 /// body and returns the function context used for that purpose, since in the case of a fn item
1039 /// there is still a bit more to do.
1042 /// * inherited: other fields inherited from the enclosing fn (if any)
1043 fn check_fn<'a, 'tcx>(
1044 inherited: &'a Inherited<'a, 'tcx>,
1045 param_env: ty::ParamEnv<'tcx>,
1046 fn_sig: ty::FnSig<'tcx>,
1047 decl: &'tcx hir::FnDecl,
1049 body: &'tcx hir::Body,
1050 can_be_generator: Option<hir::GeneratorMovability>,
1051 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1052 let mut fn_sig = fn_sig.clone();
1054 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1056 // Create the function context. This is either derived from scratch or,
1057 // in the case of closures, based on the outer context.
1058 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1059 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1061 let declared_ret_ty = fn_sig.output();
1062 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1063 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1068 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1069 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1070 fn_sig = fcx.tcx.mk_fn_sig(
1071 fn_sig.inputs().iter().cloned(),
1078 let span = body.value.span;
1080 if body.generator_kind.is_some() && can_be_generator.is_some() {
1081 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1082 kind: TypeVariableOriginKind::TypeInference,
1085 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1086 fcx.yield_ty = Some(yield_ty);
1089 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1090 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1091 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1093 // Add formal parameters.
1094 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1095 // Check the pattern.
1096 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1097 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1099 // Check that argument is Sized.
1100 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1101 // for simple cases like `fn foo(x: Trait)`,
1102 // where we would error once on the parameter as a whole, and once on the binding `x`.
1103 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1104 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1107 fcx.write_ty(arg.hir_id, arg_ty);
1110 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1112 fcx.check_return_expr(&body.value);
1114 // We insert the deferred_generator_interiors entry after visiting the body.
1115 // This ensures that all nested generators appear before the entry of this generator.
1116 // resolve_generator_interiors relies on this property.
1117 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1118 let interior = fcx.next_ty_var(TypeVariableOrigin {
1119 kind: TypeVariableOriginKind::MiscVariable,
1122 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1123 Some(GeneratorTypes {
1124 yield_ty: fcx.yield_ty.unwrap(),
1126 movability: can_be_generator.unwrap(),
1132 // Finalize the return check by taking the LUB of the return types
1133 // we saw and assigning it to the expected return type. This isn't
1134 // really expected to fail, since the coercions would have failed
1135 // earlier when trying to find a LUB.
1137 // However, the behavior around `!` is sort of complex. In the
1138 // event that the `actual_return_ty` comes back as `!`, that
1139 // indicates that the fn either does not return or "returns" only
1140 // values of type `!`. In this case, if there is an expected
1141 // return type that is *not* `!`, that should be ok. But if the
1142 // return type is being inferred, we want to "fallback" to `!`:
1144 // let x = move || panic!();
1146 // To allow for that, I am creating a type variable with diverging
1147 // fallback. This was deemed ever so slightly better than unifying
1148 // the return value with `!` because it allows for the caller to
1149 // make more assumptions about the return type (e.g., they could do
1151 // let y: Option<u32> = Some(x());
1153 // which would then cause this return type to become `u32`, not
1155 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1156 let mut actual_return_ty = coercion.complete(&fcx);
1157 if actual_return_ty.is_never() {
1158 actual_return_ty = fcx.next_diverging_ty_var(
1159 TypeVariableOrigin {
1160 kind: TypeVariableOriginKind::DivergingFn,
1165 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1167 // Check that the main return type implements the termination trait.
1168 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1169 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1170 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1171 if main_id == fn_id {
1172 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1173 let trait_ref = ty::TraitRef::new(term_id, substs);
1174 let return_ty_span = decl.output.span();
1175 let cause = traits::ObligationCause::new(
1176 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1178 inherited.register_predicate(
1179 traits::Obligation::new(
1180 cause, param_env, trait_ref.to_predicate()));
1185 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1186 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1187 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1188 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1189 // at this point we don't care if there are duplicate handlers or if the handler has
1190 // the wrong signature as this value we'll be used when writing metadata and that
1191 // only happens if compilation succeeded
1192 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1194 if declared_ret_ty.sty != ty::Never {
1195 fcx.tcx.sess.span_err(
1197 "return type should be `!`",
1201 let inputs = fn_sig.inputs();
1202 let span = fcx.tcx.hir().span(fn_id);
1203 if inputs.len() == 1 {
1204 let arg_is_panic_info = match inputs[0].sty {
1205 ty::Ref(region, ty, mutbl) => match ty.sty {
1206 ty::Adt(ref adt, _) => {
1207 adt.did == panic_info_did &&
1208 mutbl == hir::Mutability::MutImmutable &&
1209 *region != RegionKind::ReStatic
1216 if !arg_is_panic_info {
1217 fcx.tcx.sess.span_err(
1218 decl.inputs[0].span,
1219 "argument should be `&PanicInfo`",
1223 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1224 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1225 if !generics.params.is_empty() {
1226 fcx.tcx.sess.span_err(
1228 "should have no type parameters",
1234 let span = fcx.tcx.sess.source_map().def_span(span);
1235 fcx.tcx.sess.span_err(span, "function should have one argument");
1238 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1243 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1244 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1245 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1246 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1247 if declared_ret_ty.sty != ty::Never {
1248 fcx.tcx.sess.span_err(
1250 "return type should be `!`",
1254 let inputs = fn_sig.inputs();
1255 let span = fcx.tcx.hir().span(fn_id);
1256 if inputs.len() == 1 {
1257 let arg_is_alloc_layout = match inputs[0].sty {
1258 ty::Adt(ref adt, _) => {
1259 adt.did == alloc_layout_did
1264 if !arg_is_alloc_layout {
1265 fcx.tcx.sess.span_err(
1266 decl.inputs[0].span,
1267 "argument should be `Layout`",
1271 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1272 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1273 if !generics.params.is_empty() {
1274 fcx.tcx.sess.span_err(
1276 "`#[alloc_error_handler]` function should have no type \
1283 let span = fcx.tcx.sess.source_map().def_span(span);
1284 fcx.tcx.sess.span_err(span, "function should have one argument");
1287 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1295 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1296 let def_id = tcx.hir().local_def_id(id);
1297 let def = tcx.adt_def(def_id);
1298 def.destructor(tcx); // force the destructor to be evaluated
1299 check_representable(tcx, span, def_id);
1301 if def.repr.simd() {
1302 check_simd(tcx, span, def_id);
1305 check_transparent(tcx, span, def_id);
1306 check_packed(tcx, span, def_id);
1309 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1310 let def_id = tcx.hir().local_def_id(id);
1311 let def = tcx.adt_def(def_id);
1312 def.destructor(tcx); // force the destructor to be evaluated
1313 check_representable(tcx, span, def_id);
1314 check_transparent(tcx, span, def_id);
1315 check_packed(tcx, span, def_id);
1318 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1319 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1320 let mut err = struct_span_err!(
1321 tcx.sess, span, E0720,
1322 "opaque type expands to a recursive type",
1324 err.span_label(span, "expands to a recursive type");
1325 if let ty::Opaque(..) = partially_expanded_type.sty {
1326 err.note("type resolves to itself");
1328 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1334 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1336 "check_item_type(it.hir_id={}, it.name={})",
1338 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1340 let _indenter = indenter();
1342 // Consts can play a role in type-checking, so they are included here.
1343 hir::ItemKind::Static(..) => {
1344 let def_id = tcx.hir().local_def_id(it.hir_id);
1345 tcx.typeck_tables_of(def_id);
1346 maybe_check_static_with_link_section(tcx, def_id, it.span);
1348 hir::ItemKind::Const(..) => {
1349 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1351 hir::ItemKind::Enum(ref enum_definition, _) => {
1352 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1354 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1355 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1356 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1357 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1358 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1359 check_impl_items_against_trait(
1366 let trait_def_id = impl_trait_ref.def_id;
1367 check_on_unimplemented(tcx, trait_def_id, it);
1370 hir::ItemKind::Trait(..) => {
1371 let def_id = tcx.hir().local_def_id(it.hir_id);
1372 check_on_unimplemented(tcx, def_id, it);
1374 hir::ItemKind::Struct(..) => {
1375 check_struct(tcx, it.hir_id, it.span);
1377 hir::ItemKind::Union(..) => {
1378 check_union(tcx, it.hir_id, it.span);
1380 hir::ItemKind::Existential(..) => {
1381 let def_id = tcx.hir().local_def_id(it.hir_id);
1383 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1384 check_opaque(tcx, def_id, substs, it.span);
1386 hir::ItemKind::Ty(..) => {
1387 let def_id = tcx.hir().local_def_id(it.hir_id);
1388 let pty_ty = tcx.type_of(def_id);
1389 let generics = tcx.generics_of(def_id);
1390 check_bounds_are_used(tcx, &generics, pty_ty);
1392 hir::ItemKind::ForeignMod(ref m) => {
1393 check_abi(tcx, it.span, m.abi);
1395 if m.abi == Abi::RustIntrinsic {
1396 for item in &m.items {
1397 intrinsic::check_intrinsic_type(tcx, item);
1399 } else if m.abi == Abi::PlatformIntrinsic {
1400 for item in &m.items {
1401 intrinsic::check_platform_intrinsic_type(tcx, item);
1404 for item in &m.items {
1405 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1406 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1407 let mut err = struct_span_err!(
1411 "foreign items may not have type parameters"
1413 err.span_label(item.span, "can't have type parameters");
1414 // FIXME: once we start storing spans for type arguments, turn this into a
1417 "use specialization instead of type parameters by replacing them \
1418 with concrete types like `u32`",
1423 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1424 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1429 _ => { /* nothing to do */ }
1433 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1434 // Only restricted on wasm32 target for now
1435 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1439 // If `#[link_section]` is missing, then nothing to verify
1440 let attrs = tcx.codegen_fn_attrs(id);
1441 if attrs.link_section.is_none() {
1445 // For the wasm32 target statics with `#[link_section]` are placed into custom
1446 // sections of the final output file, but this isn't link custom sections of
1447 // other executable formats. Namely we can only embed a list of bytes,
1448 // nothing with pointers to anything else or relocations. If any relocation
1449 // show up, reject them here.
1450 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1451 // the consumer's responsibility to ensure all bytes that have been read
1452 // have defined values.
1453 let instance = ty::Instance::mono(tcx, id);
1454 let cid = GlobalId {
1458 let param_env = ty::ParamEnv::reveal_all();
1459 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1460 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1463 bug!("Matching on non-ByRef static")
1465 if alloc.relocations.len() != 0 {
1466 let msg = "statics with a custom `#[link_section]` must be a \
1467 simple list of bytes on the wasm target with no \
1468 extra levels of indirection such as references";
1469 tcx.sess.span_err(span, msg);
1474 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1475 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1476 // an error would be reported if this fails.
1477 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1480 fn report_forbidden_specialization(
1482 impl_item: &hir::ImplItem,
1485 let mut err = struct_span_err!(
1486 tcx.sess, impl_item.span, E0520,
1487 "`{}` specializes an item from a parent `impl`, but \
1488 that item is not marked `default`",
1490 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1493 match tcx.span_of_impl(parent_impl) {
1495 err.span_label(span, "parent `impl` is here");
1496 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1500 err.note(&format!("parent implementation is in crate `{}`", cname));
1507 fn check_specialization_validity<'tcx>(
1509 trait_def: &ty::TraitDef,
1510 trait_item: &ty::AssocItem,
1512 impl_item: &hir::ImplItem,
1514 let ancestors = trait_def.ancestors(tcx, impl_id);
1516 let kind = match impl_item.node {
1517 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1518 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1519 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1520 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1523 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1524 .map(|node_item| node_item.map(|parent| parent.defaultness));
1526 if let Some(parent) = parent {
1527 if tcx.impl_item_is_final(&parent) {
1528 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1534 fn check_impl_items_against_trait<'tcx>(
1538 impl_trait_ref: ty::TraitRef<'tcx>,
1539 impl_item_refs: &[hir::ImplItemRef],
1541 let impl_span = tcx.sess.source_map().def_span(impl_span);
1543 // If the trait reference itself is erroneous (so the compilation is going
1544 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1545 // isn't populated for such impls.
1546 if impl_trait_ref.references_error() { return; }
1548 // Locate trait definition and items
1549 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1550 let mut overridden_associated_type = None;
1552 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1554 // Check existing impl methods to see if they are both present in trait
1555 // and compatible with trait signature
1556 for impl_item in impl_items() {
1557 let ty_impl_item = tcx.associated_item(
1558 tcx.hir().local_def_id(impl_item.hir_id));
1559 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1560 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1561 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1563 // Not compatible, but needed for the error message
1564 tcx.associated_items(impl_trait_ref.def_id)
1565 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1568 // Check that impl definition matches trait definition
1569 if let Some(ty_trait_item) = ty_trait_item {
1570 match impl_item.node {
1571 hir::ImplItemKind::Const(..) => {
1572 // Find associated const definition.
1573 if ty_trait_item.kind == ty::AssocKind::Const {
1574 compare_const_impl(tcx,
1580 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1581 "item `{}` is an associated const, \
1582 which doesn't match its trait `{}`",
1585 err.span_label(impl_item.span, "does not match trait");
1586 // We can only get the spans from local trait definition
1587 // Same for E0324 and E0325
1588 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1589 err.span_label(trait_span, "item in trait");
1594 hir::ImplItemKind::Method(..) => {
1595 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1596 if ty_trait_item.kind == ty::AssocKind::Method {
1597 compare_impl_method(tcx,
1604 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1605 "item `{}` is an associated method, \
1606 which doesn't match its trait `{}`",
1609 err.span_label(impl_item.span, "does not match trait");
1610 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1611 err.span_label(trait_span, "item in trait");
1616 hir::ImplItemKind::Existential(..) |
1617 hir::ImplItemKind::Type(_) => {
1618 if ty_trait_item.kind == ty::AssocKind::Type {
1619 if ty_trait_item.defaultness.has_value() {
1620 overridden_associated_type = Some(impl_item);
1623 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1624 "item `{}` is an associated type, \
1625 which doesn't match its trait `{}`",
1628 err.span_label(impl_item.span, "does not match trait");
1629 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1630 err.span_label(trait_span, "item in trait");
1637 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1641 // Check for missing items from trait
1642 let mut missing_items = Vec::new();
1643 let mut invalidated_items = Vec::new();
1644 let associated_type_overridden = overridden_associated_type.is_some();
1645 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1646 let is_implemented = trait_def.ancestors(tcx, impl_id)
1647 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1649 .map(|node_item| !node_item.node.is_from_trait())
1652 if !is_implemented && !tcx.impl_is_default(impl_id) {
1653 if !trait_item.defaultness.has_value() {
1654 missing_items.push(trait_item);
1655 } else if associated_type_overridden {
1656 invalidated_items.push(trait_item.ident);
1661 if !missing_items.is_empty() {
1662 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1663 "not all trait items implemented, missing: `{}`",
1664 missing_items.iter()
1665 .map(|trait_item| trait_item.ident.to_string())
1666 .collect::<Vec<_>>().join("`, `"));
1667 err.span_label(impl_span, format!("missing `{}` in implementation",
1668 missing_items.iter()
1669 .map(|trait_item| trait_item.ident.to_string())
1670 .collect::<Vec<_>>().join("`, `")));
1671 for trait_item in missing_items {
1672 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1673 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1675 err.note_trait_signature(trait_item.ident.to_string(),
1676 trait_item.signature(tcx));
1682 if !invalidated_items.is_empty() {
1683 let invalidator = overridden_associated_type.unwrap();
1684 span_err!(tcx.sess, invalidator.span, E0399,
1685 "the following trait items need to be reimplemented \
1686 as `{}` was overridden: `{}`",
1688 invalidated_items.iter()
1689 .map(|name| name.to_string())
1690 .collect::<Vec<_>>().join("`, `"))
1694 /// Checks whether a type can be represented in memory. In particular, it
1695 /// identifies types that contain themselves without indirection through a
1696 /// pointer, which would mean their size is unbounded.
1697 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1698 let rty = tcx.type_of(item_def_id);
1700 // Check that it is possible to represent this type. This call identifies
1701 // (1) types that contain themselves and (2) types that contain a different
1702 // recursive type. It is only necessary to throw an error on those that
1703 // contain themselves. For case 2, there must be an inner type that will be
1704 // caught by case 1.
1705 match rty.is_representable(tcx, sp) {
1706 Representability::SelfRecursive(spans) => {
1707 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1709 err.span_label(span, "recursive without indirection");
1714 Representability::Representable | Representability::ContainsRecursive => (),
1719 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1720 let t = tcx.type_of(def_id);
1721 if let ty::Adt(def, substs) = t.sty {
1722 if def.is_struct() {
1723 let fields = &def.non_enum_variant().fields;
1724 if fields.is_empty() {
1725 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1728 let e = fields[0].ty(tcx, substs);
1729 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1730 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1731 .span_label(sp, "SIMD elements must have the same type")
1736 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1737 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1739 span_err!(tcx.sess, sp, E0077,
1740 "SIMD vector element type should be machine type");
1748 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1749 let repr = tcx.adt_def(def_id).repr;
1751 for attr in tcx.get_attrs(def_id).iter() {
1752 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1753 if let attr::ReprPacked(pack) = r {
1754 if pack != repr.pack {
1755 struct_span_err!(tcx.sess, sp, E0634,
1756 "type has conflicting packed representation hints").emit();
1762 struct_span_err!(tcx.sess, sp, E0587,
1763 "type has conflicting packed and align representation hints").emit();
1765 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1766 struct_span_err!(tcx.sess, sp, E0588,
1767 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1772 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1773 let t = tcx.type_of(def_id);
1774 if stack.contains(&def_id) {
1775 debug!("check_packed_inner: {:?} is recursive", t);
1778 if let ty::Adt(def, substs) = t.sty {
1779 if def.is_struct() || def.is_union() {
1780 if tcx.adt_def(def.did).repr.align > 0 {
1783 // push struct def_id before checking fields
1785 for field in &def.non_enum_variant().fields {
1786 let f = field.ty(tcx, substs);
1787 if let ty::Adt(def, _) = f.sty {
1788 if check_packed_inner(tcx, def.did, stack) {
1793 // only need to pop if not early out
1800 /// Emit an error when encountering more or less than one variant in a transparent enum.
1801 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1802 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1803 tcx.hir().span_if_local(variant.def_id).unwrap()
1806 "needs exactly one variant, but has {}",
1809 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1810 err.span_label(sp, &msg);
1811 if let &[ref start.., ref end] = &variant_spans[..] {
1812 for variant_span in start {
1813 err.span_label(*variant_span, "");
1815 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1820 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1822 fn bad_non_zero_sized_fields<'tcx>(
1824 adt: &'tcx ty::AdtDef,
1826 field_spans: impl Iterator<Item = Span>,
1829 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1830 let mut err = struct_span_err!(
1834 "{}transparent {} {}",
1835 if adt.is_enum() { "the variant of a " } else { "" },
1839 err.span_label(sp, &msg);
1840 for sp in field_spans {
1841 err.span_label(sp, "this field is non-zero-sized");
1846 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1847 let adt = tcx.adt_def(def_id);
1848 if !adt.repr.transparent() {
1851 let sp = tcx.sess.source_map().def_span(sp);
1854 if !tcx.features().transparent_enums {
1856 &tcx.sess.parse_sess,
1857 sym::transparent_enums,
1859 GateIssue::Language,
1860 "transparent enums are unstable",
1863 if adt.variants.len() != 1 {
1864 bad_variant_count(tcx, adt, sp, def_id);
1865 if adt.variants.is_empty() {
1866 // Don't bother checking the fields. No variants (and thus no fields) exist.
1872 if adt.is_union() && !tcx.features().transparent_unions {
1873 emit_feature_err(&tcx.sess.parse_sess,
1874 sym::transparent_unions,
1876 GateIssue::Language,
1877 "transparent unions are unstable");
1880 // For each field, figure out if it's known to be a ZST and align(1)
1881 let field_infos = adt.all_fields().map(|field| {
1882 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1883 let param_env = tcx.param_env(field.did);
1884 let layout = tcx.layout_of(param_env.and(ty));
1885 // We are currently checking the type this field came from, so it must be local
1886 let span = tcx.hir().span_if_local(field.did).unwrap();
1887 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1888 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1892 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
1897 let non_zst_count = non_zst_fields.clone().count();
1898 if non_zst_count != 1 {
1899 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
1901 for (span, zst, align1) in field_infos {
1907 "zero-sized field in transparent {} has alignment larger than 1",
1909 ).span_label(span, "has alignment larger than 1").emit();
1914 #[allow(trivial_numeric_casts)]
1915 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
1916 let def_id = tcx.hir().local_def_id(id);
1917 let def = tcx.adt_def(def_id);
1918 def.destructor(tcx); // force the destructor to be evaluated
1921 let attributes = tcx.get_attrs(def_id);
1922 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1924 tcx.sess, attr.span, E0084,
1925 "unsupported representation for zero-variant enum")
1926 .span_label(sp, "zero-variant enum")
1931 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1932 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1933 if !tcx.features().repr128 {
1934 emit_feature_err(&tcx.sess.parse_sess,
1937 GateIssue::Language,
1938 "repr with 128-bit type is unstable");
1943 if let Some(ref e) = v.node.disr_expr {
1944 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
1948 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
1950 |var: &hir::Variant| match var.node.data {
1951 hir::VariantData::Unit(..) => true,
1955 let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some();
1956 let has_non_units = vs.iter().any(|var| !is_unit(var));
1957 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
1958 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
1960 if disr_non_unit || (disr_units && has_non_units) {
1961 let mut err = struct_span_err!(tcx.sess, sp, E0732,
1962 "`#[repr(inttype)]` must be specified");
1967 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1968 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1969 // Check for duplicate discriminant values
1970 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1971 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1972 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1973 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1974 let i_span = match variant_i.node.disr_expr {
1975 Some(ref expr) => tcx.hir().span(expr.hir_id),
1976 None => tcx.hir().span(variant_i_hir_id)
1978 let span = match v.node.disr_expr {
1979 Some(ref expr) => tcx.hir().span(expr.hir_id),
1982 struct_span_err!(tcx.sess, span, E0081,
1983 "discriminant value `{}` already exists", disr_vals[i])
1984 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1985 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1988 disr_vals.push(discr);
1991 check_representable(tcx, sp, def_id);
1992 check_transparent(tcx, sp, def_id);
1995 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
1996 span_err!(tcx.sess, span, E0533,
1997 "expected unit struct/variant or constant, found {} `{}`",
1999 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2002 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2003 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2007 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2008 -> &'tcx ty::GenericPredicates<'tcx>
2011 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2012 let item_id = tcx.hir().ty_param_owner(hir_id);
2013 let item_def_id = tcx.hir().local_def_id(item_id);
2014 let generics = tcx.generics_of(item_def_id);
2015 let index = generics.param_def_id_to_index[&def_id];
2016 tcx.arena.alloc(ty::GenericPredicates {
2018 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2020 ty::Predicate::Trait(ref data)
2021 if data.skip_binder().self_ty().is_param(index) => {
2022 // HACK(eddyb) should get the original `Span`.
2023 let span = tcx.def_span(def_id);
2024 Some((predicate, span))
2034 def: Option<&ty::GenericParamDef>,
2036 ) -> Option<ty::Region<'tcx>> {
2038 Some(def) => infer::EarlyBoundRegion(span, def.name),
2039 None => infer::MiscVariable(span)
2041 Some(self.next_region_var(v))
2044 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2045 if let Some(param) = param {
2046 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2051 self.next_ty_var(TypeVariableOrigin {
2052 kind: TypeVariableOriginKind::TypeInference,
2061 param: Option<&ty::GenericParamDef>,
2063 ) -> &'tcx Const<'tcx> {
2064 if let Some(param) = param {
2065 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2070 self.next_const_var(ty, ConstVariableOrigin {
2071 kind: ConstVariableOriginKind::ConstInference,
2077 fn projected_ty_from_poly_trait_ref(&self,
2080 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2083 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2085 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2089 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2092 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2093 if ty.has_escaping_bound_vars() {
2094 ty // FIXME: normalization and escaping regions
2096 self.normalize_associated_types_in(span, &ty)
2100 fn set_tainted_by_errors(&self) {
2101 self.infcx.set_tainted_by_errors()
2104 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2105 self.write_ty(hir_id, ty)
2109 /// Controls whether the arguments are tupled. This is used for the call
2112 /// Tupling means that all call-side arguments are packed into a tuple and
2113 /// passed as a single parameter. For example, if tupling is enabled, this
2116 /// fn f(x: (isize, isize))
2118 /// Can be called as:
2125 #[derive(Clone, Eq, PartialEq)]
2126 enum TupleArgumentsFlag {
2131 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2133 inh: &'a Inherited<'a, 'tcx>,
2134 param_env: ty::ParamEnv<'tcx>,
2135 body_id: hir::HirId,
2136 ) -> FnCtxt<'a, 'tcx> {
2140 err_count_on_creation: inh.tcx.sess.err_count(),
2142 ret_coercion_span: RefCell::new(None),
2144 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2145 hir::CRATE_HIR_ID)),
2146 diverges: Cell::new(Diverges::Maybe),
2147 has_errors: Cell::new(false),
2148 enclosing_breakables: RefCell::new(EnclosingBreakables {
2150 by_id: Default::default(),
2156 pub fn sess(&self) -> &Session {
2160 pub fn errors_reported_since_creation(&self) -> bool {
2161 self.tcx.sess.err_count() > self.err_count_on_creation
2164 /// Produces warning on the given node, if the current point in the
2165 /// function is unreachable, and there hasn't been another warning.
2166 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2167 if self.diverges.get() == Diverges::Always &&
2168 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2169 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2170 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2171 !span.is_desugaring(DesugaringKind::CondTemporary) {
2172 self.diverges.set(Diverges::WarnedAlways);
2174 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2176 let msg = format!("unreachable {}", kind);
2177 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2183 code: ObligationCauseCode<'tcx>)
2184 -> ObligationCause<'tcx> {
2185 ObligationCause::new(span, self.body_id, code)
2188 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2189 self.cause(span, ObligationCauseCode::MiscObligation)
2192 /// Resolves type variables in `ty` if possible. Unlike the infcx
2193 /// version (resolve_vars_if_possible), this version will
2194 /// also select obligations if it seems useful, in an effort
2195 /// to get more type information.
2196 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2197 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2199 // No Infer()? Nothing needs doing.
2200 if !ty.has_infer_types() {
2201 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2205 // If `ty` is a type variable, see whether we already know what it is.
2206 ty = self.resolve_vars_if_possible(&ty);
2207 if !ty.has_infer_types() {
2208 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2212 // If not, try resolving pending obligations as much as
2213 // possible. This can help substantially when there are
2214 // indirect dependencies that don't seem worth tracking
2216 self.select_obligations_where_possible(false);
2217 ty = self.resolve_vars_if_possible(&ty);
2219 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2223 fn record_deferred_call_resolution(
2225 closure_def_id: DefId,
2226 r: DeferredCallResolution<'tcx>,
2228 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2229 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2232 fn remove_deferred_call_resolutions(
2234 closure_def_id: DefId,
2235 ) -> Vec<DeferredCallResolution<'tcx>> {
2236 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2237 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2240 pub fn tag(&self) -> String {
2241 format!("{:p}", self)
2244 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2245 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2246 span_bug!(span, "no type for local variable {}",
2247 self.tcx.hir().node_to_string(nid))
2252 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2253 debug!("write_ty({:?}, {:?}) in fcx {}",
2254 id, self.resolve_vars_if_possible(&ty), self.tag());
2255 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2257 if ty.references_error() {
2258 self.has_errors.set(true);
2259 self.set_tainted_by_errors();
2263 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2264 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2267 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2268 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2271 pub fn write_method_call(&self,
2273 method: MethodCallee<'tcx>) {
2274 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2275 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2276 self.write_substs(hir_id, method.substs);
2278 // When the method is confirmed, the `method.substs` includes
2279 // parameters from not just the method, but also the impl of
2280 // the method -- in particular, the `Self` type will be fully
2281 // resolved. However, those are not something that the "user
2282 // specified" -- i.e., those types come from the inferred type
2283 // of the receiver, not something the user wrote. So when we
2284 // create the user-substs, we want to replace those earlier
2285 // types with just the types that the user actually wrote --
2286 // that is, those that appear on the *method itself*.
2288 // As an example, if the user wrote something like
2289 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2290 // type of `foo` (possibly adjusted), but we don't want to
2291 // include that. We want just the `[_, u32]` part.
2292 if !method.substs.is_noop() {
2293 let method_generics = self.tcx.generics_of(method.def_id);
2294 if !method_generics.params.is_empty() {
2295 let user_type_annotation = self.infcx.probe(|_| {
2296 let user_substs = UserSubsts {
2297 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2298 let i = param.index as usize;
2299 if i < method_generics.parent_count {
2300 self.infcx.var_for_def(DUMMY_SP, param)
2305 user_self_ty: None, // not relevant here
2308 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2314 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2315 self.write_user_type_annotation(hir_id, user_type_annotation);
2320 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2321 if !substs.is_noop() {
2322 debug!("write_substs({:?}, {:?}) in fcx {}",
2327 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2331 /// Given the substs that we just converted from the HIR, try to
2332 /// canonicalize them and store them as user-given substitutions
2333 /// (i.e., substitutions that must be respected by the NLL check).
2335 /// This should be invoked **before any unifications have
2336 /// occurred**, so that annotations like `Vec<_>` are preserved
2338 pub fn write_user_type_annotation_from_substs(
2342 substs: SubstsRef<'tcx>,
2343 user_self_ty: Option<UserSelfTy<'tcx>>,
2346 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2347 user_self_ty={:?} in fcx {}",
2348 hir_id, def_id, substs, user_self_ty, self.tag(),
2351 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2352 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2353 &UserType::TypeOf(def_id, UserSubsts {
2358 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2359 self.write_user_type_annotation(hir_id, canonicalized);
2363 pub fn write_user_type_annotation(
2366 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2369 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2370 hir_id, canonical_user_type_annotation, self.tag(),
2373 if !canonical_user_type_annotation.is_identity() {
2374 self.tables.borrow_mut().user_provided_types_mut().insert(
2375 hir_id, canonical_user_type_annotation
2378 debug!("write_user_type_annotation: skipping identity substs");
2382 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2383 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2389 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2390 Entry::Vacant(entry) => { entry.insert(adj); },
2391 Entry::Occupied(mut entry) => {
2392 debug!(" - composing on top of {:?}", entry.get());
2393 match (&entry.get()[..], &adj[..]) {
2394 // Applying any adjustment on top of a NeverToAny
2395 // is a valid NeverToAny adjustment, because it can't
2397 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2399 Adjustment { kind: Adjust::Deref(_), .. },
2400 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2402 Adjustment { kind: Adjust::Deref(_), .. },
2403 .. // Any following adjustments are allowed.
2405 // A reborrow has no effect before a dereference.
2407 // FIXME: currently we never try to compose autoderefs
2408 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2410 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2411 expr, entry.get(), adj)
2413 *entry.get_mut() = adj;
2418 /// Basically whenever we are converting from a type scheme into
2419 /// the fn body space, we always want to normalize associated
2420 /// types as well. This function combines the two.
2421 fn instantiate_type_scheme<T>(&self,
2423 substs: SubstsRef<'tcx>,
2426 where T : TypeFoldable<'tcx>
2428 let value = value.subst(self.tcx, substs);
2429 let result = self.normalize_associated_types_in(span, &value);
2430 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2437 /// As `instantiate_type_scheme`, but for the bounds found in a
2438 /// generic type scheme.
2439 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2440 -> ty::InstantiatedPredicates<'tcx> {
2441 let bounds = self.tcx.predicates_of(def_id);
2442 let result = bounds.instantiate(self.tcx, substs);
2443 let result = self.normalize_associated_types_in(span, &result);
2444 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2451 /// Replaces the opaque types from the given value with type variables,
2452 /// and records the `OpaqueTypeMap` for later use during writeback. See
2453 /// `InferCtxt::instantiate_opaque_types` for more details.
2454 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2456 parent_id: hir::HirId,
2460 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2461 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2465 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2466 self.instantiate_opaque_types(
2475 let mut opaque_types = self.opaque_types.borrow_mut();
2476 for (ty, decl) in opaque_type_map {
2477 let old_value = opaque_types.insert(ty, decl);
2478 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2484 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2485 where T : TypeFoldable<'tcx>
2487 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2490 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2492 where T : TypeFoldable<'tcx>
2494 self.inh.partially_normalize_associated_types_in(span,
2500 pub fn require_type_meets(&self,
2503 code: traits::ObligationCauseCode<'tcx>,
2506 self.register_bound(
2509 traits::ObligationCause::new(span, self.body_id, code));
2512 pub fn require_type_is_sized(&self,
2515 code: traits::ObligationCauseCode<'tcx>)
2517 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2518 self.require_type_meets(ty, span, code, lang_item);
2521 pub fn require_type_is_sized_deferred(&self,
2524 code: traits::ObligationCauseCode<'tcx>)
2526 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2529 pub fn register_bound(&self,
2532 cause: traits::ObligationCause<'tcx>)
2534 self.fulfillment_cx.borrow_mut()
2535 .register_bound(self, self.param_env, ty, def_id, cause);
2538 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2539 let t = AstConv::ast_ty_to_ty(self, ast_t);
2540 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2544 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2545 let ty = self.to_ty(ast_ty);
2546 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2548 if Self::can_contain_user_lifetime_bounds(ty) {
2549 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2550 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2551 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2557 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2558 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2559 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2562 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2563 AstConv::ast_const_to_const(self, ast_c, ty)
2566 // If the type given by the user has free regions, save it for later, since
2567 // NLL would like to enforce those. Also pass in types that involve
2568 // projections, since those can resolve to `'static` bounds (modulo #54940,
2569 // which hopefully will be fixed by the time you see this comment, dear
2570 // reader, although I have my doubts). Also pass in types with inference
2571 // types, because they may be repeated. Other sorts of things are already
2572 // sufficiently enforced with erased regions. =)
2573 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2575 T: TypeFoldable<'tcx>
2577 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2580 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2581 match self.tables.borrow().node_types().get(id) {
2583 None if self.is_tainted_by_errors() => self.tcx.types.err,
2585 bug!("no type for node {}: {} in fcx {}",
2586 id, self.tcx.hir().node_to_string(id),
2592 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2593 /// outlive the region `r`.
2594 pub fn register_wf_obligation(&self,
2597 code: traits::ObligationCauseCode<'tcx>)
2599 // WF obligations never themselves fail, so no real need to give a detailed cause:
2600 let cause = traits::ObligationCause::new(span, self.body_id, code);
2601 self.register_predicate(traits::Obligation::new(cause,
2603 ty::Predicate::WellFormed(ty)));
2606 /// Registers obligations that all types appearing in `substs` are well-formed.
2607 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2608 for ty in substs.types() {
2609 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2613 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2614 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2615 /// trait/region obligations.
2617 /// For example, if there is a function:
2620 /// fn foo<'a,T:'a>(...)
2623 /// and a reference:
2629 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2630 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2631 pub fn add_obligations_for_parameters(&self,
2632 cause: traits::ObligationCause<'tcx>,
2633 predicates: &ty::InstantiatedPredicates<'tcx>)
2635 assert!(!predicates.has_escaping_bound_vars());
2637 debug!("add_obligations_for_parameters(predicates={:?})",
2640 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2641 self.register_predicate(obligation);
2645 // FIXME(arielb1): use this instead of field.ty everywhere
2646 // Only for fields! Returns <none> for methods>
2647 // Indifferent to privacy flags
2648 pub fn field_ty(&self,
2650 field: &'tcx ty::FieldDef,
2651 substs: SubstsRef<'tcx>)
2654 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2657 fn check_casts(&self) {
2658 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2659 for cast in deferred_cast_checks.drain(..) {
2664 fn resolve_generator_interiors(&self, def_id: DefId) {
2665 let mut generators = self.deferred_generator_interiors.borrow_mut();
2666 for (body_id, interior, kind) in generators.drain(..) {
2667 self.select_obligations_where_possible(false);
2668 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2672 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2673 // Non-numerics get replaced with ! or () (depending on whether
2674 // feature(never_type) is enabled, unconstrained ints with i32,
2675 // unconstrained floats with f64.
2676 // Fallback becomes very dubious if we have encountered type-checking errors.
2677 // In that case, fallback to Error.
2678 // The return value indicates whether fallback has occurred.
2679 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2680 use rustc::ty::error::UnconstrainedNumeric::Neither;
2681 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2683 assert!(ty.is_ty_infer());
2684 let fallback = match self.type_is_unconstrained_numeric(ty) {
2685 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2686 UnconstrainedInt => self.tcx.types.i32,
2687 UnconstrainedFloat => self.tcx.types.f64,
2688 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2689 Neither => return false,
2691 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2692 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2696 fn select_all_obligations_or_error(&self) {
2697 debug!("select_all_obligations_or_error");
2698 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2699 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2703 /// Select as many obligations as we can at present.
2704 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2705 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2706 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2710 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2711 /// returns a type of `&T`, but the actual type we assign to the
2712 /// *expression* is `T`. So this function just peels off the return
2713 /// type by one layer to yield `T`.
2714 fn make_overloaded_place_return_type(&self,
2715 method: MethodCallee<'tcx>)
2716 -> ty::TypeAndMut<'tcx>
2718 // extract method return type, which will be &T;
2719 let ret_ty = method.sig.output();
2721 // method returns &T, but the type as visible to user is T, so deref
2722 ret_ty.builtin_deref(true).unwrap()
2728 base_expr: &'tcx hir::Expr,
2732 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2733 // FIXME(#18741) -- this is almost but not quite the same as the
2734 // autoderef that normal method probing does. They could likely be
2737 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2738 let mut result = None;
2739 while result.is_none() && autoderef.next().is_some() {
2740 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2742 autoderef.finalize(self);
2746 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2747 /// (and otherwise adjust) `base_expr`, looking for a type which either
2748 /// supports builtin indexing or overloaded indexing.
2749 /// This loop implements one step in that search; the autoderef loop
2750 /// is implemented by `lookup_indexing`.
2754 base_expr: &hir::Expr,
2755 autoderef: &Autoderef<'a, 'tcx>,
2758 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2759 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2760 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2767 for &unsize in &[false, true] {
2768 let mut self_ty = adjusted_ty;
2770 // We only unsize arrays here.
2771 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2772 self_ty = self.tcx.mk_slice(element_ty);
2778 // If some lookup succeeds, write callee into table and extract index/element
2779 // type from the method signature.
2780 // If some lookup succeeded, install method in table
2781 let input_ty = self.next_ty_var(TypeVariableOrigin {
2782 kind: TypeVariableOriginKind::AutoDeref,
2783 span: base_expr.span,
2785 let method = self.try_overloaded_place_op(
2786 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2788 let result = method.map(|ok| {
2789 debug!("try_index_step: success, using overloaded indexing");
2790 let method = self.register_infer_ok_obligations(ok);
2792 let mut adjustments = autoderef.adjust_steps(self, needs);
2793 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2794 let mutbl = match r_mutbl {
2795 hir::MutImmutable => AutoBorrowMutability::Immutable,
2796 hir::MutMutable => AutoBorrowMutability::Mutable {
2797 // Indexing can be desugared to a method call,
2798 // so maybe we could use two-phase here.
2799 // See the documentation of AllowTwoPhase for why that's
2800 // not the case today.
2801 allow_two_phase_borrow: AllowTwoPhase::No,
2804 adjustments.push(Adjustment {
2805 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2806 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2813 adjustments.push(Adjustment {
2814 kind: Adjust::Pointer(PointerCast::Unsize),
2815 target: method.sig.inputs()[0]
2818 self.apply_adjustments(base_expr, adjustments);
2820 self.write_method_call(expr.hir_id, method);
2821 (input_ty, self.make_overloaded_place_return_type(method).ty)
2823 if result.is_some() {
2831 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2832 let (tr, name) = match (op, is_mut) {
2833 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2834 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2835 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2836 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2838 (tr, ast::Ident::with_empty_ctxt(name))
2841 fn try_overloaded_place_op(&self,
2844 arg_tys: &[Ty<'tcx>],
2847 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2849 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2855 // Try Mut first, if needed.
2856 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2857 let method = match (needs, mut_tr) {
2858 (Needs::MutPlace, Some(trait_did)) => {
2859 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2864 // Otherwise, fall back to the immutable version.
2865 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2866 let method = match (method, imm_tr) {
2867 (None, Some(trait_did)) => {
2868 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2870 (method, _) => method,
2876 fn check_method_argument_types(
2880 method: Result<MethodCallee<'tcx>, ()>,
2881 args_no_rcvr: &'tcx [hir::Expr],
2882 tuple_arguments: TupleArgumentsFlag,
2883 expected: Expectation<'tcx>,
2885 let has_error = match method {
2887 method.substs.references_error() || method.sig.references_error()
2892 let err_inputs = self.err_args(args_no_rcvr.len());
2894 let err_inputs = match tuple_arguments {
2895 DontTupleArguments => err_inputs,
2896 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2899 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2900 false, tuple_arguments, None);
2901 return self.tcx.types.err;
2904 let method = method.unwrap();
2905 // HACK(eddyb) ignore self in the definition (see above).
2906 let expected_arg_tys = self.expected_inputs_for_expected_output(
2909 method.sig.output(),
2910 &method.sig.inputs()[1..]
2912 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2913 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2914 self.tcx.hir().span_if_local(method.def_id));
2918 fn self_type_matches_expected_vid(
2920 trait_ref: ty::PolyTraitRef<'tcx>,
2921 expected_vid: ty::TyVid,
2923 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2925 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2926 trait_ref, self_ty, expected_vid
2929 ty::Infer(ty::TyVar(found_vid)) => {
2930 // FIXME: consider using `sub_root_var` here so we
2931 // can see through subtyping.
2932 let found_vid = self.root_var(found_vid);
2933 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2934 expected_vid == found_vid
2940 fn obligations_for_self_ty<'b>(
2943 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2946 // FIXME: consider using `sub_root_var` here so we
2947 // can see through subtyping.
2948 let ty_var_root = self.root_var(self_ty);
2949 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2950 self_ty, ty_var_root,
2951 self.fulfillment_cx.borrow().pending_obligations());
2955 .pending_obligations()
2957 .filter_map(move |obligation| match obligation.predicate {
2958 ty::Predicate::Projection(ref data) =>
2959 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2960 ty::Predicate::Trait(ref data) =>
2961 Some((data.to_poly_trait_ref(), obligation)),
2962 ty::Predicate::Subtype(..) => None,
2963 ty::Predicate::RegionOutlives(..) => None,
2964 ty::Predicate::TypeOutlives(..) => None,
2965 ty::Predicate::WellFormed(..) => None,
2966 ty::Predicate::ObjectSafe(..) => None,
2967 ty::Predicate::ConstEvaluatable(..) => None,
2968 // N.B., this predicate is created by breaking down a
2969 // `ClosureType: FnFoo()` predicate, where
2970 // `ClosureType` represents some `Closure`. It can't
2971 // possibly be referring to the current closure,
2972 // because we haven't produced the `Closure` for
2973 // this closure yet; this is exactly why the other
2974 // code is looking for a self type of a unresolved
2975 // inference variable.
2976 ty::Predicate::ClosureKind(..) => None,
2977 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2980 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2981 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2982 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2986 /// Generic function that factors out common logic from function calls,
2987 /// method calls and overloaded operators.
2988 fn check_argument_types(
2992 fn_inputs: &[Ty<'tcx>],
2993 expected_arg_tys: &[Ty<'tcx>],
2994 args: &'tcx [hir::Expr],
2996 tuple_arguments: TupleArgumentsFlag,
2997 def_span: Option<Span>,
3001 // Grab the argument types, supplying fresh type variables
3002 // if the wrong number of arguments were supplied
3003 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3009 // All the input types from the fn signature must outlive the call
3010 // so as to validate implied bounds.
3011 for &fn_input_ty in fn_inputs {
3012 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
3015 let expected_arg_count = fn_inputs.len();
3017 let param_count_error = |expected_count: usize,
3022 let mut err = tcx.sess.struct_span_err_with_code(sp,
3023 &format!("this function takes {}{} but {} {} supplied",
3024 if c_variadic { "at least " } else { "" },
3025 potentially_plural_count(expected_count, "parameter"),
3026 potentially_plural_count(arg_count, "parameter"),
3027 if arg_count == 1 {"was"} else {"were"}),
3028 DiagnosticId::Error(error_code.to_owned()));
3030 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3031 err.span_label(def_s, "defined here");
3034 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3035 // remove closing `)` from the span
3036 let sugg_span = sugg_span.shrink_to_lo();
3037 err.span_suggestion(
3039 "expected the unit value `()`; create it with empty parentheses",
3041 Applicability::MachineApplicable);
3043 err.span_label(sp, format!("expected {}{}",
3044 if c_variadic { "at least " } else { "" },
3045 potentially_plural_count(expected_count, "parameter")));
3050 let mut expected_arg_tys = expected_arg_tys.to_vec();
3052 let formal_tys = if tuple_arguments == TupleArguments {
3053 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3054 match tuple_type.sty {
3055 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3056 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3057 expected_arg_tys = vec![];
3058 self.err_args(args.len())
3060 ty::Tuple(arg_types) => {
3061 expected_arg_tys = match expected_arg_tys.get(0) {
3062 Some(&ty) => match ty.sty {
3063 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3068 arg_types.iter().map(|k| k.expect_ty()).collect()
3071 span_err!(tcx.sess, sp, E0059,
3072 "cannot use call notation; the first type parameter \
3073 for the function trait is neither a tuple nor unit");
3074 expected_arg_tys = vec![];
3075 self.err_args(args.len())
3078 } else if expected_arg_count == supplied_arg_count {
3080 } else if c_variadic {
3081 if supplied_arg_count >= expected_arg_count {
3084 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3085 expected_arg_tys = vec![];
3086 self.err_args(supplied_arg_count)
3089 // is the missing argument of type `()`?
3090 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3091 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3092 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3093 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3097 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3099 expected_arg_tys = vec![];
3100 self.err_args(supplied_arg_count)
3103 debug!("check_argument_types: formal_tys={:?}",
3104 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3106 // If there is no expectation, expect formal_tys.
3107 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3113 // Check the arguments.
3114 // We do this in a pretty awful way: first we type-check any arguments
3115 // that are not closures, then we type-check the closures. This is so
3116 // that we have more information about the types of arguments when we
3117 // type-check the functions. This isn't really the right way to do this.
3118 for &check_closures in &[false, true] {
3119 debug!("check_closures={}", check_closures);
3121 // More awful hacks: before we check argument types, try to do
3122 // an "opportunistic" vtable resolution of any trait bounds on
3123 // the call. This helps coercions.
3125 self.select_obligations_where_possible(false);
3128 // For C-variadic functions, we don't have a declared type for all of
3129 // the arguments hence we only do our usual type checking with
3130 // the arguments who's types we do know.
3131 let t = if c_variadic {
3133 } else if tuple_arguments == TupleArguments {
3138 for (i, arg) in args.iter().take(t).enumerate() {
3139 // Warn only for the first loop (the "no closures" one).
3140 // Closure arguments themselves can't be diverging, but
3141 // a previous argument can, e.g., `foo(panic!(), || {})`.
3142 if !check_closures {
3143 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3146 let is_closure = match arg.node {
3147 ExprKind::Closure(..) => true,
3151 if is_closure != check_closures {
3155 debug!("checking the argument");
3156 let formal_ty = formal_tys[i];
3158 // The special-cased logic below has three functions:
3159 // 1. Provide as good of an expected type as possible.
3160 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3162 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3164 // 2. Coerce to the most detailed type that could be coerced
3165 // to, which is `expected_ty` if `rvalue_hint` returns an
3166 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3167 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3168 // We're processing function arguments so we definitely want to use
3169 // two-phase borrows.
3170 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3172 // 3. Relate the expected type and the formal one,
3173 // if the expected type was used for the coercion.
3174 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3178 // We also need to make sure we at least write the ty of the other
3179 // arguments which we skipped above.
3181 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3182 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3183 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3186 for arg in args.iter().skip(expected_arg_count) {
3187 let arg_ty = self.check_expr(&arg);
3189 // There are a few types which get autopromoted when passed via varargs
3190 // in C but we just error out instead and require explicit casts.
3191 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3193 ty::Float(ast::FloatTy::F32) => {
3194 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3196 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3197 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3199 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3200 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3203 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3204 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3205 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3213 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3214 vec![self.tcx.types.err; len]
3217 // AST fragment checking
3220 expected: Expectation<'tcx>)
3226 ast::LitKind::Str(..) => tcx.mk_static_str(),
3227 ast::LitKind::ByteStr(ref v) => {
3228 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3229 tcx.mk_array(tcx.types.u8, v.len() as u64))
3231 ast::LitKind::Byte(_) => tcx.types.u8,
3232 ast::LitKind::Char(_) => tcx.types.char,
3233 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3234 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3235 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3236 let opt_ty = expected.to_option(self).and_then(|ty| {
3238 ty::Int(_) | ty::Uint(_) => Some(ty),
3239 ty::Char => Some(tcx.types.u8),
3240 ty::RawPtr(..) => Some(tcx.types.usize),
3241 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3245 opt_ty.unwrap_or_else(|| self.next_int_var())
3247 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3248 ast::LitKind::FloatUnsuffixed(_) => {
3249 let opt_ty = expected.to_option(self).and_then(|ty| {
3251 ty::Float(_) => Some(ty),
3255 opt_ty.unwrap_or_else(|| self.next_float_var())
3257 ast::LitKind::Bool(_) => tcx.types.bool,
3258 ast::LitKind::Err(_) => tcx.types.err,
3262 // Determine the `Self` type, using fresh variables for all variables
3263 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3264 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3266 pub fn impl_self_ty(&self,
3267 span: Span, // (potential) receiver for this impl
3269 -> TypeAndSubsts<'tcx> {
3270 let ity = self.tcx.type_of(did);
3271 debug!("impl_self_ty: ity={:?}", ity);
3273 let substs = self.fresh_substs_for_item(span, did);
3274 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3276 TypeAndSubsts { substs: substs, ty: substd_ty }
3279 /// Unifies the output type with the expected type early, for more coercions
3280 /// and forward type information on the input expressions.
3281 fn expected_inputs_for_expected_output(&self,
3283 expected_ret: Expectation<'tcx>,
3284 formal_ret: Ty<'tcx>,
3285 formal_args: &[Ty<'tcx>])
3287 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3288 let ret_ty = match expected_ret.only_has_type(self) {
3290 None => return Vec::new()
3292 let expect_args = self.fudge_inference_if_ok(|| {
3293 // Attempt to apply a subtyping relationship between the formal
3294 // return type (likely containing type variables if the function
3295 // is polymorphic) and the expected return type.
3296 // No argument expectations are produced if unification fails.
3297 let origin = self.misc(call_span);
3298 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3300 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3301 // to identity so the resulting type is not constrained.
3304 // Process any obligations locally as much as
3305 // we can. We don't care if some things turn
3306 // out unconstrained or ambiguous, as we're
3307 // just trying to get hints here.
3308 self.save_and_restore_in_snapshot_flag(|_| {
3309 let mut fulfill = TraitEngine::new(self.tcx);
3310 for obligation in ok.obligations {
3311 fulfill.register_predicate_obligation(self, obligation);
3313 fulfill.select_where_possible(self)
3314 }).map_err(|_| ())?;
3316 Err(_) => return Err(()),
3319 // Record all the argument types, with the substitutions
3320 // produced from the above subtyping unification.
3321 Ok(formal_args.iter().map(|ty| {
3322 self.resolve_vars_if_possible(ty)
3324 }).unwrap_or_default();
3325 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3326 formal_args, formal_ret,
3327 expect_args, expected_ret);
3331 pub fn check_struct_path(&self,
3334 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3335 let path_span = match *qpath {
3336 QPath::Resolved(_, ref path) => path.span,
3337 QPath::TypeRelative(ref qself, _) => qself.span
3339 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3340 let variant = match def {
3342 self.set_tainted_by_errors();
3345 Res::Def(DefKind::Variant, _) => {
3347 ty::Adt(adt, substs) => {
3348 Some((adt.variant_of_res(def), adt.did, substs))
3350 _ => bug!("unexpected type: {:?}", ty)
3353 Res::Def(DefKind::Struct, _)
3354 | Res::Def(DefKind::Union, _)
3355 | Res::Def(DefKind::TyAlias, _)
3356 | Res::Def(DefKind::AssocTy, _)
3357 | Res::SelfTy(..) => {
3359 ty::Adt(adt, substs) if !adt.is_enum() => {
3360 Some((adt.non_enum_variant(), adt.did, substs))
3365 _ => bug!("unexpected definition: {:?}", def)
3368 if let Some((variant, did, substs)) = variant {
3369 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3370 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3372 // Check bounds on type arguments used in the path.
3373 let bounds = self.instantiate_bounds(path_span, did, substs);
3374 let cause = traits::ObligationCause::new(path_span, self.body_id,
3375 traits::ItemObligation(did));
3376 self.add_obligations_for_parameters(cause, &bounds);
3380 struct_span_err!(self.tcx.sess, path_span, E0071,
3381 "expected struct, variant or union type, found {}",
3382 ty.sort_string(self.tcx))
3383 .span_label(path_span, "not a struct")
3389 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3390 // The newly resolved definition is written into `type_dependent_defs`.
3391 fn finish_resolving_struct_path(&self,
3398 QPath::Resolved(ref maybe_qself, ref path) => {
3399 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3400 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3403 QPath::TypeRelative(ref qself, ref segment) => {
3404 let ty = self.to_ty(qself);
3406 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3411 let result = AstConv::associated_path_to_ty(
3420 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3421 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3423 // Write back the new resolution.
3424 self.write_resolution(hir_id, result);
3426 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3431 /// Resolves an associated value path into a base type and associated constant, or method
3432 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3433 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3437 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3439 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3440 let (ty, qself, item_segment) = match *qpath {
3441 QPath::Resolved(ref opt_qself, ref path) => {
3443 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3444 &path.segments[..]);
3446 QPath::TypeRelative(ref qself, ref segment) => {
3447 (self.to_ty(qself), qself, segment)
3450 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3451 // Return directly on cache hit. This is useful to avoid doubly reporting
3452 // errors with default match binding modes. See #44614.
3453 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3454 .unwrap_or(Res::Err);
3455 return (def, Some(ty), slice::from_ref(&**item_segment));
3457 let item_name = item_segment.ident;
3458 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3459 let result = match error {
3460 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3461 _ => Err(ErrorReported),
3463 if item_name.name != kw::Invalid {
3464 self.report_method_error(
3468 SelfSource::QPath(qself),
3476 // Write back the new resolution.
3477 self.write_resolution(hir_id, result);
3479 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3481 slice::from_ref(&**item_segment),
3485 pub fn check_decl_initializer(
3487 local: &'tcx hir::Local,
3488 init: &'tcx hir::Expr,
3490 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3491 // for #42640 (default match binding modes).
3494 let ref_bindings = local.pat.contains_explicit_ref_binding();
3496 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3497 if let Some(m) = ref_bindings {
3498 // Somewhat subtle: if we have a `ref` binding in the pattern,
3499 // we want to avoid introducing coercions for the RHS. This is
3500 // both because it helps preserve sanity and, in the case of
3501 // ref mut, for soundness (issue #23116). In particular, in
3502 // the latter case, we need to be clear that the type of the
3503 // referent for the reference that results is *equal to* the
3504 // type of the place it is referencing, and not some
3505 // supertype thereof.
3506 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3507 self.demand_eqtype(init.span, local_ty, init_ty);
3510 self.check_expr_coercable_to_type(init, local_ty)
3514 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3515 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3516 self.write_ty(local.hir_id, t);
3518 if let Some(ref init) = local.init {
3519 let init_ty = self.check_decl_initializer(local, &init);
3520 if init_ty.references_error() {
3521 self.write_ty(local.hir_id, init_ty);
3525 self.check_pat_walk(
3528 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
3531 let pat_ty = self.node_ty(local.pat.hir_id);
3532 if pat_ty.references_error() {
3533 self.write_ty(local.hir_id, pat_ty);
3537 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3538 // Don't do all the complex logic below for `DeclItem`.
3540 hir::StmtKind::Item(..) => return,
3541 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3544 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3546 // Hide the outer diverging and `has_errors` flags.
3547 let old_diverges = self.diverges.get();
3548 let old_has_errors = self.has_errors.get();
3549 self.diverges.set(Diverges::Maybe);
3550 self.has_errors.set(false);
3553 hir::StmtKind::Local(ref l) => {
3554 self.check_decl_local(&l);
3557 hir::StmtKind::Item(_) => {}
3558 hir::StmtKind::Expr(ref expr) => {
3559 // Check with expected type of `()`.
3560 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3562 hir::StmtKind::Semi(ref expr) => {
3563 self.check_expr(&expr);
3567 // Combine the diverging and `has_error` flags.
3568 self.diverges.set(self.diverges.get() | old_diverges);
3569 self.has_errors.set(self.has_errors.get() | old_has_errors);
3572 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3573 let unit = self.tcx.mk_unit();
3574 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3576 // if the block produces a `!` value, that can always be
3577 // (effectively) coerced to unit.
3579 self.demand_suptype(blk.span, unit, ty);
3583 fn check_block_with_expected(
3585 blk: &'tcx hir::Block,
3586 expected: Expectation<'tcx>,
3589 let mut fcx_ps = self.ps.borrow_mut();
3590 let unsafety_state = fcx_ps.recurse(blk);
3591 replace(&mut *fcx_ps, unsafety_state)
3594 // In some cases, blocks have just one exit, but other blocks
3595 // can be targeted by multiple breaks. This can happen both
3596 // with labeled blocks as well as when we desugar
3597 // a `try { ... }` expression.
3601 // 'a: { if true { break 'a Err(()); } Ok(()) }
3603 // Here we would wind up with two coercions, one from
3604 // `Err(())` and the other from the tail expression
3605 // `Ok(())`. If the tail expression is omitted, that's a
3606 // "forced unit" -- unless the block diverges, in which
3607 // case we can ignore the tail expression (e.g., `'a: {
3608 // break 'a 22; }` would not force the type of the block
3610 let tail_expr = blk.expr.as_ref();
3611 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3612 let coerce = if blk.targeted_by_break {
3613 CoerceMany::new(coerce_to_ty)
3615 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3616 Some(e) => slice::from_ref(e),
3619 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3622 let prev_diverges = self.diverges.get();
3623 let ctxt = BreakableCtxt {
3624 coerce: Some(coerce),
3628 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3629 for s in &blk.stmts {
3633 // check the tail expression **without** holding the
3634 // `enclosing_breakables` lock below.
3635 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3637 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3638 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3639 let coerce = ctxt.coerce.as_mut().unwrap();
3640 if let Some(tail_expr_ty) = tail_expr_ty {
3641 let tail_expr = tail_expr.unwrap();
3642 let cause = self.cause(tail_expr.span,
3643 ObligationCauseCode::BlockTailExpression(blk.hir_id));
3649 // Subtle: if there is no explicit tail expression,
3650 // that is typically equivalent to a tail expression
3651 // of `()` -- except if the block diverges. In that
3652 // case, there is no value supplied from the tail
3653 // expression (assuming there are no other breaks,
3654 // this implies that the type of the block will be
3657 // #41425 -- label the implicit `()` as being the
3658 // "found type" here, rather than the "expected type".
3659 if !self.diverges.get().always() {
3660 // #50009 -- Do not point at the entire fn block span, point at the return type
3661 // span, as it is the cause of the requirement, and
3662 // `consider_hint_about_removing_semicolon` will point at the last expression
3663 // if it were a relevant part of the error. This improves usability in editors
3664 // that highlight errors inline.
3665 let mut sp = blk.span;
3666 let mut fn_span = None;
3667 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3668 let ret_sp = decl.output.span();
3669 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3670 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3671 // output would otherwise be incorrect and even misleading. Make sure
3672 // the span we're aiming at correspond to a `fn` body.
3673 if block_sp == blk.span {
3675 fn_span = Some(ident.span);
3679 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3680 if let Some(expected_ty) = expected.only_has_type(self) {
3681 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3683 if let Some(fn_span) = fn_span {
3684 err.span_label(fn_span, "this function's body doesn't return");
3692 // If we can break from the block, then the block's exit is always reachable
3693 // (... as long as the entry is reachable) - regardless of the tail of the block.
3694 self.diverges.set(prev_diverges);
3697 let mut ty = ctxt.coerce.unwrap().complete(self);
3699 if self.has_errors.get() || ty.references_error() {
3700 ty = self.tcx.types.err
3703 self.write_ty(blk.hir_id, ty);
3705 *self.ps.borrow_mut() = prev;
3709 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3710 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
3712 Node::Item(&hir::Item {
3713 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3715 Node::ImplItem(&hir::ImplItem {
3716 node: hir::ImplItemKind::Method(_, body_id), ..
3718 let body = self.tcx.hir().body(body_id);
3719 if let ExprKind::Block(block, _) = &body.value.node {
3720 return Some(block.span);
3728 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3729 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
3730 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
3731 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3734 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3735 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
3737 Node::Item(&hir::Item {
3738 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3740 // This is less than ideal, it will not suggest a return type span on any
3741 // method called `main`, regardless of whether it is actually the entry point,
3742 // but it will still present it as the reason for the expected type.
3743 Some((decl, ident, ident.name != sym::main))
3745 Node::TraitItem(&hir::TraitItem {
3746 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3749 }) => Some((decl, ident, true)),
3750 Node::ImplItem(&hir::ImplItem {
3751 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3754 }) => Some((decl, ident, false)),
3759 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3760 /// suggestion can be made, `None` otherwise.
3761 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
3762 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3763 // `while` before reaching it, as block tail returns are not available in them.
3764 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3765 let parent = self.tcx.hir().get(blk_id);
3766 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3770 /// On implicit return expressions with mismatched types, provides the following suggestions:
3772 /// - Points out the method's return type as the reason for the expected type.
3773 /// - Possible missing semicolon.
3774 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3775 pub fn suggest_mismatched_types_on_tail(
3777 err: &mut DiagnosticBuilder<'tcx>,
3778 expression: &'tcx hir::Expr,
3784 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3785 let mut pointing_at_return_type = false;
3786 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3787 pointing_at_return_type = self.suggest_missing_return_type(
3788 err, &fn_decl, expected, found, can_suggest);
3790 self.suggest_ref_or_into(err, expression, expected, found);
3791 pointing_at_return_type
3794 pub fn suggest_ref_or_into(
3796 err: &mut DiagnosticBuilder<'tcx>,
3801 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
3802 err.span_suggestion(
3806 Applicability::MachineApplicable,
3808 } else if !self.check_for_cast(err, expr, found, expected) {
3809 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
3813 let methods = self.get_conversion_methods(expr.span, expected, found);
3814 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
3815 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
3816 .filter_map(|(receiver, method)| {
3817 let method_call = format!(".{}()", method.ident);
3818 if receiver.ends_with(&method_call) {
3819 None // do not suggest code that is already there (#53348)
3821 let method_call_list = [".to_vec()", ".to_string()"];
3822 let sugg = if receiver.ends_with(".clone()")
3823 && method_call_list.contains(&method_call.as_str()) {
3824 let max_len = receiver.rfind(".").unwrap();
3825 format!("{}{}", &receiver[..max_len], method_call)
3827 format!("{}{}", receiver, method_call)
3829 Some(if is_struct_pat_shorthand_field {
3830 format!("{}: {}", receiver, sugg)
3836 if suggestions.peek().is_some() {
3837 err.span_suggestions(
3839 "try using a conversion method",
3841 Applicability::MaybeIncorrect,
3848 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
3852 /// bar_that_returns_u32()
3856 /// This routine checks if the return expression in a block would make sense on its own as a
3857 /// statement and the return type has been left as default or has been specified as `()`. If so,
3858 /// it suggests adding a semicolon.
3859 fn suggest_missing_semicolon(
3861 err: &mut DiagnosticBuilder<'tcx>,
3862 expression: &'tcx hir::Expr,
3866 if expected.is_unit() {
3867 // `BlockTailExpression` only relevant if the tail expr would be
3868 // useful on its own.
3869 match expression.node {
3870 ExprKind::Call(..) |
3871 ExprKind::MethodCall(..) |
3872 ExprKind::Loop(..) |
3873 ExprKind::Match(..) |
3874 ExprKind::Block(..) => {
3875 let sp = self.tcx.sess.source_map().next_point(cause_span);
3876 err.span_suggestion(
3878 "try adding a semicolon",
3880 Applicability::MachineApplicable);
3887 /// A possible error is to forget to add a return type that is needed:
3891 /// bar_that_returns_u32()
3895 /// This routine checks if the return type is left as default, the method is not part of an
3896 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
3898 fn suggest_missing_return_type(
3900 err: &mut DiagnosticBuilder<'tcx>,
3901 fn_decl: &hir::FnDecl,
3906 // Only suggest changing the return type for methods that
3907 // haven't set a return type at all (and aren't `fn main()` or an impl).
3908 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
3909 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
3910 err.span_suggestion(
3912 "try adding a return type",
3913 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
3914 Applicability::MachineApplicable);
3917 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
3918 err.span_label(span, "possibly return type missing here?");
3921 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
3922 // `fn main()` must return `()`, do not suggest changing return type
3923 err.span_label(span, "expected `()` because of default return type");
3926 // expectation was caused by something else, not the default return
3927 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
3928 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
3929 // Only point to return type if the expected type is the return type, as if they
3930 // are not, the expectation must have been caused by something else.
3931 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
3933 let ty = AstConv::ast_ty_to_ty(self, ty);
3934 debug!("suggest_missing_return_type: return type {:?}", ty);
3935 debug!("suggest_missing_return_type: expected type {:?}", ty);
3936 if ty.sty == expected.sty {
3937 err.span_label(sp, format!("expected `{}` because of return type",
3946 /// A possible error is to forget to add `.await` when using futures:
3949 /// #![feature(async_await)]
3951 /// async fn make_u32() -> u32 {
3955 /// fn take_u32(x: u32) {}
3957 /// async fn foo() {
3958 /// let x = make_u32();
3963 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
3964 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
3965 /// `.await` to the tail of the expression.
3966 fn suggest_missing_await(
3968 err: &mut DiagnosticBuilder<'tcx>,
3973 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
3974 // body isn't `async`.
3975 let item_id = self.tcx().hir().get_parent_node(self.body_id);
3976 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
3977 let body = self.tcx().hir().body(body_id);
3978 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
3980 // Check for `Future` implementations by constructing a predicate to
3981 // prove: `<T as Future>::Output == U`
3982 let future_trait = self.tcx.lang_items().future_trait().unwrap();
3983 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
3984 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
3985 // `<T as Future>::Output`
3986 projection_ty: ty::ProjectionTy {
3988 substs: self.tcx.mk_substs_trait(
3990 self.fresh_substs_for_item(sp, item_def_id)
3997 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
3998 if self.infcx.predicate_may_hold(&obligation) {
3999 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4000 err.span_suggestion(
4002 "consider using `.await` here",
4003 format!("{}.await", code),
4004 Applicability::MaybeIncorrect,
4012 /// A common error is to add an extra semicolon:
4015 /// fn foo() -> usize {
4020 /// This routine checks if the final statement in a block is an
4021 /// expression with an explicit semicolon whose type is compatible
4022 /// with `expected_ty`. If so, it suggests removing the semicolon.
4023 fn consider_hint_about_removing_semicolon(
4025 blk: &'tcx hir::Block,
4026 expected_ty: Ty<'tcx>,
4027 err: &mut DiagnosticBuilder<'_>,
4029 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4030 err.span_suggestion(
4032 "consider removing this semicolon",
4034 Applicability::MachineApplicable,
4039 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4040 // Be helpful when the user wrote `{... expr;}` and
4041 // taking the `;` off is enough to fix the error.
4042 let last_stmt = blk.stmts.last()?;
4043 let last_expr = match last_stmt.node {
4044 hir::StmtKind::Semi(ref e) => e,
4047 let last_expr_ty = self.node_ty(last_expr.hir_id);
4048 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4051 let original_span = original_sp(last_stmt.span, blk.span);
4052 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4055 // Instantiates the given path, which must refer to an item with the given
4056 // number of type parameters and type.
4057 pub fn instantiate_value_path(&self,
4058 segments: &[hir::PathSegment],
4059 self_ty: Option<Ty<'tcx>>,
4063 -> (Ty<'tcx>, Res) {
4065 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4074 let path_segs = match res {
4075 Res::Local(_) | Res::SelfCtor(_) => vec![],
4076 Res::Def(kind, def_id) =>
4077 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4078 _ => bug!("instantiate_value_path on {:?}", res),
4081 let mut user_self_ty = None;
4082 let mut is_alias_variant_ctor = false;
4084 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4085 if let Some(self_ty) = self_ty {
4086 let adt_def = self_ty.ty_adt_def().unwrap();
4087 user_self_ty = Some(UserSelfTy {
4088 impl_def_id: adt_def.did,
4091 is_alias_variant_ctor = true;
4094 Res::Def(DefKind::Method, def_id)
4095 | Res::Def(DefKind::AssocConst, def_id) => {
4096 let container = tcx.associated_item(def_id).container;
4097 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4099 ty::TraitContainer(trait_did) => {
4100 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4102 ty::ImplContainer(impl_def_id) => {
4103 if segments.len() == 1 {
4104 // `<T>::assoc` will end up here, and so
4105 // can `T::assoc`. It this came from an
4106 // inherent impl, we need to record the
4107 // `T` for posterity (see `UserSelfTy` for
4109 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4110 user_self_ty = Some(UserSelfTy {
4121 // Now that we have categorized what space the parameters for each
4122 // segment belong to, let's sort out the parameters that the user
4123 // provided (if any) into their appropriate spaces. We'll also report
4124 // errors if type parameters are provided in an inappropriate place.
4126 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4127 let generics_has_err = AstConv::prohibit_generics(
4128 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4129 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4136 if let Res::Local(hid) = res {
4137 let ty = self.local_ty(span, hid).decl_ty;
4138 let ty = self.normalize_associated_types_in(span, &ty);
4139 self.write_ty(hir_id, ty);
4143 if generics_has_err {
4144 // Don't try to infer type parameters when prohibited generic arguments were given.
4145 user_self_ty = None;
4148 // Now we have to compare the types that the user *actually*
4149 // provided against the types that were *expected*. If the user
4150 // did not provide any types, then we want to substitute inference
4151 // variables. If the user provided some types, we may still need
4152 // to add defaults. If the user provided *too many* types, that's
4155 let mut infer_args_for_err = FxHashSet::default();
4156 for &PathSeg(def_id, index) in &path_segs {
4157 let seg = &segments[index];
4158 let generics = tcx.generics_of(def_id);
4159 // Argument-position `impl Trait` is treated as a normal generic
4160 // parameter internally, but we don't allow users to specify the
4161 // parameter's value explicitly, so we have to do some error-
4163 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4168 false, // `is_method_call`
4170 if suppress_errors {
4171 infer_args_for_err.insert(index);
4172 self.set_tainted_by_errors(); // See issue #53251.
4176 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4177 tcx.generics_of(*def_id).has_self
4178 }).unwrap_or(false);
4180 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4181 let ty = self.impl_self_ty(span, impl_def_id).ty;
4182 let adt_def = ty.ty_adt_def();
4185 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4186 let variant = adt_def.non_enum_variant();
4187 let ctor_def_id = variant.ctor_def_id.unwrap();
4189 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4194 let mut err = tcx.sess.struct_span_err(span,
4195 "the `Self` constructor can only be used with tuple or unit structs");
4196 if let Some(adt_def) = adt_def {
4197 match adt_def.adt_kind() {
4199 err.help("did you mean to use one of the enum's variants?");
4203 err.span_suggestion(
4205 "use curly brackets",
4206 String::from("Self { /* fields */ }"),
4207 Applicability::HasPlaceholders,
4214 return (tcx.types.err, res)
4220 let def_id = res.def_id();
4222 // The things we are substituting into the type should not contain
4223 // escaping late-bound regions, and nor should the base type scheme.
4224 let ty = tcx.type_of(def_id);
4226 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4232 // Provide the generic args, and whether types should be inferred.
4234 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4237 // If we've encountered an `impl Trait`-related error, we're just
4238 // going to infer the arguments for better error messages.
4239 if !infer_args_for_err.contains(&index) {
4240 // Check whether the user has provided generic arguments.
4241 if let Some(ref data) = segments[index].args {
4242 return (Some(data), segments[index].infer_args);
4245 return (None, segments[index].infer_args);
4250 // Provide substitutions for parameters for which (valid) arguments have been provided.
4252 match (¶m.kind, arg) {
4253 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4254 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4256 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4257 self.to_ty(ty).into()
4259 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4260 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4262 _ => unreachable!(),
4265 // Provide substitutions for parameters for which arguments are inferred.
4266 |substs, param, infer_args| {
4268 GenericParamDefKind::Lifetime => {
4269 self.re_infer(Some(param), span).unwrap().into()
4271 GenericParamDefKind::Type { has_default, .. } => {
4272 if !infer_args && has_default {
4273 // If we have a default, then we it doesn't matter that we're not
4274 // inferring the type arguments: we provide the default where any
4276 let default = tcx.type_of(param.def_id);
4279 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4282 // If no type arguments were provided, we have to infer them.
4283 // This case also occurs as a result of some malformed input, e.g.
4284 // a lifetime argument being given instead of a type parameter.
4285 // Using inference instead of `Error` gives better error messages.
4286 self.var_for_def(span, param)
4289 GenericParamDefKind::Const => {
4290 // FIXME(const_generics:defaults)
4291 // No const parameters were provided, we have to infer them.
4292 self.var_for_def(span, param)
4297 assert!(!substs.has_escaping_bound_vars());
4298 assert!(!ty.has_escaping_bound_vars());
4300 // First, store the "user substs" for later.
4301 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4303 // Add all the obligations that are required, substituting and
4304 // normalized appropriately.
4305 let bounds = self.instantiate_bounds(span, def_id, &substs);
4306 self.add_obligations_for_parameters(
4307 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4310 // Substitute the values for the type parameters into the type of
4311 // the referenced item.
4312 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4314 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4315 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4316 // is inherent, there is no `Self` parameter; instead, the impl needs
4317 // type parameters, which we can infer by unifying the provided `Self`
4318 // with the substituted impl type.
4319 // This also occurs for an enum variant on a type alias.
4320 let ty = tcx.type_of(impl_def_id);
4322 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4323 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4324 Ok(ok) => self.register_infer_ok_obligations(ok),
4326 self.tcx.sess.delay_span_bug(span, &format!(
4327 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4335 self.check_rustc_args_require_const(def_id, hir_id, span);
4337 debug!("instantiate_value_path: type of {:?} is {:?}",
4340 self.write_substs(hir_id, substs);
4342 (ty_substituted, res)
4345 fn check_rustc_args_require_const(&self,
4349 // We're only interested in functions tagged with
4350 // #[rustc_args_required_const], so ignore anything that's not.
4351 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4355 // If our calling expression is indeed the function itself, we're good!
4356 // If not, generate an error that this can only be called directly.
4357 if let Node::Expr(expr) = self.tcx.hir().get(
4358 self.tcx.hir().get_parent_node(hir_id))
4360 if let ExprKind::Call(ref callee, ..) = expr.node {
4361 if callee.hir_id == hir_id {
4367 self.tcx.sess.span_err(span, "this function can only be invoked \
4368 directly, not through a function pointer");
4371 // Resolves `typ` by a single level if `typ` is a type variable.
4372 // If no resolution is possible, then an error is reported.
4373 // Numeric inference variables may be left unresolved.
4374 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4375 let ty = self.resolve_type_vars_with_obligations(ty);
4376 if !ty.is_ty_var() {
4379 if !self.is_tainted_by_errors() {
4380 self.need_type_info_err((**self).body_id, sp, ty)
4381 .note("type must be known at this point")
4384 self.demand_suptype(sp, self.tcx.types.err, ty);
4389 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4392 ctxt: BreakableCtxt<'tcx>,
4394 ) -> (BreakableCtxt<'tcx>, R) {
4397 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4398 index = enclosing_breakables.stack.len();
4399 enclosing_breakables.by_id.insert(id, index);
4400 enclosing_breakables.stack.push(ctxt);
4404 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4405 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4406 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4407 enclosing_breakables.stack.pop().expect("missing breakable context")
4412 /// Instantiate a QueryResponse in a probe context, without a
4413 /// good ObligationCause.
4414 fn probe_instantiate_query_response(
4417 original_values: &OriginalQueryValues<'tcx>,
4418 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4419 ) -> InferResult<'tcx, Ty<'tcx>>
4421 self.instantiate_query_response_and_region_obligations(
4422 &traits::ObligationCause::misc(span, self.body_id),
4428 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4429 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4430 let mut contained_in_place = false;
4432 while let hir::Node::Expr(parent_expr) =
4433 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4435 match &parent_expr.node {
4436 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4437 if lhs.hir_id == expr_id {
4438 contained_in_place = true;
4444 expr_id = parent_expr.hir_id;
4451 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4452 let own_counts = generics.own_counts();
4454 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4460 if own_counts.types == 0 {
4464 // Make a vector of booleans initially `false`; set to `true` when used.
4465 let mut types_used = vec![false; own_counts.types];
4467 for leaf_ty in ty.walk() {
4468 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4469 debug!("found use of ty param num {}", index);
4470 types_used[index as usize - own_counts.lifetimes] = true;
4471 } else if let ty::Error = leaf_ty.sty {
4472 // If there is already another error, do not emit
4473 // an error for not using a type parameter.
4474 assert!(tcx.sess.has_errors());
4479 let types = generics.params.iter().filter(|param| match param.kind {
4480 ty::GenericParamDefKind::Type { .. } => true,
4483 for (&used, param) in types_used.iter().zip(types) {
4485 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4486 let span = tcx.hir().span(id);
4487 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4488 .span_label(span, "unused type parameter")
4494 fn fatally_break_rust(sess: &Session) {
4495 let handler = sess.diagnostic();
4496 handler.span_bug_no_panic(
4498 "It looks like you're trying to break rust; would you like some ICE?",
4500 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4501 handler.note_without_error(
4502 "we would appreciate a joke overview: \
4503 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4505 handler.note_without_error(&format!("rustc {} running on {}",
4506 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4507 crate::session::config::host_triple(),
4511 fn potentially_plural_count(count: usize, word: &str) -> String {
4512 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })