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 crate::middle::lang_items;
97 use crate::namespace::Namespace;
98 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
99 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
100 use rustc_data_structures::indexed_vec::Idx;
101 use rustc_target::spec::abi::Abi;
102 use rustc::infer::opaque_types::OpaqueTypeDecl;
103 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
104 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
105 use rustc::middle::region;
106 use rustc::mir::interpret::{ConstValue, GlobalId};
107 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
109 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
110 ToPolyTraitRef, ToPredicate, RegionKind, UserType
112 use rustc::ty::adjustment::{
113 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
115 use rustc::ty::fold::TypeFoldable;
116 use rustc::ty::query::Providers;
117 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
118 use rustc::ty::util::{Representability, IntTypeExt, Discr};
119 use rustc::ty::layout::VariantIdx;
120 use syntax_pos::{self, BytePos, Span, MultiSpan};
121 use syntax_pos::hygiene::CompilerDesugaringKind;
124 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(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>(tcx: TyCtxt<'tcx>) {
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>(tcx: TyCtxt<'tcx>, module_def_id: DefId) {
707 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
710 fn typeck_item_bodies<'tcx>(tcx: TyCtxt<'tcx>, 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>(tcx: TyCtxt<'tcx>, def_id: DefId) {
718 wfcheck::check_item_well_formed(tcx, def_id);
721 fn check_trait_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) {
722 wfcheck::check_trait_item(tcx, def_id);
725 fn check_impl_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, 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>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option<ty::Destructor> {
746 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
749 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
750 /// with information about it's body-id and fn-decl (if any). Otherwise,
753 /// If this function returns "some", then `typeck_tables(def_id)` will
754 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
755 /// may not succeed. In some cases where this function returns `None`
756 /// (notably closures), `typeck_tables(def_id)` would wind up
757 /// redirecting to the owning function.
758 fn primary_body_of<'tcx>(
761 ) -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)> {
762 match tcx.hir().get(id) {
763 Node::Item(item) => {
765 hir::ItemKind::Const(_, body) |
766 hir::ItemKind::Static(_, _, body) =>
768 hir::ItemKind::Fn(ref decl, .., body) =>
769 Some((body, Some(decl))),
774 Node::TraitItem(item) => {
776 hir::TraitItemKind::Const(_, Some(body)) =>
778 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
779 Some((body, Some(&sig.decl))),
784 Node::ImplItem(item) => {
786 hir::ImplItemKind::Const(_, body) =>
788 hir::ImplItemKind::Method(ref sig, body) =>
789 Some((body, Some(&sig.decl))),
794 Node::AnonConst(constant) => Some((constant.body, None)),
799 fn has_typeck_tables<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
800 // Closures' tables come from their outermost function,
801 // as they are part of the same "inference environment".
802 let outer_def_id = tcx.closure_base_def_id(def_id);
803 if outer_def_id != def_id {
804 return tcx.has_typeck_tables(outer_def_id);
807 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
808 primary_body_of(tcx, id).is_some()
811 fn used_trait_imports<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx DefIdSet {
812 &*tcx.typeck_tables_of(def_id).used_trait_imports
815 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::TypeckTables<'tcx> {
816 // Closures' tables come from their outermost function,
817 // as they are part of the same "inference environment".
818 let outer_def_id = tcx.closure_base_def_id(def_id);
819 if outer_def_id != def_id {
820 return tcx.typeck_tables_of(outer_def_id);
823 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
824 let span = tcx.hir().span(id);
826 // Figure out what primary body this item has.
827 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
828 span_bug!(span, "can't type-check body of {:?}", def_id);
830 let body = tcx.hir().body(body_id);
832 let tables = Inherited::build(tcx, def_id).enter(|inh| {
833 let param_env = tcx.param_env(def_id);
834 let fcx = if let Some(decl) = fn_decl {
835 let fn_sig = tcx.fn_sig(def_id);
837 check_abi(tcx, span, fn_sig.abi());
839 // Compute the fty from point of view of inside the fn.
841 tcx.liberate_late_bound_regions(def_id, &fn_sig);
843 inh.normalize_associated_types_in(body.value.span,
848 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
851 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
852 let expected_type = tcx.type_of(def_id);
853 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
854 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
856 let revealed_ty = if tcx.features().impl_trait_in_bindings {
857 fcx.instantiate_opaque_types_from_value(
865 // Gather locals in statics (because of block expressions).
866 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
868 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
870 fcx.write_ty(id, revealed_ty);
875 // All type checking constraints were added, try to fallback unsolved variables.
876 fcx.select_obligations_where_possible(false);
877 let mut fallback_has_occurred = false;
878 for ty in &fcx.unsolved_variables() {
879 fallback_has_occurred |= fcx.fallback_if_possible(ty);
881 fcx.select_obligations_where_possible(fallback_has_occurred);
883 // Even though coercion casts provide type hints, we check casts after fallback for
884 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
887 // Closure and generator analysis may run after fallback
888 // because they don't constrain other type variables.
889 fcx.closure_analyze(body);
890 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
891 fcx.resolve_generator_interiors(def_id);
893 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
894 let ty = fcx.normalize_ty(span, ty);
895 fcx.require_type_is_sized(ty, span, code);
897 fcx.select_all_obligations_or_error();
899 if fn_decl.is_some() {
900 fcx.regionck_fn(id, body);
902 fcx.regionck_expr(body);
905 fcx.resolve_type_vars_in_body(body)
908 // Consistency check our TypeckTables instance can hold all ItemLocalIds
909 // it will need to hold.
910 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
915 fn check_abi<'tcx>(tcx: TyCtxt<'tcx>, span: Span, abi: Abi) {
916 if !tcx.sess.target.target.is_abi_supported(abi) {
917 struct_span_err!(tcx.sess, span, E0570,
918 "The ABI `{}` is not supported for the current target", abi).emit()
922 struct GatherLocalsVisitor<'a, 'tcx> {
923 fcx: &'a FnCtxt<'a, 'tcx>,
924 parent_id: hir::HirId,
927 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
928 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
931 // infer the variable's type
932 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
933 kind: TypeVariableOriginKind::TypeInference,
936 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
943 // take type that the user specified
944 self.fcx.locals.borrow_mut().insert(nid, typ);
951 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
952 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
953 NestedVisitorMap::None
956 // Add explicitly-declared locals.
957 fn visit_local(&mut self, local: &'tcx hir::Local) {
958 let local_ty = match local.ty {
960 let o_ty = self.fcx.to_ty(&ty);
962 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
963 self.fcx.instantiate_opaque_types_from_value(
971 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
972 &UserType::Ty(revealed_ty)
974 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
975 ty.hir_id, o_ty, revealed_ty, c_ty);
976 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
978 Some(LocalTy { decl_ty: o_ty, revealed_ty })
982 self.assign(local.span, local.hir_id, local_ty);
984 debug!("Local variable {:?} is assigned type {}",
986 self.fcx.ty_to_string(
987 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
988 intravisit::walk_local(self, local);
991 // Add pattern bindings.
992 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
993 if let PatKind::Binding(_, _, ident, _) = p.node {
994 let var_ty = self.assign(p.span, p.hir_id, None);
996 if !self.fcx.tcx.features().unsized_locals {
997 self.fcx.require_type_is_sized(var_ty, p.span,
998 traits::VariableType(p.hir_id));
1001 debug!("Pattern binding {} is assigned to {} with type {:?}",
1003 self.fcx.ty_to_string(
1004 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1007 intravisit::walk_pat(self, p);
1010 // Don't descend into the bodies of nested closures
1013 _: intravisit::FnKind<'tcx>,
1014 _: &'tcx hir::FnDecl,
1021 /// When `check_fn` is invoked on a generator (i.e., a body that
1022 /// includes yield), it returns back some information about the yield
1024 struct GeneratorTypes<'tcx> {
1025 /// Type of value that is yielded.
1028 /// Types that are captured (see `GeneratorInterior` for more).
1031 /// Indicates if the generator is movable or static (immovable).
1032 movability: hir::GeneratorMovability,
1035 /// Helper used for fns and closures. Does the grungy work of checking a function
1036 /// body and returns the function context used for that purpose, since in the case of a fn item
1037 /// there is still a bit more to do.
1040 /// * inherited: other fields inherited from the enclosing fn (if any)
1041 fn check_fn<'a, 'tcx>(
1042 inherited: &'a Inherited<'a, 'tcx>,
1043 param_env: ty::ParamEnv<'tcx>,
1044 fn_sig: ty::FnSig<'tcx>,
1045 decl: &'tcx hir::FnDecl,
1047 body: &'tcx hir::Body,
1048 can_be_generator: Option<hir::GeneratorMovability>,
1049 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1050 let mut fn_sig = fn_sig.clone();
1052 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1054 // Create the function context. This is either derived from scratch or,
1055 // in the case of closures, based on the outer context.
1056 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1057 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1059 let declared_ret_ty = fn_sig.output();
1060 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1061 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1062 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1063 fn_sig = fcx.tcx.mk_fn_sig(
1064 fn_sig.inputs().iter().cloned(),
1071 let span = body.value.span;
1073 if body.generator_kind.is_some() && can_be_generator.is_some() {
1074 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1075 kind: TypeVariableOriginKind::TypeInference,
1078 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1079 fcx.yield_ty = Some(yield_ty);
1082 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1083 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1084 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1086 // Add formal parameters.
1087 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1088 // Check the pattern.
1089 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1090 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1092 // Check that argument is Sized.
1093 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1094 // for simple cases like `fn foo(x: Trait)`,
1095 // where we would error once on the parameter as a whole, and once on the binding `x`.
1096 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1097 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1100 fcx.write_ty(arg.hir_id, arg_ty);
1103 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1105 fcx.check_return_expr(&body.value);
1107 // We insert the deferred_generator_interiors entry after visiting the body.
1108 // This ensures that all nested generators appear before the entry of this generator.
1109 // resolve_generator_interiors relies on this property.
1110 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1111 let interior = fcx.next_ty_var(TypeVariableOrigin {
1112 kind: TypeVariableOriginKind::MiscVariable,
1115 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1116 Some(GeneratorTypes {
1117 yield_ty: fcx.yield_ty.unwrap(),
1119 movability: can_be_generator.unwrap(),
1125 // Finalize the return check by taking the LUB of the return types
1126 // we saw and assigning it to the expected return type. This isn't
1127 // really expected to fail, since the coercions would have failed
1128 // earlier when trying to find a LUB.
1130 // However, the behavior around `!` is sort of complex. In the
1131 // event that the `actual_return_ty` comes back as `!`, that
1132 // indicates that the fn either does not return or "returns" only
1133 // values of type `!`. In this case, if there is an expected
1134 // return type that is *not* `!`, that should be ok. But if the
1135 // return type is being inferred, we want to "fallback" to `!`:
1137 // let x = move || panic!();
1139 // To allow for that, I am creating a type variable with diverging
1140 // fallback. This was deemed ever so slightly better than unifying
1141 // the return value with `!` because it allows for the caller to
1142 // make more assumptions about the return type (e.g., they could do
1144 // let y: Option<u32> = Some(x());
1146 // which would then cause this return type to become `u32`, not
1148 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1149 let mut actual_return_ty = coercion.complete(&fcx);
1150 if actual_return_ty.is_never() {
1151 actual_return_ty = fcx.next_diverging_ty_var(
1152 TypeVariableOrigin {
1153 kind: TypeVariableOriginKind::DivergingFn,
1158 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1160 // Check that the main return type implements the termination trait.
1161 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1162 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1163 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1164 if main_id == fn_id {
1165 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1166 let trait_ref = ty::TraitRef::new(term_id, substs);
1167 let return_ty_span = decl.output.span();
1168 let cause = traits::ObligationCause::new(
1169 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1171 inherited.register_predicate(
1172 traits::Obligation::new(
1173 cause, param_env, trait_ref.to_predicate()));
1178 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1179 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1180 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1181 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1182 // at this point we don't care if there are duplicate handlers or if the handler has
1183 // the wrong signature as this value we'll be used when writing metadata and that
1184 // only happens if compilation succeeded
1185 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1187 if declared_ret_ty.sty != ty::Never {
1188 fcx.tcx.sess.span_err(
1190 "return type should be `!`",
1194 let inputs = fn_sig.inputs();
1195 let span = fcx.tcx.hir().span(fn_id);
1196 if inputs.len() == 1 {
1197 let arg_is_panic_info = match inputs[0].sty {
1198 ty::Ref(region, ty, mutbl) => match ty.sty {
1199 ty::Adt(ref adt, _) => {
1200 adt.did == panic_info_did &&
1201 mutbl == hir::Mutability::MutImmutable &&
1202 *region != RegionKind::ReStatic
1209 if !arg_is_panic_info {
1210 fcx.tcx.sess.span_err(
1211 decl.inputs[0].span,
1212 "argument should be `&PanicInfo`",
1216 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1217 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1218 if !generics.params.is_empty() {
1219 fcx.tcx.sess.span_err(
1221 "should have no type parameters",
1227 let span = fcx.tcx.sess.source_map().def_span(span);
1228 fcx.tcx.sess.span_err(span, "function should have one argument");
1231 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1236 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1237 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1238 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1239 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1240 if declared_ret_ty.sty != ty::Never {
1241 fcx.tcx.sess.span_err(
1243 "return type should be `!`",
1247 let inputs = fn_sig.inputs();
1248 let span = fcx.tcx.hir().span(fn_id);
1249 if inputs.len() == 1 {
1250 let arg_is_alloc_layout = match inputs[0].sty {
1251 ty::Adt(ref adt, _) => {
1252 adt.did == alloc_layout_did
1257 if !arg_is_alloc_layout {
1258 fcx.tcx.sess.span_err(
1259 decl.inputs[0].span,
1260 "argument should be `Layout`",
1264 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1265 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1266 if !generics.params.is_empty() {
1267 fcx.tcx.sess.span_err(
1269 "`#[alloc_error_handler]` function should have no type \
1276 let span = fcx.tcx.sess.source_map().def_span(span);
1277 fcx.tcx.sess.span_err(span, "function should have one argument");
1280 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1288 fn check_struct<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) {
1289 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1290 let def = tcx.adt_def(def_id);
1291 def.destructor(tcx); // force the destructor to be evaluated
1292 check_representable(tcx, span, def_id);
1294 if def.repr.simd() {
1295 check_simd(tcx, span, def_id);
1298 check_transparent(tcx, span, def_id);
1299 check_packed(tcx, span, def_id);
1302 fn check_union<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) {
1303 let def_id = tcx.hir().local_def_id_from_hir_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);
1307 check_transparent(tcx, span, def_id);
1308 check_packed(tcx, span, def_id);
1311 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1312 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1313 let mut err = struct_span_err!(
1314 tcx.sess, span, E0720,
1315 "opaque type expands to a recursive type",
1317 err.span_label(span, "expands to self-referential type");
1318 if let ty::Opaque(..) = partially_expanded_type.sty {
1319 err.note("type resolves to itself");
1321 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1327 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1329 "check_item_type(it.hir_id={}, it.name={})",
1331 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1333 let _indenter = indenter();
1335 // Consts can play a role in type-checking, so they are included here.
1336 hir::ItemKind::Static(..) => {
1337 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1338 tcx.typeck_tables_of(def_id);
1339 maybe_check_static_with_link_section(tcx, def_id, it.span);
1341 hir::ItemKind::Const(..) => {
1342 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1344 hir::ItemKind::Enum(ref enum_definition, _) => {
1345 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1347 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1348 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1349 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1350 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1351 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1352 check_impl_items_against_trait(
1359 let trait_def_id = impl_trait_ref.def_id;
1360 check_on_unimplemented(tcx, trait_def_id, it);
1363 hir::ItemKind::Trait(..) => {
1364 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1365 check_on_unimplemented(tcx, def_id, it);
1367 hir::ItemKind::Struct(..) => {
1368 check_struct(tcx, it.hir_id, it.span);
1370 hir::ItemKind::Union(..) => {
1371 check_union(tcx, it.hir_id, it.span);
1373 hir::ItemKind::Existential(..) => {
1374 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1376 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1377 check_opaque(tcx, def_id, substs, it.span);
1379 hir::ItemKind::Ty(..) => {
1380 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1381 let pty_ty = tcx.type_of(def_id);
1382 let generics = tcx.generics_of(def_id);
1383 check_bounds_are_used(tcx, &generics, pty_ty);
1385 hir::ItemKind::ForeignMod(ref m) => {
1386 check_abi(tcx, it.span, m.abi);
1388 if m.abi == Abi::RustIntrinsic {
1389 for item in &m.items {
1390 intrinsic::check_intrinsic_type(tcx, item);
1392 } else if m.abi == Abi::PlatformIntrinsic {
1393 for item in &m.items {
1394 intrinsic::check_platform_intrinsic_type(tcx, item);
1397 for item in &m.items {
1398 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1399 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1400 let mut err = struct_span_err!(
1404 "foreign items may not have type parameters"
1406 err.span_label(item.span, "can't have type parameters");
1407 // FIXME: once we start storing spans for type arguments, turn this into a
1410 "use specialization instead of type parameters by replacing them \
1411 with concrete types like `u32`",
1416 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1417 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1422 _ => { /* nothing to do */ }
1426 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1427 // Only restricted on wasm32 target for now
1428 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1432 // If `#[link_section]` is missing, then nothing to verify
1433 let attrs = tcx.codegen_fn_attrs(id);
1434 if attrs.link_section.is_none() {
1438 // For the wasm32 target statics with #[link_section] are placed into custom
1439 // sections of the final output file, but this isn't link custom sections of
1440 // other executable formats. Namely we can only embed a list of bytes,
1441 // nothing with pointers to anything else or relocations. If any relocation
1442 // show up, reject them here.
1443 let instance = ty::Instance::mono(tcx, id);
1444 let cid = GlobalId {
1448 let param_env = ty::ParamEnv::reveal_all();
1449 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1450 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1453 bug!("Matching on non-ByRef static")
1455 if alloc.relocations.len() != 0 {
1456 let msg = "statics with a custom `#[link_section]` must be a \
1457 simple list of bytes on the wasm target with no \
1458 extra levels of indirection such as references";
1459 tcx.sess.span_err(span, msg);
1464 fn check_on_unimplemented<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId, item: &hir::Item) {
1465 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1466 // an error would be reported if this fails.
1467 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1470 fn report_forbidden_specialization<'tcx>(
1472 impl_item: &hir::ImplItem,
1475 let mut err = struct_span_err!(
1476 tcx.sess, impl_item.span, E0520,
1477 "`{}` specializes an item from a parent `impl`, but \
1478 that item is not marked `default`",
1480 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1483 match tcx.span_of_impl(parent_impl) {
1485 err.span_label(span, "parent `impl` is here");
1486 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1490 err.note(&format!("parent implementation is in crate `{}`", cname));
1497 fn check_specialization_validity<'tcx>(
1499 trait_def: &ty::TraitDef,
1500 trait_item: &ty::AssocItem,
1502 impl_item: &hir::ImplItem,
1504 let ancestors = trait_def.ancestors(tcx, impl_id);
1506 let kind = match impl_item.node {
1507 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1508 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1509 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1510 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1513 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1514 .map(|node_item| node_item.map(|parent| parent.defaultness));
1516 if let Some(parent) = parent {
1517 if tcx.impl_item_is_final(&parent) {
1518 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1524 fn check_impl_items_against_trait<'tcx>(
1528 impl_trait_ref: ty::TraitRef<'tcx>,
1529 impl_item_refs: &[hir::ImplItemRef],
1531 let impl_span = tcx.sess.source_map().def_span(impl_span);
1533 // If the trait reference itself is erroneous (so the compilation is going
1534 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1535 // isn't populated for such impls.
1536 if impl_trait_ref.references_error() { return; }
1538 // Locate trait definition and items
1539 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1540 let mut overridden_associated_type = None;
1542 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1544 // Check existing impl methods to see if they are both present in trait
1545 // and compatible with trait signature
1546 for impl_item in impl_items() {
1547 let ty_impl_item = tcx.associated_item(
1548 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1549 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1550 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1551 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1553 // Not compatible, but needed for the error message
1554 tcx.associated_items(impl_trait_ref.def_id)
1555 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1558 // Check that impl definition matches trait definition
1559 if let Some(ty_trait_item) = ty_trait_item {
1560 match impl_item.node {
1561 hir::ImplItemKind::Const(..) => {
1562 // Find associated const definition.
1563 if ty_trait_item.kind == ty::AssocKind::Const {
1564 compare_const_impl(tcx,
1570 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1571 "item `{}` is an associated const, \
1572 which doesn't match its trait `{}`",
1575 err.span_label(impl_item.span, "does not match trait");
1576 // We can only get the spans from local trait definition
1577 // Same for E0324 and E0325
1578 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1579 err.span_label(trait_span, "item in trait");
1584 hir::ImplItemKind::Method(..) => {
1585 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1586 if ty_trait_item.kind == ty::AssocKind::Method {
1587 compare_impl_method(tcx,
1594 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1595 "item `{}` is an associated method, \
1596 which doesn't match its trait `{}`",
1599 err.span_label(impl_item.span, "does not match trait");
1600 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1601 err.span_label(trait_span, "item in trait");
1606 hir::ImplItemKind::Existential(..) |
1607 hir::ImplItemKind::Type(_) => {
1608 if ty_trait_item.kind == ty::AssocKind::Type {
1609 if ty_trait_item.defaultness.has_value() {
1610 overridden_associated_type = Some(impl_item);
1613 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1614 "item `{}` is an associated type, \
1615 which doesn't match its trait `{}`",
1618 err.span_label(impl_item.span, "does not match trait");
1619 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1620 err.span_label(trait_span, "item in trait");
1627 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1631 // Check for missing items from trait
1632 let mut missing_items = Vec::new();
1633 let mut invalidated_items = Vec::new();
1634 let associated_type_overridden = overridden_associated_type.is_some();
1635 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1636 let is_implemented = trait_def.ancestors(tcx, impl_id)
1637 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1639 .map(|node_item| !node_item.node.is_from_trait())
1642 if !is_implemented && !tcx.impl_is_default(impl_id) {
1643 if !trait_item.defaultness.has_value() {
1644 missing_items.push(trait_item);
1645 } else if associated_type_overridden {
1646 invalidated_items.push(trait_item.ident);
1651 if !missing_items.is_empty() {
1652 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1653 "not all trait items implemented, missing: `{}`",
1654 missing_items.iter()
1655 .map(|trait_item| trait_item.ident.to_string())
1656 .collect::<Vec<_>>().join("`, `"));
1657 err.span_label(impl_span, format!("missing `{}` in implementation",
1658 missing_items.iter()
1659 .map(|trait_item| trait_item.ident.to_string())
1660 .collect::<Vec<_>>().join("`, `")));
1661 for trait_item in missing_items {
1662 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1663 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1665 err.note_trait_signature(trait_item.ident.to_string(),
1666 trait_item.signature(tcx));
1672 if !invalidated_items.is_empty() {
1673 let invalidator = overridden_associated_type.unwrap();
1674 span_err!(tcx.sess, invalidator.span, E0399,
1675 "the following trait items need to be reimplemented \
1676 as `{}` was overridden: `{}`",
1678 invalidated_items.iter()
1679 .map(|name| name.to_string())
1680 .collect::<Vec<_>>().join("`, `"))
1684 /// Checks whether a type can be represented in memory. In particular, it
1685 /// identifies types that contain themselves without indirection through a
1686 /// pointer, which would mean their size is unbounded.
1687 fn check_representable<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, item_def_id: DefId) -> bool {
1688 let rty = tcx.type_of(item_def_id);
1690 // Check that it is possible to represent this type. This call identifies
1691 // (1) types that contain themselves and (2) types that contain a different
1692 // recursive type. It is only necessary to throw an error on those that
1693 // contain themselves. For case 2, there must be an inner type that will be
1694 // caught by case 1.
1695 match rty.is_representable(tcx, sp) {
1696 Representability::SelfRecursive(spans) => {
1697 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1699 err.span_label(span, "recursive without indirection");
1704 Representability::Representable | Representability::ContainsRecursive => (),
1709 pub fn check_simd<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) {
1710 let t = tcx.type_of(def_id);
1711 if let ty::Adt(def, substs) = t.sty {
1712 if def.is_struct() {
1713 let fields = &def.non_enum_variant().fields;
1714 if fields.is_empty() {
1715 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1718 let e = fields[0].ty(tcx, substs);
1719 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1720 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1721 .span_label(sp, "SIMD elements must have the same type")
1726 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1727 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1729 span_err!(tcx.sess, sp, E0077,
1730 "SIMD vector element type should be machine type");
1738 fn check_packed<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) {
1739 let repr = tcx.adt_def(def_id).repr;
1741 for attr in tcx.get_attrs(def_id).iter() {
1742 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1743 if let attr::ReprPacked(pack) = r {
1744 if pack != repr.pack {
1745 struct_span_err!(tcx.sess, sp, E0634,
1746 "type has conflicting packed representation hints").emit();
1752 struct_span_err!(tcx.sess, sp, E0587,
1753 "type has conflicting packed and align representation hints").emit();
1755 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1756 struct_span_err!(tcx.sess, sp, E0588,
1757 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1762 fn check_packed_inner<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1763 let t = tcx.type_of(def_id);
1764 if stack.contains(&def_id) {
1765 debug!("check_packed_inner: {:?} is recursive", t);
1768 if let ty::Adt(def, substs) = t.sty {
1769 if def.is_struct() || def.is_union() {
1770 if tcx.adt_def(def.did).repr.align > 0 {
1773 // push struct def_id before checking fields
1775 for field in &def.non_enum_variant().fields {
1776 let f = field.ty(tcx, substs);
1777 if let ty::Adt(def, _) = f.sty {
1778 if check_packed_inner(tcx, def.did, stack) {
1783 // only need to pop if not early out
1790 /// Emit an error when encountering more or less than one variant in a transparent enum.
1791 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1792 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1793 tcx.hir().span_if_local(variant.def_id).unwrap()
1796 "needs exactly one variant, but has {}",
1799 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1800 err.span_label(sp, &msg);
1801 if let &[ref start.., ref end] = &variant_spans[..] {
1802 for variant_span in start {
1803 err.span_label(*variant_span, "");
1805 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1810 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1812 fn bad_non_zero_sized_fields<'tcx>(
1814 adt: &'tcx ty::AdtDef,
1816 field_spans: impl Iterator<Item = Span>,
1819 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1820 let mut err = struct_span_err!(
1824 "{}transparent {} {}",
1825 if adt.is_enum() { "the variant of a " } else { "" },
1829 err.span_label(sp, &msg);
1830 for sp in field_spans {
1831 err.span_label(sp, "this field is non-zero-sized");
1836 fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) {
1837 let adt = tcx.adt_def(def_id);
1838 if !adt.repr.transparent() {
1841 let sp = tcx.sess.source_map().def_span(sp);
1844 if !tcx.features().transparent_enums {
1846 &tcx.sess.parse_sess,
1847 sym::transparent_enums,
1849 GateIssue::Language,
1850 "transparent enums are unstable",
1853 if adt.variants.len() != 1 {
1854 bad_variant_count(tcx, adt, sp, def_id);
1855 if adt.variants.is_empty() {
1856 // Don't bother checking the fields. No variants (and thus no fields) exist.
1862 if adt.is_union() && !tcx.features().transparent_unions {
1863 emit_feature_err(&tcx.sess.parse_sess,
1864 sym::transparent_unions,
1866 GateIssue::Language,
1867 "transparent unions are unstable");
1870 // For each field, figure out if it's known to be a ZST and align(1)
1871 let field_infos = adt.all_fields().map(|field| {
1872 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1873 let param_env = tcx.param_env(field.did);
1874 let layout = tcx.layout_of(param_env.and(ty));
1875 // We are currently checking the type this field came from, so it must be local
1876 let span = tcx.hir().span_if_local(field.did).unwrap();
1877 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1878 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1882 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
1887 let non_zst_count = non_zst_fields.clone().count();
1888 if non_zst_count != 1 {
1889 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
1891 for (span, zst, align1) in field_infos {
1897 "zero-sized field in transparent {} has alignment larger than 1",
1899 ).span_label(span, "has alignment larger than 1").emit();
1904 #[allow(trivial_numeric_casts)]
1905 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
1906 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1907 let def = tcx.adt_def(def_id);
1908 def.destructor(tcx); // force the destructor to be evaluated
1911 let attributes = tcx.get_attrs(def_id);
1912 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1914 tcx.sess, attr.span, E0084,
1915 "unsupported representation for zero-variant enum")
1916 .span_label(sp, "zero-variant enum")
1921 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1922 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1923 if !tcx.features().repr128 {
1924 emit_feature_err(&tcx.sess.parse_sess,
1927 GateIssue::Language,
1928 "repr with 128-bit type is unstable");
1933 if let Some(ref e) = v.node.disr_expr {
1934 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1938 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
1940 |var: &hir::Variant| match var.node.data {
1941 hir::VariantData::Unit(..) => true,
1945 let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some();
1946 let has_non_units = vs.iter().any(|var| !is_unit(var));
1947 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
1948 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
1950 if disr_non_unit || (disr_units && has_non_units) {
1951 let mut err = struct_span_err!(tcx.sess, sp, E0732,
1952 "`#[repr(inttype)]` must be specified");
1957 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1958 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1959 // Check for duplicate discriminant values
1960 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1961 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1962 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1963 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1964 let i_span = match variant_i.node.disr_expr {
1965 Some(ref expr) => tcx.hir().span(expr.hir_id),
1966 None => tcx.hir().span(variant_i_hir_id)
1968 let span = match v.node.disr_expr {
1969 Some(ref expr) => tcx.hir().span(expr.hir_id),
1972 struct_span_err!(tcx.sess, span, E0081,
1973 "discriminant value `{}` already exists", disr_vals[i])
1974 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1975 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1978 disr_vals.push(discr);
1981 check_representable(tcx, sp, def_id);
1982 check_transparent(tcx, sp, def_id);
1985 fn report_unexpected_variant_res<'tcx>(tcx: TyCtxt<'tcx>, res: Res, span: Span, qpath: &QPath) {
1986 span_err!(tcx.sess, span, E0533,
1987 "expected unit struct/variant or constant, found {} `{}`",
1989 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1992 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
1993 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
1997 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1998 -> &'tcx ty::GenericPredicates<'tcx>
2001 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2002 let item_id = tcx.hir().ty_param_owner(hir_id);
2003 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
2004 let generics = tcx.generics_of(item_def_id);
2005 let index = generics.param_def_id_to_index[&def_id];
2006 tcx.arena.alloc(ty::GenericPredicates {
2008 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2010 ty::Predicate::Trait(ref data)
2011 if data.skip_binder().self_ty().is_param(index) => {
2012 // HACK(eddyb) should get the original `Span`.
2013 let span = tcx.def_span(def_id);
2014 Some((predicate, span))
2024 def: Option<&ty::GenericParamDef>,
2026 ) -> Option<ty::Region<'tcx>> {
2028 Some(def) => infer::EarlyBoundRegion(span, def.name),
2029 None => infer::MiscVariable(span)
2031 Some(self.next_region_var(v))
2034 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2035 if let Some(param) = param {
2036 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2041 self.next_ty_var(TypeVariableOrigin {
2042 kind: TypeVariableOriginKind::TypeInference,
2051 param: Option<&ty::GenericParamDef>,
2053 ) -> &'tcx Const<'tcx> {
2054 if let Some(param) = param {
2055 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2060 self.next_const_var(ty, ConstVariableOrigin {
2061 kind: ConstVariableOriginKind::ConstInference,
2067 fn projected_ty_from_poly_trait_ref(&self,
2070 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2073 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2075 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2079 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2082 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2083 if ty.has_escaping_bound_vars() {
2084 ty // FIXME: normalization and escaping regions
2086 self.normalize_associated_types_in(span, &ty)
2090 fn set_tainted_by_errors(&self) {
2091 self.infcx.set_tainted_by_errors()
2094 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2095 self.write_ty(hir_id, ty)
2099 /// Controls whether the arguments are tupled. This is used for the call
2102 /// Tupling means that all call-side arguments are packed into a tuple and
2103 /// passed as a single parameter. For example, if tupling is enabled, this
2106 /// fn f(x: (isize, isize))
2108 /// Can be called as:
2115 #[derive(Clone, Eq, PartialEq)]
2116 enum TupleArgumentsFlag {
2121 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2123 inh: &'a Inherited<'a, 'tcx>,
2124 param_env: ty::ParamEnv<'tcx>,
2125 body_id: hir::HirId,
2126 ) -> FnCtxt<'a, 'tcx> {
2130 err_count_on_creation: inh.tcx.sess.err_count(),
2132 ret_coercion_span: RefCell::new(None),
2134 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2135 hir::CRATE_HIR_ID)),
2136 diverges: Cell::new(Diverges::Maybe),
2137 has_errors: Cell::new(false),
2138 enclosing_breakables: RefCell::new(EnclosingBreakables {
2140 by_id: Default::default(),
2146 pub fn sess(&self) -> &Session {
2150 pub fn errors_reported_since_creation(&self) -> bool {
2151 self.tcx.sess.err_count() > self.err_count_on_creation
2154 /// Produces warning on the given node, if the current point in the
2155 /// function is unreachable, and there hasn't been another warning.
2156 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2157 if self.diverges.get() == Diverges::Always &&
2158 // If span arose from a desugaring of `if` then it is the condition itself,
2159 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2160 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2161 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2162 self.diverges.set(Diverges::WarnedAlways);
2164 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2166 let msg = format!("unreachable {}", kind);
2167 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2173 code: ObligationCauseCode<'tcx>)
2174 -> ObligationCause<'tcx> {
2175 ObligationCause::new(span, self.body_id, code)
2178 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2179 self.cause(span, ObligationCauseCode::MiscObligation)
2182 /// Resolves type variables in `ty` if possible. Unlike the infcx
2183 /// version (resolve_vars_if_possible), this version will
2184 /// also select obligations if it seems useful, in an effort
2185 /// to get more type information.
2186 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2187 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2189 // No Infer()? Nothing needs doing.
2190 if !ty.has_infer_types() {
2191 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2195 // If `ty` is a type variable, see whether we already know what it is.
2196 ty = self.resolve_vars_if_possible(&ty);
2197 if !ty.has_infer_types() {
2198 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2202 // If not, try resolving pending obligations as much as
2203 // possible. This can help substantially when there are
2204 // indirect dependencies that don't seem worth tracking
2206 self.select_obligations_where_possible(false);
2207 ty = self.resolve_vars_if_possible(&ty);
2209 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2213 fn record_deferred_call_resolution(
2215 closure_def_id: DefId,
2216 r: DeferredCallResolution<'tcx>,
2218 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2219 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2222 fn remove_deferred_call_resolutions(
2224 closure_def_id: DefId,
2225 ) -> Vec<DeferredCallResolution<'tcx>> {
2226 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2227 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2230 pub fn tag(&self) -> String {
2231 format!("{:p}", self)
2234 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2235 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2236 span_bug!(span, "no type for local variable {}",
2237 self.tcx.hir().node_to_string(nid))
2242 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2243 debug!("write_ty({:?}, {:?}) in fcx {}",
2244 id, self.resolve_vars_if_possible(&ty), self.tag());
2245 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2247 if ty.references_error() {
2248 self.has_errors.set(true);
2249 self.set_tainted_by_errors();
2253 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2254 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2257 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2258 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2261 pub fn write_method_call(&self,
2263 method: MethodCallee<'tcx>) {
2264 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2265 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2266 self.write_substs(hir_id, method.substs);
2268 // When the method is confirmed, the `method.substs` includes
2269 // parameters from not just the method, but also the impl of
2270 // the method -- in particular, the `Self` type will be fully
2271 // resolved. However, those are not something that the "user
2272 // specified" -- i.e., those types come from the inferred type
2273 // of the receiver, not something the user wrote. So when we
2274 // create the user-substs, we want to replace those earlier
2275 // types with just the types that the user actually wrote --
2276 // that is, those that appear on the *method itself*.
2278 // As an example, if the user wrote something like
2279 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2280 // type of `foo` (possibly adjusted), but we don't want to
2281 // include that. We want just the `[_, u32]` part.
2282 if !method.substs.is_noop() {
2283 let method_generics = self.tcx.generics_of(method.def_id);
2284 if !method_generics.params.is_empty() {
2285 let user_type_annotation = self.infcx.probe(|_| {
2286 let user_substs = UserSubsts {
2287 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2288 let i = param.index as usize;
2289 if i < method_generics.parent_count {
2290 self.infcx.var_for_def(DUMMY_SP, param)
2295 user_self_ty: None, // not relevant here
2298 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2304 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2305 self.write_user_type_annotation(hir_id, user_type_annotation);
2310 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2311 if !substs.is_noop() {
2312 debug!("write_substs({:?}, {:?}) in fcx {}",
2317 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2321 /// Given the substs that we just converted from the HIR, try to
2322 /// canonicalize them and store them as user-given substitutions
2323 /// (i.e., substitutions that must be respected by the NLL check).
2325 /// This should be invoked **before any unifications have
2326 /// occurred**, so that annotations like `Vec<_>` are preserved
2328 pub fn write_user_type_annotation_from_substs(
2332 substs: SubstsRef<'tcx>,
2333 user_self_ty: Option<UserSelfTy<'tcx>>,
2336 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2337 user_self_ty={:?} in fcx {}",
2338 hir_id, def_id, substs, user_self_ty, self.tag(),
2341 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2342 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2343 &UserType::TypeOf(def_id, UserSubsts {
2348 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2349 self.write_user_type_annotation(hir_id, canonicalized);
2353 pub fn write_user_type_annotation(
2356 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2359 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2360 hir_id, canonical_user_type_annotation, self.tag(),
2363 if !canonical_user_type_annotation.is_identity() {
2364 self.tables.borrow_mut().user_provided_types_mut().insert(
2365 hir_id, canonical_user_type_annotation
2368 debug!("write_user_type_annotation: skipping identity substs");
2372 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2373 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2379 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2380 Entry::Vacant(entry) => { entry.insert(adj); },
2381 Entry::Occupied(mut entry) => {
2382 debug!(" - composing on top of {:?}", entry.get());
2383 match (&entry.get()[..], &adj[..]) {
2384 // Applying any adjustment on top of a NeverToAny
2385 // is a valid NeverToAny adjustment, because it can't
2387 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2389 Adjustment { kind: Adjust::Deref(_), .. },
2390 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2392 Adjustment { kind: Adjust::Deref(_), .. },
2393 .. // Any following adjustments are allowed.
2395 // A reborrow has no effect before a dereference.
2397 // FIXME: currently we never try to compose autoderefs
2398 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2400 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2401 expr, entry.get(), adj)
2403 *entry.get_mut() = adj;
2408 /// Basically whenever we are converting from a type scheme into
2409 /// the fn body space, we always want to normalize associated
2410 /// types as well. This function combines the two.
2411 fn instantiate_type_scheme<T>(&self,
2413 substs: SubstsRef<'tcx>,
2416 where T : TypeFoldable<'tcx>
2418 let value = value.subst(self.tcx, substs);
2419 let result = self.normalize_associated_types_in(span, &value);
2420 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2427 /// As `instantiate_type_scheme`, but for the bounds found in a
2428 /// generic type scheme.
2429 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2430 -> ty::InstantiatedPredicates<'tcx> {
2431 let bounds = self.tcx.predicates_of(def_id);
2432 let result = bounds.instantiate(self.tcx, substs);
2433 let result = self.normalize_associated_types_in(span, &result);
2434 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2441 /// Replaces the opaque types from the given value with type variables,
2442 /// and records the `OpaqueTypeMap` for later use during writeback. See
2443 /// `InferCtxt::instantiate_opaque_types` for more details.
2444 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2446 parent_id: hir::HirId,
2449 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2450 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2454 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2455 self.instantiate_opaque_types(
2463 let mut opaque_types = self.opaque_types.borrow_mut();
2464 for (ty, decl) in opaque_type_map {
2465 let old_value = opaque_types.insert(ty, decl);
2466 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2472 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2473 where T : TypeFoldable<'tcx>
2475 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2478 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2480 where T : TypeFoldable<'tcx>
2482 self.inh.partially_normalize_associated_types_in(span,
2488 pub fn require_type_meets(&self,
2491 code: traits::ObligationCauseCode<'tcx>,
2494 self.register_bound(
2497 traits::ObligationCause::new(span, self.body_id, code));
2500 pub fn require_type_is_sized(&self,
2503 code: traits::ObligationCauseCode<'tcx>)
2505 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2506 self.require_type_meets(ty, span, code, lang_item);
2509 pub fn require_type_is_sized_deferred(&self,
2512 code: traits::ObligationCauseCode<'tcx>)
2514 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2517 pub fn register_bound(&self,
2520 cause: traits::ObligationCause<'tcx>)
2522 self.fulfillment_cx.borrow_mut()
2523 .register_bound(self, self.param_env, ty, def_id, cause);
2526 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2527 let t = AstConv::ast_ty_to_ty(self, ast_t);
2528 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2532 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2533 let ty = self.to_ty(ast_ty);
2534 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2536 if Self::can_contain_user_lifetime_bounds(ty) {
2537 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2538 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2539 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2545 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2546 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2547 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2550 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2551 AstConv::ast_const_to_const(self, ast_c, ty)
2554 // If the type given by the user has free regions, save it for later, since
2555 // NLL would like to enforce those. Also pass in types that involve
2556 // projections, since those can resolve to `'static` bounds (modulo #54940,
2557 // which hopefully will be fixed by the time you see this comment, dear
2558 // reader, although I have my doubts). Also pass in types with inference
2559 // types, because they may be repeated. Other sorts of things are already
2560 // sufficiently enforced with erased regions. =)
2561 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2563 T: TypeFoldable<'tcx>
2565 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2568 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2569 match self.tables.borrow().node_types().get(id) {
2571 None if self.is_tainted_by_errors() => self.tcx.types.err,
2573 bug!("no type for node {}: {} in fcx {}",
2574 id, self.tcx.hir().node_to_string(id),
2580 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2581 /// outlive the region `r`.
2582 pub fn register_wf_obligation(&self,
2585 code: traits::ObligationCauseCode<'tcx>)
2587 // WF obligations never themselves fail, so no real need to give a detailed cause:
2588 let cause = traits::ObligationCause::new(span, self.body_id, code);
2589 self.register_predicate(traits::Obligation::new(cause,
2591 ty::Predicate::WellFormed(ty)));
2594 /// Registers obligations that all types appearing in `substs` are well-formed.
2595 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2596 for ty in substs.types() {
2597 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2601 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2602 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2603 /// trait/region obligations.
2605 /// For example, if there is a function:
2608 /// fn foo<'a,T:'a>(...)
2611 /// and a reference:
2617 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2618 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2619 pub fn add_obligations_for_parameters(&self,
2620 cause: traits::ObligationCause<'tcx>,
2621 predicates: &ty::InstantiatedPredicates<'tcx>)
2623 assert!(!predicates.has_escaping_bound_vars());
2625 debug!("add_obligations_for_parameters(predicates={:?})",
2628 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2629 self.register_predicate(obligation);
2633 // FIXME(arielb1): use this instead of field.ty everywhere
2634 // Only for fields! Returns <none> for methods>
2635 // Indifferent to privacy flags
2636 pub fn field_ty(&self,
2638 field: &'tcx ty::FieldDef,
2639 substs: SubstsRef<'tcx>)
2642 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2645 fn check_casts(&self) {
2646 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2647 for cast in deferred_cast_checks.drain(..) {
2652 fn resolve_generator_interiors(&self, def_id: DefId) {
2653 let mut generators = self.deferred_generator_interiors.borrow_mut();
2654 for (body_id, interior, kind) in generators.drain(..) {
2655 self.select_obligations_where_possible(false);
2656 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2660 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2661 // Non-numerics get replaced with ! or () (depending on whether
2662 // feature(never_type) is enabled, unconstrained ints with i32,
2663 // unconstrained floats with f64.
2664 // Fallback becomes very dubious if we have encountered type-checking errors.
2665 // In that case, fallback to Error.
2666 // The return value indicates whether fallback has occurred.
2667 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2668 use rustc::ty::error::UnconstrainedNumeric::Neither;
2669 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2671 assert!(ty.is_ty_infer());
2672 let fallback = match self.type_is_unconstrained_numeric(ty) {
2673 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2674 UnconstrainedInt => self.tcx.types.i32,
2675 UnconstrainedFloat => self.tcx.types.f64,
2676 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2677 Neither => return false,
2679 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2680 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2684 fn select_all_obligations_or_error(&self) {
2685 debug!("select_all_obligations_or_error");
2686 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2687 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2691 /// Select as many obligations as we can at present.
2692 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2693 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2694 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2698 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2699 /// returns a type of `&T`, but the actual type we assign to the
2700 /// *expression* is `T`. So this function just peels off the return
2701 /// type by one layer to yield `T`.
2702 fn make_overloaded_place_return_type(&self,
2703 method: MethodCallee<'tcx>)
2704 -> ty::TypeAndMut<'tcx>
2706 // extract method return type, which will be &T;
2707 let ret_ty = method.sig.output();
2709 // method returns &T, but the type as visible to user is T, so deref
2710 ret_ty.builtin_deref(true).unwrap()
2716 base_expr: &'tcx hir::Expr,
2720 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2721 // FIXME(#18741) -- this is almost but not quite the same as the
2722 // autoderef that normal method probing does. They could likely be
2725 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2726 let mut result = None;
2727 while result.is_none() && autoderef.next().is_some() {
2728 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2730 autoderef.finalize(self);
2734 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2735 /// (and otherwise adjust) `base_expr`, looking for a type which either
2736 /// supports builtin indexing or overloaded indexing.
2737 /// This loop implements one step in that search; the autoderef loop
2738 /// is implemented by `lookup_indexing`.
2742 base_expr: &hir::Expr,
2743 autoderef: &Autoderef<'a, 'tcx>,
2746 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2747 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2748 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2755 for &unsize in &[false, true] {
2756 let mut self_ty = adjusted_ty;
2758 // We only unsize arrays here.
2759 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2760 self_ty = self.tcx.mk_slice(element_ty);
2766 // If some lookup succeeds, write callee into table and extract index/element
2767 // type from the method signature.
2768 // If some lookup succeeded, install method in table
2769 let input_ty = self.next_ty_var(TypeVariableOrigin {
2770 kind: TypeVariableOriginKind::AutoDeref,
2771 span: base_expr.span,
2773 let method = self.try_overloaded_place_op(
2774 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2776 let result = method.map(|ok| {
2777 debug!("try_index_step: success, using overloaded indexing");
2778 let method = self.register_infer_ok_obligations(ok);
2780 let mut adjustments = autoderef.adjust_steps(self, needs);
2781 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2782 let mutbl = match r_mutbl {
2783 hir::MutImmutable => AutoBorrowMutability::Immutable,
2784 hir::MutMutable => AutoBorrowMutability::Mutable {
2785 // Indexing can be desugared to a method call,
2786 // so maybe we could use two-phase here.
2787 // See the documentation of AllowTwoPhase for why that's
2788 // not the case today.
2789 allow_two_phase_borrow: AllowTwoPhase::No,
2792 adjustments.push(Adjustment {
2793 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2794 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2801 adjustments.push(Adjustment {
2802 kind: Adjust::Pointer(PointerCast::Unsize),
2803 target: method.sig.inputs()[0]
2806 self.apply_adjustments(base_expr, adjustments);
2808 self.write_method_call(expr.hir_id, method);
2809 (input_ty, self.make_overloaded_place_return_type(method).ty)
2811 if result.is_some() {
2819 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2820 let (tr, name) = match (op, is_mut) {
2821 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2822 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2823 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2824 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2826 (tr, ast::Ident::with_empty_ctxt(name))
2829 fn try_overloaded_place_op(&self,
2832 arg_tys: &[Ty<'tcx>],
2835 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2837 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2843 // Try Mut first, if needed.
2844 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2845 let method = match (needs, mut_tr) {
2846 (Needs::MutPlace, Some(trait_did)) => {
2847 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2852 // Otherwise, fall back to the immutable version.
2853 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2854 let method = match (method, imm_tr) {
2855 (None, Some(trait_did)) => {
2856 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2858 (method, _) => method,
2864 fn check_method_argument_types(
2868 method: Result<MethodCallee<'tcx>, ()>,
2869 args_no_rcvr: &'tcx [hir::Expr],
2870 tuple_arguments: TupleArgumentsFlag,
2871 expected: Expectation<'tcx>,
2873 let has_error = match method {
2875 method.substs.references_error() || method.sig.references_error()
2880 let err_inputs = self.err_args(args_no_rcvr.len());
2882 let err_inputs = match tuple_arguments {
2883 DontTupleArguments => err_inputs,
2884 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2887 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2888 false, tuple_arguments, None);
2889 return self.tcx.types.err;
2892 let method = method.unwrap();
2893 // HACK(eddyb) ignore self in the definition (see above).
2894 let expected_arg_tys = self.expected_inputs_for_expected_output(
2897 method.sig.output(),
2898 &method.sig.inputs()[1..]
2900 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2901 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2902 self.tcx.hir().span_if_local(method.def_id));
2906 fn self_type_matches_expected_vid(
2908 trait_ref: ty::PolyTraitRef<'tcx>,
2909 expected_vid: ty::TyVid,
2911 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2913 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2914 trait_ref, self_ty, expected_vid
2917 ty::Infer(ty::TyVar(found_vid)) => {
2918 // FIXME: consider using `sub_root_var` here so we
2919 // can see through subtyping.
2920 let found_vid = self.root_var(found_vid);
2921 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2922 expected_vid == found_vid
2928 fn obligations_for_self_ty<'b>(
2931 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2934 // FIXME: consider using `sub_root_var` here so we
2935 // can see through subtyping.
2936 let ty_var_root = self.root_var(self_ty);
2937 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2938 self_ty, ty_var_root,
2939 self.fulfillment_cx.borrow().pending_obligations());
2943 .pending_obligations()
2945 .filter_map(move |obligation| match obligation.predicate {
2946 ty::Predicate::Projection(ref data) =>
2947 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2948 ty::Predicate::Trait(ref data) =>
2949 Some((data.to_poly_trait_ref(), obligation)),
2950 ty::Predicate::Subtype(..) => None,
2951 ty::Predicate::RegionOutlives(..) => None,
2952 ty::Predicate::TypeOutlives(..) => None,
2953 ty::Predicate::WellFormed(..) => None,
2954 ty::Predicate::ObjectSafe(..) => None,
2955 ty::Predicate::ConstEvaluatable(..) => None,
2956 // N.B., this predicate is created by breaking down a
2957 // `ClosureType: FnFoo()` predicate, where
2958 // `ClosureType` represents some `Closure`. It can't
2959 // possibly be referring to the current closure,
2960 // because we haven't produced the `Closure` for
2961 // this closure yet; this is exactly why the other
2962 // code is looking for a self type of a unresolved
2963 // inference variable.
2964 ty::Predicate::ClosureKind(..) => None,
2965 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2968 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2969 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2970 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2974 /// Generic function that factors out common logic from function calls,
2975 /// method calls and overloaded operators.
2976 fn check_argument_types(
2980 fn_inputs: &[Ty<'tcx>],
2981 expected_arg_tys: &[Ty<'tcx>],
2982 args: &'tcx [hir::Expr],
2984 tuple_arguments: TupleArgumentsFlag,
2985 def_span: Option<Span>,
2989 // Grab the argument types, supplying fresh type variables
2990 // if the wrong number of arguments were supplied
2991 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2997 // All the input types from the fn signature must outlive the call
2998 // so as to validate implied bounds.
2999 for &fn_input_ty in fn_inputs {
3000 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
3003 let expected_arg_count = fn_inputs.len();
3005 let param_count_error = |expected_count: usize,
3010 let mut err = tcx.sess.struct_span_err_with_code(sp,
3011 &format!("this function takes {}{} but {} {} supplied",
3012 if c_variadic { "at least " } else { "" },
3013 potentially_plural_count(expected_count, "parameter"),
3014 potentially_plural_count(arg_count, "parameter"),
3015 if arg_count == 1 {"was"} else {"were"}),
3016 DiagnosticId::Error(error_code.to_owned()));
3018 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3019 err.span_label(def_s, "defined here");
3022 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3023 // remove closing `)` from the span
3024 let sugg_span = sugg_span.shrink_to_lo();
3025 err.span_suggestion(
3027 "expected the unit value `()`; create it with empty parentheses",
3029 Applicability::MachineApplicable);
3031 err.span_label(sp, format!("expected {}{}",
3032 if c_variadic { "at least " } else { "" },
3033 potentially_plural_count(expected_count, "parameter")));
3038 let mut expected_arg_tys = expected_arg_tys.to_vec();
3040 let formal_tys = if tuple_arguments == TupleArguments {
3041 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3042 match tuple_type.sty {
3043 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3044 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3045 expected_arg_tys = vec![];
3046 self.err_args(args.len())
3048 ty::Tuple(arg_types) => {
3049 expected_arg_tys = match expected_arg_tys.get(0) {
3050 Some(&ty) => match ty.sty {
3051 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3056 arg_types.iter().map(|k| k.expect_ty()).collect()
3059 span_err!(tcx.sess, sp, E0059,
3060 "cannot use call notation; the first type parameter \
3061 for the function trait is neither a tuple nor unit");
3062 expected_arg_tys = vec![];
3063 self.err_args(args.len())
3066 } else if expected_arg_count == supplied_arg_count {
3068 } else if c_variadic {
3069 if supplied_arg_count >= expected_arg_count {
3072 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3073 expected_arg_tys = vec![];
3074 self.err_args(supplied_arg_count)
3077 // is the missing argument of type `()`?
3078 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3079 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3080 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3081 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3085 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3087 expected_arg_tys = vec![];
3088 self.err_args(supplied_arg_count)
3091 debug!("check_argument_types: formal_tys={:?}",
3092 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3094 // If there is no expectation, expect formal_tys.
3095 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3101 // Check the arguments.
3102 // We do this in a pretty awful way: first we type-check any arguments
3103 // that are not closures, then we type-check the closures. This is so
3104 // that we have more information about the types of arguments when we
3105 // type-check the functions. This isn't really the right way to do this.
3106 for &check_closures in &[false, true] {
3107 debug!("check_closures={}", check_closures);
3109 // More awful hacks: before we check argument types, try to do
3110 // an "opportunistic" vtable resolution of any trait bounds on
3111 // the call. This helps coercions.
3113 self.select_obligations_where_possible(false);
3116 // For C-variadic functions, we don't have a declared type for all of
3117 // the arguments hence we only do our usual type checking with
3118 // the arguments who's types we do know.
3119 let t = if c_variadic {
3121 } else if tuple_arguments == TupleArguments {
3126 for (i, arg) in args.iter().take(t).enumerate() {
3127 // Warn only for the first loop (the "no closures" one).
3128 // Closure arguments themselves can't be diverging, but
3129 // a previous argument can, e.g., `foo(panic!(), || {})`.
3130 if !check_closures {
3131 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3134 let is_closure = match arg.node {
3135 ExprKind::Closure(..) => true,
3139 if is_closure != check_closures {
3143 debug!("checking the argument");
3144 let formal_ty = formal_tys[i];
3146 // The special-cased logic below has three functions:
3147 // 1. Provide as good of an expected type as possible.
3148 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3150 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3152 // 2. Coerce to the most detailed type that could be coerced
3153 // to, which is `expected_ty` if `rvalue_hint` returns an
3154 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3155 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3156 // We're processing function arguments so we definitely want to use
3157 // two-phase borrows.
3158 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3160 // 3. Relate the expected type and the formal one,
3161 // if the expected type was used for the coercion.
3162 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3166 // We also need to make sure we at least write the ty of the other
3167 // arguments which we skipped above.
3169 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3170 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3171 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3174 for arg in args.iter().skip(expected_arg_count) {
3175 let arg_ty = self.check_expr(&arg);
3177 // There are a few types which get autopromoted when passed via varargs
3178 // in C but we just error out instead and require explicit casts.
3179 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3181 ty::Float(ast::FloatTy::F32) => {
3182 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3184 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3185 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3187 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3188 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3191 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3192 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3193 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3201 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3202 vec![self.tcx.types.err; len]
3205 // AST fragment checking
3208 expected: Expectation<'tcx>)
3214 ast::LitKind::Str(..) => tcx.mk_static_str(),
3215 ast::LitKind::ByteStr(ref v) => {
3216 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3217 tcx.mk_array(tcx.types.u8, v.len() as u64))
3219 ast::LitKind::Byte(_) => tcx.types.u8,
3220 ast::LitKind::Char(_) => tcx.types.char,
3221 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3222 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3223 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3224 let opt_ty = expected.to_option(self).and_then(|ty| {
3226 ty::Int(_) | ty::Uint(_) => Some(ty),
3227 ty::Char => Some(tcx.types.u8),
3228 ty::RawPtr(..) => Some(tcx.types.usize),
3229 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3233 opt_ty.unwrap_or_else(|| self.next_int_var())
3235 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3236 ast::LitKind::FloatUnsuffixed(_) => {
3237 let opt_ty = expected.to_option(self).and_then(|ty| {
3239 ty::Float(_) => Some(ty),
3243 opt_ty.unwrap_or_else(|| self.next_float_var())
3245 ast::LitKind::Bool(_) => tcx.types.bool,
3246 ast::LitKind::Err(_) => tcx.types.err,
3250 // Determine the `Self` type, using fresh variables for all variables
3251 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3252 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3254 pub fn impl_self_ty(&self,
3255 span: Span, // (potential) receiver for this impl
3257 -> TypeAndSubsts<'tcx> {
3258 let ity = self.tcx.type_of(did);
3259 debug!("impl_self_ty: ity={:?}", ity);
3261 let substs = self.fresh_substs_for_item(span, did);
3262 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3264 TypeAndSubsts { substs: substs, ty: substd_ty }
3267 /// Unifies the output type with the expected type early, for more coercions
3268 /// and forward type information on the input expressions.
3269 fn expected_inputs_for_expected_output(&self,
3271 expected_ret: Expectation<'tcx>,
3272 formal_ret: Ty<'tcx>,
3273 formal_args: &[Ty<'tcx>])
3275 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3276 let ret_ty = match expected_ret.only_has_type(self) {
3278 None => return Vec::new()
3280 let expect_args = self.fudge_inference_if_ok(|| {
3281 // Attempt to apply a subtyping relationship between the formal
3282 // return type (likely containing type variables if the function
3283 // is polymorphic) and the expected return type.
3284 // No argument expectations are produced if unification fails.
3285 let origin = self.misc(call_span);
3286 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3288 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3289 // to identity so the resulting type is not constrained.
3292 // Process any obligations locally as much as
3293 // we can. We don't care if some things turn
3294 // out unconstrained or ambiguous, as we're
3295 // just trying to get hints here.
3296 self.save_and_restore_in_snapshot_flag(|_| {
3297 let mut fulfill = TraitEngine::new(self.tcx);
3298 for obligation in ok.obligations {
3299 fulfill.register_predicate_obligation(self, obligation);
3301 fulfill.select_where_possible(self)
3302 }).map_err(|_| ())?;
3304 Err(_) => return Err(()),
3307 // Record all the argument types, with the substitutions
3308 // produced from the above subtyping unification.
3309 Ok(formal_args.iter().map(|ty| {
3310 self.resolve_vars_if_possible(ty)
3312 }).unwrap_or_default();
3313 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3314 formal_args, formal_ret,
3315 expect_args, expected_ret);
3319 pub fn check_struct_path(&self,
3322 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3323 let path_span = match *qpath {
3324 QPath::Resolved(_, ref path) => path.span,
3325 QPath::TypeRelative(ref qself, _) => qself.span
3327 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3328 let variant = match def {
3330 self.set_tainted_by_errors();
3333 Res::Def(DefKind::Variant, _) => {
3335 ty::Adt(adt, substs) => {
3336 Some((adt.variant_of_res(def), adt.did, substs))
3338 _ => bug!("unexpected type: {:?}", ty)
3341 Res::Def(DefKind::Struct, _)
3342 | Res::Def(DefKind::Union, _)
3343 | Res::Def(DefKind::TyAlias, _)
3344 | Res::Def(DefKind::AssocTy, _)
3345 | Res::SelfTy(..) => {
3347 ty::Adt(adt, substs) if !adt.is_enum() => {
3348 Some((adt.non_enum_variant(), adt.did, substs))
3353 _ => bug!("unexpected definition: {:?}", def)
3356 if let Some((variant, did, substs)) = variant {
3357 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3358 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3360 // Check bounds on type arguments used in the path.
3361 let bounds = self.instantiate_bounds(path_span, did, substs);
3362 let cause = traits::ObligationCause::new(path_span, self.body_id,
3363 traits::ItemObligation(did));
3364 self.add_obligations_for_parameters(cause, &bounds);
3368 struct_span_err!(self.tcx.sess, path_span, E0071,
3369 "expected struct, variant or union type, found {}",
3370 ty.sort_string(self.tcx))
3371 .span_label(path_span, "not a struct")
3377 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3378 // The newly resolved definition is written into `type_dependent_defs`.
3379 fn finish_resolving_struct_path(&self,
3386 QPath::Resolved(ref maybe_qself, ref path) => {
3387 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3388 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3391 QPath::TypeRelative(ref qself, ref segment) => {
3392 let ty = self.to_ty(qself);
3394 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3399 let result = AstConv::associated_path_to_ty(
3408 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3409 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3411 // Write back the new resolution.
3412 self.write_resolution(hir_id, result);
3414 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3419 /// Resolves an associated value path into a base type and associated constant, or method
3420 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3421 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3425 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3427 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3428 let (ty, qself, item_segment) = match *qpath {
3429 QPath::Resolved(ref opt_qself, ref path) => {
3431 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3432 &path.segments[..]);
3434 QPath::TypeRelative(ref qself, ref segment) => {
3435 (self.to_ty(qself), qself, segment)
3438 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3439 // Return directly on cache hit. This is useful to avoid doubly reporting
3440 // errors with default match binding modes. See #44614.
3441 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3442 .unwrap_or(Res::Err);
3443 return (def, Some(ty), slice::from_ref(&**item_segment));
3445 let item_name = item_segment.ident;
3446 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3447 let result = match error {
3448 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3449 _ => Err(ErrorReported),
3451 if item_name.name != kw::Invalid {
3452 self.report_method_error(
3456 SelfSource::QPath(qself),
3464 // Write back the new resolution.
3465 self.write_resolution(hir_id, result);
3467 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3469 slice::from_ref(&**item_segment),
3473 pub fn check_decl_initializer(
3475 local: &'tcx hir::Local,
3476 init: &'tcx hir::Expr,
3478 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3479 // for #42640 (default match binding modes).
3482 let ref_bindings = local.pat.contains_explicit_ref_binding();
3484 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3485 if let Some(m) = ref_bindings {
3486 // Somewhat subtle: if we have a `ref` binding in the pattern,
3487 // we want to avoid introducing coercions for the RHS. This is
3488 // both because it helps preserve sanity and, in the case of
3489 // ref mut, for soundness (issue #23116). In particular, in
3490 // the latter case, we need to be clear that the type of the
3491 // referent for the reference that results is *equal to* the
3492 // type of the place it is referencing, and not some
3493 // supertype thereof.
3494 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3495 self.demand_eqtype(init.span, local_ty, init_ty);
3498 self.check_expr_coercable_to_type(init, local_ty)
3502 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3503 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3504 self.write_ty(local.hir_id, t);
3506 if let Some(ref init) = local.init {
3507 let init_ty = self.check_decl_initializer(local, &init);
3508 if init_ty.references_error() {
3509 self.write_ty(local.hir_id, init_ty);
3513 self.check_pat_walk(
3516 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
3519 let pat_ty = self.node_ty(local.pat.hir_id);
3520 if pat_ty.references_error() {
3521 self.write_ty(local.hir_id, pat_ty);
3525 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3526 // Don't do all the complex logic below for `DeclItem`.
3528 hir::StmtKind::Item(..) => return,
3529 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3532 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3534 // Hide the outer diverging and `has_errors` flags.
3535 let old_diverges = self.diverges.get();
3536 let old_has_errors = self.has_errors.get();
3537 self.diverges.set(Diverges::Maybe);
3538 self.has_errors.set(false);
3541 hir::StmtKind::Local(ref l) => {
3542 self.check_decl_local(&l);
3545 hir::StmtKind::Item(_) => {}
3546 hir::StmtKind::Expr(ref expr) => {
3547 // Check with expected type of `()`.
3548 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3550 hir::StmtKind::Semi(ref expr) => {
3551 self.check_expr(&expr);
3555 // Combine the diverging and `has_error` flags.
3556 self.diverges.set(self.diverges.get() | old_diverges);
3557 self.has_errors.set(self.has_errors.get() | old_has_errors);
3560 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3561 let unit = self.tcx.mk_unit();
3562 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3564 // if the block produces a `!` value, that can always be
3565 // (effectively) coerced to unit.
3567 self.demand_suptype(blk.span, unit, ty);
3571 fn check_block_with_expected(
3573 blk: &'tcx hir::Block,
3574 expected: Expectation<'tcx>,
3577 let mut fcx_ps = self.ps.borrow_mut();
3578 let unsafety_state = fcx_ps.recurse(blk);
3579 replace(&mut *fcx_ps, unsafety_state)
3582 // In some cases, blocks have just one exit, but other blocks
3583 // can be targeted by multiple breaks. This can happen both
3584 // with labeled blocks as well as when we desugar
3585 // a `try { ... }` expression.
3589 // 'a: { if true { break 'a Err(()); } Ok(()) }
3591 // Here we would wind up with two coercions, one from
3592 // `Err(())` and the other from the tail expression
3593 // `Ok(())`. If the tail expression is omitted, that's a
3594 // "forced unit" -- unless the block diverges, in which
3595 // case we can ignore the tail expression (e.g., `'a: {
3596 // break 'a 22; }` would not force the type of the block
3598 let tail_expr = blk.expr.as_ref();
3599 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3600 let coerce = if blk.targeted_by_break {
3601 CoerceMany::new(coerce_to_ty)
3603 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3604 Some(e) => slice::from_ref(e),
3607 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3610 let prev_diverges = self.diverges.get();
3611 let ctxt = BreakableCtxt {
3612 coerce: Some(coerce),
3616 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3617 for s in &blk.stmts {
3621 // check the tail expression **without** holding the
3622 // `enclosing_breakables` lock below.
3623 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3625 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3626 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3627 let coerce = ctxt.coerce.as_mut().unwrap();
3628 if let Some(tail_expr_ty) = tail_expr_ty {
3629 let tail_expr = tail_expr.unwrap();
3630 let cause = self.cause(tail_expr.span,
3631 ObligationCauseCode::BlockTailExpression(blk.hir_id));
3637 // Subtle: if there is no explicit tail expression,
3638 // that is typically equivalent to a tail expression
3639 // of `()` -- except if the block diverges. In that
3640 // case, there is no value supplied from the tail
3641 // expression (assuming there are no other breaks,
3642 // this implies that the type of the block will be
3645 // #41425 -- label the implicit `()` as being the
3646 // "found type" here, rather than the "expected type".
3647 if !self.diverges.get().always() {
3648 // #50009 -- Do not point at the entire fn block span, point at the return type
3649 // span, as it is the cause of the requirement, and
3650 // `consider_hint_about_removing_semicolon` will point at the last expression
3651 // if it were a relevant part of the error. This improves usability in editors
3652 // that highlight errors inline.
3653 let mut sp = blk.span;
3654 let mut fn_span = None;
3655 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3656 let ret_sp = decl.output.span();
3657 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3658 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3659 // output would otherwise be incorrect and even misleading. Make sure
3660 // the span we're aiming at correspond to a `fn` body.
3661 if block_sp == blk.span {
3663 fn_span = Some(ident.span);
3667 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3668 if let Some(expected_ty) = expected.only_has_type(self) {
3669 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3671 if let Some(fn_span) = fn_span {
3672 err.span_label(fn_span, "this function's body doesn't return");
3680 // If we can break from the block, then the block's exit is always reachable
3681 // (... as long as the entry is reachable) - regardless of the tail of the block.
3682 self.diverges.set(prev_diverges);
3685 let mut ty = ctxt.coerce.unwrap().complete(self);
3687 if self.has_errors.get() || ty.references_error() {
3688 ty = self.tcx.types.err
3691 self.write_ty(blk.hir_id, ty);
3693 *self.ps.borrow_mut() = prev;
3697 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3698 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
3700 Node::Item(&hir::Item {
3701 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3703 Node::ImplItem(&hir::ImplItem {
3704 node: hir::ImplItemKind::Method(_, body_id), ..
3706 let body = self.tcx.hir().body(body_id);
3707 if let ExprKind::Block(block, _) = &body.value.node {
3708 return Some(block.span);
3716 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3717 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
3718 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
3719 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3722 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3723 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
3725 Node::Item(&hir::Item {
3726 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3728 // This is less than ideal, it will not suggest a return type span on any
3729 // method called `main`, regardless of whether it is actually the entry point,
3730 // but it will still present it as the reason for the expected type.
3731 Some((decl, ident, ident.name != sym::main))
3733 Node::TraitItem(&hir::TraitItem {
3734 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3737 }) => Some((decl, ident, true)),
3738 Node::ImplItem(&hir::ImplItem {
3739 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3742 }) => Some((decl, ident, false)),
3747 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3748 /// suggestion can be made, `None` otherwise.
3749 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
3750 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3751 // `while` before reaching it, as block tail returns are not available in them.
3752 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3753 let parent = self.tcx.hir().get(blk_id);
3754 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3758 /// On implicit return expressions with mismatched types, provides the following suggestions:
3760 /// - Points out the method's return type as the reason for the expected type.
3761 /// - Possible missing semicolon.
3762 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3763 pub fn suggest_mismatched_types_on_tail(
3765 err: &mut DiagnosticBuilder<'tcx>,
3766 expression: &'tcx hir::Expr,
3772 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3773 let mut pointing_at_return_type = false;
3774 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3775 pointing_at_return_type = self.suggest_missing_return_type(
3776 err, &fn_decl, expected, found, can_suggest);
3778 self.suggest_ref_or_into(err, expression, expected, found);
3779 pointing_at_return_type
3782 pub fn suggest_ref_or_into(
3784 err: &mut DiagnosticBuilder<'tcx>,
3789 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
3790 err.span_suggestion(
3794 Applicability::MachineApplicable,
3796 } else if !self.check_for_cast(err, expr, found, expected) {
3797 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
3801 let methods = self.get_conversion_methods(expr.span, expected, found);
3802 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
3803 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
3804 .filter_map(|(receiver, method)| {
3805 let method_call = format!(".{}()", method.ident);
3806 if receiver.ends_with(&method_call) {
3807 None // do not suggest code that is already there (#53348)
3809 let method_call_list = [".to_vec()", ".to_string()"];
3810 let sugg = if receiver.ends_with(".clone()")
3811 && method_call_list.contains(&method_call.as_str()) {
3812 let max_len = receiver.rfind(".").unwrap();
3813 format!("{}{}", &receiver[..max_len], method_call)
3815 format!("{}{}", receiver, method_call)
3817 Some(if is_struct_pat_shorthand_field {
3818 format!("{}: {}", receiver, sugg)
3824 if suggestions.peek().is_some() {
3825 err.span_suggestions(
3827 "try using a conversion method",
3829 Applicability::MaybeIncorrect,
3836 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
3840 /// bar_that_returns_u32()
3844 /// This routine checks if the return expression in a block would make sense on its own as a
3845 /// statement and the return type has been left as default or has been specified as `()`. If so,
3846 /// it suggests adding a semicolon.
3847 fn suggest_missing_semicolon(
3849 err: &mut DiagnosticBuilder<'tcx>,
3850 expression: &'tcx hir::Expr,
3854 if expected.is_unit() {
3855 // `BlockTailExpression` only relevant if the tail expr would be
3856 // useful on its own.
3857 match expression.node {
3858 ExprKind::Call(..) |
3859 ExprKind::MethodCall(..) |
3860 ExprKind::While(..) |
3861 ExprKind::Loop(..) |
3862 ExprKind::Match(..) |
3863 ExprKind::Block(..) => {
3864 let sp = self.tcx.sess.source_map().next_point(cause_span);
3865 err.span_suggestion(
3867 "try adding a semicolon",
3869 Applicability::MachineApplicable);
3876 /// A possible error is to forget to add a return type that is needed:
3880 /// bar_that_returns_u32()
3884 /// This routine checks if the return type is left as default, the method is not part of an
3885 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
3887 fn suggest_missing_return_type(
3889 err: &mut DiagnosticBuilder<'tcx>,
3890 fn_decl: &hir::FnDecl,
3895 // Only suggest changing the return type for methods that
3896 // haven't set a return type at all (and aren't `fn main()` or an impl).
3897 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
3898 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
3899 err.span_suggestion(
3901 "try adding a return type",
3902 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
3903 Applicability::MachineApplicable);
3906 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
3907 err.span_label(span, "possibly return type missing here?");
3910 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
3911 // `fn main()` must return `()`, do not suggest changing return type
3912 err.span_label(span, "expected `()` because of default return type");
3915 // expectation was caused by something else, not the default return
3916 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
3917 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
3918 // Only point to return type if the expected type is the return type, as if they
3919 // are not, the expectation must have been caused by something else.
3920 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
3922 let ty = AstConv::ast_ty_to_ty(self, ty);
3923 debug!("suggest_missing_return_type: return type {:?}", ty);
3924 debug!("suggest_missing_return_type: expected type {:?}", ty);
3925 if ty.sty == expected.sty {
3926 err.span_label(sp, format!("expected `{}` because of return type",
3935 /// A possible error is to forget to add `.await` when using futures:
3938 /// #![feature(async_await)]
3940 /// async fn make_u32() -> u32 {
3944 /// fn take_u32(x: u32) {}
3946 /// async fn foo() {
3947 /// let x = make_u32();
3952 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
3953 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
3954 /// `.await` to the tail of the expression.
3955 fn suggest_missing_await(
3957 err: &mut DiagnosticBuilder<'tcx>,
3962 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
3963 // body isn't `async`.
3964 let item_id = self.tcx().hir().get_parent_node(self.body_id);
3965 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
3966 let body = self.tcx().hir().body(body_id);
3967 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
3969 // Check for `Future` implementations by constructing a predicate to
3970 // prove: `<T as Future>::Output == U`
3971 let future_trait = self.tcx.lang_items().future_trait().unwrap();
3972 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
3973 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
3974 // `<T as Future>::Output`
3975 projection_ty: ty::ProjectionTy {
3977 substs: self.tcx.mk_substs_trait(
3979 self.fresh_substs_for_item(sp, item_def_id)
3986 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
3987 if self.infcx.predicate_may_hold(&obligation) {
3988 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
3989 err.span_suggestion(
3991 "consider using `.await` here",
3992 format!("{}.await", code),
3993 Applicability::MaybeIncorrect,
4001 /// A common error is to add an extra semicolon:
4004 /// fn foo() -> usize {
4009 /// This routine checks if the final statement in a block is an
4010 /// expression with an explicit semicolon whose type is compatible
4011 /// with `expected_ty`. If so, it suggests removing the semicolon.
4012 fn consider_hint_about_removing_semicolon(
4014 blk: &'tcx hir::Block,
4015 expected_ty: Ty<'tcx>,
4016 err: &mut DiagnosticBuilder<'_>,
4018 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4019 err.span_suggestion(
4021 "consider removing this semicolon",
4023 Applicability::MachineApplicable,
4028 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4029 // Be helpful when the user wrote `{... expr;}` and
4030 // taking the `;` off is enough to fix the error.
4031 let last_stmt = blk.stmts.last()?;
4032 let last_expr = match last_stmt.node {
4033 hir::StmtKind::Semi(ref e) => e,
4036 let last_expr_ty = self.node_ty(last_expr.hir_id);
4037 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4040 let original_span = original_sp(last_stmt.span, blk.span);
4041 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4044 // Instantiates the given path, which must refer to an item with the given
4045 // number of type parameters and type.
4046 pub fn instantiate_value_path(&self,
4047 segments: &[hir::PathSegment],
4048 self_ty: Option<Ty<'tcx>>,
4052 -> (Ty<'tcx>, Res) {
4054 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4063 let path_segs = match res {
4064 Res::Local(_) | Res::SelfCtor(_) => vec![],
4065 Res::Def(kind, def_id) =>
4066 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4067 _ => bug!("instantiate_value_path on {:?}", res),
4070 let mut user_self_ty = None;
4071 let mut is_alias_variant_ctor = false;
4073 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4074 if let Some(self_ty) = self_ty {
4075 let adt_def = self_ty.ty_adt_def().unwrap();
4076 user_self_ty = Some(UserSelfTy {
4077 impl_def_id: adt_def.did,
4080 is_alias_variant_ctor = true;
4083 Res::Def(DefKind::Method, def_id)
4084 | Res::Def(DefKind::AssocConst, def_id) => {
4085 let container = tcx.associated_item(def_id).container;
4086 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4088 ty::TraitContainer(trait_did) => {
4089 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4091 ty::ImplContainer(impl_def_id) => {
4092 if segments.len() == 1 {
4093 // `<T>::assoc` will end up here, and so
4094 // can `T::assoc`. It this came from an
4095 // inherent impl, we need to record the
4096 // `T` for posterity (see `UserSelfTy` for
4098 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4099 user_self_ty = Some(UserSelfTy {
4110 // Now that we have categorized what space the parameters for each
4111 // segment belong to, let's sort out the parameters that the user
4112 // provided (if any) into their appropriate spaces. We'll also report
4113 // errors if type parameters are provided in an inappropriate place.
4115 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4116 let generics_has_err = AstConv::prohibit_generics(
4117 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4118 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4125 if let Res::Local(hid) = res {
4126 let ty = self.local_ty(span, hid).decl_ty;
4127 let ty = self.normalize_associated_types_in(span, &ty);
4128 self.write_ty(hir_id, ty);
4132 if generics_has_err {
4133 // Don't try to infer type parameters when prohibited generic arguments were given.
4134 user_self_ty = None;
4137 // Now we have to compare the types that the user *actually*
4138 // provided against the types that were *expected*. If the user
4139 // did not provide any types, then we want to substitute inference
4140 // variables. If the user provided some types, we may still need
4141 // to add defaults. If the user provided *too many* types, that's
4144 let mut infer_args_for_err = FxHashSet::default();
4145 for &PathSeg(def_id, index) in &path_segs {
4146 let seg = &segments[index];
4147 let generics = tcx.generics_of(def_id);
4148 // Argument-position `impl Trait` is treated as a normal generic
4149 // parameter internally, but we don't allow users to specify the
4150 // parameter's value explicitly, so we have to do some error-
4152 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4157 false, // `is_method_call`
4159 if suppress_errors {
4160 infer_args_for_err.insert(index);
4161 self.set_tainted_by_errors(); // See issue #53251.
4165 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4166 tcx.generics_of(*def_id).has_self
4167 }).unwrap_or(false);
4169 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4170 let ty = self.impl_self_ty(span, impl_def_id).ty;
4171 let adt_def = ty.ty_adt_def();
4174 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4175 let variant = adt_def.non_enum_variant();
4176 let ctor_def_id = variant.ctor_def_id.unwrap();
4178 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4183 let mut err = tcx.sess.struct_span_err(span,
4184 "the `Self` constructor can only be used with tuple or unit structs");
4185 if let Some(adt_def) = adt_def {
4186 match adt_def.adt_kind() {
4188 err.help("did you mean to use one of the enum's variants?");
4192 err.span_suggestion(
4194 "use curly brackets",
4195 String::from("Self { /* fields */ }"),
4196 Applicability::HasPlaceholders,
4203 return (tcx.types.err, res)
4209 let def_id = res.def_id();
4211 // The things we are substituting into the type should not contain
4212 // escaping late-bound regions, and nor should the base type scheme.
4213 let ty = tcx.type_of(def_id);
4215 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4221 // Provide the generic args, and whether types should be inferred.
4223 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4226 // If we've encountered an `impl Trait`-related error, we're just
4227 // going to infer the arguments for better error messages.
4228 if !infer_args_for_err.contains(&index) {
4229 // Check whether the user has provided generic arguments.
4230 if let Some(ref data) = segments[index].args {
4231 return (Some(data), segments[index].infer_args);
4234 return (None, segments[index].infer_args);
4239 // Provide substitutions for parameters for which (valid) arguments have been provided.
4241 match (¶m.kind, arg) {
4242 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4243 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4245 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4246 self.to_ty(ty).into()
4248 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4249 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4251 _ => unreachable!(),
4254 // Provide substitutions for parameters for which arguments are inferred.
4255 |substs, param, infer_args| {
4257 GenericParamDefKind::Lifetime => {
4258 self.re_infer(Some(param), span).unwrap().into()
4260 GenericParamDefKind::Type { has_default, .. } => {
4261 if !infer_args && has_default {
4262 // If we have a default, then we it doesn't matter that we're not
4263 // inferring the type arguments: we provide the default where any
4265 let default = tcx.type_of(param.def_id);
4268 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4271 // If no type arguments were provided, we have to infer them.
4272 // This case also occurs as a result of some malformed input, e.g.
4273 // a lifetime argument being given instead of a type parameter.
4274 // Using inference instead of `Error` gives better error messages.
4275 self.var_for_def(span, param)
4278 GenericParamDefKind::Const => {
4279 // FIXME(const_generics:defaults)
4280 // No const parameters were provided, we have to infer them.
4281 self.var_for_def(span, param)
4286 assert!(!substs.has_escaping_bound_vars());
4287 assert!(!ty.has_escaping_bound_vars());
4289 // First, store the "user substs" for later.
4290 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4292 // Add all the obligations that are required, substituting and
4293 // normalized appropriately.
4294 let bounds = self.instantiate_bounds(span, def_id, &substs);
4295 self.add_obligations_for_parameters(
4296 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4299 // Substitute the values for the type parameters into the type of
4300 // the referenced item.
4301 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4303 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4304 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4305 // is inherent, there is no `Self` parameter; instead, the impl needs
4306 // type parameters, which we can infer by unifying the provided `Self`
4307 // with the substituted impl type.
4308 // This also occurs for an enum variant on a type alias.
4309 let ty = tcx.type_of(impl_def_id);
4311 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4312 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4313 Ok(ok) => self.register_infer_ok_obligations(ok),
4315 self.tcx.sess.delay_span_bug(span, &format!(
4316 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4324 self.check_rustc_args_require_const(def_id, hir_id, span);
4326 debug!("instantiate_value_path: type of {:?} is {:?}",
4329 self.write_substs(hir_id, substs);
4331 (ty_substituted, res)
4334 fn check_rustc_args_require_const(&self,
4338 // We're only interested in functions tagged with
4339 // #[rustc_args_required_const], so ignore anything that's not.
4340 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4344 // If our calling expression is indeed the function itself, we're good!
4345 // If not, generate an error that this can only be called directly.
4346 if let Node::Expr(expr) = self.tcx.hir().get(
4347 self.tcx.hir().get_parent_node(hir_id))
4349 if let ExprKind::Call(ref callee, ..) = expr.node {
4350 if callee.hir_id == hir_id {
4356 self.tcx.sess.span_err(span, "this function can only be invoked \
4357 directly, not through a function pointer");
4360 // Resolves `typ` by a single level if `typ` is a type variable.
4361 // If no resolution is possible, then an error is reported.
4362 // Numeric inference variables may be left unresolved.
4363 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4364 let ty = self.resolve_type_vars_with_obligations(ty);
4365 if !ty.is_ty_var() {
4368 if !self.is_tainted_by_errors() {
4369 self.need_type_info_err((**self).body_id, sp, ty)
4370 .note("type must be known at this point")
4373 self.demand_suptype(sp, self.tcx.types.err, ty);
4378 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4381 ctxt: BreakableCtxt<'tcx>,
4383 ) -> (BreakableCtxt<'tcx>, R) {
4386 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4387 index = enclosing_breakables.stack.len();
4388 enclosing_breakables.by_id.insert(id, index);
4389 enclosing_breakables.stack.push(ctxt);
4393 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4394 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4395 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4396 enclosing_breakables.stack.pop().expect("missing breakable context")
4401 /// Instantiate a QueryResponse in a probe context, without a
4402 /// good ObligationCause.
4403 fn probe_instantiate_query_response(
4406 original_values: &OriginalQueryValues<'tcx>,
4407 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4408 ) -> InferResult<'tcx, Ty<'tcx>>
4410 self.instantiate_query_response_and_region_obligations(
4411 &traits::ObligationCause::misc(span, self.body_id),
4417 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4418 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4419 let mut contained_in_place = false;
4421 while let hir::Node::Expr(parent_expr) =
4422 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4424 match &parent_expr.node {
4425 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4426 if lhs.hir_id == expr_id {
4427 contained_in_place = true;
4433 expr_id = parent_expr.hir_id;
4440 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4441 let own_counts = generics.own_counts();
4443 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4449 if own_counts.types == 0 {
4453 // Make a vector of booleans initially false, set to true when used.
4454 let mut types_used = vec![false; own_counts.types];
4456 for leaf_ty in ty.walk() {
4457 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4458 debug!("Found use of ty param num {}", index);
4459 types_used[index as usize - own_counts.lifetimes] = true;
4460 } else if let ty::Error = leaf_ty.sty {
4461 // If there is already another error, do not emit
4462 // an error for not using a type Parameter.
4463 assert!(tcx.sess.has_errors());
4468 let types = generics.params.iter().filter(|param| match param.kind {
4469 ty::GenericParamDefKind::Type { .. } => true,
4472 for (&used, param) in types_used.iter().zip(types) {
4474 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4475 let span = tcx.hir().span(id);
4476 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4477 .span_label(span, "unused type parameter")
4483 fn fatally_break_rust(sess: &Session) {
4484 let handler = sess.diagnostic();
4485 handler.span_bug_no_panic(
4487 "It looks like you're trying to break rust; would you like some ICE?",
4489 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4490 handler.note_without_error(
4491 "we would appreciate a joke overview: \
4492 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4494 handler.note_without_error(&format!("rustc {} running on {}",
4495 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4496 crate::session::config::host_triple(),
4500 fn potentially_plural_count(count: usize, word: &str) -> String {
4501 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })