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
750 /// `Some((body_id, header, decl))` with information about
751 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
754 /// If this function returns `Some`, then `typeck_tables(def_id)` will
755 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
756 /// may not succeed. In some cases where this function returns `None`
757 /// (notably closures), `typeck_tables(def_id)` would wind up
758 /// redirecting to the owning function.
762 ) -> Option<(hir::BodyId, Option<&hir::FnHeader>, Option<&hir::FnDecl>)> {
763 match tcx.hir().get(id) {
764 Node::Item(item) => {
766 hir::ItemKind::Const(_, body) |
767 hir::ItemKind::Static(_, _, body) =>
768 Some((body, None, None)),
769 hir::ItemKind::Fn(ref decl, ref header, .., body) =>
770 Some((body, Some(header), Some(decl))),
775 Node::TraitItem(item) => {
777 hir::TraitItemKind::Const(_, Some(body)) =>
778 Some((body, None, None)),
779 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
780 Some((body, Some(&sig.header), Some(&sig.decl))),
785 Node::ImplItem(item) => {
787 hir::ImplItemKind::Const(_, body) =>
788 Some((body, None, None)),
789 hir::ImplItemKind::Method(ref sig, body) =>
790 Some((body, Some(&sig.header), Some(&sig.decl))),
795 Node::AnonConst(constant) => Some((constant.body, None, None)),
800 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
801 // Closures' tables come from their outermost function,
802 // as they are part of the same "inference environment".
803 let outer_def_id = tcx.closure_base_def_id(def_id);
804 if outer_def_id != def_id {
805 return tcx.has_typeck_tables(outer_def_id);
808 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
809 primary_body_of(tcx, id).is_some()
812 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
813 &*tcx.typeck_tables_of(def_id).used_trait_imports
816 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
817 // Closures' tables come from their outermost function,
818 // as they are part of the same "inference environment".
819 let outer_def_id = tcx.closure_base_def_id(def_id);
820 if outer_def_id != def_id {
821 return tcx.typeck_tables_of(outer_def_id);
824 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
825 let span = tcx.hir().span(id);
827 // Figure out what primary body this item has.
828 let (body_id, fn_header, fn_decl) = primary_body_of(tcx, id)
830 span_bug!(span, "can't type-check body of {:?}", def_id);
832 let body = tcx.hir().body(body_id);
834 let tables = Inherited::build(tcx, def_id).enter(|inh| {
835 let param_env = tcx.param_env(def_id);
836 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
837 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
838 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
839 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl)
844 check_abi(tcx, span, fn_sig.abi());
846 // Compute the fty from point of view of inside the fn.
848 tcx.liberate_late_bound_regions(def_id, &fn_sig);
850 inh.normalize_associated_types_in(body.value.span,
855 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
858 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
859 let expected_type = tcx.type_of(def_id);
860 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
861 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
863 let revealed_ty = if tcx.features().impl_trait_in_bindings {
864 fcx.instantiate_opaque_types_from_value(
873 // Gather locals in statics (because of block expressions).
874 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
876 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
878 fcx.write_ty(id, revealed_ty);
883 // All type checking constraints were added, try to fallback unsolved variables.
884 fcx.select_obligations_where_possible(false);
885 let mut fallback_has_occurred = false;
886 for ty in &fcx.unsolved_variables() {
887 fallback_has_occurred |= fcx.fallback_if_possible(ty);
889 fcx.select_obligations_where_possible(fallback_has_occurred);
891 // Even though coercion casts provide type hints, we check casts after fallback for
892 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
895 // Closure and generator analysis may run after fallback
896 // because they don't constrain other type variables.
897 fcx.closure_analyze(body);
898 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
899 fcx.resolve_generator_interiors(def_id);
901 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
902 let ty = fcx.normalize_ty(span, ty);
903 fcx.require_type_is_sized(ty, span, code);
905 fcx.select_all_obligations_or_error();
907 if fn_decl.is_some() {
908 fcx.regionck_fn(id, body);
910 fcx.regionck_expr(body);
913 fcx.resolve_type_vars_in_body(body)
916 // Consistency check our TypeckTables instance can hold all ItemLocalIds
917 // it will need to hold.
918 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
923 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
924 if !tcx.sess.target.target.is_abi_supported(abi) {
925 struct_span_err!(tcx.sess, span, E0570,
926 "The ABI `{}` is not supported for the current target", abi).emit()
930 struct GatherLocalsVisitor<'a, 'tcx> {
931 fcx: &'a FnCtxt<'a, 'tcx>,
932 parent_id: hir::HirId,
935 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
936 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
939 // infer the variable's type
940 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
941 kind: TypeVariableOriginKind::TypeInference,
944 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
951 // take type that the user specified
952 self.fcx.locals.borrow_mut().insert(nid, typ);
959 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
960 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
961 NestedVisitorMap::None
964 // Add explicitly-declared locals.
965 fn visit_local(&mut self, local: &'tcx hir::Local) {
966 let local_ty = match local.ty {
968 let o_ty = self.fcx.to_ty(&ty);
970 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
971 self.fcx.instantiate_opaque_types_from_value(
980 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
981 &UserType::Ty(revealed_ty)
983 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
984 ty.hir_id, o_ty, revealed_ty, c_ty);
985 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
987 Some(LocalTy { decl_ty: o_ty, revealed_ty })
991 self.assign(local.span, local.hir_id, local_ty);
993 debug!("local variable {:?} is assigned type {}",
995 self.fcx.ty_to_string(
996 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
997 intravisit::walk_local(self, local);
1000 // Add pattern bindings.
1001 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
1002 if let PatKind::Binding(_, _, ident, _) = p.node {
1003 let var_ty = self.assign(p.span, p.hir_id, None);
1005 if !self.fcx.tcx.features().unsized_locals {
1006 self.fcx.require_type_is_sized(var_ty, p.span,
1007 traits::VariableType(p.hir_id));
1010 debug!("pattern binding {} is assigned to {} with type {:?}",
1012 self.fcx.ty_to_string(
1013 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1016 intravisit::walk_pat(self, p);
1019 // Don't descend into the bodies of nested closures
1022 _: intravisit::FnKind<'tcx>,
1023 _: &'tcx hir::FnDecl,
1030 /// When `check_fn` is invoked on a generator (i.e., a body that
1031 /// includes yield), it returns back some information about the yield
1033 struct GeneratorTypes<'tcx> {
1034 /// Type of value that is yielded.
1037 /// Types that are captured (see `GeneratorInterior` for more).
1040 /// Indicates if the generator is movable or static (immovable).
1041 movability: hir::GeneratorMovability,
1044 /// Helper used for fns and closures. Does the grungy work of checking a function
1045 /// body and returns the function context used for that purpose, since in the case of a fn item
1046 /// there is still a bit more to do.
1049 /// * inherited: other fields inherited from the enclosing fn (if any)
1050 fn check_fn<'a, 'tcx>(
1051 inherited: &'a Inherited<'a, 'tcx>,
1052 param_env: ty::ParamEnv<'tcx>,
1053 fn_sig: ty::FnSig<'tcx>,
1054 decl: &'tcx hir::FnDecl,
1056 body: &'tcx hir::Body,
1057 can_be_generator: Option<hir::GeneratorMovability>,
1058 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1059 let mut fn_sig = fn_sig.clone();
1061 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1063 // Create the function context. This is either derived from scratch or,
1064 // in the case of closures, based on the outer context.
1065 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1066 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1068 let declared_ret_ty = fn_sig.output();
1069 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1070 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1075 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1076 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1077 fn_sig = fcx.tcx.mk_fn_sig(
1078 fn_sig.inputs().iter().cloned(),
1085 let span = body.value.span;
1087 if body.generator_kind.is_some() && can_be_generator.is_some() {
1088 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1089 kind: TypeVariableOriginKind::TypeInference,
1092 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1093 fcx.yield_ty = Some(yield_ty);
1096 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1097 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1098 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1100 // Add formal parameters.
1101 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1102 // Check the pattern.
1103 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1104 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1106 // Check that argument is Sized.
1107 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1108 // for simple cases like `fn foo(x: Trait)`,
1109 // where we would error once on the parameter as a whole, and once on the binding `x`.
1110 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1111 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1114 fcx.write_ty(arg.hir_id, arg_ty);
1117 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1119 fcx.check_return_expr(&body.value);
1121 // We insert the deferred_generator_interiors entry after visiting the body.
1122 // This ensures that all nested generators appear before the entry of this generator.
1123 // resolve_generator_interiors relies on this property.
1124 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1125 let interior = fcx.next_ty_var(TypeVariableOrigin {
1126 kind: TypeVariableOriginKind::MiscVariable,
1129 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1130 Some(GeneratorTypes {
1131 yield_ty: fcx.yield_ty.unwrap(),
1133 movability: can_be_generator.unwrap(),
1139 // Finalize the return check by taking the LUB of the return types
1140 // we saw and assigning it to the expected return type. This isn't
1141 // really expected to fail, since the coercions would have failed
1142 // earlier when trying to find a LUB.
1144 // However, the behavior around `!` is sort of complex. In the
1145 // event that the `actual_return_ty` comes back as `!`, that
1146 // indicates that the fn either does not return or "returns" only
1147 // values of type `!`. In this case, if there is an expected
1148 // return type that is *not* `!`, that should be ok. But if the
1149 // return type is being inferred, we want to "fallback" to `!`:
1151 // let x = move || panic!();
1153 // To allow for that, I am creating a type variable with diverging
1154 // fallback. This was deemed ever so slightly better than unifying
1155 // the return value with `!` because it allows for the caller to
1156 // make more assumptions about the return type (e.g., they could do
1158 // let y: Option<u32> = Some(x());
1160 // which would then cause this return type to become `u32`, not
1162 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1163 let mut actual_return_ty = coercion.complete(&fcx);
1164 if actual_return_ty.is_never() {
1165 actual_return_ty = fcx.next_diverging_ty_var(
1166 TypeVariableOrigin {
1167 kind: TypeVariableOriginKind::DivergingFn,
1172 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1174 // Check that the main return type implements the termination trait.
1175 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1176 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1177 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1178 if main_id == fn_id {
1179 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1180 let trait_ref = ty::TraitRef::new(term_id, substs);
1181 let return_ty_span = decl.output.span();
1182 let cause = traits::ObligationCause::new(
1183 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1185 inherited.register_predicate(
1186 traits::Obligation::new(
1187 cause, param_env, trait_ref.to_predicate()));
1192 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1193 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1194 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1195 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1196 // at this point we don't care if there are duplicate handlers or if the handler has
1197 // the wrong signature as this value we'll be used when writing metadata and that
1198 // only happens if compilation succeeded
1199 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1201 if declared_ret_ty.sty != ty::Never {
1202 fcx.tcx.sess.span_err(
1204 "return type should be `!`",
1208 let inputs = fn_sig.inputs();
1209 let span = fcx.tcx.hir().span(fn_id);
1210 if inputs.len() == 1 {
1211 let arg_is_panic_info = match inputs[0].sty {
1212 ty::Ref(region, ty, mutbl) => match ty.sty {
1213 ty::Adt(ref adt, _) => {
1214 adt.did == panic_info_did &&
1215 mutbl == hir::Mutability::MutImmutable &&
1216 *region != RegionKind::ReStatic
1223 if !arg_is_panic_info {
1224 fcx.tcx.sess.span_err(
1225 decl.inputs[0].span,
1226 "argument should be `&PanicInfo`",
1230 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1231 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1232 if !generics.params.is_empty() {
1233 fcx.tcx.sess.span_err(
1235 "should have no type parameters",
1241 let span = fcx.tcx.sess.source_map().def_span(span);
1242 fcx.tcx.sess.span_err(span, "function should have one argument");
1245 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1250 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1251 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1252 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1253 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1254 if declared_ret_ty.sty != ty::Never {
1255 fcx.tcx.sess.span_err(
1257 "return type should be `!`",
1261 let inputs = fn_sig.inputs();
1262 let span = fcx.tcx.hir().span(fn_id);
1263 if inputs.len() == 1 {
1264 let arg_is_alloc_layout = match inputs[0].sty {
1265 ty::Adt(ref adt, _) => {
1266 adt.did == alloc_layout_did
1271 if !arg_is_alloc_layout {
1272 fcx.tcx.sess.span_err(
1273 decl.inputs[0].span,
1274 "argument should be `Layout`",
1278 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1279 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1280 if !generics.params.is_empty() {
1281 fcx.tcx.sess.span_err(
1283 "`#[alloc_error_handler]` function should have no type \
1290 let span = fcx.tcx.sess.source_map().def_span(span);
1291 fcx.tcx.sess.span_err(span, "function should have one argument");
1294 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1302 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1303 let def_id = tcx.hir().local_def_id(id);
1304 let def = tcx.adt_def(def_id);
1305 def.destructor(tcx); // force the destructor to be evaluated
1306 check_representable(tcx, span, def_id);
1308 if def.repr.simd() {
1309 check_simd(tcx, span, def_id);
1312 check_transparent(tcx, span, def_id);
1313 check_packed(tcx, span, def_id);
1316 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1317 let def_id = tcx.hir().local_def_id(id);
1318 let def = tcx.adt_def(def_id);
1319 def.destructor(tcx); // force the destructor to be evaluated
1320 check_representable(tcx, span, def_id);
1321 check_transparent(tcx, span, def_id);
1322 check_packed(tcx, span, def_id);
1325 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1326 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1327 let mut err = struct_span_err!(
1328 tcx.sess, span, E0720,
1329 "opaque type expands to a recursive type",
1331 err.span_label(span, "expands to a recursive type");
1332 if let ty::Opaque(..) = partially_expanded_type.sty {
1333 err.note("type resolves to itself");
1335 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1341 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1343 "check_item_type(it.hir_id={}, it.name={})",
1345 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1347 let _indenter = indenter();
1349 // Consts can play a role in type-checking, so they are included here.
1350 hir::ItemKind::Static(..) => {
1351 let def_id = tcx.hir().local_def_id(it.hir_id);
1352 tcx.typeck_tables_of(def_id);
1353 maybe_check_static_with_link_section(tcx, def_id, it.span);
1355 hir::ItemKind::Const(..) => {
1356 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1358 hir::ItemKind::Enum(ref enum_definition, _) => {
1359 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1361 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1362 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1363 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1364 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1365 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1366 check_impl_items_against_trait(
1373 let trait_def_id = impl_trait_ref.def_id;
1374 check_on_unimplemented(tcx, trait_def_id, it);
1377 hir::ItemKind::Trait(..) => {
1378 let def_id = tcx.hir().local_def_id(it.hir_id);
1379 check_on_unimplemented(tcx, def_id, it);
1381 hir::ItemKind::Struct(..) => {
1382 check_struct(tcx, it.hir_id, it.span);
1384 hir::ItemKind::Union(..) => {
1385 check_union(tcx, it.hir_id, it.span);
1387 hir::ItemKind::Existential(..) => {
1388 let def_id = tcx.hir().local_def_id(it.hir_id);
1390 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1391 check_opaque(tcx, def_id, substs, it.span);
1393 hir::ItemKind::Ty(..) => {
1394 let def_id = tcx.hir().local_def_id(it.hir_id);
1395 let pty_ty = tcx.type_of(def_id);
1396 let generics = tcx.generics_of(def_id);
1397 check_bounds_are_used(tcx, &generics, pty_ty);
1399 hir::ItemKind::ForeignMod(ref m) => {
1400 check_abi(tcx, it.span, m.abi);
1402 if m.abi == Abi::RustIntrinsic {
1403 for item in &m.items {
1404 intrinsic::check_intrinsic_type(tcx, item);
1406 } else if m.abi == Abi::PlatformIntrinsic {
1407 for item in &m.items {
1408 intrinsic::check_platform_intrinsic_type(tcx, item);
1411 for item in &m.items {
1412 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1413 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1414 let mut err = struct_span_err!(
1418 "foreign items may not have type parameters"
1420 err.span_label(item.span, "can't have type parameters");
1421 // FIXME: once we start storing spans for type arguments, turn this into a
1424 "use specialization instead of type parameters by replacing them \
1425 with concrete types like `u32`",
1430 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1431 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1436 _ => { /* nothing to do */ }
1440 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1441 // Only restricted on wasm32 target for now
1442 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1446 // If `#[link_section]` is missing, then nothing to verify
1447 let attrs = tcx.codegen_fn_attrs(id);
1448 if attrs.link_section.is_none() {
1452 // For the wasm32 target statics with `#[link_section]` are placed into custom
1453 // sections of the final output file, but this isn't link custom sections of
1454 // other executable formats. Namely we can only embed a list of bytes,
1455 // nothing with pointers to anything else or relocations. If any relocation
1456 // show up, reject them here.
1457 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1458 // the consumer's responsibility to ensure all bytes that have been read
1459 // have defined values.
1460 let instance = ty::Instance::mono(tcx, id);
1461 let cid = GlobalId {
1465 let param_env = ty::ParamEnv::reveal_all();
1466 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1467 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1470 bug!("Matching on non-ByRef static")
1472 if alloc.relocations.len() != 0 {
1473 let msg = "statics with a custom `#[link_section]` must be a \
1474 simple list of bytes on the wasm target with no \
1475 extra levels of indirection such as references";
1476 tcx.sess.span_err(span, msg);
1481 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1482 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1483 // an error would be reported if this fails.
1484 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1487 fn report_forbidden_specialization(
1489 impl_item: &hir::ImplItem,
1492 let mut err = struct_span_err!(
1493 tcx.sess, impl_item.span, E0520,
1494 "`{}` specializes an item from a parent `impl`, but \
1495 that item is not marked `default`",
1497 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1500 match tcx.span_of_impl(parent_impl) {
1502 err.span_label(span, "parent `impl` is here");
1503 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1507 err.note(&format!("parent implementation is in crate `{}`", cname));
1514 fn check_specialization_validity<'tcx>(
1516 trait_def: &ty::TraitDef,
1517 trait_item: &ty::AssocItem,
1519 impl_item: &hir::ImplItem,
1521 let ancestors = trait_def.ancestors(tcx, impl_id);
1523 let kind = match impl_item.node {
1524 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1525 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1526 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1527 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1530 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1531 .map(|node_item| node_item.map(|parent| parent.defaultness));
1533 if let Some(parent) = parent {
1534 if tcx.impl_item_is_final(&parent) {
1535 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1541 fn check_impl_items_against_trait<'tcx>(
1545 impl_trait_ref: ty::TraitRef<'tcx>,
1546 impl_item_refs: &[hir::ImplItemRef],
1548 let impl_span = tcx.sess.source_map().def_span(impl_span);
1550 // If the trait reference itself is erroneous (so the compilation is going
1551 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1552 // isn't populated for such impls.
1553 if impl_trait_ref.references_error() { return; }
1555 // Locate trait definition and items
1556 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1557 let mut overridden_associated_type = None;
1559 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1561 // Check existing impl methods to see if they are both present in trait
1562 // and compatible with trait signature
1563 for impl_item in impl_items() {
1564 let ty_impl_item = tcx.associated_item(
1565 tcx.hir().local_def_id(impl_item.hir_id));
1566 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1567 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1568 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1570 // Not compatible, but needed for the error message
1571 tcx.associated_items(impl_trait_ref.def_id)
1572 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1575 // Check that impl definition matches trait definition
1576 if let Some(ty_trait_item) = ty_trait_item {
1577 match impl_item.node {
1578 hir::ImplItemKind::Const(..) => {
1579 // Find associated const definition.
1580 if ty_trait_item.kind == ty::AssocKind::Const {
1581 compare_const_impl(tcx,
1587 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1588 "item `{}` is an associated const, \
1589 which doesn't match its trait `{}`",
1592 err.span_label(impl_item.span, "does not match trait");
1593 // We can only get the spans from local trait definition
1594 // Same for E0324 and E0325
1595 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1596 err.span_label(trait_span, "item in trait");
1601 hir::ImplItemKind::Method(..) => {
1602 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1603 if ty_trait_item.kind == ty::AssocKind::Method {
1604 compare_impl_method(tcx,
1611 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1612 "item `{}` is an associated method, \
1613 which doesn't match its trait `{}`",
1616 err.span_label(impl_item.span, "does not match trait");
1617 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1618 err.span_label(trait_span, "item in trait");
1623 hir::ImplItemKind::Existential(..) |
1624 hir::ImplItemKind::Type(_) => {
1625 if ty_trait_item.kind == ty::AssocKind::Type {
1626 if ty_trait_item.defaultness.has_value() {
1627 overridden_associated_type = Some(impl_item);
1630 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1631 "item `{}` is an associated type, \
1632 which doesn't match its trait `{}`",
1635 err.span_label(impl_item.span, "does not match trait");
1636 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1637 err.span_label(trait_span, "item in trait");
1644 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1648 // Check for missing items from trait
1649 let mut missing_items = Vec::new();
1650 let mut invalidated_items = Vec::new();
1651 let associated_type_overridden = overridden_associated_type.is_some();
1652 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1653 let is_implemented = trait_def.ancestors(tcx, impl_id)
1654 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1656 .map(|node_item| !node_item.node.is_from_trait())
1659 if !is_implemented && !tcx.impl_is_default(impl_id) {
1660 if !trait_item.defaultness.has_value() {
1661 missing_items.push(trait_item);
1662 } else if associated_type_overridden {
1663 invalidated_items.push(trait_item.ident);
1668 if !missing_items.is_empty() {
1669 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1670 "not all trait items implemented, missing: `{}`",
1671 missing_items.iter()
1672 .map(|trait_item| trait_item.ident.to_string())
1673 .collect::<Vec<_>>().join("`, `"));
1674 err.span_label(impl_span, format!("missing `{}` in implementation",
1675 missing_items.iter()
1676 .map(|trait_item| trait_item.ident.to_string())
1677 .collect::<Vec<_>>().join("`, `")));
1678 for trait_item in missing_items {
1679 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1680 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1682 err.note_trait_signature(trait_item.ident.to_string(),
1683 trait_item.signature(tcx));
1689 if !invalidated_items.is_empty() {
1690 let invalidator = overridden_associated_type.unwrap();
1691 span_err!(tcx.sess, invalidator.span, E0399,
1692 "the following trait items need to be reimplemented \
1693 as `{}` was overridden: `{}`",
1695 invalidated_items.iter()
1696 .map(|name| name.to_string())
1697 .collect::<Vec<_>>().join("`, `"))
1701 /// Checks whether a type can be represented in memory. In particular, it
1702 /// identifies types that contain themselves without indirection through a
1703 /// pointer, which would mean their size is unbounded.
1704 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1705 let rty = tcx.type_of(item_def_id);
1707 // Check that it is possible to represent this type. This call identifies
1708 // (1) types that contain themselves and (2) types that contain a different
1709 // recursive type. It is only necessary to throw an error on those that
1710 // contain themselves. For case 2, there must be an inner type that will be
1711 // caught by case 1.
1712 match rty.is_representable(tcx, sp) {
1713 Representability::SelfRecursive(spans) => {
1714 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1716 err.span_label(span, "recursive without indirection");
1721 Representability::Representable | Representability::ContainsRecursive => (),
1726 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1727 let t = tcx.type_of(def_id);
1728 if let ty::Adt(def, substs) = t.sty {
1729 if def.is_struct() {
1730 let fields = &def.non_enum_variant().fields;
1731 if fields.is_empty() {
1732 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1735 let e = fields[0].ty(tcx, substs);
1736 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1737 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1738 .span_label(sp, "SIMD elements must have the same type")
1743 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1744 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1746 span_err!(tcx.sess, sp, E0077,
1747 "SIMD vector element type should be machine type");
1755 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1756 let repr = tcx.adt_def(def_id).repr;
1758 for attr in tcx.get_attrs(def_id).iter() {
1759 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1760 if let attr::ReprPacked(pack) = r {
1761 if pack != repr.pack {
1762 struct_span_err!(tcx.sess, sp, E0634,
1763 "type has conflicting packed representation hints").emit();
1769 struct_span_err!(tcx.sess, sp, E0587,
1770 "type has conflicting packed and align representation hints").emit();
1772 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1773 struct_span_err!(tcx.sess, sp, E0588,
1774 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1779 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1780 let t = tcx.type_of(def_id);
1781 if stack.contains(&def_id) {
1782 debug!("check_packed_inner: {:?} is recursive", t);
1785 if let ty::Adt(def, substs) = t.sty {
1786 if def.is_struct() || def.is_union() {
1787 if tcx.adt_def(def.did).repr.align > 0 {
1790 // push struct def_id before checking fields
1792 for field in &def.non_enum_variant().fields {
1793 let f = field.ty(tcx, substs);
1794 if let ty::Adt(def, _) = f.sty {
1795 if check_packed_inner(tcx, def.did, stack) {
1800 // only need to pop if not early out
1807 /// Emit an error when encountering more or less than one variant in a transparent enum.
1808 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1809 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1810 tcx.hir().span_if_local(variant.def_id).unwrap()
1813 "needs exactly one variant, but has {}",
1816 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1817 err.span_label(sp, &msg);
1818 if let &[ref start.., ref end] = &variant_spans[..] {
1819 for variant_span in start {
1820 err.span_label(*variant_span, "");
1822 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1827 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1829 fn bad_non_zero_sized_fields<'tcx>(
1831 adt: &'tcx ty::AdtDef,
1833 field_spans: impl Iterator<Item = Span>,
1836 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1837 let mut err = struct_span_err!(
1841 "{}transparent {} {}",
1842 if adt.is_enum() { "the variant of a " } else { "" },
1846 err.span_label(sp, &msg);
1847 for sp in field_spans {
1848 err.span_label(sp, "this field is non-zero-sized");
1853 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1854 let adt = tcx.adt_def(def_id);
1855 if !adt.repr.transparent() {
1858 let sp = tcx.sess.source_map().def_span(sp);
1861 if !tcx.features().transparent_enums {
1863 &tcx.sess.parse_sess,
1864 sym::transparent_enums,
1866 GateIssue::Language,
1867 "transparent enums are unstable",
1870 if adt.variants.len() != 1 {
1871 bad_variant_count(tcx, adt, sp, def_id);
1872 if adt.variants.is_empty() {
1873 // Don't bother checking the fields. No variants (and thus no fields) exist.
1879 if adt.is_union() && !tcx.features().transparent_unions {
1880 emit_feature_err(&tcx.sess.parse_sess,
1881 sym::transparent_unions,
1883 GateIssue::Language,
1884 "transparent unions are unstable");
1887 // For each field, figure out if it's known to be a ZST and align(1)
1888 let field_infos = adt.all_fields().map(|field| {
1889 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1890 let param_env = tcx.param_env(field.did);
1891 let layout = tcx.layout_of(param_env.and(ty));
1892 // We are currently checking the type this field came from, so it must be local
1893 let span = tcx.hir().span_if_local(field.did).unwrap();
1894 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1895 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1899 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
1904 let non_zst_count = non_zst_fields.clone().count();
1905 if non_zst_count != 1 {
1906 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
1908 for (span, zst, align1) in field_infos {
1914 "zero-sized field in transparent {} has alignment larger than 1",
1916 ).span_label(span, "has alignment larger than 1").emit();
1921 #[allow(trivial_numeric_casts)]
1922 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
1923 let def_id = tcx.hir().local_def_id(id);
1924 let def = tcx.adt_def(def_id);
1925 def.destructor(tcx); // force the destructor to be evaluated
1928 let attributes = tcx.get_attrs(def_id);
1929 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1931 tcx.sess, attr.span, E0084,
1932 "unsupported representation for zero-variant enum")
1933 .span_label(sp, "zero-variant enum")
1938 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1939 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1940 if !tcx.features().repr128 {
1941 emit_feature_err(&tcx.sess.parse_sess,
1944 GateIssue::Language,
1945 "repr with 128-bit type is unstable");
1950 if let Some(ref e) = v.node.disr_expr {
1951 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
1955 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
1957 |var: &hir::Variant| match var.node.data {
1958 hir::VariantData::Unit(..) => true,
1962 let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some();
1963 let has_non_units = vs.iter().any(|var| !is_unit(var));
1964 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
1965 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
1967 if disr_non_unit || (disr_units && has_non_units) {
1968 let mut err = struct_span_err!(tcx.sess, sp, E0732,
1969 "`#[repr(inttype)]` must be specified");
1974 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1975 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1976 // Check for duplicate discriminant values
1977 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1978 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1979 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1980 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1981 let i_span = match variant_i.node.disr_expr {
1982 Some(ref expr) => tcx.hir().span(expr.hir_id),
1983 None => tcx.hir().span(variant_i_hir_id)
1985 let span = match v.node.disr_expr {
1986 Some(ref expr) => tcx.hir().span(expr.hir_id),
1989 struct_span_err!(tcx.sess, span, E0081,
1990 "discriminant value `{}` already exists", disr_vals[i])
1991 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1992 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1995 disr_vals.push(discr);
1998 check_representable(tcx, sp, def_id);
1999 check_transparent(tcx, sp, def_id);
2002 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2003 span_err!(tcx.sess, span, E0533,
2004 "expected unit struct/variant or constant, found {} `{}`",
2006 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2009 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2010 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2014 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2015 -> &'tcx ty::GenericPredicates<'tcx>
2018 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2019 let item_id = tcx.hir().ty_param_owner(hir_id);
2020 let item_def_id = tcx.hir().local_def_id(item_id);
2021 let generics = tcx.generics_of(item_def_id);
2022 let index = generics.param_def_id_to_index[&def_id];
2023 tcx.arena.alloc(ty::GenericPredicates {
2025 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2027 ty::Predicate::Trait(ref data)
2028 if data.skip_binder().self_ty().is_param(index) => {
2029 // HACK(eddyb) should get the original `Span`.
2030 let span = tcx.def_span(def_id);
2031 Some((predicate, span))
2041 def: Option<&ty::GenericParamDef>,
2043 ) -> Option<ty::Region<'tcx>> {
2045 Some(def) => infer::EarlyBoundRegion(span, def.name),
2046 None => infer::MiscVariable(span)
2048 Some(self.next_region_var(v))
2051 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2052 if let Some(param) = param {
2053 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2058 self.next_ty_var(TypeVariableOrigin {
2059 kind: TypeVariableOriginKind::TypeInference,
2068 param: Option<&ty::GenericParamDef>,
2070 ) -> &'tcx Const<'tcx> {
2071 if let Some(param) = param {
2072 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2077 self.next_const_var(ty, ConstVariableOrigin {
2078 kind: ConstVariableOriginKind::ConstInference,
2084 fn projected_ty_from_poly_trait_ref(&self,
2087 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2090 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2092 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2096 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2099 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2100 if ty.has_escaping_bound_vars() {
2101 ty // FIXME: normalization and escaping regions
2103 self.normalize_associated_types_in(span, &ty)
2107 fn set_tainted_by_errors(&self) {
2108 self.infcx.set_tainted_by_errors()
2111 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2112 self.write_ty(hir_id, ty)
2116 /// Controls whether the arguments are tupled. This is used for the call
2119 /// Tupling means that all call-side arguments are packed into a tuple and
2120 /// passed as a single parameter. For example, if tupling is enabled, this
2123 /// fn f(x: (isize, isize))
2125 /// Can be called as:
2132 #[derive(Clone, Eq, PartialEq)]
2133 enum TupleArgumentsFlag {
2138 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2140 inh: &'a Inherited<'a, 'tcx>,
2141 param_env: ty::ParamEnv<'tcx>,
2142 body_id: hir::HirId,
2143 ) -> FnCtxt<'a, 'tcx> {
2147 err_count_on_creation: inh.tcx.sess.err_count(),
2149 ret_coercion_span: RefCell::new(None),
2151 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2152 hir::CRATE_HIR_ID)),
2153 diverges: Cell::new(Diverges::Maybe),
2154 has_errors: Cell::new(false),
2155 enclosing_breakables: RefCell::new(EnclosingBreakables {
2157 by_id: Default::default(),
2163 pub fn sess(&self) -> &Session {
2167 pub fn errors_reported_since_creation(&self) -> bool {
2168 self.tcx.sess.err_count() > self.err_count_on_creation
2171 /// Produces warning on the given node, if the current point in the
2172 /// function is unreachable, and there hasn't been another warning.
2173 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2174 if self.diverges.get() == Diverges::Always &&
2175 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2176 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2177 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2178 !span.is_desugaring(DesugaringKind::CondTemporary) {
2179 self.diverges.set(Diverges::WarnedAlways);
2181 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2183 let msg = format!("unreachable {}", kind);
2184 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2190 code: ObligationCauseCode<'tcx>)
2191 -> ObligationCause<'tcx> {
2192 ObligationCause::new(span, self.body_id, code)
2195 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2196 self.cause(span, ObligationCauseCode::MiscObligation)
2199 /// Resolves type variables in `ty` if possible. Unlike the infcx
2200 /// version (resolve_vars_if_possible), this version will
2201 /// also select obligations if it seems useful, in an effort
2202 /// to get more type information.
2203 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2204 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2206 // No Infer()? Nothing needs doing.
2207 if !ty.has_infer_types() {
2208 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2212 // If `ty` is a type variable, see whether we already know what it is.
2213 ty = self.resolve_vars_if_possible(&ty);
2214 if !ty.has_infer_types() {
2215 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2219 // If not, try resolving pending obligations as much as
2220 // possible. This can help substantially when there are
2221 // indirect dependencies that don't seem worth tracking
2223 self.select_obligations_where_possible(false);
2224 ty = self.resolve_vars_if_possible(&ty);
2226 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2230 fn record_deferred_call_resolution(
2232 closure_def_id: DefId,
2233 r: DeferredCallResolution<'tcx>,
2235 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2236 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2239 fn remove_deferred_call_resolutions(
2241 closure_def_id: DefId,
2242 ) -> Vec<DeferredCallResolution<'tcx>> {
2243 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2244 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2247 pub fn tag(&self) -> String {
2248 format!("{:p}", self)
2251 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2252 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2253 span_bug!(span, "no type for local variable {}",
2254 self.tcx.hir().node_to_string(nid))
2259 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2260 debug!("write_ty({:?}, {:?}) in fcx {}",
2261 id, self.resolve_vars_if_possible(&ty), self.tag());
2262 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2264 if ty.references_error() {
2265 self.has_errors.set(true);
2266 self.set_tainted_by_errors();
2270 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2271 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2274 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2275 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2278 pub fn write_method_call(&self,
2280 method: MethodCallee<'tcx>) {
2281 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2282 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2283 self.write_substs(hir_id, method.substs);
2285 // When the method is confirmed, the `method.substs` includes
2286 // parameters from not just the method, but also the impl of
2287 // the method -- in particular, the `Self` type will be fully
2288 // resolved. However, those are not something that the "user
2289 // specified" -- i.e., those types come from the inferred type
2290 // of the receiver, not something the user wrote. So when we
2291 // create the user-substs, we want to replace those earlier
2292 // types with just the types that the user actually wrote --
2293 // that is, those that appear on the *method itself*.
2295 // As an example, if the user wrote something like
2296 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2297 // type of `foo` (possibly adjusted), but we don't want to
2298 // include that. We want just the `[_, u32]` part.
2299 if !method.substs.is_noop() {
2300 let method_generics = self.tcx.generics_of(method.def_id);
2301 if !method_generics.params.is_empty() {
2302 let user_type_annotation = self.infcx.probe(|_| {
2303 let user_substs = UserSubsts {
2304 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2305 let i = param.index as usize;
2306 if i < method_generics.parent_count {
2307 self.infcx.var_for_def(DUMMY_SP, param)
2312 user_self_ty: None, // not relevant here
2315 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2321 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2322 self.write_user_type_annotation(hir_id, user_type_annotation);
2327 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2328 if !substs.is_noop() {
2329 debug!("write_substs({:?}, {:?}) in fcx {}",
2334 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2338 /// Given the substs that we just converted from the HIR, try to
2339 /// canonicalize them and store them as user-given substitutions
2340 /// (i.e., substitutions that must be respected by the NLL check).
2342 /// This should be invoked **before any unifications have
2343 /// occurred**, so that annotations like `Vec<_>` are preserved
2345 pub fn write_user_type_annotation_from_substs(
2349 substs: SubstsRef<'tcx>,
2350 user_self_ty: Option<UserSelfTy<'tcx>>,
2353 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2354 user_self_ty={:?} in fcx {}",
2355 hir_id, def_id, substs, user_self_ty, self.tag(),
2358 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2359 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2360 &UserType::TypeOf(def_id, UserSubsts {
2365 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2366 self.write_user_type_annotation(hir_id, canonicalized);
2370 pub fn write_user_type_annotation(
2373 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2376 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2377 hir_id, canonical_user_type_annotation, self.tag(),
2380 if !canonical_user_type_annotation.is_identity() {
2381 self.tables.borrow_mut().user_provided_types_mut().insert(
2382 hir_id, canonical_user_type_annotation
2385 debug!("write_user_type_annotation: skipping identity substs");
2389 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2390 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2396 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2397 Entry::Vacant(entry) => { entry.insert(adj); },
2398 Entry::Occupied(mut entry) => {
2399 debug!(" - composing on top of {:?}", entry.get());
2400 match (&entry.get()[..], &adj[..]) {
2401 // Applying any adjustment on top of a NeverToAny
2402 // is a valid NeverToAny adjustment, because it can't
2404 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2406 Adjustment { kind: Adjust::Deref(_), .. },
2407 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2409 Adjustment { kind: Adjust::Deref(_), .. },
2410 .. // Any following adjustments are allowed.
2412 // A reborrow has no effect before a dereference.
2414 // FIXME: currently we never try to compose autoderefs
2415 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2417 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2418 expr, entry.get(), adj)
2420 *entry.get_mut() = adj;
2425 /// Basically whenever we are converting from a type scheme into
2426 /// the fn body space, we always want to normalize associated
2427 /// types as well. This function combines the two.
2428 fn instantiate_type_scheme<T>(&self,
2430 substs: SubstsRef<'tcx>,
2433 where T : TypeFoldable<'tcx>
2435 let value = value.subst(self.tcx, substs);
2436 let result = self.normalize_associated_types_in(span, &value);
2437 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2444 /// As `instantiate_type_scheme`, but for the bounds found in a
2445 /// generic type scheme.
2446 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2447 -> ty::InstantiatedPredicates<'tcx> {
2448 let bounds = self.tcx.predicates_of(def_id);
2449 let result = bounds.instantiate(self.tcx, substs);
2450 let result = self.normalize_associated_types_in(span, &result);
2451 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2458 /// Replaces the opaque types from the given value with type variables,
2459 /// and records the `OpaqueTypeMap` for later use during writeback. See
2460 /// `InferCtxt::instantiate_opaque_types` for more details.
2461 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2463 parent_id: hir::HirId,
2467 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2468 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2472 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2473 self.instantiate_opaque_types(
2482 let mut opaque_types = self.opaque_types.borrow_mut();
2483 for (ty, decl) in opaque_type_map {
2484 let old_value = opaque_types.insert(ty, decl);
2485 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2491 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2492 where T : TypeFoldable<'tcx>
2494 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2497 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2499 where T : TypeFoldable<'tcx>
2501 self.inh.partially_normalize_associated_types_in(span,
2507 pub fn require_type_meets(&self,
2510 code: traits::ObligationCauseCode<'tcx>,
2513 self.register_bound(
2516 traits::ObligationCause::new(span, self.body_id, code));
2519 pub fn require_type_is_sized(&self,
2522 code: traits::ObligationCauseCode<'tcx>)
2524 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2525 self.require_type_meets(ty, span, code, lang_item);
2528 pub fn require_type_is_sized_deferred(&self,
2531 code: traits::ObligationCauseCode<'tcx>)
2533 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2536 pub fn register_bound(&self,
2539 cause: traits::ObligationCause<'tcx>)
2541 self.fulfillment_cx.borrow_mut()
2542 .register_bound(self, self.param_env, ty, def_id, cause);
2545 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2546 let t = AstConv::ast_ty_to_ty(self, ast_t);
2547 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2551 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2552 let ty = self.to_ty(ast_ty);
2553 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2555 if Self::can_contain_user_lifetime_bounds(ty) {
2556 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2557 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2558 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2564 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2565 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2566 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2569 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2570 AstConv::ast_const_to_const(self, ast_c, ty)
2573 // If the type given by the user has free regions, save it for later, since
2574 // NLL would like to enforce those. Also pass in types that involve
2575 // projections, since those can resolve to `'static` bounds (modulo #54940,
2576 // which hopefully will be fixed by the time you see this comment, dear
2577 // reader, although I have my doubts). Also pass in types with inference
2578 // types, because they may be repeated. Other sorts of things are already
2579 // sufficiently enforced with erased regions. =)
2580 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2582 T: TypeFoldable<'tcx>
2584 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2587 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2588 match self.tables.borrow().node_types().get(id) {
2590 None if self.is_tainted_by_errors() => self.tcx.types.err,
2592 bug!("no type for node {}: {} in fcx {}",
2593 id, self.tcx.hir().node_to_string(id),
2599 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2600 /// outlive the region `r`.
2601 pub fn register_wf_obligation(&self,
2604 code: traits::ObligationCauseCode<'tcx>)
2606 // WF obligations never themselves fail, so no real need to give a detailed cause:
2607 let cause = traits::ObligationCause::new(span, self.body_id, code);
2608 self.register_predicate(traits::Obligation::new(cause,
2610 ty::Predicate::WellFormed(ty)));
2613 /// Registers obligations that all types appearing in `substs` are well-formed.
2614 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2615 for ty in substs.types() {
2616 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2620 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2621 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2622 /// trait/region obligations.
2624 /// For example, if there is a function:
2627 /// fn foo<'a,T:'a>(...)
2630 /// and a reference:
2636 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2637 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2638 pub fn add_obligations_for_parameters(&self,
2639 cause: traits::ObligationCause<'tcx>,
2640 predicates: &ty::InstantiatedPredicates<'tcx>)
2642 assert!(!predicates.has_escaping_bound_vars());
2644 debug!("add_obligations_for_parameters(predicates={:?})",
2647 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2648 self.register_predicate(obligation);
2652 // FIXME(arielb1): use this instead of field.ty everywhere
2653 // Only for fields! Returns <none> for methods>
2654 // Indifferent to privacy flags
2655 pub fn field_ty(&self,
2657 field: &'tcx ty::FieldDef,
2658 substs: SubstsRef<'tcx>)
2661 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2664 fn check_casts(&self) {
2665 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2666 for cast in deferred_cast_checks.drain(..) {
2671 fn resolve_generator_interiors(&self, def_id: DefId) {
2672 let mut generators = self.deferred_generator_interiors.borrow_mut();
2673 for (body_id, interior, kind) in generators.drain(..) {
2674 self.select_obligations_where_possible(false);
2675 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2679 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2680 // Non-numerics get replaced with ! or () (depending on whether
2681 // feature(never_type) is enabled, unconstrained ints with i32,
2682 // unconstrained floats with f64.
2683 // Fallback becomes very dubious if we have encountered type-checking errors.
2684 // In that case, fallback to Error.
2685 // The return value indicates whether fallback has occurred.
2686 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2687 use rustc::ty::error::UnconstrainedNumeric::Neither;
2688 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2690 assert!(ty.is_ty_infer());
2691 let fallback = match self.type_is_unconstrained_numeric(ty) {
2692 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2693 UnconstrainedInt => self.tcx.types.i32,
2694 UnconstrainedFloat => self.tcx.types.f64,
2695 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2696 Neither => return false,
2698 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2699 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2703 fn select_all_obligations_or_error(&self) {
2704 debug!("select_all_obligations_or_error");
2705 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2706 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2710 /// Select as many obligations as we can at present.
2711 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2712 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2713 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2717 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2718 /// returns a type of `&T`, but the actual type we assign to the
2719 /// *expression* is `T`. So this function just peels off the return
2720 /// type by one layer to yield `T`.
2721 fn make_overloaded_place_return_type(&self,
2722 method: MethodCallee<'tcx>)
2723 -> ty::TypeAndMut<'tcx>
2725 // extract method return type, which will be &T;
2726 let ret_ty = method.sig.output();
2728 // method returns &T, but the type as visible to user is T, so deref
2729 ret_ty.builtin_deref(true).unwrap()
2735 base_expr: &'tcx hir::Expr,
2739 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2740 // FIXME(#18741) -- this is almost but not quite the same as the
2741 // autoderef that normal method probing does. They could likely be
2744 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2745 let mut result = None;
2746 while result.is_none() && autoderef.next().is_some() {
2747 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2749 autoderef.finalize(self);
2753 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2754 /// (and otherwise adjust) `base_expr`, looking for a type which either
2755 /// supports builtin indexing or overloaded indexing.
2756 /// This loop implements one step in that search; the autoderef loop
2757 /// is implemented by `lookup_indexing`.
2761 base_expr: &hir::Expr,
2762 autoderef: &Autoderef<'a, 'tcx>,
2765 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2766 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2767 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2774 for &unsize in &[false, true] {
2775 let mut self_ty = adjusted_ty;
2777 // We only unsize arrays here.
2778 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2779 self_ty = self.tcx.mk_slice(element_ty);
2785 // If some lookup succeeds, write callee into table and extract index/element
2786 // type from the method signature.
2787 // If some lookup succeeded, install method in table
2788 let input_ty = self.next_ty_var(TypeVariableOrigin {
2789 kind: TypeVariableOriginKind::AutoDeref,
2790 span: base_expr.span,
2792 let method = self.try_overloaded_place_op(
2793 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2795 let result = method.map(|ok| {
2796 debug!("try_index_step: success, using overloaded indexing");
2797 let method = self.register_infer_ok_obligations(ok);
2799 let mut adjustments = autoderef.adjust_steps(self, needs);
2800 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2801 let mutbl = match r_mutbl {
2802 hir::MutImmutable => AutoBorrowMutability::Immutable,
2803 hir::MutMutable => AutoBorrowMutability::Mutable {
2804 // Indexing can be desugared to a method call,
2805 // so maybe we could use two-phase here.
2806 // See the documentation of AllowTwoPhase for why that's
2807 // not the case today.
2808 allow_two_phase_borrow: AllowTwoPhase::No,
2811 adjustments.push(Adjustment {
2812 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2813 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2820 adjustments.push(Adjustment {
2821 kind: Adjust::Pointer(PointerCast::Unsize),
2822 target: method.sig.inputs()[0]
2825 self.apply_adjustments(base_expr, adjustments);
2827 self.write_method_call(expr.hir_id, method);
2828 (input_ty, self.make_overloaded_place_return_type(method).ty)
2830 if result.is_some() {
2838 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2839 let (tr, name) = match (op, is_mut) {
2840 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2841 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2842 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2843 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2845 (tr, ast::Ident::with_empty_ctxt(name))
2848 fn try_overloaded_place_op(&self,
2851 arg_tys: &[Ty<'tcx>],
2854 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2856 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2862 // Try Mut first, if needed.
2863 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2864 let method = match (needs, mut_tr) {
2865 (Needs::MutPlace, Some(trait_did)) => {
2866 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2871 // Otherwise, fall back to the immutable version.
2872 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2873 let method = match (method, imm_tr) {
2874 (None, Some(trait_did)) => {
2875 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2877 (method, _) => method,
2883 fn check_method_argument_types(
2887 method: Result<MethodCallee<'tcx>, ()>,
2888 args_no_rcvr: &'tcx [hir::Expr],
2889 tuple_arguments: TupleArgumentsFlag,
2890 expected: Expectation<'tcx>,
2892 let has_error = match method {
2894 method.substs.references_error() || method.sig.references_error()
2899 let err_inputs = self.err_args(args_no_rcvr.len());
2901 let err_inputs = match tuple_arguments {
2902 DontTupleArguments => err_inputs,
2903 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2906 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2907 false, tuple_arguments, None);
2908 return self.tcx.types.err;
2911 let method = method.unwrap();
2912 // HACK(eddyb) ignore self in the definition (see above).
2913 let expected_arg_tys = self.expected_inputs_for_expected_output(
2916 method.sig.output(),
2917 &method.sig.inputs()[1..]
2919 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2920 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2921 self.tcx.hir().span_if_local(method.def_id));
2925 fn self_type_matches_expected_vid(
2927 trait_ref: ty::PolyTraitRef<'tcx>,
2928 expected_vid: ty::TyVid,
2930 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2932 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2933 trait_ref, self_ty, expected_vid
2936 ty::Infer(ty::TyVar(found_vid)) => {
2937 // FIXME: consider using `sub_root_var` here so we
2938 // can see through subtyping.
2939 let found_vid = self.root_var(found_vid);
2940 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2941 expected_vid == found_vid
2947 fn obligations_for_self_ty<'b>(
2950 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2953 // FIXME: consider using `sub_root_var` here so we
2954 // can see through subtyping.
2955 let ty_var_root = self.root_var(self_ty);
2956 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2957 self_ty, ty_var_root,
2958 self.fulfillment_cx.borrow().pending_obligations());
2962 .pending_obligations()
2964 .filter_map(move |obligation| match obligation.predicate {
2965 ty::Predicate::Projection(ref data) =>
2966 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2967 ty::Predicate::Trait(ref data) =>
2968 Some((data.to_poly_trait_ref(), obligation)),
2969 ty::Predicate::Subtype(..) => None,
2970 ty::Predicate::RegionOutlives(..) => None,
2971 ty::Predicate::TypeOutlives(..) => None,
2972 ty::Predicate::WellFormed(..) => None,
2973 ty::Predicate::ObjectSafe(..) => None,
2974 ty::Predicate::ConstEvaluatable(..) => None,
2975 // N.B., this predicate is created by breaking down a
2976 // `ClosureType: FnFoo()` predicate, where
2977 // `ClosureType` represents some `Closure`. It can't
2978 // possibly be referring to the current closure,
2979 // because we haven't produced the `Closure` for
2980 // this closure yet; this is exactly why the other
2981 // code is looking for a self type of a unresolved
2982 // inference variable.
2983 ty::Predicate::ClosureKind(..) => None,
2984 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2987 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2988 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2989 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2993 /// Generic function that factors out common logic from function calls,
2994 /// method calls and overloaded operators.
2995 fn check_argument_types(
2999 fn_inputs: &[Ty<'tcx>],
3000 expected_arg_tys: &[Ty<'tcx>],
3001 args: &'tcx [hir::Expr],
3003 tuple_arguments: TupleArgumentsFlag,
3004 def_span: Option<Span>,
3008 // Grab the argument types, supplying fresh type variables
3009 // if the wrong number of arguments were supplied
3010 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3016 // All the input types from the fn signature must outlive the call
3017 // so as to validate implied bounds.
3018 for &fn_input_ty in fn_inputs {
3019 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
3022 let expected_arg_count = fn_inputs.len();
3024 let param_count_error = |expected_count: usize,
3029 let mut err = tcx.sess.struct_span_err_with_code(sp,
3030 &format!("this function takes {}{} but {} {} supplied",
3031 if c_variadic { "at least " } else { "" },
3032 potentially_plural_count(expected_count, "parameter"),
3033 potentially_plural_count(arg_count, "parameter"),
3034 if arg_count == 1 {"was"} else {"were"}),
3035 DiagnosticId::Error(error_code.to_owned()));
3037 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3038 err.span_label(def_s, "defined here");
3041 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3042 // remove closing `)` from the span
3043 let sugg_span = sugg_span.shrink_to_lo();
3044 err.span_suggestion(
3046 "expected the unit value `()`; create it with empty parentheses",
3048 Applicability::MachineApplicable);
3050 err.span_label(sp, format!("expected {}{}",
3051 if c_variadic { "at least " } else { "" },
3052 potentially_plural_count(expected_count, "parameter")));
3057 let mut expected_arg_tys = expected_arg_tys.to_vec();
3059 let formal_tys = if tuple_arguments == TupleArguments {
3060 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3061 match tuple_type.sty {
3062 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3063 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3064 expected_arg_tys = vec![];
3065 self.err_args(args.len())
3067 ty::Tuple(arg_types) => {
3068 expected_arg_tys = match expected_arg_tys.get(0) {
3069 Some(&ty) => match ty.sty {
3070 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3075 arg_types.iter().map(|k| k.expect_ty()).collect()
3078 span_err!(tcx.sess, sp, E0059,
3079 "cannot use call notation; the first type parameter \
3080 for the function trait is neither a tuple nor unit");
3081 expected_arg_tys = vec![];
3082 self.err_args(args.len())
3085 } else if expected_arg_count == supplied_arg_count {
3087 } else if c_variadic {
3088 if supplied_arg_count >= expected_arg_count {
3091 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3092 expected_arg_tys = vec![];
3093 self.err_args(supplied_arg_count)
3096 // is the missing argument of type `()`?
3097 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3098 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3099 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3100 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3104 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3106 expected_arg_tys = vec![];
3107 self.err_args(supplied_arg_count)
3110 debug!("check_argument_types: formal_tys={:?}",
3111 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3113 // If there is no expectation, expect formal_tys.
3114 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3120 // Check the arguments.
3121 // We do this in a pretty awful way: first we type-check any arguments
3122 // that are not closures, then we type-check the closures. This is so
3123 // that we have more information about the types of arguments when we
3124 // type-check the functions. This isn't really the right way to do this.
3125 for &check_closures in &[false, true] {
3126 debug!("check_closures={}", check_closures);
3128 // More awful hacks: before we check argument types, try to do
3129 // an "opportunistic" vtable resolution of any trait bounds on
3130 // the call. This helps coercions.
3132 self.select_obligations_where_possible(false);
3135 // For C-variadic functions, we don't have a declared type for all of
3136 // the arguments hence we only do our usual type checking with
3137 // the arguments who's types we do know.
3138 let t = if c_variadic {
3140 } else if tuple_arguments == TupleArguments {
3145 for (i, arg) in args.iter().take(t).enumerate() {
3146 // Warn only for the first loop (the "no closures" one).
3147 // Closure arguments themselves can't be diverging, but
3148 // a previous argument can, e.g., `foo(panic!(), || {})`.
3149 if !check_closures {
3150 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3153 let is_closure = match arg.node {
3154 ExprKind::Closure(..) => true,
3158 if is_closure != check_closures {
3162 debug!("checking the argument");
3163 let formal_ty = formal_tys[i];
3165 // The special-cased logic below has three functions:
3166 // 1. Provide as good of an expected type as possible.
3167 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3169 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3171 // 2. Coerce to the most detailed type that could be coerced
3172 // to, which is `expected_ty` if `rvalue_hint` returns an
3173 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3174 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3175 // We're processing function arguments so we definitely want to use
3176 // two-phase borrows.
3177 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3179 // 3. Relate the expected type and the formal one,
3180 // if the expected type was used for the coercion.
3181 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3185 // We also need to make sure we at least write the ty of the other
3186 // arguments which we skipped above.
3188 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3189 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3190 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3193 for arg in args.iter().skip(expected_arg_count) {
3194 let arg_ty = self.check_expr(&arg);
3196 // There are a few types which get autopromoted when passed via varargs
3197 // in C but we just error out instead and require explicit casts.
3198 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3200 ty::Float(ast::FloatTy::F32) => {
3201 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3203 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3204 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3206 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3207 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3210 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3211 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3212 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3220 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3221 vec![self.tcx.types.err; len]
3224 // AST fragment checking
3227 expected: Expectation<'tcx>)
3233 ast::LitKind::Str(..) => tcx.mk_static_str(),
3234 ast::LitKind::ByteStr(ref v) => {
3235 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3236 tcx.mk_array(tcx.types.u8, v.len() as u64))
3238 ast::LitKind::Byte(_) => tcx.types.u8,
3239 ast::LitKind::Char(_) => tcx.types.char,
3240 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3241 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3242 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3243 let opt_ty = expected.to_option(self).and_then(|ty| {
3245 ty::Int(_) | ty::Uint(_) => Some(ty),
3246 ty::Char => Some(tcx.types.u8),
3247 ty::RawPtr(..) => Some(tcx.types.usize),
3248 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3252 opt_ty.unwrap_or_else(|| self.next_int_var())
3254 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3255 ast::LitKind::FloatUnsuffixed(_) => {
3256 let opt_ty = expected.to_option(self).and_then(|ty| {
3258 ty::Float(_) => Some(ty),
3262 opt_ty.unwrap_or_else(|| self.next_float_var())
3264 ast::LitKind::Bool(_) => tcx.types.bool,
3265 ast::LitKind::Err(_) => tcx.types.err,
3269 // Determine the `Self` type, using fresh variables for all variables
3270 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3271 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3273 pub fn impl_self_ty(&self,
3274 span: Span, // (potential) receiver for this impl
3276 -> TypeAndSubsts<'tcx> {
3277 let ity = self.tcx.type_of(did);
3278 debug!("impl_self_ty: ity={:?}", ity);
3280 let substs = self.fresh_substs_for_item(span, did);
3281 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3283 TypeAndSubsts { substs: substs, ty: substd_ty }
3286 /// Unifies the output type with the expected type early, for more coercions
3287 /// and forward type information on the input expressions.
3288 fn expected_inputs_for_expected_output(&self,
3290 expected_ret: Expectation<'tcx>,
3291 formal_ret: Ty<'tcx>,
3292 formal_args: &[Ty<'tcx>])
3294 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3295 let ret_ty = match expected_ret.only_has_type(self) {
3297 None => return Vec::new()
3299 let expect_args = self.fudge_inference_if_ok(|| {
3300 // Attempt to apply a subtyping relationship between the formal
3301 // return type (likely containing type variables if the function
3302 // is polymorphic) and the expected return type.
3303 // No argument expectations are produced if unification fails.
3304 let origin = self.misc(call_span);
3305 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3307 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3308 // to identity so the resulting type is not constrained.
3311 // Process any obligations locally as much as
3312 // we can. We don't care if some things turn
3313 // out unconstrained or ambiguous, as we're
3314 // just trying to get hints here.
3315 self.save_and_restore_in_snapshot_flag(|_| {
3316 let mut fulfill = TraitEngine::new(self.tcx);
3317 for obligation in ok.obligations {
3318 fulfill.register_predicate_obligation(self, obligation);
3320 fulfill.select_where_possible(self)
3321 }).map_err(|_| ())?;
3323 Err(_) => return Err(()),
3326 // Record all the argument types, with the substitutions
3327 // produced from the above subtyping unification.
3328 Ok(formal_args.iter().map(|ty| {
3329 self.resolve_vars_if_possible(ty)
3331 }).unwrap_or_default();
3332 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3333 formal_args, formal_ret,
3334 expect_args, expected_ret);
3338 pub fn check_struct_path(&self,
3341 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3342 let path_span = match *qpath {
3343 QPath::Resolved(_, ref path) => path.span,
3344 QPath::TypeRelative(ref qself, _) => qself.span
3346 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3347 let variant = match def {
3349 self.set_tainted_by_errors();
3352 Res::Def(DefKind::Variant, _) => {
3354 ty::Adt(adt, substs) => {
3355 Some((adt.variant_of_res(def), adt.did, substs))
3357 _ => bug!("unexpected type: {:?}", ty)
3360 Res::Def(DefKind::Struct, _)
3361 | Res::Def(DefKind::Union, _)
3362 | Res::Def(DefKind::TyAlias, _)
3363 | Res::Def(DefKind::AssocTy, _)
3364 | Res::SelfTy(..) => {
3366 ty::Adt(adt, substs) if !adt.is_enum() => {
3367 Some((adt.non_enum_variant(), adt.did, substs))
3372 _ => bug!("unexpected definition: {:?}", def)
3375 if let Some((variant, did, substs)) = variant {
3376 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3377 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3379 // Check bounds on type arguments used in the path.
3380 let bounds = self.instantiate_bounds(path_span, did, substs);
3381 let cause = traits::ObligationCause::new(path_span, self.body_id,
3382 traits::ItemObligation(did));
3383 self.add_obligations_for_parameters(cause, &bounds);
3387 struct_span_err!(self.tcx.sess, path_span, E0071,
3388 "expected struct, variant or union type, found {}",
3389 ty.sort_string(self.tcx))
3390 .span_label(path_span, "not a struct")
3396 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3397 // The newly resolved definition is written into `type_dependent_defs`.
3398 fn finish_resolving_struct_path(&self,
3405 QPath::Resolved(ref maybe_qself, ref path) => {
3406 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3407 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3410 QPath::TypeRelative(ref qself, ref segment) => {
3411 let ty = self.to_ty(qself);
3413 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3418 let result = AstConv::associated_path_to_ty(
3427 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3428 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3430 // Write back the new resolution.
3431 self.write_resolution(hir_id, result);
3433 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3438 /// Resolves an associated value path into a base type and associated constant, or method
3439 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3440 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3444 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3446 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3447 let (ty, qself, item_segment) = match *qpath {
3448 QPath::Resolved(ref opt_qself, ref path) => {
3450 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3451 &path.segments[..]);
3453 QPath::TypeRelative(ref qself, ref segment) => {
3454 (self.to_ty(qself), qself, segment)
3457 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3458 // Return directly on cache hit. This is useful to avoid doubly reporting
3459 // errors with default match binding modes. See #44614.
3460 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3461 .unwrap_or(Res::Err);
3462 return (def, Some(ty), slice::from_ref(&**item_segment));
3464 let item_name = item_segment.ident;
3465 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3466 let result = match error {
3467 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3468 _ => Err(ErrorReported),
3470 if item_name.name != kw::Invalid {
3471 self.report_method_error(
3475 SelfSource::QPath(qself),
3483 // Write back the new resolution.
3484 self.write_resolution(hir_id, result);
3486 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3488 slice::from_ref(&**item_segment),
3492 pub fn check_decl_initializer(
3494 local: &'tcx hir::Local,
3495 init: &'tcx hir::Expr,
3497 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3498 // for #42640 (default match binding modes).
3501 let ref_bindings = local.pat.contains_explicit_ref_binding();
3503 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3504 if let Some(m) = ref_bindings {
3505 // Somewhat subtle: if we have a `ref` binding in the pattern,
3506 // we want to avoid introducing coercions for the RHS. This is
3507 // both because it helps preserve sanity and, in the case of
3508 // ref mut, for soundness (issue #23116). In particular, in
3509 // the latter case, we need to be clear that the type of the
3510 // referent for the reference that results is *equal to* the
3511 // type of the place it is referencing, and not some
3512 // supertype thereof.
3513 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3514 self.demand_eqtype(init.span, local_ty, init_ty);
3517 self.check_expr_coercable_to_type(init, local_ty)
3521 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3522 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3523 self.write_ty(local.hir_id, t);
3525 if let Some(ref init) = local.init {
3526 let init_ty = self.check_decl_initializer(local, &init);
3527 if init_ty.references_error() {
3528 self.write_ty(local.hir_id, init_ty);
3532 self.check_pat_walk(
3535 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
3538 let pat_ty = self.node_ty(local.pat.hir_id);
3539 if pat_ty.references_error() {
3540 self.write_ty(local.hir_id, pat_ty);
3544 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3545 // Don't do all the complex logic below for `DeclItem`.
3547 hir::StmtKind::Item(..) => return,
3548 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3551 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3553 // Hide the outer diverging and `has_errors` flags.
3554 let old_diverges = self.diverges.get();
3555 let old_has_errors = self.has_errors.get();
3556 self.diverges.set(Diverges::Maybe);
3557 self.has_errors.set(false);
3560 hir::StmtKind::Local(ref l) => {
3561 self.check_decl_local(&l);
3564 hir::StmtKind::Item(_) => {}
3565 hir::StmtKind::Expr(ref expr) => {
3566 // Check with expected type of `()`.
3567 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3569 hir::StmtKind::Semi(ref expr) => {
3570 self.check_expr(&expr);
3574 // Combine the diverging and `has_error` flags.
3575 self.diverges.set(self.diverges.get() | old_diverges);
3576 self.has_errors.set(self.has_errors.get() | old_has_errors);
3579 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3580 let unit = self.tcx.mk_unit();
3581 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3583 // if the block produces a `!` value, that can always be
3584 // (effectively) coerced to unit.
3586 self.demand_suptype(blk.span, unit, ty);
3590 fn check_block_with_expected(
3592 blk: &'tcx hir::Block,
3593 expected: Expectation<'tcx>,
3596 let mut fcx_ps = self.ps.borrow_mut();
3597 let unsafety_state = fcx_ps.recurse(blk);
3598 replace(&mut *fcx_ps, unsafety_state)
3601 // In some cases, blocks have just one exit, but other blocks
3602 // can be targeted by multiple breaks. This can happen both
3603 // with labeled blocks as well as when we desugar
3604 // a `try { ... }` expression.
3608 // 'a: { if true { break 'a Err(()); } Ok(()) }
3610 // Here we would wind up with two coercions, one from
3611 // `Err(())` and the other from the tail expression
3612 // `Ok(())`. If the tail expression is omitted, that's a
3613 // "forced unit" -- unless the block diverges, in which
3614 // case we can ignore the tail expression (e.g., `'a: {
3615 // break 'a 22; }` would not force the type of the block
3617 let tail_expr = blk.expr.as_ref();
3618 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3619 let coerce = if blk.targeted_by_break {
3620 CoerceMany::new(coerce_to_ty)
3622 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3623 Some(e) => slice::from_ref(e),
3626 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3629 let prev_diverges = self.diverges.get();
3630 let ctxt = BreakableCtxt {
3631 coerce: Some(coerce),
3635 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3636 for s in &blk.stmts {
3640 // check the tail expression **without** holding the
3641 // `enclosing_breakables` lock below.
3642 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3644 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3645 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3646 let coerce = ctxt.coerce.as_mut().unwrap();
3647 if let Some(tail_expr_ty) = tail_expr_ty {
3648 let tail_expr = tail_expr.unwrap();
3649 let cause = self.cause(tail_expr.span,
3650 ObligationCauseCode::BlockTailExpression(blk.hir_id));
3656 // Subtle: if there is no explicit tail expression,
3657 // that is typically equivalent to a tail expression
3658 // of `()` -- except if the block diverges. In that
3659 // case, there is no value supplied from the tail
3660 // expression (assuming there are no other breaks,
3661 // this implies that the type of the block will be
3664 // #41425 -- label the implicit `()` as being the
3665 // "found type" here, rather than the "expected type".
3666 if !self.diverges.get().always() {
3667 // #50009 -- Do not point at the entire fn block span, point at the return type
3668 // span, as it is the cause of the requirement, and
3669 // `consider_hint_about_removing_semicolon` will point at the last expression
3670 // if it were a relevant part of the error. This improves usability in editors
3671 // that highlight errors inline.
3672 let mut sp = blk.span;
3673 let mut fn_span = None;
3674 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3675 let ret_sp = decl.output.span();
3676 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3677 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3678 // output would otherwise be incorrect and even misleading. Make sure
3679 // the span we're aiming at correspond to a `fn` body.
3680 if block_sp == blk.span {
3682 fn_span = Some(ident.span);
3686 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3687 if let Some(expected_ty) = expected.only_has_type(self) {
3688 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3690 if let Some(fn_span) = fn_span {
3691 err.span_label(fn_span, "this function's body doesn't return");
3699 // If we can break from the block, then the block's exit is always reachable
3700 // (... as long as the entry is reachable) - regardless of the tail of the block.
3701 self.diverges.set(prev_diverges);
3704 let mut ty = ctxt.coerce.unwrap().complete(self);
3706 if self.has_errors.get() || ty.references_error() {
3707 ty = self.tcx.types.err
3710 self.write_ty(blk.hir_id, ty);
3712 *self.ps.borrow_mut() = prev;
3716 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3717 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
3719 Node::Item(&hir::Item {
3720 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3722 Node::ImplItem(&hir::ImplItem {
3723 node: hir::ImplItemKind::Method(_, body_id), ..
3725 let body = self.tcx.hir().body(body_id);
3726 if let ExprKind::Block(block, _) = &body.value.node {
3727 return Some(block.span);
3735 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3736 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
3737 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
3738 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3741 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3742 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
3744 Node::Item(&hir::Item {
3745 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3747 // This is less than ideal, it will not suggest a return type span on any
3748 // method called `main`, regardless of whether it is actually the entry point,
3749 // but it will still present it as the reason for the expected type.
3750 Some((decl, ident, ident.name != sym::main))
3752 Node::TraitItem(&hir::TraitItem {
3753 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3756 }) => Some((decl, ident, true)),
3757 Node::ImplItem(&hir::ImplItem {
3758 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3761 }) => Some((decl, ident, false)),
3766 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3767 /// suggestion can be made, `None` otherwise.
3768 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
3769 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3770 // `while` before reaching it, as block tail returns are not available in them.
3771 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3772 let parent = self.tcx.hir().get(blk_id);
3773 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3777 /// On implicit return expressions with mismatched types, provides the following suggestions:
3779 /// - Points out the method's return type as the reason for the expected type.
3780 /// - Possible missing semicolon.
3781 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3782 pub fn suggest_mismatched_types_on_tail(
3784 err: &mut DiagnosticBuilder<'tcx>,
3785 expression: &'tcx hir::Expr,
3791 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3792 let mut pointing_at_return_type = false;
3793 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3794 pointing_at_return_type = self.suggest_missing_return_type(
3795 err, &fn_decl, expected, found, can_suggest);
3797 self.suggest_ref_or_into(err, expression, expected, found);
3798 pointing_at_return_type
3801 pub fn suggest_ref_or_into(
3803 err: &mut DiagnosticBuilder<'tcx>,
3808 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
3809 err.span_suggestion(
3813 Applicability::MachineApplicable,
3815 } else if !self.check_for_cast(err, expr, found, expected) {
3816 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
3820 let methods = self.get_conversion_methods(expr.span, expected, found);
3821 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
3822 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
3823 .filter_map(|(receiver, method)| {
3824 let method_call = format!(".{}()", method.ident);
3825 if receiver.ends_with(&method_call) {
3826 None // do not suggest code that is already there (#53348)
3828 let method_call_list = [".to_vec()", ".to_string()"];
3829 let sugg = if receiver.ends_with(".clone()")
3830 && method_call_list.contains(&method_call.as_str()) {
3831 let max_len = receiver.rfind(".").unwrap();
3832 format!("{}{}", &receiver[..max_len], method_call)
3834 format!("{}{}", receiver, method_call)
3836 Some(if is_struct_pat_shorthand_field {
3837 format!("{}: {}", receiver, sugg)
3843 if suggestions.peek().is_some() {
3844 err.span_suggestions(
3846 "try using a conversion method",
3848 Applicability::MaybeIncorrect,
3855 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
3859 /// bar_that_returns_u32()
3863 /// This routine checks if the return expression in a block would make sense on its own as a
3864 /// statement and the return type has been left as default or has been specified as `()`. If so,
3865 /// it suggests adding a semicolon.
3866 fn suggest_missing_semicolon(
3868 err: &mut DiagnosticBuilder<'tcx>,
3869 expression: &'tcx hir::Expr,
3873 if expected.is_unit() {
3874 // `BlockTailExpression` only relevant if the tail expr would be
3875 // useful on its own.
3876 match expression.node {
3877 ExprKind::Call(..) |
3878 ExprKind::MethodCall(..) |
3879 ExprKind::Loop(..) |
3880 ExprKind::Match(..) |
3881 ExprKind::Block(..) => {
3882 let sp = self.tcx.sess.source_map().next_point(cause_span);
3883 err.span_suggestion(
3885 "try adding a semicolon",
3887 Applicability::MachineApplicable);
3894 /// A possible error is to forget to add a return type that is needed:
3898 /// bar_that_returns_u32()
3902 /// This routine checks if the return type is left as default, the method is not part of an
3903 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
3905 fn suggest_missing_return_type(
3907 err: &mut DiagnosticBuilder<'tcx>,
3908 fn_decl: &hir::FnDecl,
3913 // Only suggest changing the return type for methods that
3914 // haven't set a return type at all (and aren't `fn main()` or an impl).
3915 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
3916 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
3917 err.span_suggestion(
3919 "try adding a return type",
3920 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
3921 Applicability::MachineApplicable);
3924 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
3925 err.span_label(span, "possibly return type missing here?");
3928 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
3929 // `fn main()` must return `()`, do not suggest changing return type
3930 err.span_label(span, "expected `()` because of default return type");
3933 // expectation was caused by something else, not the default return
3934 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
3935 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
3936 // Only point to return type if the expected type is the return type, as if they
3937 // are not, the expectation must have been caused by something else.
3938 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
3940 let ty = AstConv::ast_ty_to_ty(self, ty);
3941 debug!("suggest_missing_return_type: return type {:?}", ty);
3942 debug!("suggest_missing_return_type: expected type {:?}", ty);
3943 if ty.sty == expected.sty {
3944 err.span_label(sp, format!("expected `{}` because of return type",
3953 /// A possible error is to forget to add `.await` when using futures:
3956 /// #![feature(async_await)]
3958 /// async fn make_u32() -> u32 {
3962 /// fn take_u32(x: u32) {}
3964 /// async fn foo() {
3965 /// let x = make_u32();
3970 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
3971 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
3972 /// `.await` to the tail of the expression.
3973 fn suggest_missing_await(
3975 err: &mut DiagnosticBuilder<'tcx>,
3980 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
3981 // body isn't `async`.
3982 let item_id = self.tcx().hir().get_parent_node(self.body_id);
3983 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
3984 let body = self.tcx().hir().body(body_id);
3985 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
3987 // Check for `Future` implementations by constructing a predicate to
3988 // prove: `<T as Future>::Output == U`
3989 let future_trait = self.tcx.lang_items().future_trait().unwrap();
3990 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
3991 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
3992 // `<T as Future>::Output`
3993 projection_ty: ty::ProjectionTy {
3995 substs: self.tcx.mk_substs_trait(
3997 self.fresh_substs_for_item(sp, item_def_id)
4004 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4005 if self.infcx.predicate_may_hold(&obligation) {
4006 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4007 err.span_suggestion(
4009 "consider using `.await` here",
4010 format!("{}.await", code),
4011 Applicability::MaybeIncorrect,
4019 /// A common error is to add an extra semicolon:
4022 /// fn foo() -> usize {
4027 /// This routine checks if the final statement in a block is an
4028 /// expression with an explicit semicolon whose type is compatible
4029 /// with `expected_ty`. If so, it suggests removing the semicolon.
4030 fn consider_hint_about_removing_semicolon(
4032 blk: &'tcx hir::Block,
4033 expected_ty: Ty<'tcx>,
4034 err: &mut DiagnosticBuilder<'_>,
4036 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4037 err.span_suggestion(
4039 "consider removing this semicolon",
4041 Applicability::MachineApplicable,
4046 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4047 // Be helpful when the user wrote `{... expr;}` and
4048 // taking the `;` off is enough to fix the error.
4049 let last_stmt = blk.stmts.last()?;
4050 let last_expr = match last_stmt.node {
4051 hir::StmtKind::Semi(ref e) => e,
4054 let last_expr_ty = self.node_ty(last_expr.hir_id);
4055 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4058 let original_span = original_sp(last_stmt.span, blk.span);
4059 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4062 // Instantiates the given path, which must refer to an item with the given
4063 // number of type parameters and type.
4064 pub fn instantiate_value_path(&self,
4065 segments: &[hir::PathSegment],
4066 self_ty: Option<Ty<'tcx>>,
4070 -> (Ty<'tcx>, Res) {
4072 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4081 let path_segs = match res {
4082 Res::Local(_) | Res::SelfCtor(_) => vec![],
4083 Res::Def(kind, def_id) =>
4084 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4085 _ => bug!("instantiate_value_path on {:?}", res),
4088 let mut user_self_ty = None;
4089 let mut is_alias_variant_ctor = false;
4091 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4092 if let Some(self_ty) = self_ty {
4093 let adt_def = self_ty.ty_adt_def().unwrap();
4094 user_self_ty = Some(UserSelfTy {
4095 impl_def_id: adt_def.did,
4098 is_alias_variant_ctor = true;
4101 Res::Def(DefKind::Method, def_id)
4102 | Res::Def(DefKind::AssocConst, def_id) => {
4103 let container = tcx.associated_item(def_id).container;
4104 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4106 ty::TraitContainer(trait_did) => {
4107 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4109 ty::ImplContainer(impl_def_id) => {
4110 if segments.len() == 1 {
4111 // `<T>::assoc` will end up here, and so
4112 // can `T::assoc`. It this came from an
4113 // inherent impl, we need to record the
4114 // `T` for posterity (see `UserSelfTy` for
4116 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4117 user_self_ty = Some(UserSelfTy {
4128 // Now that we have categorized what space the parameters for each
4129 // segment belong to, let's sort out the parameters that the user
4130 // provided (if any) into their appropriate spaces. We'll also report
4131 // errors if type parameters are provided in an inappropriate place.
4133 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4134 let generics_has_err = AstConv::prohibit_generics(
4135 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4136 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4143 if let Res::Local(hid) = res {
4144 let ty = self.local_ty(span, hid).decl_ty;
4145 let ty = self.normalize_associated_types_in(span, &ty);
4146 self.write_ty(hir_id, ty);
4150 if generics_has_err {
4151 // Don't try to infer type parameters when prohibited generic arguments were given.
4152 user_self_ty = None;
4155 // Now we have to compare the types that the user *actually*
4156 // provided against the types that were *expected*. If the user
4157 // did not provide any types, then we want to substitute inference
4158 // variables. If the user provided some types, we may still need
4159 // to add defaults. If the user provided *too many* types, that's
4162 let mut infer_args_for_err = FxHashSet::default();
4163 for &PathSeg(def_id, index) in &path_segs {
4164 let seg = &segments[index];
4165 let generics = tcx.generics_of(def_id);
4166 // Argument-position `impl Trait` is treated as a normal generic
4167 // parameter internally, but we don't allow users to specify the
4168 // parameter's value explicitly, so we have to do some error-
4170 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4175 false, // `is_method_call`
4177 if suppress_errors {
4178 infer_args_for_err.insert(index);
4179 self.set_tainted_by_errors(); // See issue #53251.
4183 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4184 tcx.generics_of(*def_id).has_self
4185 }).unwrap_or(false);
4187 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4188 let ty = self.impl_self_ty(span, impl_def_id).ty;
4189 let adt_def = ty.ty_adt_def();
4192 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4193 let variant = adt_def.non_enum_variant();
4194 let ctor_def_id = variant.ctor_def_id.unwrap();
4196 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4201 let mut err = tcx.sess.struct_span_err(span,
4202 "the `Self` constructor can only be used with tuple or unit structs");
4203 if let Some(adt_def) = adt_def {
4204 match adt_def.adt_kind() {
4206 err.help("did you mean to use one of the enum's variants?");
4210 err.span_suggestion(
4212 "use curly brackets",
4213 String::from("Self { /* fields */ }"),
4214 Applicability::HasPlaceholders,
4221 return (tcx.types.err, res)
4227 let def_id = res.def_id();
4229 // The things we are substituting into the type should not contain
4230 // escaping late-bound regions, and nor should the base type scheme.
4231 let ty = tcx.type_of(def_id);
4233 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4239 // Provide the generic args, and whether types should be inferred.
4241 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4244 // If we've encountered an `impl Trait`-related error, we're just
4245 // going to infer the arguments for better error messages.
4246 if !infer_args_for_err.contains(&index) {
4247 // Check whether the user has provided generic arguments.
4248 if let Some(ref data) = segments[index].args {
4249 return (Some(data), segments[index].infer_args);
4252 return (None, segments[index].infer_args);
4257 // Provide substitutions for parameters for which (valid) arguments have been provided.
4259 match (¶m.kind, arg) {
4260 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4261 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4263 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4264 self.to_ty(ty).into()
4266 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4267 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4269 _ => unreachable!(),
4272 // Provide substitutions for parameters for which arguments are inferred.
4273 |substs, param, infer_args| {
4275 GenericParamDefKind::Lifetime => {
4276 self.re_infer(Some(param), span).unwrap().into()
4278 GenericParamDefKind::Type { has_default, .. } => {
4279 if !infer_args && has_default {
4280 // If we have a default, then we it doesn't matter that we're not
4281 // inferring the type arguments: we provide the default where any
4283 let default = tcx.type_of(param.def_id);
4286 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4289 // If no type arguments were provided, we have to infer them.
4290 // This case also occurs as a result of some malformed input, e.g.
4291 // a lifetime argument being given instead of a type parameter.
4292 // Using inference instead of `Error` gives better error messages.
4293 self.var_for_def(span, param)
4296 GenericParamDefKind::Const => {
4297 // FIXME(const_generics:defaults)
4298 // No const parameters were provided, we have to infer them.
4299 self.var_for_def(span, param)
4304 assert!(!substs.has_escaping_bound_vars());
4305 assert!(!ty.has_escaping_bound_vars());
4307 // First, store the "user substs" for later.
4308 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4310 // Add all the obligations that are required, substituting and
4311 // normalized appropriately.
4312 let bounds = self.instantiate_bounds(span, def_id, &substs);
4313 self.add_obligations_for_parameters(
4314 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4317 // Substitute the values for the type parameters into the type of
4318 // the referenced item.
4319 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4321 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4322 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4323 // is inherent, there is no `Self` parameter; instead, the impl needs
4324 // type parameters, which we can infer by unifying the provided `Self`
4325 // with the substituted impl type.
4326 // This also occurs for an enum variant on a type alias.
4327 let ty = tcx.type_of(impl_def_id);
4329 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4330 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4331 Ok(ok) => self.register_infer_ok_obligations(ok),
4333 self.tcx.sess.delay_span_bug(span, &format!(
4334 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4342 self.check_rustc_args_require_const(def_id, hir_id, span);
4344 debug!("instantiate_value_path: type of {:?} is {:?}",
4347 self.write_substs(hir_id, substs);
4349 (ty_substituted, res)
4352 fn check_rustc_args_require_const(&self,
4356 // We're only interested in functions tagged with
4357 // #[rustc_args_required_const], so ignore anything that's not.
4358 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4362 // If our calling expression is indeed the function itself, we're good!
4363 // If not, generate an error that this can only be called directly.
4364 if let Node::Expr(expr) = self.tcx.hir().get(
4365 self.tcx.hir().get_parent_node(hir_id))
4367 if let ExprKind::Call(ref callee, ..) = expr.node {
4368 if callee.hir_id == hir_id {
4374 self.tcx.sess.span_err(span, "this function can only be invoked \
4375 directly, not through a function pointer");
4378 // Resolves `typ` by a single level if `typ` is a type variable.
4379 // If no resolution is possible, then an error is reported.
4380 // Numeric inference variables may be left unresolved.
4381 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4382 let ty = self.resolve_type_vars_with_obligations(ty);
4383 if !ty.is_ty_var() {
4386 if !self.is_tainted_by_errors() {
4387 self.need_type_info_err((**self).body_id, sp, ty)
4388 .note("type must be known at this point")
4391 self.demand_suptype(sp, self.tcx.types.err, ty);
4396 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4399 ctxt: BreakableCtxt<'tcx>,
4401 ) -> (BreakableCtxt<'tcx>, R) {
4404 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4405 index = enclosing_breakables.stack.len();
4406 enclosing_breakables.by_id.insert(id, index);
4407 enclosing_breakables.stack.push(ctxt);
4411 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4412 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4413 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4414 enclosing_breakables.stack.pop().expect("missing breakable context")
4419 /// Instantiate a QueryResponse in a probe context, without a
4420 /// good ObligationCause.
4421 fn probe_instantiate_query_response(
4424 original_values: &OriginalQueryValues<'tcx>,
4425 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4426 ) -> InferResult<'tcx, Ty<'tcx>>
4428 self.instantiate_query_response_and_region_obligations(
4429 &traits::ObligationCause::misc(span, self.body_id),
4435 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4436 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4437 let mut contained_in_place = false;
4439 while let hir::Node::Expr(parent_expr) =
4440 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4442 match &parent_expr.node {
4443 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4444 if lhs.hir_id == expr_id {
4445 contained_in_place = true;
4451 expr_id = parent_expr.hir_id;
4458 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4459 let own_counts = generics.own_counts();
4461 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4467 if own_counts.types == 0 {
4471 // Make a vector of booleans initially `false`; set to `true` when used.
4472 let mut types_used = vec![false; own_counts.types];
4474 for leaf_ty in ty.walk() {
4475 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4476 debug!("found use of ty param num {}", index);
4477 types_used[index as usize - own_counts.lifetimes] = true;
4478 } else if let ty::Error = leaf_ty.sty {
4479 // If there is already another error, do not emit
4480 // an error for not using a type parameter.
4481 assert!(tcx.sess.has_errors());
4486 let types = generics.params.iter().filter(|param| match param.kind {
4487 ty::GenericParamDefKind::Type { .. } => true,
4490 for (&used, param) in types_used.iter().zip(types) {
4492 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4493 let span = tcx.hir().span(id);
4494 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4495 .span_label(span, "unused type parameter")
4501 fn fatally_break_rust(sess: &Session) {
4502 let handler = sess.diagnostic();
4503 handler.span_bug_no_panic(
4505 "It looks like you're trying to break rust; would you like some ICE?",
4507 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4508 handler.note_without_error(
4509 "we would appreciate a joke overview: \
4510 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4512 handler.note_without_error(&format!("rustc {} running on {}",
4513 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4514 crate::session::config::host_triple(),
4518 fn potentially_plural_count(count: usize, word: &str) -> String {
4519 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })