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
86 mod generator_interior;
90 use crate::astconv::{AstConv, PathSeg};
91 use errors::{Applicability, DiagnosticBuilder, DiagnosticId, pluralize};
92 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
93 use rustc::hir::def::{CtorOf, Res, DefKind};
94 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
95 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
96 use rustc::hir::itemlikevisit::ItemLikeVisitor;
97 use rustc::hir::ptr::P;
98 use crate::middle::lang_items;
99 use crate::namespace::Namespace;
100 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
101 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
102 use rustc_index::vec::Idx;
103 use rustc_target::spec::abi::Abi;
104 use rustc::infer::opaque_types::OpaqueTypeDecl;
105 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
106 use rustc::infer::error_reporting::TypeAnnotationNeeded::E0282;
107 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
108 use rustc::middle::region;
109 use rustc::mir::interpret::{ConstValue, GlobalId};
110 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
112 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
113 ToPolyTraitRef, ToPredicate, RegionKind, UserType
115 use rustc::ty::adjustment::{
116 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
118 use rustc::ty::fold::{TypeFoldable, TypeFolder};
119 use rustc::ty::query::Providers;
120 use rustc::ty::subst::{
121 GenericArgKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts,
123 use rustc::ty::util::{Representability, IntTypeExt, Discr};
124 use rustc::ty::layout::VariantIdx;
125 use syntax_pos::{self, BytePos, Span, MultiSpan};
126 use syntax_pos::hygiene::DesugaringKind;
129 use syntax::feature_gate::feature_err;
130 use syntax::source_map::{DUMMY_SP, original_sp};
131 use syntax::symbol::{kw, sym, Ident};
132 use syntax::util::parser::ExprPrecedence;
134 use rustc_error_codes::*;
136 use std::cell::{Cell, RefCell, Ref, RefMut};
137 use std::collections::hash_map::Entry;
140 use std::mem::replace;
141 use std::ops::{self, Deref};
144 use crate::require_c_abi_if_c_variadic;
145 use crate::session::Session;
146 use crate::session::config::EntryFnType;
147 use crate::TypeAndSubsts;
149 use crate::util::captures::Captures;
150 use crate::util::common::{ErrorReported, indenter};
151 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap};
153 pub use self::Expectation::*;
154 use self::autoderef::Autoderef;
155 use self::callee::DeferredCallResolution;
156 use self::coercion::{CoerceMany, DynamicCoerceMany};
157 pub use self::compare_method::{compare_impl_method, compare_const_impl};
158 use self::method::{MethodCallee, SelfSource};
159 use self::TupleArgumentsFlag::*;
161 /// The type of a local binding, including the revealed type for anon types.
162 #[derive(Copy, Clone, Debug)]
163 pub struct LocalTy<'tcx> {
165 revealed_ty: Ty<'tcx>
168 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
169 #[derive(Copy, Clone)]
170 struct MaybeInProgressTables<'a, 'tcx> {
171 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
174 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
175 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
176 match self.maybe_tables {
177 Some(tables) => tables.borrow(),
179 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
184 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
185 match self.maybe_tables {
186 Some(tables) => tables.borrow_mut(),
188 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
194 /// Closures defined within the function. For example:
197 /// bar(move|| { ... })
200 /// Here, the function `foo()` and the closure passed to
201 /// `bar()` will each have their own `FnCtxt`, but they will
202 /// share the inherited fields.
203 pub struct Inherited<'a, 'tcx> {
204 infcx: InferCtxt<'a, 'tcx>,
206 tables: MaybeInProgressTables<'a, 'tcx>,
208 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
210 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
212 // Some additional `Sized` obligations badly affect type inference.
213 // These obligations are added in a later stage of typeck.
214 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
216 // When we process a call like `c()` where `c` is a closure type,
217 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
218 // `FnOnce` closure. In that case, we defer full resolution of the
219 // call until upvar inference can kick in and make the
220 // decision. We keep these deferred resolutions grouped by the
221 // def-id of the closure, so that once we decide, we can easily go
222 // back and process them.
223 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
225 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
227 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
229 // Opaque types found in explicit return types and their
230 // associated fresh inference variable. Writeback resolves these
231 // variables to get the concrete type, which can be used to
232 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
233 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
235 /// A map from inference variables created from opaque
236 /// type instantiations (`ty::Infer`) to the actual opaque
237 /// type (`ty::Opaque`). Used during fallback to map unconstrained
238 /// opaque type inference variables to their corresponding
240 opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
242 /// Each type parameter has an implicit region bound that
243 /// indicates it must outlive at least the function body (the user
244 /// may specify stronger requirements). This field indicates the
245 /// region of the callee. If it is `None`, then the parameter
246 /// environment is for an item or something where the "callee" is
248 implicit_region_bound: Option<ty::Region<'tcx>>,
250 body_id: Option<hir::BodyId>,
253 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
254 type Target = InferCtxt<'a, 'tcx>;
255 fn deref(&self) -> &Self::Target {
260 /// When type-checking an expression, we propagate downward
261 /// whatever type hint we are able in the form of an `Expectation`.
262 #[derive(Copy, Clone, Debug)]
263 pub enum Expectation<'tcx> {
264 /// We know nothing about what type this expression should have.
267 /// This expression should have the type given (or some subtype).
268 ExpectHasType(Ty<'tcx>),
270 /// This expression will be cast to the `Ty`.
271 ExpectCastableToType(Ty<'tcx>),
273 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
274 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
275 ExpectRvalueLikeUnsized(Ty<'tcx>),
278 impl<'a, 'tcx> Expectation<'tcx> {
279 // Disregard "castable to" expectations because they
280 // can lead us astray. Consider for example `if cond
281 // {22} else {c} as u8` -- if we propagate the
282 // "castable to u8" constraint to 22, it will pick the
283 // type 22u8, which is overly constrained (c might not
284 // be a u8). In effect, the problem is that the
285 // "castable to" expectation is not the tightest thing
286 // we can say, so we want to drop it in this case.
287 // The tightest thing we can say is "must unify with
288 // else branch". Note that in the case of a "has type"
289 // constraint, this limitation does not hold.
291 // If the expected type is just a type variable, then don't use
292 // an expected type. Otherwise, we might write parts of the type
293 // when checking the 'then' block which are incompatible with the
295 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
297 ExpectHasType(ety) => {
298 let ety = fcx.shallow_resolve(ety);
299 if !ety.is_ty_var() {
305 ExpectRvalueLikeUnsized(ety) => {
306 ExpectRvalueLikeUnsized(ety)
312 /// Provides an expectation for an rvalue expression given an *optional*
313 /// hint, which is not required for type safety (the resulting type might
314 /// be checked higher up, as is the case with `&expr` and `box expr`), but
315 /// is useful in determining the concrete type.
317 /// The primary use case is where the expected type is a fat pointer,
318 /// like `&[isize]`. For example, consider the following statement:
320 /// let x: &[isize] = &[1, 2, 3];
322 /// In this case, the expected type for the `&[1, 2, 3]` expression is
323 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
324 /// expectation `ExpectHasType([isize])`, that would be too strong --
325 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
326 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
327 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
328 /// which still is useful, because it informs integer literals and the like.
329 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
330 /// for examples of where this comes up,.
331 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
332 match fcx.tcx.struct_tail_without_normalization(ty).kind {
333 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
334 ExpectRvalueLikeUnsized(ty)
336 _ => ExpectHasType(ty)
340 // Resolves `expected` by a single level if it is a variable. If
341 // there is no expected type or resolution is not possible (e.g.,
342 // no constraints yet present), just returns `None`.
343 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
345 NoExpectation => NoExpectation,
346 ExpectCastableToType(t) => {
347 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
349 ExpectHasType(t) => {
350 ExpectHasType(fcx.resolve_vars_if_possible(&t))
352 ExpectRvalueLikeUnsized(t) => {
353 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
358 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
359 match self.resolve(fcx) {
360 NoExpectation => None,
361 ExpectCastableToType(ty) |
363 ExpectRvalueLikeUnsized(ty) => Some(ty),
367 /// It sometimes happens that we want to turn an expectation into
368 /// a **hard constraint** (i.e., something that must be satisfied
369 /// for the program to type-check). `only_has_type` will return
370 /// such a constraint, if it exists.
371 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
372 match self.resolve(fcx) {
373 ExpectHasType(ty) => Some(ty),
374 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
378 /// Like `only_has_type`, but instead of returning `None` if no
379 /// hard constraint exists, creates a fresh type variable.
380 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
381 self.only_has_type(fcx)
383 fcx.next_ty_var(TypeVariableOrigin {
384 kind: TypeVariableOriginKind::MiscVariable,
391 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
398 fn maybe_mut_place(m: hir::Mutability) -> Self {
400 hir::Mutability::Mut => Needs::MutPlace,
401 hir::Mutability::Not => Needs::None,
406 #[derive(Copy, Clone)]
407 pub struct UnsafetyState {
409 pub unsafety: hir::Unsafety,
410 pub unsafe_push_count: u32,
415 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
416 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
419 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
420 match self.unsafety {
421 // If this unsafe, then if the outer function was already marked as
422 // unsafe we shouldn't attribute the unsafe'ness to the block. This
423 // way the block can be warned about instead of ignoring this
424 // extraneous block (functions are never warned about).
425 hir::Unsafety::Unsafe if self.from_fn => *self,
428 let (unsafety, def, count) = match blk.rules {
429 hir::PushUnsafeBlock(..) =>
430 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
431 hir::PopUnsafeBlock(..) =>
432 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
433 hir::UnsafeBlock(..) =>
434 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
436 (unsafety, self.def, self.unsafe_push_count),
440 unsafe_push_count: count,
447 #[derive(Debug, Copy, Clone)]
453 /// Tracks whether executing a node may exit normally (versus
454 /// return/break/panic, which "diverge", leaving dead code in their
455 /// wake). Tracked semi-automatically (through type variables marked
456 /// as diverging), with some manual adjustments for control-flow
457 /// primitives (approximating a CFG).
458 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
460 /// Potentially unknown, some cases converge,
461 /// others require a CFG to determine them.
464 /// Definitely known to diverge and therefore
465 /// not reach the next sibling or its parent.
467 /// The `Span` points to the expression
468 /// that caused us to diverge
469 /// (e.g. `return`, `break`, etc).
471 /// In some cases (e.g. a `match` expression
472 /// where all arms diverge), we may be
473 /// able to provide a more informative
474 /// message to the user.
475 /// If this is `None`, a default messsage
476 /// will be generated, which is suitable
478 custom_note: Option<&'static str>
481 /// Same as `Always` but with a reachability
482 /// warning already emitted.
486 // Convenience impls for combining `Diverges`.
488 impl ops::BitAnd for Diverges {
490 fn bitand(self, other: Self) -> Self {
491 cmp::min(self, other)
495 impl ops::BitOr for Diverges {
497 fn bitor(self, other: Self) -> Self {
498 cmp::max(self, other)
502 impl ops::BitAndAssign for Diverges {
503 fn bitand_assign(&mut self, other: Self) {
504 *self = *self & other;
508 impl ops::BitOrAssign for Diverges {
509 fn bitor_assign(&mut self, other: Self) {
510 *self = *self | other;
515 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
516 fn always(span: Span) -> Diverges {
523 fn is_always(self) -> bool {
524 // Enum comparison ignores the
525 // contents of fields, so we just
526 // fill them in with garbage here.
527 self >= Diverges::Always {
534 pub struct BreakableCtxt<'tcx> {
537 // this is `null` for loops where break with a value is illegal,
538 // such as `while`, `for`, and `while let`
539 coerce: Option<DynamicCoerceMany<'tcx>>,
542 pub struct EnclosingBreakables<'tcx> {
543 stack: Vec<BreakableCtxt<'tcx>>,
544 by_id: HirIdMap<usize>,
547 impl<'tcx> EnclosingBreakables<'tcx> {
548 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
549 self.opt_find_breakable(target_id).unwrap_or_else(|| {
550 bug!("could not find enclosing breakable with id {}", target_id);
554 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
555 match self.by_id.get(&target_id) {
556 Some(ix) => Some(&mut self.stack[*ix]),
562 pub struct FnCtxt<'a, 'tcx> {
565 /// The parameter environment used for proving trait obligations
566 /// in this function. This can change when we descend into
567 /// closures (as they bring new things into scope), hence it is
568 /// not part of `Inherited` (as of the time of this writing,
569 /// closures do not yet change the environment, but they will
571 param_env: ty::ParamEnv<'tcx>,
573 /// Number of errors that had been reported when we started
574 /// checking this function. On exit, if we find that *more* errors
575 /// have been reported, we will skip regionck and other work that
576 /// expects the types within the function to be consistent.
577 // FIXME(matthewjasper) This should not exist, and it's not correct
578 // if type checking is run in parallel.
579 err_count_on_creation: usize,
581 /// If `Some`, this stores coercion information for returned
582 /// expressions. If `None`, this is in a context where return is
583 /// inappropriate, such as a const expression.
585 /// This is a `RefCell<DynamicCoerceMany>`, which means that we
586 /// can track all the return expressions and then use them to
587 /// compute a useful coercion from the set, similar to a match
588 /// expression or other branching context. You can use methods
589 /// like `expected_ty` to access the declared return type (if
591 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
593 /// First span of a return site that we find. Used in error messages.
594 ret_coercion_span: RefCell<Option<Span>>,
596 yield_ty: Option<Ty<'tcx>>,
598 ps: RefCell<UnsafetyState>,
600 /// Whether the last checked node generates a divergence (e.g.,
601 /// `return` will set this to `Always`). In general, when entering
602 /// an expression or other node in the tree, the initial value
603 /// indicates whether prior parts of the containing expression may
604 /// have diverged. It is then typically set to `Maybe` (and the
605 /// old value remembered) for processing the subparts of the
606 /// current expression. As each subpart is processed, they may set
607 /// the flag to `Always`, etc. Finally, at the end, we take the
608 /// result and "union" it with the original value, so that when we
609 /// return the flag indicates if any subpart of the parent
610 /// expression (up to and including this part) has diverged. So,
611 /// if you read it after evaluating a subexpression `X`, the value
612 /// you get indicates whether any subexpression that was
613 /// evaluating up to and including `X` diverged.
615 /// We currently use this flag only for diagnostic purposes:
617 /// - To warn about unreachable code: if, after processing a
618 /// sub-expression but before we have applied the effects of the
619 /// current node, we see that the flag is set to `Always`, we
620 /// can issue a warning. This corresponds to something like
621 /// `foo(return)`; we warn on the `foo()` expression. (We then
622 /// update the flag to `WarnedAlways` to suppress duplicate
623 /// reports.) Similarly, if we traverse to a fresh statement (or
624 /// tail expression) from a `Always` setting, we will issue a
625 /// warning. This corresponds to something like `{return;
626 /// foo();}` or `{return; 22}`, where we would warn on the
629 /// An expression represents dead code if, after checking it,
630 /// the diverges flag is set to something other than `Maybe`.
631 diverges: Cell<Diverges>,
633 /// Whether any child nodes have any type errors.
634 has_errors: Cell<bool>,
636 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
638 inh: &'a Inherited<'a, 'tcx>,
641 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
642 type Target = Inherited<'a, 'tcx>;
643 fn deref(&self) -> &Self::Target {
648 /// Helper type of a temporary returned by `Inherited::build(...)`.
649 /// Necessary because we can't write the following bound:
650 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
651 pub struct InheritedBuilder<'tcx> {
652 infcx: infer::InferCtxtBuilder<'tcx>,
656 impl Inherited<'_, 'tcx> {
657 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
658 let hir_id_root = if def_id.is_local() {
659 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
660 DefId::local(hir_id.owner)
666 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
672 impl<'tcx> InheritedBuilder<'tcx> {
673 fn enter<F, R>(&mut self, f: F) -> R
675 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
677 let def_id = self.def_id;
678 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
682 impl Inherited<'a, 'tcx> {
683 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
685 let item_id = tcx.hir().as_local_hir_id(def_id);
686 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
687 let implicit_region_bound = body_id.map(|body_id| {
688 let body = tcx.hir().body(body_id);
689 tcx.mk_region(ty::ReScope(region::Scope {
690 id: body.value.hir_id.local_id,
691 data: region::ScopeData::CallSite
696 tables: MaybeInProgressTables {
697 maybe_tables: infcx.in_progress_tables,
700 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
701 locals: RefCell::new(Default::default()),
702 deferred_sized_obligations: RefCell::new(Vec::new()),
703 deferred_call_resolutions: RefCell::new(Default::default()),
704 deferred_cast_checks: RefCell::new(Vec::new()),
705 deferred_generator_interiors: RefCell::new(Vec::new()),
706 opaque_types: RefCell::new(Default::default()),
707 opaque_types_vars: RefCell::new(Default::default()),
708 implicit_region_bound,
713 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
714 debug!("register_predicate({:?})", obligation);
715 if obligation.has_escaping_bound_vars() {
716 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
721 .register_predicate_obligation(self, obligation);
724 fn register_predicates<I>(&self, obligations: I)
725 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
727 for obligation in obligations {
728 self.register_predicate(obligation);
732 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
733 self.register_predicates(infer_ok.obligations);
737 fn normalize_associated_types_in<T>(&self,
740 param_env: ty::ParamEnv<'tcx>,
742 where T : TypeFoldable<'tcx>
744 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
745 self.register_infer_ok_obligations(ok)
749 struct CheckItemTypesVisitor<'tcx> {
753 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
754 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
755 check_item_type(self.tcx, i);
757 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) { }
758 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) { }
761 pub fn check_wf_new(tcx: TyCtxt<'_>) {
762 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
763 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
766 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
767 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
770 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
771 debug_assert!(crate_num == LOCAL_CRATE);
772 tcx.par_body_owners(|body_owner_def_id| {
773 tcx.ensure().typeck_tables_of(body_owner_def_id);
777 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
778 wfcheck::check_item_well_formed(tcx, def_id);
781 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
782 wfcheck::check_trait_item(tcx, def_id);
785 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
786 wfcheck::check_impl_item(tcx, def_id);
789 pub fn provide(providers: &mut Providers<'_>) {
790 method::provide(providers);
791 *providers = Providers {
797 check_item_well_formed,
798 check_trait_item_well_formed,
799 check_impl_item_well_formed,
800 check_mod_item_types,
805 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
806 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
809 /// If this `DefId` is a "primary tables entry", returns
810 /// `Some((body_id, header, decl))` with information about
811 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
814 /// If this function returns `Some`, then `typeck_tables(def_id)` will
815 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
816 /// may not succeed. In some cases where this function returns `None`
817 /// (notably closures), `typeck_tables(def_id)` would wind up
818 /// redirecting to the owning function.
822 ) -> Option<(hir::BodyId, Option<&hir::Ty>, Option<&hir::FnHeader>, Option<&hir::FnDecl>)> {
823 match tcx.hir().get(id) {
824 Node::Item(item) => {
826 hir::ItemKind::Const(ref ty, body) |
827 hir::ItemKind::Static(ref ty, _, body) =>
828 Some((body, Some(ty), None, None)),
829 hir::ItemKind::Fn(ref sig, .., body) =>
830 Some((body, None, Some(&sig.header), Some(&sig.decl))),
835 Node::TraitItem(item) => {
837 hir::TraitItemKind::Const(ref ty, Some(body)) =>
838 Some((body, Some(ty), None, None)),
839 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
840 Some((body, None, Some(&sig.header), Some(&sig.decl))),
845 Node::ImplItem(item) => {
847 hir::ImplItemKind::Const(ref ty, body) =>
848 Some((body, Some(ty), None, None)),
849 hir::ImplItemKind::Method(ref sig, body) =>
850 Some((body, None, Some(&sig.header), Some(&sig.decl))),
855 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
860 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
861 // Closures' tables come from their outermost function,
862 // as they are part of the same "inference environment".
863 let outer_def_id = tcx.closure_base_def_id(def_id);
864 if outer_def_id != def_id {
865 return tcx.has_typeck_tables(outer_def_id);
868 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
869 primary_body_of(tcx, id).is_some()
872 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
873 &*tcx.typeck_tables_of(def_id).used_trait_imports
876 /// Inspects the substs of opaque types, replacing any inference variables
877 /// with proper generic parameter from the identity substs.
879 /// This is run after we normalize the function signature, to fix any inference
880 /// variables introduced by the projection of associated types. This ensures that
881 /// any opaque types used in the signature continue to refer to generic parameters,
882 /// allowing them to be considered for defining uses in the function body
884 /// For example, consider this code.
889 /// fn use_it(self) -> Self::MyItem
891 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
892 /// type MyItem = impl Iterator<Item = I>;
893 /// fn use_it(self) -> Self::MyItem {
899 /// When we normalize the signature of `use_it` from the impl block,
900 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
901 /// However, this projection result may contain inference variables, due
902 /// to the way that projection works. We didn't have any inference variables
903 /// in the signature to begin with - leaving them in will cause us to incorrectly
904 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
905 /// variables back to the actual generic parameters, we will correctly see that
906 /// we have a defining use of `MyItem`
907 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T where T: TypeFoldable<'tcx> {
908 struct FixupFolder<'tcx> {
912 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
913 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
917 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
919 ty::Opaque(def_id, substs) => {
920 debug!("fixup_opaque_types: found type {:?}", ty);
921 // Here, we replace any inference variables that occur within
922 // the substs of an opaque type. By definition, any type occuring
923 // in the substs has a corresponding generic parameter, which is what
924 // we replace it with.
925 // This replacement is only run on the function signature, so any
926 // inference variables that we come across must be the rust of projection
927 // (there's no other way for a user to get inference variables into
928 // a function signature).
929 if ty.needs_infer() {
930 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
931 let old_param = substs[param.index as usize];
932 match old_param.unpack() {
933 GenericArgKind::Type(old_ty) => {
934 if let ty::Infer(_) = old_ty.kind {
935 // Replace inference type with a generic parameter
936 self.tcx.mk_param_from_def(param)
938 old_param.fold_with(self)
941 GenericArgKind::Const(old_const) => {
942 if let ty::ConstKind::Infer(_) = old_const.val {
943 // This should never happen - we currently do not support
944 // 'const projections', e.g.:
945 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
946 // which should be the only way for us to end up with a const inference
947 // variable after projection. If Rust ever gains support for this kind
948 // of projection, this should *probably* be changed to
949 // `self.tcx.mk_param_from_def(param)`
950 bug!("Found infer const: `{:?}` in opaque type: {:?}",
953 old_param.fold_with(self)
956 GenericArgKind::Lifetime(old_region) => {
957 if let RegionKind::ReVar(_) = old_region {
958 self.tcx.mk_param_from_def(param)
960 old_param.fold_with(self)
965 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
966 debug!("fixup_opaque_types: new type: {:?}", new_ty);
972 _ => ty.super_fold_with(self)
977 debug!("fixup_opaque_types({:?})", val);
978 val.fold_with(&mut FixupFolder { tcx })
981 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
982 // Closures' tables come from their outermost function,
983 // as they are part of the same "inference environment".
984 let outer_def_id = tcx.closure_base_def_id(def_id);
985 if outer_def_id != def_id {
986 return tcx.typeck_tables_of(outer_def_id);
989 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
990 let span = tcx.hir().span(id);
992 // Figure out what primary body this item has.
993 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id)
995 span_bug!(span, "can't type-check body of {:?}", def_id);
997 let body = tcx.hir().body(body_id);
999 let tables = Inherited::build(tcx, def_id).enter(|inh| {
1000 let param_env = tcx.param_env(def_id);
1001 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
1002 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
1003 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1004 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl)
1009 check_abi(tcx, span, fn_sig.abi());
1011 // Compute the fty from point of view of inside the fn.
1013 tcx.liberate_late_bound_regions(def_id, &fn_sig);
1015 inh.normalize_associated_types_in(body.value.span,
1020 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1022 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1025 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1026 let expected_type = body_ty.and_then(|ty| match ty.kind {
1027 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1029 }).unwrap_or_else(|| tcx.type_of(def_id));
1030 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1031 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1033 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1034 fcx.instantiate_opaque_types_from_value(
1043 // Gather locals in statics (because of block expressions).
1044 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
1046 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
1048 fcx.write_ty(id, revealed_ty);
1053 // All type checking constraints were added, try to fallback unsolved variables.
1054 fcx.select_obligations_where_possible(false, |_| {});
1055 let mut fallback_has_occurred = false;
1057 // We do fallback in two passes, to try to generate
1058 // better error messages.
1059 // The first time, we do *not* replace opaque types.
1060 for ty in &fcx.unsolved_variables() {
1061 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1063 // We now see if we can make progress. This might
1064 // cause us to unify inference variables for opaque types,
1065 // since we may have unified some other type variables
1066 // during the first phase of fallback.
1067 // This means that we only replace inference variables with their underlying
1068 // opaque types as a last resort.
1070 // In code like this:
1073 // type MyType = impl Copy;
1074 // fn produce() -> MyType { true }
1075 // fn bad_produce() -> MyType { panic!() }
1078 // we want to unify the opaque inference variable in `bad_produce`
1079 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1080 // This will produce a nice error message about conflicting concrete
1081 // types for `MyType`.
1083 // If we had tried to fallback the opaque inference variable to `MyType`,
1084 // we will generate a confusing type-check error that does not explicitly
1085 // refer to opaque types.
1086 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1088 // We now run fallback again, but this time we allow it to replace
1089 // unconstrained opaque type variables, in addition to performing
1090 // other kinds of fallback.
1091 for ty in &fcx.unsolved_variables() {
1092 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1095 // See if we can make any more progress.
1096 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1098 // Even though coercion casts provide type hints, we check casts after fallback for
1099 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1102 // Closure and generator analysis may run after fallback
1103 // because they don't constrain other type variables.
1104 fcx.closure_analyze(body);
1105 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1106 fcx.resolve_generator_interiors(def_id);
1108 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1109 let ty = fcx.normalize_ty(span, ty);
1110 fcx.require_type_is_sized(ty, span, code);
1112 fcx.select_all_obligations_or_error();
1114 if fn_decl.is_some() {
1115 fcx.regionck_fn(id, body);
1117 fcx.regionck_expr(body);
1120 fcx.resolve_type_vars_in_body(body)
1123 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1124 // it will need to hold.
1125 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
1130 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1131 if !tcx.sess.target.target.is_abi_supported(abi) {
1132 struct_span_err!(tcx.sess, span, E0570,
1133 "The ABI `{}` is not supported for the current target", abi).emit()
1137 struct GatherLocalsVisitor<'a, 'tcx> {
1138 fcx: &'a FnCtxt<'a, 'tcx>,
1139 parent_id: hir::HirId,
1142 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1143 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1146 // infer the variable's type
1147 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1148 kind: TypeVariableOriginKind::TypeInference,
1151 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
1158 // take type that the user specified
1159 self.fcx.locals.borrow_mut().insert(nid, typ);
1166 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1167 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
1168 NestedVisitorMap::None
1171 // Add explicitly-declared locals.
1172 fn visit_local(&mut self, local: &'tcx hir::Local) {
1173 let local_ty = match local.ty {
1175 let o_ty = self.fcx.to_ty(&ty);
1177 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1178 self.fcx.instantiate_opaque_types_from_value(
1187 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
1188 &UserType::Ty(revealed_ty)
1190 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1191 ty.hir_id, o_ty, revealed_ty, c_ty);
1192 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1194 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1198 self.assign(local.span, local.hir_id, local_ty);
1200 debug!("local variable {:?} is assigned type {}",
1202 self.fcx.ty_to_string(
1203 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
1204 intravisit::walk_local(self, local);
1207 // Add pattern bindings.
1208 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
1209 if let PatKind::Binding(_, _, ident, _) = p.kind {
1210 let var_ty = self.assign(p.span, p.hir_id, None);
1212 if !self.fcx.tcx.features().unsized_locals {
1213 self.fcx.require_type_is_sized(var_ty, p.span,
1214 traits::VariableType(p.hir_id));
1217 debug!("pattern binding {} is assigned to {} with type {:?}",
1219 self.fcx.ty_to_string(
1220 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1223 intravisit::walk_pat(self, p);
1226 // Don't descend into the bodies of nested closures
1229 _: intravisit::FnKind<'tcx>,
1230 _: &'tcx hir::FnDecl,
1237 /// When `check_fn` is invoked on a generator (i.e., a body that
1238 /// includes yield), it returns back some information about the yield
1240 struct GeneratorTypes<'tcx> {
1241 /// Type of value that is yielded.
1244 /// Types that are captured (see `GeneratorInterior` for more).
1247 /// Indicates if the generator is movable or static (immovable).
1248 movability: hir::Movability,
1251 /// Helper used for fns and closures. Does the grungy work of checking a function
1252 /// body and returns the function context used for that purpose, since in the case of a fn item
1253 /// there is still a bit more to do.
1256 /// * inherited: other fields inherited from the enclosing fn (if any)
1257 fn check_fn<'a, 'tcx>(
1258 inherited: &'a Inherited<'a, 'tcx>,
1259 param_env: ty::ParamEnv<'tcx>,
1260 fn_sig: ty::FnSig<'tcx>,
1261 decl: &'tcx hir::FnDecl,
1263 body: &'tcx hir::Body,
1264 can_be_generator: Option<hir::Movability>,
1265 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1266 let mut fn_sig = fn_sig.clone();
1268 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1270 // Create the function context. This is either derived from scratch or,
1271 // in the case of closures, based on the outer context.
1272 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1273 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1275 let declared_ret_ty = fn_sig.output();
1276 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1277 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1282 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1283 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1284 fn_sig = fcx.tcx.mk_fn_sig(
1285 fn_sig.inputs().iter().cloned(),
1292 let span = body.value.span;
1294 fn_maybe_err(fcx.tcx, span, fn_sig.abi);
1296 if body.generator_kind.is_some() && can_be_generator.is_some() {
1297 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1298 kind: TypeVariableOriginKind::TypeInference,
1301 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1302 fcx.yield_ty = Some(yield_ty);
1305 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1306 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1307 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1309 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1310 // (as it's created inside the body itself, not passed in from outside).
1311 let maybe_va_list = if fn_sig.c_variadic {
1312 let va_list_did = fcx.tcx.require_lang_item(
1313 lang_items::VaListTypeLangItem,
1314 Some(body.params.last().unwrap().span),
1316 let region = fcx.tcx.mk_region(ty::ReScope(region::Scope {
1317 id: body.value.hir_id.local_id,
1318 data: region::ScopeData::CallSite
1321 Some(fcx.tcx.type_of(va_list_did).subst(fcx.tcx, &[region.into()]))
1326 // Add formal parameters.
1327 for (param_ty, param) in
1328 fn_sig.inputs().iter().copied()
1329 .chain(maybe_va_list)
1332 // Check the pattern.
1333 fcx.check_pat_top(¶m.pat, param_ty, None);
1335 // Check that argument is Sized.
1336 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1337 // for simple cases like `fn foo(x: Trait)`,
1338 // where we would error once on the parameter as a whole, and once on the binding `x`.
1339 if param.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1340 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1343 fcx.write_ty(param.hir_id, param_ty);
1346 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1348 fcx.check_return_expr(&body.value);
1350 // We insert the deferred_generator_interiors entry after visiting the body.
1351 // This ensures that all nested generators appear before the entry of this generator.
1352 // resolve_generator_interiors relies on this property.
1353 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1354 let interior = fcx.next_ty_var(TypeVariableOrigin {
1355 kind: TypeVariableOriginKind::MiscVariable,
1358 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1359 Some(GeneratorTypes {
1360 yield_ty: fcx.yield_ty.unwrap(),
1362 movability: can_be_generator.unwrap(),
1368 // Finalize the return check by taking the LUB of the return types
1369 // we saw and assigning it to the expected return type. This isn't
1370 // really expected to fail, since the coercions would have failed
1371 // earlier when trying to find a LUB.
1373 // However, the behavior around `!` is sort of complex. In the
1374 // event that the `actual_return_ty` comes back as `!`, that
1375 // indicates that the fn either does not return or "returns" only
1376 // values of type `!`. In this case, if there is an expected
1377 // return type that is *not* `!`, that should be ok. But if the
1378 // return type is being inferred, we want to "fallback" to `!`:
1380 // let x = move || panic!();
1382 // To allow for that, I am creating a type variable with diverging
1383 // fallback. This was deemed ever so slightly better than unifying
1384 // the return value with `!` because it allows for the caller to
1385 // make more assumptions about the return type (e.g., they could do
1387 // let y: Option<u32> = Some(x());
1389 // which would then cause this return type to become `u32`, not
1391 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1392 let mut actual_return_ty = coercion.complete(&fcx);
1393 if actual_return_ty.is_never() {
1394 actual_return_ty = fcx.next_diverging_ty_var(
1395 TypeVariableOrigin {
1396 kind: TypeVariableOriginKind::DivergingFn,
1401 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1403 // Check that the main return type implements the termination trait.
1404 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1405 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1406 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1407 if main_id == fn_id {
1408 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1409 let trait_ref = ty::TraitRef::new(term_id, substs);
1410 let return_ty_span = decl.output.span();
1411 let cause = traits::ObligationCause::new(
1412 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1414 inherited.register_predicate(
1415 traits::Obligation::new(
1416 cause, param_env, trait_ref.to_predicate()));
1421 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1422 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1423 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1424 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1425 if declared_ret_ty.kind != ty::Never {
1426 fcx.tcx.sess.span_err(
1428 "return type should be `!`",
1432 let inputs = fn_sig.inputs();
1433 let span = fcx.tcx.hir().span(fn_id);
1434 if inputs.len() == 1 {
1435 let arg_is_panic_info = match inputs[0].kind {
1436 ty::Ref(region, ty, mutbl) => match ty.kind {
1437 ty::Adt(ref adt, _) => {
1438 adt.did == panic_info_did &&
1439 mutbl == hir::Mutability::Not &&
1440 *region != RegionKind::ReStatic
1447 if !arg_is_panic_info {
1448 fcx.tcx.sess.span_err(
1449 decl.inputs[0].span,
1450 "argument should be `&PanicInfo`",
1454 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1455 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1456 if !generics.params.is_empty() {
1457 fcx.tcx.sess.span_err(
1459 "should have no type parameters",
1465 let span = fcx.tcx.sess.source_map().def_span(span);
1466 fcx.tcx.sess.span_err(span, "function should have one argument");
1469 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1474 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1475 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1476 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1477 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1478 if declared_ret_ty.kind != ty::Never {
1479 fcx.tcx.sess.span_err(
1481 "return type should be `!`",
1485 let inputs = fn_sig.inputs();
1486 let span = fcx.tcx.hir().span(fn_id);
1487 if inputs.len() == 1 {
1488 let arg_is_alloc_layout = match inputs[0].kind {
1489 ty::Adt(ref adt, _) => {
1490 adt.did == alloc_layout_did
1495 if !arg_is_alloc_layout {
1496 fcx.tcx.sess.span_err(
1497 decl.inputs[0].span,
1498 "argument should be `Layout`",
1502 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1503 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1504 if !generics.params.is_empty() {
1505 fcx.tcx.sess.span_err(
1507 "`#[alloc_error_handler]` function should have no type \
1514 let span = fcx.tcx.sess.source_map().def_span(span);
1515 fcx.tcx.sess.span_err(span, "function should have one argument");
1518 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1526 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1527 let def_id = tcx.hir().local_def_id(id);
1528 let def = tcx.adt_def(def_id);
1529 def.destructor(tcx); // force the destructor to be evaluated
1530 check_representable(tcx, span, def_id);
1532 if def.repr.simd() {
1533 check_simd(tcx, span, def_id);
1536 check_transparent(tcx, span, def_id);
1537 check_packed(tcx, span, def_id);
1540 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1541 let def_id = tcx.hir().local_def_id(id);
1542 let def = tcx.adt_def(def_id);
1543 def.destructor(tcx); // force the destructor to be evaluated
1544 check_representable(tcx, span, def_id);
1545 check_transparent(tcx, span, def_id);
1546 check_union_fields(tcx, span, def_id);
1547 check_packed(tcx, span, def_id);
1550 /// When the `#![feature(untagged_unions)]` gate is active,
1551 /// check that the fields of the `union` does not contain fields that need dropping.
1552 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool {
1553 let item_type = tcx.type_of(item_def_id);
1554 if let ty::Adt(def, substs) = item_type.kind {
1555 assert!(def.is_union());
1556 let fields = &def.non_enum_variant().fields;
1557 for field in fields {
1558 let field_ty = field.ty(tcx, substs);
1559 // We are currently checking the type this field came from, so it must be local.
1560 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1561 let param_env = tcx.param_env(field.did);
1562 if field_ty.needs_drop(tcx, param_env) {
1563 struct_span_err!(tcx.sess, field_span, E0740,
1564 "unions may not contain fields that need dropping")
1565 .span_note(field_span,
1566 "`std::mem::ManuallyDrop` can be used to wrap the type")
1572 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1577 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1578 /// projections that would result in "inheriting lifetimes".
1579 fn check_opaque<'tcx>(
1582 substs: SubstsRef<'tcx>,
1584 origin: &hir::OpaqueTyOrigin,
1586 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1587 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1590 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1591 /// in "inheriting lifetimes".
1592 fn check_opaque_for_inheriting_lifetimes(
1597 let item = tcx.hir().expect_item(
1598 tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1599 debug!("check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1600 def_id, span, item);
1603 struct ProhibitOpaqueVisitor<'tcx> {
1604 opaque_identity_ty: Ty<'tcx>,
1605 generics: &'tcx ty::Generics,
1608 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1609 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1610 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1611 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1614 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1615 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1616 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1617 return *index < self.generics.parent_count as u32;
1620 r.super_visit_with(self)
1624 let prohibit_opaque = match item.kind {
1625 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. }) |
1626 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1627 let mut visitor = ProhibitOpaqueVisitor {
1628 opaque_identity_ty: tcx.mk_opaque(
1629 def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1630 generics: tcx.generics_of(def_id),
1632 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1634 tcx.predicates_of(def_id).predicates.iter().any(
1635 |(predicate, _)| predicate.visit_with(&mut visitor))
1640 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1641 if prohibit_opaque {
1642 let is_async = match item.kind {
1643 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1644 hir::OpaqueTyOrigin::AsyncFn => true,
1647 _ => unreachable!(),
1650 tcx.sess.span_err(span, &format!(
1651 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1653 if is_async { "async fn" } else { "impl Trait" },
1658 /// Checks that an opaque type does not contain cycles.
1659 fn check_opaque_for_cycles<'tcx>(
1662 substs: SubstsRef<'tcx>,
1664 origin: &hir::OpaqueTyOrigin,
1666 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1667 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1669 tcx.sess, span, E0733,
1670 "recursion in an `async fn` requires boxing",
1672 .span_label(span, "recursive `async fn`")
1673 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
1676 let mut err = struct_span_err!(
1677 tcx.sess, span, E0720,
1678 "opaque type expands to a recursive type",
1680 err.span_label(span, "expands to a recursive type");
1681 if let ty::Opaque(..) = partially_expanded_type.kind {
1682 err.note("type resolves to itself");
1684 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1691 // Forbid defining intrinsics in Rust code,
1692 // as they must always be defined by the compiler.
1693 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1694 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1695 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1699 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
1701 "check_item_type(it.hir_id={}, it.name={})",
1703 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1705 let _indenter = indenter();
1707 // Consts can play a role in type-checking, so they are included here.
1708 hir::ItemKind::Static(..) => {
1709 let def_id = tcx.hir().local_def_id(it.hir_id);
1710 tcx.typeck_tables_of(def_id);
1711 maybe_check_static_with_link_section(tcx, def_id, it.span);
1713 hir::ItemKind::Const(..) => {
1714 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1716 hir::ItemKind::Enum(ref enum_definition, _) => {
1717 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1719 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1720 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1721 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1722 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1723 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1724 check_impl_items_against_trait(
1731 let trait_def_id = impl_trait_ref.def_id;
1732 check_on_unimplemented(tcx, trait_def_id, it);
1735 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1736 let def_id = tcx.hir().local_def_id(it.hir_id);
1737 check_on_unimplemented(tcx, def_id, it);
1739 for item in items.iter() {
1740 let item = tcx.hir().trait_item(item.id);
1741 if let hir::TraitItemKind::Method(sig, _) = &item.kind {
1742 let abi = sig.header.abi;
1743 fn_maybe_err(tcx, item.ident.span, abi);
1747 hir::ItemKind::Struct(..) => {
1748 check_struct(tcx, it.hir_id, it.span);
1750 hir::ItemKind::Union(..) => {
1751 check_union(tcx, it.hir_id, it.span);
1753 hir::ItemKind::OpaqueTy(hir::OpaqueTy{origin, ..}) => {
1754 let def_id = tcx.hir().local_def_id(it.hir_id);
1756 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1757 check_opaque(tcx, def_id, substs, it.span, &origin);
1759 hir::ItemKind::TyAlias(..) => {
1760 let def_id = tcx.hir().local_def_id(it.hir_id);
1761 let pty_ty = tcx.type_of(def_id);
1762 let generics = tcx.generics_of(def_id);
1763 check_bounds_are_used(tcx, &generics, pty_ty);
1765 hir::ItemKind::ForeignMod(ref m) => {
1766 check_abi(tcx, it.span, m.abi);
1768 if m.abi == Abi::RustIntrinsic {
1769 for item in m.items {
1770 intrinsic::check_intrinsic_type(tcx, item);
1772 } else if m.abi == Abi::PlatformIntrinsic {
1773 for item in m.items {
1774 intrinsic::check_platform_intrinsic_type(tcx, item);
1777 for item in m.items {
1778 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1779 let own_counts = generics.own_counts();
1780 if generics.params.len() - own_counts.lifetimes != 0 {
1781 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1782 (_, 0) => ("type", "types", Some("u32")),
1783 // We don't specify an example value, because we can't generate
1784 // a valid value for any type.
1785 (0, _) => ("const", "consts", None),
1786 _ => ("type or const", "types or consts", None),
1792 "foreign items may not have {} parameters",
1796 &format!("can't have {} parameters", kinds),
1798 // FIXME: once we start storing spans for type arguments, turn this
1799 // into a suggestion.
1801 "replace the {} parameters with concrete {}{}",
1804 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1809 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1810 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1815 _ => { /* nothing to do */ }
1819 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1820 // Only restricted on wasm32 target for now
1821 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1825 // If `#[link_section]` is missing, then nothing to verify
1826 let attrs = tcx.codegen_fn_attrs(id);
1827 if attrs.link_section.is_none() {
1831 // For the wasm32 target statics with `#[link_section]` are placed into custom
1832 // sections of the final output file, but this isn't link custom sections of
1833 // other executable formats. Namely we can only embed a list of bytes,
1834 // nothing with pointers to anything else or relocations. If any relocation
1835 // show up, reject them here.
1836 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1837 // the consumer's responsibility to ensure all bytes that have been read
1838 // have defined values.
1839 let instance = ty::Instance::mono(tcx, id);
1840 let cid = GlobalId {
1844 let param_env = ty::ParamEnv::reveal_all();
1845 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1846 let alloc = if let ty::ConstKind::Value(ConstValue::ByRef { alloc, .. }) = static_.val {
1849 bug!("Matching on non-ByRef static")
1851 if alloc.relocations().len() != 0 {
1852 let msg = "statics with a custom `#[link_section]` must be a \
1853 simple list of bytes on the wasm target with no \
1854 extra levels of indirection such as references";
1855 tcx.sess.span_err(span, msg);
1860 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
1861 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1862 // an error would be reported if this fails.
1863 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1866 fn report_forbidden_specialization(
1868 impl_item: &hir::ImplItem<'_>,
1871 let mut err = struct_span_err!(
1872 tcx.sess, impl_item.span, E0520,
1873 "`{}` specializes an item from a parent `impl`, but \
1874 that item is not marked `default`",
1876 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1879 match tcx.span_of_impl(parent_impl) {
1881 err.span_label(span, "parent `impl` is here");
1882 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1886 err.note(&format!("parent implementation is in crate `{}`", cname));
1893 fn check_specialization_validity<'tcx>(
1895 trait_def: &ty::TraitDef,
1896 trait_item: &ty::AssocItem,
1898 impl_item: &hir::ImplItem<'_>,
1900 let kind = match impl_item.kind {
1901 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1902 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1903 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1904 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1907 let mut ancestor_impls = trait_def.ancestors(tcx, impl_id)
1909 .filter_map(|parent| {
1910 if parent.is_from_trait() {
1913 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
1918 if ancestor_impls.peek().is_none() {
1919 // No parent, nothing to specialize.
1923 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1925 // Parent impl exists, and contains the parent item we're trying to specialize, but
1926 // doesn't mark it `default`.
1927 Some(parent_item) if tcx.impl_item_is_final(&parent_item) => {
1928 Some(Err(parent_impl.def_id()))
1931 // Parent impl contains item and makes it specializable.
1936 // Parent impl doesn't mention the item. This means it's inherited from the
1937 // grandparent. In that case, if parent is a `default impl`, inherited items use the
1938 // "defaultness" from the grandparent, else they are final.
1939 None => if tcx.impl_is_default(parent_impl.def_id()) {
1942 Some(Err(parent_impl.def_id()))
1947 // If `opt_result` is `None`, we have only encoutered `default impl`s that don't contain the
1948 // item. This is allowed, the item isn't actually getting specialized here.
1949 let result = opt_result.unwrap_or(Ok(()));
1951 if let Err(parent_impl) = result {
1952 report_forbidden_specialization(tcx, impl_item, parent_impl);
1956 fn check_impl_items_against_trait<'tcx>(
1958 full_impl_span: Span,
1960 impl_trait_ref: ty::TraitRef<'tcx>,
1961 impl_item_refs: &[hir::ImplItemRef],
1963 let impl_span = tcx.sess.source_map().def_span(full_impl_span);
1965 // If the trait reference itself is erroneous (so the compilation is going
1966 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1967 // isn't populated for such impls.
1968 if impl_trait_ref.references_error() { return; }
1970 // Locate trait definition and items
1971 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1972 let mut overridden_associated_type = None;
1974 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1976 // Check existing impl methods to see if they are both present in trait
1977 // and compatible with trait signature
1978 for impl_item in impl_items() {
1979 let ty_impl_item = tcx.associated_item(
1980 tcx.hir().local_def_id(impl_item.hir_id));
1981 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1982 .find(|ac| Namespace::from(&impl_item.kind) == Namespace::from(ac.kind) &&
1983 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1985 // Not compatible, but needed for the error message
1986 tcx.associated_items(impl_trait_ref.def_id)
1987 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1990 // Check that impl definition matches trait definition
1991 if let Some(ty_trait_item) = ty_trait_item {
1992 match impl_item.kind {
1993 hir::ImplItemKind::Const(..) => {
1994 // Find associated const definition.
1995 if ty_trait_item.kind == ty::AssocKind::Const {
1996 compare_const_impl(tcx,
2002 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
2003 "item `{}` is an associated const, \
2004 which doesn't match its trait `{}`",
2006 impl_trait_ref.print_only_trait_path());
2007 err.span_label(impl_item.span, "does not match trait");
2008 // We can only get the spans from local trait definition
2009 // Same for E0324 and E0325
2010 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2011 err.span_label(trait_span, "item in trait");
2016 hir::ImplItemKind::Method(..) => {
2017 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2018 if ty_trait_item.kind == ty::AssocKind::Method {
2019 compare_impl_method(tcx,
2026 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
2027 "item `{}` is an associated method, \
2028 which doesn't match its trait `{}`",
2030 impl_trait_ref.print_only_trait_path());
2031 err.span_label(impl_item.span, "does not match trait");
2032 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2033 err.span_label(trait_span, "item in trait");
2038 hir::ImplItemKind::OpaqueTy(..) |
2039 hir::ImplItemKind::TyAlias(_) => {
2040 if ty_trait_item.kind == ty::AssocKind::Type {
2041 if ty_trait_item.defaultness.has_value() {
2042 overridden_associated_type = Some(impl_item);
2045 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
2046 "item `{}` is an associated type, \
2047 which doesn't match its trait `{}`",
2049 impl_trait_ref.print_only_trait_path());
2050 err.span_label(impl_item.span, "does not match trait");
2051 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2052 err.span_label(trait_span, "item in trait");
2059 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
2063 // Check for missing items from trait
2064 let mut missing_items = Vec::new();
2065 let mut invalidated_items = Vec::new();
2066 let associated_type_overridden = overridden_associated_type.is_some();
2067 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
2068 let is_implemented = trait_def.ancestors(tcx, impl_id)
2069 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2070 .map(|node_item| !node_item.node.is_from_trait())
2073 if !is_implemented && !tcx.impl_is_default(impl_id) {
2074 if !trait_item.defaultness.has_value() {
2075 missing_items.push(trait_item);
2076 } else if associated_type_overridden {
2077 invalidated_items.push(trait_item.ident);
2082 if !missing_items.is_empty() {
2083 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2086 if !invalidated_items.is_empty() {
2087 let invalidator = overridden_associated_type.unwrap();
2092 "the following trait items need to be reimplemented as `{}` was overridden: `{}`",
2094 invalidated_items.iter()
2095 .map(|name| name.to_string())
2096 .collect::<Vec<_>>().join("`, `")
2101 fn missing_items_err(
2104 missing_items: &[ty::AssocItem],
2105 full_impl_span: Span,
2107 let missing_items_msg = missing_items.iter()
2108 .map(|trait_item| trait_item.ident.to_string())
2109 .collect::<Vec<_>>().join("`, `");
2111 let mut err = struct_span_err!(
2115 "not all trait items implemented, missing: `{}`",
2118 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2120 // `Span` before impl block closing brace.
2121 let hi = full_impl_span.hi() - BytePos(1);
2122 // Point at the place right before the closing brace of the relevant `impl` to suggest
2123 // adding the associated item at the end of its body.
2124 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2125 // Obtain the level of indentation ending in `sugg_sp`.
2126 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2127 // Make the whitespace that will make the suggestion have the right indentation.
2128 let padding: String = (0..indentation).map(|_| " ").collect();
2130 for trait_item in missing_items {
2131 let snippet = suggestion_signature(&trait_item, tcx);
2132 let code = format!("{}{}\n{}", padding, snippet, padding);
2133 let msg = format!("implement the missing item: `{}`", snippet);
2134 let appl = Applicability::HasPlaceholders;
2135 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2136 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2137 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2139 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2145 /// Return placeholder code for the given function.
2146 fn fn_sig_suggestion(sig: &ty::FnSig<'_>, ident: Ident) -> String {
2147 let args = sig.inputs()
2149 .map(|ty| Some(match ty.kind {
2150 ty::Param(param) if param.name == kw::SelfUpper => "self".to_string(),
2151 ty::Ref(reg, ref_ty, mutability) => {
2152 let reg = match &format!("{}", reg)[..] {
2153 "'_" | "" => String::new(),
2154 reg => format!("{} ", reg),
2157 ty::Param(param) if param.name == kw::SelfUpper => {
2158 format!("&{}{}self", reg, mutability.prefix_str())
2160 _ => format!("_: {:?}", ty),
2163 _ => format!("_: {:?}", ty),
2165 .chain(std::iter::once(if sig.c_variadic {
2166 Some("...".to_string())
2170 .filter_map(|arg| arg)
2171 .collect::<Vec<String>>()
2173 let output = sig.output();
2174 let output = if !output.is_unit() {
2175 format!(" -> {:?}", output)
2180 let unsafety = sig.unsafety.prefix_str();
2181 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2182 // not be present in the `fn` definition, not will we account for renamed
2183 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2184 // fill in a significant portion of the missing code, and other subsequent
2185 // suggestions can help the user fix the code.
2186 format!("{}fn {}({}){} {{ unimplemented!() }}", unsafety, ident, args, output)
2189 /// Return placeholder code for the given associated item.
2190 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2191 /// structured suggestion.
2192 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2194 ty::AssocKind::Method => {
2195 // We skip the binder here because the binder would deanonymize all
2196 // late-bound regions, and we don't want method signatures to show up
2197 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2198 // regions just fine, showing `fn(&MyType)`.
2199 fn_sig_suggestion(tcx.fn_sig(assoc.def_id).skip_binder(), assoc.ident)
2201 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2202 // FIXME(type_alias_impl_trait): we should print bounds here too.
2203 ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident),
2204 ty::AssocKind::Const => {
2205 let ty = tcx.type_of(assoc.def_id);
2206 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2207 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2212 /// Checks whether a type can be represented in memory. In particular, it
2213 /// identifies types that contain themselves without indirection through a
2214 /// pointer, which would mean their size is unbounded.
2215 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
2216 let rty = tcx.type_of(item_def_id);
2218 // Check that it is possible to represent this type. This call identifies
2219 // (1) types that contain themselves and (2) types that contain a different
2220 // recursive type. It is only necessary to throw an error on those that
2221 // contain themselves. For case 2, there must be an inner type that will be
2222 // caught by case 1.
2223 match rty.is_representable(tcx, sp) {
2224 Representability::SelfRecursive(spans) => {
2225 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
2227 err.span_label(span, "recursive without indirection");
2232 Representability::Representable | Representability::ContainsRecursive => (),
2237 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2238 let t = tcx.type_of(def_id);
2239 if let ty::Adt(def, substs) = t.kind {
2240 if def.is_struct() {
2241 let fields = &def.non_enum_variant().fields;
2242 if fields.is_empty() {
2243 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
2246 let e = fields[0].ty(tcx, substs);
2247 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2248 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2249 .span_label(sp, "SIMD elements must have the same type")
2254 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2255 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2257 span_err!(tcx.sess, sp, E0077,
2258 "SIMD vector element type should be machine type");
2266 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2267 let repr = tcx.adt_def(def_id).repr;
2269 for attr in tcx.get_attrs(def_id).iter() {
2270 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2271 if let attr::ReprPacked(pack) = r {
2272 if let Some(repr_pack) = repr.pack {
2273 if pack as u64 != repr_pack.bytes() {
2275 tcx.sess, sp, E0634,
2276 "type has conflicting packed representation hints"
2283 if repr.align.is_some() {
2284 struct_span_err!(tcx.sess, sp, E0587,
2285 "type has conflicting packed and align representation hints").emit();
2287 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
2288 struct_span_err!(tcx.sess, sp, E0588,
2289 "packed type cannot transitively contain a `[repr(align)]` type").emit();
2294 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
2295 let t = tcx.type_of(def_id);
2296 if stack.contains(&def_id) {
2297 debug!("check_packed_inner: {:?} is recursive", t);
2300 if let ty::Adt(def, substs) = t.kind {
2301 if def.is_struct() || def.is_union() {
2302 if tcx.adt_def(def.did).repr.align.is_some() {
2305 // push struct def_id before checking fields
2307 for field in &def.non_enum_variant().fields {
2308 let f = field.ty(tcx, substs);
2309 if let ty::Adt(def, _) = f.kind {
2310 if check_packed_inner(tcx, def.did, stack) {
2315 // only need to pop if not early out
2322 /// Emit an error when encountering more or less than one variant in a transparent enum.
2323 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2324 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
2325 tcx.hir().span_if_local(variant.def_id).unwrap()
2328 "needs exactly one variant, but has {}",
2331 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2332 err.span_label(sp, &msg);
2333 if let [start @ .., end] = &*variant_spans {
2334 for variant_span in start {
2335 err.span_label(*variant_span, "");
2337 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2342 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2344 fn bad_non_zero_sized_fields<'tcx>(
2346 adt: &'tcx ty::AdtDef,
2348 field_spans: impl Iterator<Item = Span>,
2351 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2352 let mut err = struct_span_err!(
2356 "{}transparent {} {}",
2357 if adt.is_enum() { "the variant of a " } else { "" },
2361 err.span_label(sp, &msg);
2362 for sp in field_spans {
2363 err.span_label(sp, "this field is non-zero-sized");
2368 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2369 let adt = tcx.adt_def(def_id);
2370 if !adt.repr.transparent() {
2373 let sp = tcx.sess.source_map().def_span(sp);
2375 if adt.is_enum() && !tcx.features().transparent_enums {
2377 &tcx.sess.parse_sess,
2378 sym::transparent_enums,
2380 "transparent enums are unstable",
2385 if adt.is_union() && !tcx.features().transparent_unions {
2387 &tcx.sess.parse_sess,
2388 sym::transparent_unions,
2390 "transparent unions are unstable",
2395 if adt.variants.len() != 1 {
2396 bad_variant_count(tcx, adt, sp, def_id);
2397 if adt.variants.is_empty() {
2398 // Don't bother checking the fields. No variants (and thus no fields) exist.
2403 // For each field, figure out if it's known to be a ZST and align(1)
2404 let field_infos = adt.all_fields().map(|field| {
2405 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2406 let param_env = tcx.param_env(field.did);
2407 let layout = tcx.layout_of(param_env.and(ty));
2408 // We are currently checking the type this field came from, so it must be local
2409 let span = tcx.hir().span_if_local(field.did).unwrap();
2410 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2411 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2415 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
2420 let non_zst_count = non_zst_fields.clone().count();
2421 if non_zst_count != 1 {
2422 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2424 for (span, zst, align1) in field_infos {
2430 "zero-sized field in transparent {} has alignment larger than 1",
2432 ).span_label(span, "has alignment larger than 1").emit();
2437 #[allow(trivial_numeric_casts)]
2438 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant<'tcx>], id: hir::HirId) {
2439 let def_id = tcx.hir().local_def_id(id);
2440 let def = tcx.adt_def(def_id);
2441 def.destructor(tcx); // force the destructor to be evaluated
2444 let attributes = tcx.get_attrs(def_id);
2445 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2447 tcx.sess, attr.span, E0084,
2448 "unsupported representation for zero-variant enum")
2449 .span_label(sp, "zero-variant enum")
2454 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2455 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2456 if !tcx.features().repr128 {
2458 &tcx.sess.parse_sess,
2461 "repr with 128-bit type is unstable",
2468 if let Some(ref e) = v.disr_expr {
2469 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2473 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2475 |var: &hir::Variant<'_>| match var.data {
2476 hir::VariantData::Unit(..) => true,
2480 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2481 let has_non_units = vs.iter().any(|var| !is_unit(var));
2482 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2483 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2485 if disr_non_unit || (disr_units && has_non_units) {
2486 let mut err = struct_span_err!(tcx.sess, sp, E0732,
2487 "`#[repr(inttype)]` must be specified");
2492 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2493 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2494 // Check for duplicate discriminant values
2495 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2496 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2497 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2498 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2499 let i_span = match variant_i.disr_expr {
2500 Some(ref expr) => tcx.hir().span(expr.hir_id),
2501 None => tcx.hir().span(variant_i_hir_id)
2503 let span = match v.disr_expr {
2504 Some(ref expr) => tcx.hir().span(expr.hir_id),
2507 struct_span_err!(tcx.sess, span, E0081,
2508 "discriminant value `{}` already exists", disr_vals[i])
2509 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2510 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
2513 disr_vals.push(discr);
2516 check_representable(tcx, sp, def_id);
2517 check_transparent(tcx, sp, def_id);
2520 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2521 span_err!(tcx.sess, span, E0533,
2522 "expected unit struct, unit variant or constant, found {} `{}`",
2524 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2527 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2528 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2532 fn item_def_id(&self) -> Option<DefId> {
2536 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2538 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2539 let item_id = tcx.hir().ty_param_owner(hir_id);
2540 let item_def_id = tcx.hir().local_def_id(item_id);
2541 let generics = tcx.generics_of(item_def_id);
2542 let index = generics.param_def_id_to_index[&def_id];
2543 ty::GenericPredicates {
2545 predicates: tcx.arena.alloc_from_iter(
2546 self.param_env.caller_bounds.iter().filter_map(|&predicate| match predicate {
2547 ty::Predicate::Trait(ref data)
2548 if data.skip_binder().self_ty().is_param(index) => {
2549 // HACK(eddyb) should get the original `Span`.
2550 let span = tcx.def_span(def_id);
2551 Some((predicate, span))
2561 def: Option<&ty::GenericParamDef>,
2563 ) -> Option<ty::Region<'tcx>> {
2565 Some(def) => infer::EarlyBoundRegion(span, def.name),
2566 None => infer::MiscVariable(span)
2568 Some(self.next_region_var(v))
2571 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2572 if let Some(param) = param {
2573 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2578 self.next_ty_var(TypeVariableOrigin {
2579 kind: TypeVariableOriginKind::TypeInference,
2588 param: Option<&ty::GenericParamDef>,
2590 ) -> &'tcx Const<'tcx> {
2591 if let Some(param) = param {
2592 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2597 self.next_const_var(ty, ConstVariableOrigin {
2598 kind: ConstVariableOriginKind::ConstInference,
2604 fn projected_ty_from_poly_trait_ref(&self,
2607 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2610 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2612 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2616 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2619 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2620 if ty.has_escaping_bound_vars() {
2621 ty // FIXME: normalization and escaping regions
2623 self.normalize_associated_types_in(span, &ty)
2627 fn set_tainted_by_errors(&self) {
2628 self.infcx.set_tainted_by_errors()
2631 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2632 self.write_ty(hir_id, ty)
2636 /// Controls whether the arguments are tupled. This is used for the call
2639 /// Tupling means that all call-side arguments are packed into a tuple and
2640 /// passed as a single parameter. For example, if tupling is enabled, this
2643 /// fn f(x: (isize, isize))
2645 /// Can be called as:
2652 #[derive(Clone, Eq, PartialEq)]
2653 enum TupleArgumentsFlag {
2658 /// Controls how we perform fallback for unconstrained
2661 /// Do not fallback type variables to opaque types.
2663 /// Perform all possible kinds of fallback, including
2664 /// turning type variables to opaque types.
2668 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2670 inh: &'a Inherited<'a, 'tcx>,
2671 param_env: ty::ParamEnv<'tcx>,
2672 body_id: hir::HirId,
2673 ) -> FnCtxt<'a, 'tcx> {
2677 err_count_on_creation: inh.tcx.sess.err_count(),
2679 ret_coercion_span: RefCell::new(None),
2681 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2682 hir::CRATE_HIR_ID)),
2683 diverges: Cell::new(Diverges::Maybe),
2684 has_errors: Cell::new(false),
2685 enclosing_breakables: RefCell::new(EnclosingBreakables {
2687 by_id: Default::default(),
2693 pub fn sess(&self) -> &Session {
2697 pub fn errors_reported_since_creation(&self) -> bool {
2698 self.tcx.sess.err_count() > self.err_count_on_creation
2701 /// Produces warning on the given node, if the current point in the
2702 /// function is unreachable, and there hasn't been another warning.
2703 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2704 // FIXME: Combine these two 'if' expressions into one once
2705 // let chains are implemented
2706 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2707 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2708 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2709 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2710 if !span.is_desugaring(DesugaringKind::CondTemporary) &&
2711 !span.is_desugaring(DesugaringKind::Async) &&
2712 !orig_span.is_desugaring(DesugaringKind::Await)
2714 self.diverges.set(Diverges::WarnedAlways);
2716 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2718 let msg = format!("unreachable {}", kind);
2719 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2720 .span_label(span, &msg)
2723 custom_note.unwrap_or("any code following this expression is unreachable"),
2732 code: ObligationCauseCode<'tcx>)
2733 -> ObligationCause<'tcx> {
2734 ObligationCause::new(span, self.body_id, code)
2737 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2738 self.cause(span, ObligationCauseCode::MiscObligation)
2741 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
2742 /// version (resolve_vars_if_possible), this version will
2743 /// also select obligations if it seems useful, in an effort
2744 /// to get more type information.
2745 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2746 debug!("resolve_vars_with_obligations(ty={:?})", ty);
2748 // No Infer()? Nothing needs doing.
2749 if !ty.has_infer_types() && !ty.has_infer_consts() {
2750 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2754 // If `ty` is a type variable, see whether we already know what it is.
2755 ty = self.resolve_vars_if_possible(&ty);
2756 if !ty.has_infer_types() && !ty.has_infer_consts() {
2757 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2761 // If not, try resolving pending obligations as much as
2762 // possible. This can help substantially when there are
2763 // indirect dependencies that don't seem worth tracking
2765 self.select_obligations_where_possible(false, |_| {});
2766 ty = self.resolve_vars_if_possible(&ty);
2768 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2772 fn record_deferred_call_resolution(
2774 closure_def_id: DefId,
2775 r: DeferredCallResolution<'tcx>,
2777 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2778 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2781 fn remove_deferred_call_resolutions(
2783 closure_def_id: DefId,
2784 ) -> Vec<DeferredCallResolution<'tcx>> {
2785 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2786 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2789 pub fn tag(&self) -> String {
2790 format!("{:p}", self)
2793 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2794 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2795 span_bug!(span, "no type for local variable {}",
2796 self.tcx.hir().node_to_string(nid))
2801 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2802 debug!("write_ty({:?}, {:?}) in fcx {}",
2803 id, self.resolve_vars_if_possible(&ty), self.tag());
2804 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2806 if ty.references_error() {
2807 self.has_errors.set(true);
2808 self.set_tainted_by_errors();
2812 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2813 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2816 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2817 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2820 pub fn write_method_call(&self,
2822 method: MethodCallee<'tcx>) {
2823 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2824 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2825 self.write_substs(hir_id, method.substs);
2827 // When the method is confirmed, the `method.substs` includes
2828 // parameters from not just the method, but also the impl of
2829 // the method -- in particular, the `Self` type will be fully
2830 // resolved. However, those are not something that the "user
2831 // specified" -- i.e., those types come from the inferred type
2832 // of the receiver, not something the user wrote. So when we
2833 // create the user-substs, we want to replace those earlier
2834 // types with just the types that the user actually wrote --
2835 // that is, those that appear on the *method itself*.
2837 // As an example, if the user wrote something like
2838 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2839 // type of `foo` (possibly adjusted), but we don't want to
2840 // include that. We want just the `[_, u32]` part.
2841 if !method.substs.is_noop() {
2842 let method_generics = self.tcx.generics_of(method.def_id);
2843 if !method_generics.params.is_empty() {
2844 let user_type_annotation = self.infcx.probe(|_| {
2845 let user_substs = UserSubsts {
2846 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2847 let i = param.index as usize;
2848 if i < method_generics.parent_count {
2849 self.infcx.var_for_def(DUMMY_SP, param)
2854 user_self_ty: None, // not relevant here
2857 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2863 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2864 self.write_user_type_annotation(hir_id, user_type_annotation);
2869 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2870 if !substs.is_noop() {
2871 debug!("write_substs({:?}, {:?}) in fcx {}",
2876 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2880 /// Given the substs that we just converted from the HIR, try to
2881 /// canonicalize them and store them as user-given substitutions
2882 /// (i.e., substitutions that must be respected by the NLL check).
2884 /// This should be invoked **before any unifications have
2885 /// occurred**, so that annotations like `Vec<_>` are preserved
2887 pub fn write_user_type_annotation_from_substs(
2891 substs: SubstsRef<'tcx>,
2892 user_self_ty: Option<UserSelfTy<'tcx>>,
2895 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2896 user_self_ty={:?} in fcx {}",
2897 hir_id, def_id, substs, user_self_ty, self.tag(),
2900 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2901 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2902 &UserType::TypeOf(def_id, UserSubsts {
2907 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2908 self.write_user_type_annotation(hir_id, canonicalized);
2912 pub fn write_user_type_annotation(
2915 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2918 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2919 hir_id, canonical_user_type_annotation, self.tag(),
2922 if !canonical_user_type_annotation.is_identity() {
2923 self.tables.borrow_mut().user_provided_types_mut().insert(
2924 hir_id, canonical_user_type_annotation
2927 debug!("write_user_type_annotation: skipping identity substs");
2931 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2932 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2938 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2939 Entry::Vacant(entry) => { entry.insert(adj); },
2940 Entry::Occupied(mut entry) => {
2941 debug!(" - composing on top of {:?}", entry.get());
2942 match (&entry.get()[..], &adj[..]) {
2943 // Applying any adjustment on top of a NeverToAny
2944 // is a valid NeverToAny adjustment, because it can't
2946 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2948 Adjustment { kind: Adjust::Deref(_), .. },
2949 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2951 Adjustment { kind: Adjust::Deref(_), .. },
2952 .. // Any following adjustments are allowed.
2954 // A reborrow has no effect before a dereference.
2956 // FIXME: currently we never try to compose autoderefs
2957 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2959 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2960 expr, entry.get(), adj)
2962 *entry.get_mut() = adj;
2967 /// Basically whenever we are converting from a type scheme into
2968 /// the fn body space, we always want to normalize associated
2969 /// types as well. This function combines the two.
2970 fn instantiate_type_scheme<T>(&self,
2972 substs: SubstsRef<'tcx>,
2975 where T : TypeFoldable<'tcx>
2977 let value = value.subst(self.tcx, substs);
2978 let result = self.normalize_associated_types_in(span, &value);
2979 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2986 /// As `instantiate_type_scheme`, but for the bounds found in a
2987 /// generic type scheme.
2988 fn instantiate_bounds(
2992 substs: SubstsRef<'tcx>,
2993 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
2994 let bounds = self.tcx.predicates_of(def_id);
2995 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
2996 let result = bounds.instantiate(self.tcx, substs);
2997 let result = self.normalize_associated_types_in(span, &result);
2999 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3008 /// Replaces the opaque types from the given value with type variables,
3009 /// and records the `OpaqueTypeMap` for later use during writeback. See
3010 /// `InferCtxt::instantiate_opaque_types` for more details.
3011 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3013 parent_id: hir::HirId,
3017 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3018 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3022 let (value, opaque_type_map) = self.register_infer_ok_obligations(
3023 self.instantiate_opaque_types(
3032 let mut opaque_types = self.opaque_types.borrow_mut();
3033 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3034 for (ty, decl) in opaque_type_map {
3035 let _ = opaque_types.insert(ty, decl);
3036 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3042 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3043 where T : TypeFoldable<'tcx>
3045 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3048 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
3050 where T : TypeFoldable<'tcx>
3052 self.inh.partially_normalize_associated_types_in(span,
3058 pub fn require_type_meets(&self,
3061 code: traits::ObligationCauseCode<'tcx>,
3064 self.register_bound(
3067 traits::ObligationCause::new(span, self.body_id, code));
3070 pub fn require_type_is_sized(
3074 code: traits::ObligationCauseCode<'tcx>,
3076 if !ty.references_error() {
3077 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
3078 self.require_type_meets(ty, span, code, lang_item);
3082 pub fn require_type_is_sized_deferred(
3086 code: traits::ObligationCauseCode<'tcx>,
3088 if !ty.references_error() {
3089 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3093 pub fn register_bound(
3097 cause: traits::ObligationCause<'tcx>,
3099 if !ty.references_error() {
3100 self.fulfillment_cx.borrow_mut()
3101 .register_bound(self, self.param_env, ty, def_id, cause);
3105 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
3106 let t = AstConv::ast_ty_to_ty(self, ast_t);
3107 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
3111 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
3112 let ty = self.to_ty(ast_ty);
3113 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3115 if Self::can_contain_user_lifetime_bounds(ty) {
3116 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3117 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3118 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3124 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
3125 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
3126 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
3129 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
3130 AstConv::ast_const_to_const(self, ast_c, ty)
3133 // If the type given by the user has free regions, save it for later, since
3134 // NLL would like to enforce those. Also pass in types that involve
3135 // projections, since those can resolve to `'static` bounds (modulo #54940,
3136 // which hopefully will be fixed by the time you see this comment, dear
3137 // reader, although I have my doubts). Also pass in types with inference
3138 // types, because they may be repeated. Other sorts of things are already
3139 // sufficiently enforced with erased regions. =)
3140 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3142 T: TypeFoldable<'tcx>
3144 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3147 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3148 match self.tables.borrow().node_types().get(id) {
3150 None if self.is_tainted_by_errors() => self.tcx.types.err,
3152 bug!("no type for node {}: {} in fcx {}",
3153 id, self.tcx.hir().node_to_string(id),
3159 /// Registers an obligation for checking later, during regionck, that the type `ty` must
3160 /// outlive the region `r`.
3161 pub fn register_wf_obligation(
3165 code: traits::ObligationCauseCode<'tcx>,
3167 // WF obligations never themselves fail, so no real need to give a detailed cause:
3168 let cause = traits::ObligationCause::new(span, self.body_id, code);
3169 self.register_predicate(
3170 traits::Obligation::new(cause, self.param_env, ty::Predicate::WellFormed(ty)),
3174 /// Registers obligations that all types appearing in `substs` are well-formed.
3175 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
3176 for ty in substs.types() {
3177 if !ty.references_error() {
3178 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
3183 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3184 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3185 /// trait/region obligations.
3187 /// For example, if there is a function:
3190 /// fn foo<'a,T:'a>(...)
3193 /// and a reference:
3199 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3200 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3201 pub fn add_obligations_for_parameters(&self,
3202 cause: traits::ObligationCause<'tcx>,
3203 predicates: &ty::InstantiatedPredicates<'tcx>)
3205 assert!(!predicates.has_escaping_bound_vars());
3207 debug!("add_obligations_for_parameters(predicates={:?})",
3210 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3211 self.register_predicate(obligation);
3215 // FIXME(arielb1): use this instead of field.ty everywhere
3216 // Only for fields! Returns <none> for methods>
3217 // Indifferent to privacy flags
3221 field: &'tcx ty::FieldDef,
3222 substs: SubstsRef<'tcx>,
3224 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3227 fn check_casts(&self) {
3228 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3229 for cast in deferred_cast_checks.drain(..) {
3234 fn resolve_generator_interiors(&self, def_id: DefId) {
3235 let mut generators = self.deferred_generator_interiors.borrow_mut();
3236 for (body_id, interior, kind) in generators.drain(..) {
3237 self.select_obligations_where_possible(false, |_| {});
3238 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3242 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3244 // - Unconstrained ints are replaced with `i32`.
3246 // - Unconstrained floats are replaced with with `f64`.
3248 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3249 // is enabled. Otherwise, they are replaced with `()`.
3251 // Fallback becomes very dubious if we have encountered type-checking errors.
3252 // In that case, fallback to Error.
3253 // The return value indicates whether fallback has occurred.
3254 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3255 use rustc::ty::error::UnconstrainedNumeric::Neither;
3256 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
3258 assert!(ty.is_ty_infer());
3259 let fallback = match self.type_is_unconstrained_numeric(ty) {
3260 _ if self.is_tainted_by_errors() => self.tcx().types.err,
3261 UnconstrainedInt => self.tcx.types.i32,
3262 UnconstrainedFloat => self.tcx.types.f64,
3263 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3265 // This type variable was created from the instantiation of an opaque
3266 // type. The fact that we're attempting to perform fallback for it
3267 // means that the function neither constrained it to a concrete
3268 // type, nor to the opaque type itself.
3270 // For example, in this code:
3273 // type MyType = impl Copy;
3274 // fn defining_use() -> MyType { true }
3275 // fn other_use() -> MyType { defining_use() }
3278 // `defining_use` will constrain the instantiated inference
3279 // variable to `bool`, while `other_use` will constrain
3280 // the instantiated inference variable to `MyType`.
3282 // When we process opaque types during writeback, we
3283 // will handle cases like `other_use`, and not count
3284 // them as defining usages
3286 // However, we also need to handle cases like this:
3289 // pub type Foo = impl Copy;
3290 // fn produce() -> Option<Foo> {
3295 // In the above snippet, the inference varaible created by
3296 // instantiating `Option<Foo>` will be completely unconstrained.
3297 // We treat this as a non-defining use by making the inference
3298 // variable fall back to the opaque type itself.
3299 if let FallbackMode::All = mode {
3300 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3301 debug!("fallback_if_possible: falling back opaque type var {:?} to {:?}",
3312 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3313 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
3317 fn select_all_obligations_or_error(&self) {
3318 debug!("select_all_obligations_or_error");
3319 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3320 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3324 /// Select as many obligations as we can at present.
3325 fn select_obligations_where_possible(
3327 fallback_has_occurred: bool,
3328 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3330 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3331 if let Err(mut errors) = result {
3332 mutate_fullfillment_errors(&mut errors);
3333 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3337 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3338 /// returns a type of `&T`, but the actual type we assign to the
3339 /// *expression* is `T`. So this function just peels off the return
3340 /// type by one layer to yield `T`.
3341 fn make_overloaded_place_return_type(&self,
3342 method: MethodCallee<'tcx>)
3343 -> ty::TypeAndMut<'tcx>
3345 // extract method return type, which will be &T;
3346 let ret_ty = method.sig.output();
3348 // method returns &T, but the type as visible to user is T, so deref
3349 ret_ty.builtin_deref(true).unwrap()
3355 base_expr: &'tcx hir::Expr,
3359 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3360 // FIXME(#18741) -- this is almost but not quite the same as the
3361 // autoderef that normal method probing does. They could likely be
3364 let mut autoderef = self.autoderef(base_expr.span, base_ty);
3365 let mut result = None;
3366 while result.is_none() && autoderef.next().is_some() {
3367 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
3369 autoderef.finalize(self);
3373 /// To type-check `base_expr[index_expr]`, we progressively autoderef
3374 /// (and otherwise adjust) `base_expr`, looking for a type which either
3375 /// supports builtin indexing or overloaded indexing.
3376 /// This loop implements one step in that search; the autoderef loop
3377 /// is implemented by `lookup_indexing`.
3381 base_expr: &hir::Expr,
3382 autoderef: &Autoderef<'a, 'tcx>,
3385 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3386 let adjusted_ty = autoderef.unambiguous_final_ty(self);
3387 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
3394 for &unsize in &[false, true] {
3395 let mut self_ty = adjusted_ty;
3397 // We only unsize arrays here.
3398 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3399 self_ty = self.tcx.mk_slice(element_ty);
3405 // If some lookup succeeds, write callee into table and extract index/element
3406 // type from the method signature.
3407 // If some lookup succeeded, install method in table
3408 let input_ty = self.next_ty_var(TypeVariableOrigin {
3409 kind: TypeVariableOriginKind::AutoDeref,
3410 span: base_expr.span,
3412 let method = self.try_overloaded_place_op(
3413 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
3415 let result = method.map(|ok| {
3416 debug!("try_index_step: success, using overloaded indexing");
3417 let method = self.register_infer_ok_obligations(ok);
3419 let mut adjustments = autoderef.adjust_steps(self, needs);
3420 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3421 let mutbl = match r_mutbl {
3422 hir::Mutability::Not => AutoBorrowMutability::Not,
3423 hir::Mutability::Mut => AutoBorrowMutability::Mut {
3424 // Indexing can be desugared to a method call,
3425 // so maybe we could use two-phase here.
3426 // See the documentation of AllowTwoPhase for why that's
3427 // not the case today.
3428 allow_two_phase_borrow: AllowTwoPhase::No,
3431 adjustments.push(Adjustment {
3432 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3433 target: self.tcx.mk_ref(region, ty::TypeAndMut {
3440 adjustments.push(Adjustment {
3441 kind: Adjust::Pointer(PointerCast::Unsize),
3442 target: method.sig.inputs()[0]
3445 self.apply_adjustments(base_expr, adjustments);
3447 self.write_method_call(expr.hir_id, method);
3448 (input_ty, self.make_overloaded_place_return_type(method).ty)
3450 if result.is_some() {
3458 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3459 let (tr, name) = match (op, is_mut) {
3460 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3461 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3462 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3463 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3465 (tr, ast::Ident::with_dummy_span(name))
3468 fn try_overloaded_place_op(&self,
3471 arg_tys: &[Ty<'tcx>],
3474 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
3476 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
3482 // Try Mut first, if needed.
3483 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3484 let method = match (needs, mut_tr) {
3485 (Needs::MutPlace, Some(trait_did)) => {
3486 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3491 // Otherwise, fall back to the immutable version.
3492 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3493 let method = match (method, imm_tr) {
3494 (None, Some(trait_did)) => {
3495 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3497 (method, _) => method,
3503 fn check_method_argument_types(
3506 expr: &'tcx hir::Expr,
3507 method: Result<MethodCallee<'tcx>, ()>,
3508 args_no_rcvr: &'tcx [hir::Expr],
3509 tuple_arguments: TupleArgumentsFlag,
3510 expected: Expectation<'tcx>,
3513 let has_error = match method {
3515 method.substs.references_error() || method.sig.references_error()
3520 let err_inputs = self.err_args(args_no_rcvr.len());
3522 let err_inputs = match tuple_arguments {
3523 DontTupleArguments => err_inputs,
3524 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3527 self.check_argument_types(
3537 return self.tcx.types.err;
3540 let method = method.unwrap();
3541 // HACK(eddyb) ignore self in the definition (see above).
3542 let expected_arg_tys = self.expected_inputs_for_expected_output(
3545 method.sig.output(),
3546 &method.sig.inputs()[1..]
3548 self.check_argument_types(
3551 &method.sig.inputs()[1..],
3552 &expected_arg_tys[..],
3554 method.sig.c_variadic,
3556 self.tcx.hir().span_if_local(method.def_id),
3561 fn self_type_matches_expected_vid(
3563 trait_ref: ty::PolyTraitRef<'tcx>,
3564 expected_vid: ty::TyVid,
3566 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3568 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3569 trait_ref, self_ty, expected_vid
3571 match self_ty.kind {
3572 ty::Infer(ty::TyVar(found_vid)) => {
3573 // FIXME: consider using `sub_root_var` here so we
3574 // can see through subtyping.
3575 let found_vid = self.root_var(found_vid);
3576 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3577 expected_vid == found_vid
3583 fn obligations_for_self_ty<'b>(
3586 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3589 // FIXME: consider using `sub_root_var` here so we
3590 // can see through subtyping.
3591 let ty_var_root = self.root_var(self_ty);
3592 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3593 self_ty, ty_var_root,
3594 self.fulfillment_cx.borrow().pending_obligations());
3598 .pending_obligations()
3600 .filter_map(move |obligation| match obligation.predicate {
3601 ty::Predicate::Projection(ref data) =>
3602 Some((data.to_poly_trait_ref(self.tcx), obligation)),
3603 ty::Predicate::Trait(ref data) =>
3604 Some((data.to_poly_trait_ref(), obligation)),
3605 ty::Predicate::Subtype(..) => None,
3606 ty::Predicate::RegionOutlives(..) => None,
3607 ty::Predicate::TypeOutlives(..) => None,
3608 ty::Predicate::WellFormed(..) => None,
3609 ty::Predicate::ObjectSafe(..) => None,
3610 ty::Predicate::ConstEvaluatable(..) => None,
3611 // N.B., this predicate is created by breaking down a
3612 // `ClosureType: FnFoo()` predicate, where
3613 // `ClosureType` represents some `Closure`. It can't
3614 // possibly be referring to the current closure,
3615 // because we haven't produced the `Closure` for
3616 // this closure yet; this is exactly why the other
3617 // code is looking for a self type of a unresolved
3618 // inference variable.
3619 ty::Predicate::ClosureKind(..) => None,
3620 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3623 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3624 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
3625 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
3629 /// Generic function that factors out common logic from function calls,
3630 /// method calls and overloaded operators.
3631 fn check_argument_types(
3634 expr: &'tcx hir::Expr,
3635 fn_inputs: &[Ty<'tcx>],
3636 expected_arg_tys: &[Ty<'tcx>],
3637 args: &'tcx [hir::Expr],
3639 tuple_arguments: TupleArgumentsFlag,
3640 def_span: Option<Span>,
3643 // Grab the argument types, supplying fresh type variables
3644 // if the wrong number of arguments were supplied
3645 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3651 // All the input types from the fn signature must outlive the call
3652 // so as to validate implied bounds.
3653 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3654 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3657 let expected_arg_count = fn_inputs.len();
3659 let param_count_error = |expected_count: usize,
3664 let mut err = tcx.sess.struct_span_err_with_code(sp,
3665 &format!("this function takes {}{} but {} {} supplied",
3666 if c_variadic { "at least " } else { "" },
3667 potentially_plural_count(expected_count, "parameter"),
3668 potentially_plural_count(arg_count, "parameter"),
3669 if arg_count == 1 {"was"} else {"were"}),
3670 DiagnosticId::Error(error_code.to_owned()));
3672 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3673 err.span_label(def_s, "defined here");
3676 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3677 // remove closing `)` from the span
3678 let sugg_span = sugg_span.shrink_to_lo();
3679 err.span_suggestion(
3681 "expected the unit value `()`; create it with empty parentheses",
3683 Applicability::MachineApplicable);
3685 err.span_label(sp, format!("expected {}{}",
3686 if c_variadic { "at least " } else { "" },
3687 potentially_plural_count(expected_count, "parameter")));
3692 let mut expected_arg_tys = expected_arg_tys.to_vec();
3694 let formal_tys = if tuple_arguments == TupleArguments {
3695 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3696 match tuple_type.kind {
3697 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3698 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3699 expected_arg_tys = vec![];
3700 self.err_args(args.len())
3702 ty::Tuple(arg_types) => {
3703 expected_arg_tys = match expected_arg_tys.get(0) {
3704 Some(&ty) => match ty.kind {
3705 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3710 arg_types.iter().map(|k| k.expect_ty()).collect()
3713 span_err!(tcx.sess, sp, E0059,
3714 "cannot use call notation; the first type parameter \
3715 for the function trait is neither a tuple nor unit");
3716 expected_arg_tys = vec![];
3717 self.err_args(args.len())
3720 } else if expected_arg_count == supplied_arg_count {
3722 } else if c_variadic {
3723 if supplied_arg_count >= expected_arg_count {
3726 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3727 expected_arg_tys = vec![];
3728 self.err_args(supplied_arg_count)
3731 // is the missing argument of type `()`?
3732 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3733 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3734 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3735 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3739 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3741 expected_arg_tys = vec![];
3742 self.err_args(supplied_arg_count)
3745 debug!("check_argument_types: formal_tys={:?}",
3746 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3748 // If there is no expectation, expect formal_tys.
3749 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3755 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
3757 // Check the arguments.
3758 // We do this in a pretty awful way: first we type-check any arguments
3759 // that are not closures, then we type-check the closures. This is so
3760 // that we have more information about the types of arguments when we
3761 // type-check the functions. This isn't really the right way to do this.
3762 for &check_closures in &[false, true] {
3763 debug!("check_closures={}", check_closures);
3765 // More awful hacks: before we check argument types, try to do
3766 // an "opportunistic" vtable resolution of any trait bounds on
3767 // the call. This helps coercions.
3769 self.select_obligations_where_possible(false, |errors| {
3770 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3771 self.point_at_arg_instead_of_call_if_possible(
3773 &final_arg_types[..],
3780 // For C-variadic functions, we don't have a declared type for all of
3781 // the arguments hence we only do our usual type checking with
3782 // the arguments who's types we do know.
3783 let t = if c_variadic {
3785 } else if tuple_arguments == TupleArguments {
3790 for (i, arg) in args.iter().take(t).enumerate() {
3791 // Warn only for the first loop (the "no closures" one).
3792 // Closure arguments themselves can't be diverging, but
3793 // a previous argument can, e.g., `foo(panic!(), || {})`.
3794 if !check_closures {
3795 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3798 let is_closure = match arg.kind {
3799 ExprKind::Closure(..) => true,
3803 if is_closure != check_closures {
3807 debug!("checking the argument");
3808 let formal_ty = formal_tys[i];
3810 // The special-cased logic below has three functions:
3811 // 1. Provide as good of an expected type as possible.
3812 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3814 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3816 // 2. Coerce to the most detailed type that could be coerced
3817 // to, which is `expected_ty` if `rvalue_hint` returns an
3818 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3819 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3820 // We're processing function arguments so we definitely want to use
3821 // two-phase borrows.
3822 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3823 final_arg_types.push((i, checked_ty, coerce_ty));
3825 // 3. Relate the expected type and the formal one,
3826 // if the expected type was used for the coercion.
3827 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3831 // We also need to make sure we at least write the ty of the other
3832 // arguments which we skipped above.
3834 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3835 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3836 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3839 for arg in args.iter().skip(expected_arg_count) {
3840 let arg_ty = self.check_expr(&arg);
3842 // There are a few types which get autopromoted when passed via varargs
3843 // in C but we just error out instead and require explicit casts.
3844 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3846 ty::Float(ast::FloatTy::F32) => {
3847 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3849 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3850 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3852 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3853 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3856 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3857 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3858 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3866 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3867 vec![self.tcx.types.err; len]
3870 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
3871 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
3872 /// reference a type argument. The reason to walk also the checked type is that the coerced type
3873 /// can be not easily comparable with predicate type (because of coercion). If the types match
3874 /// for either checked or coerced type, and there's only *one* argument that does, we point at
3875 /// the corresponding argument's expression span instead of the `fn` call path span.
3876 fn point_at_arg_instead_of_call_if_possible(
3878 errors: &mut Vec<traits::FulfillmentError<'_>>,
3879 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
3881 args: &'tcx [hir::Expr],
3883 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3884 // the `?` operator.
3885 if call_sp.desugaring_kind().is_some() {
3889 for error in errors {
3890 // Only if the cause is somewhere inside the expression we want try to point at arg.
3891 // Otherwise, it means that the cause is somewhere else and we should not change
3892 // anything because we can break the correct span.
3893 if !call_sp.contains(error.obligation.cause.span) {
3897 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3898 // Collect the argument position for all arguments that could have caused this
3899 // `FulfillmentError`.
3900 let mut referenced_in = final_arg_types.iter()
3901 .map(|(i, checked_ty, _)| (i, checked_ty))
3902 .chain(final_arg_types.iter().map(|(i, _, coerced_ty)| (i, coerced_ty)))
3903 .flat_map(|(i, ty)| {
3904 let ty = self.resolve_vars_if_possible(ty);
3905 // We walk the argument type because the argument's type could have
3906 // been `Option<T>`, but the `FulfillmentError` references `T`.
3908 .filter(|&ty| ty == predicate.skip_binder().self_ty())
3911 .collect::<Vec<_>>();
3913 // Both checked and coerced types could have matched, thus we need to remove
3915 referenced_in.dedup();
3917 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
3918 // We make sure that only *one* argument matches the obligation failure
3919 // and we assign the obligation's span to its expression's.
3920 error.obligation.cause.span = args[ref_in].span;
3921 error.points_at_arg_span = true;
3927 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
3928 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
3929 /// were caused by them. If they were, we point at the corresponding type argument's span
3930 /// instead of the `fn` call path span.
3931 fn point_at_type_arg_instead_of_call_if_possible(
3933 errors: &mut Vec<traits::FulfillmentError<'_>>,
3934 call_expr: &'tcx hir::Expr,
3936 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
3937 if let hir::ExprKind::Path(qpath) = &path.kind {
3938 if let hir::QPath::Resolved(_, path) = &qpath {
3939 for error in errors {
3940 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3941 // If any of the type arguments in this path segment caused the
3942 // `FullfillmentError`, point at its span (#61860).
3943 for arg in path.segments.iter()
3944 .filter_map(|seg| seg.args.as_ref())
3945 .flat_map(|a| a.args.iter())
3947 if let hir::GenericArg::Type(hir_ty) = &arg {
3948 if let hir::TyKind::Path(
3949 hir::QPath::TypeRelative(..),
3951 // Avoid ICE with associated types. As this is best
3952 // effort only, it's ok to ignore the case. It
3953 // would trigger in `is_send::<T::AssocType>();`
3954 // from `typeck-default-trait-impl-assoc-type.rs`.
3956 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
3957 let ty = self.resolve_vars_if_possible(&ty);
3958 if ty == predicate.skip_binder().self_ty() {
3959 error.obligation.cause.span = hir_ty.span;
3971 // AST fragment checking
3974 expected: Expectation<'tcx>)
3980 ast::LitKind::Str(..) => tcx.mk_static_str(),
3981 ast::LitKind::ByteStr(ref v) => {
3982 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3983 tcx.mk_array(tcx.types.u8, v.len() as u64))
3985 ast::LitKind::Byte(_) => tcx.types.u8,
3986 ast::LitKind::Char(_) => tcx.types.char,
3987 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3988 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3989 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3990 let opt_ty = expected.to_option(self).and_then(|ty| {
3992 ty::Int(_) | ty::Uint(_) => Some(ty),
3993 ty::Char => Some(tcx.types.u8),
3994 ty::RawPtr(..) => Some(tcx.types.usize),
3995 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3999 opt_ty.unwrap_or_else(|| self.next_int_var())
4001 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4002 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4003 let opt_ty = expected.to_option(self).and_then(|ty| {
4005 ty::Float(_) => Some(ty),
4009 opt_ty.unwrap_or_else(|| self.next_float_var())
4011 ast::LitKind::Bool(_) => tcx.types.bool,
4012 ast::LitKind::Err(_) => tcx.types.err,
4016 // Determine the `Self` type, using fresh variables for all variables
4017 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
4018 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
4020 pub fn impl_self_ty(&self,
4021 span: Span, // (potential) receiver for this impl
4023 -> TypeAndSubsts<'tcx> {
4024 let ity = self.tcx.type_of(did);
4025 debug!("impl_self_ty: ity={:?}", ity);
4027 let substs = self.fresh_substs_for_item(span, did);
4028 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
4030 TypeAndSubsts { substs: substs, ty: substd_ty }
4033 /// Unifies the output type with the expected type early, for more coercions
4034 /// and forward type information on the input expressions.
4035 fn expected_inputs_for_expected_output(&self,
4037 expected_ret: Expectation<'tcx>,
4038 formal_ret: Ty<'tcx>,
4039 formal_args: &[Ty<'tcx>])
4041 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4042 let ret_ty = match expected_ret.only_has_type(self) {
4044 None => return Vec::new()
4046 let expect_args = self.fudge_inference_if_ok(|| {
4047 // Attempt to apply a subtyping relationship between the formal
4048 // return type (likely containing type variables if the function
4049 // is polymorphic) and the expected return type.
4050 // No argument expectations are produced if unification fails.
4051 let origin = self.misc(call_span);
4052 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4054 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4055 // to identity so the resulting type is not constrained.
4058 // Process any obligations locally as much as
4059 // we can. We don't care if some things turn
4060 // out unconstrained or ambiguous, as we're
4061 // just trying to get hints here.
4062 self.save_and_restore_in_snapshot_flag(|_| {
4063 let mut fulfill = TraitEngine::new(self.tcx);
4064 for obligation in ok.obligations {
4065 fulfill.register_predicate_obligation(self, obligation);
4067 fulfill.select_where_possible(self)
4068 }).map_err(|_| ())?;
4070 Err(_) => return Err(()),
4073 // Record all the argument types, with the substitutions
4074 // produced from the above subtyping unification.
4075 Ok(formal_args.iter().map(|ty| {
4076 self.resolve_vars_if_possible(ty)
4078 }).unwrap_or_default();
4079 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4080 formal_args, formal_ret,
4081 expect_args, expected_ret);
4085 pub fn check_struct_path(&self,
4088 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4089 let path_span = match *qpath {
4090 QPath::Resolved(_, ref path) => path.span,
4091 QPath::TypeRelative(ref qself, _) => qself.span
4093 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4094 let variant = match def {
4096 self.set_tainted_by_errors();
4099 Res::Def(DefKind::Variant, _) => {
4101 ty::Adt(adt, substs) => {
4102 Some((adt.variant_of_res(def), adt.did, substs))
4104 _ => bug!("unexpected type: {:?}", ty)
4107 Res::Def(DefKind::Struct, _)
4108 | Res::Def(DefKind::Union, _)
4109 | Res::Def(DefKind::TyAlias, _)
4110 | Res::Def(DefKind::AssocTy, _)
4111 | Res::SelfTy(..) => {
4113 ty::Adt(adt, substs) if !adt.is_enum() => {
4114 Some((adt.non_enum_variant(), adt.did, substs))
4119 _ => bug!("unexpected definition: {:?}", def)
4122 if let Some((variant, did, substs)) = variant {
4123 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4124 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4126 // Check bounds on type arguments used in the path.
4127 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4128 let cause = traits::ObligationCause::new(
4131 traits::ItemObligation(did),
4133 self.add_obligations_for_parameters(cause, &bounds);
4137 struct_span_err!(self.tcx.sess, path_span, E0071,
4138 "expected struct, variant or union type, found {}",
4139 ty.sort_string(self.tcx))
4140 .span_label(path_span, "not a struct")
4146 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4147 // The newly resolved definition is written into `type_dependent_defs`.
4148 fn finish_resolving_struct_path(&self,
4155 QPath::Resolved(ref maybe_qself, ref path) => {
4156 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4157 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4160 QPath::TypeRelative(ref qself, ref segment) => {
4161 let ty = self.to_ty(qself);
4163 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4168 let result = AstConv::associated_path_to_ty(
4177 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4178 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4180 // Write back the new resolution.
4181 self.write_resolution(hir_id, result);
4183 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4188 /// Resolves an associated value path into a base type and associated constant, or method
4189 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4190 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4194 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4196 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4197 let (ty, qself, item_segment) = match *qpath {
4198 QPath::Resolved(ref opt_qself, ref path) => {
4200 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4201 &path.segments[..]);
4203 QPath::TypeRelative(ref qself, ref segment) => {
4204 (self.to_ty(qself), qself, segment)
4207 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4208 // Return directly on cache hit. This is useful to avoid doubly reporting
4209 // errors with default match binding modes. See #44614.
4210 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4211 .unwrap_or(Res::Err);
4212 return (def, Some(ty), slice::from_ref(&**item_segment));
4214 let item_name = item_segment.ident;
4215 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4216 let result = match error {
4217 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4218 _ => Err(ErrorReported),
4220 if item_name.name != kw::Invalid {
4221 self.report_method_error(
4225 SelfSource::QPath(qself),
4228 ).map(|mut e| e.emit());
4233 // Write back the new resolution.
4234 self.write_resolution(hir_id, result);
4236 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4238 slice::from_ref(&**item_segment),
4242 pub fn check_decl_initializer(
4244 local: &'tcx hir::Local,
4245 init: &'tcx hir::Expr,
4247 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4248 // for #42640 (default match binding modes).
4251 let ref_bindings = local.pat.contains_explicit_ref_binding();
4253 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4254 if let Some(m) = ref_bindings {
4255 // Somewhat subtle: if we have a `ref` binding in the pattern,
4256 // we want to avoid introducing coercions for the RHS. This is
4257 // both because it helps preserve sanity and, in the case of
4258 // ref mut, for soundness (issue #23116). In particular, in
4259 // the latter case, we need to be clear that the type of the
4260 // referent for the reference that results is *equal to* the
4261 // type of the place it is referencing, and not some
4262 // supertype thereof.
4263 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4264 self.demand_eqtype(init.span, local_ty, init_ty);
4267 self.check_expr_coercable_to_type(init, local_ty)
4271 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
4272 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4273 self.write_ty(local.hir_id, t);
4275 if let Some(ref init) = local.init {
4276 let init_ty = self.check_decl_initializer(local, &init);
4277 self.overwrite_local_ty_if_err(local, t, init_ty);
4280 self.check_pat_top(&local.pat, t, None);
4281 let pat_ty = self.node_ty(local.pat.hir_id);
4282 self.overwrite_local_ty_if_err(local, t, pat_ty);
4285 fn overwrite_local_ty_if_err(&self, local: &'tcx hir::Local, decl_ty: Ty<'tcx>, ty: Ty<'tcx>) {
4286 if ty.references_error() {
4287 // Override the types everywhere with `types.err` to avoid knock down errors.
4288 self.write_ty(local.hir_id, ty);
4289 self.write_ty(local.pat.hir_id, ty);
4290 let local_ty = LocalTy {
4294 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4295 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4299 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4300 err.span_suggestion_short(
4301 span.shrink_to_hi(),
4302 "consider using a semicolon here",
4304 Applicability::MachineApplicable,
4308 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
4309 // Don't do all the complex logic below for `DeclItem`.
4311 hir::StmtKind::Item(..) => return,
4312 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4315 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4317 // Hide the outer diverging and `has_errors` flags.
4318 let old_diverges = self.diverges.get();
4319 let old_has_errors = self.has_errors.get();
4320 self.diverges.set(Diverges::Maybe);
4321 self.has_errors.set(false);
4324 hir::StmtKind::Local(ref l) => {
4325 self.check_decl_local(&l);
4328 hir::StmtKind::Item(_) => {}
4329 hir::StmtKind::Expr(ref expr) => {
4330 // Check with expected type of `()`.
4332 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4333 self.suggest_semicolon_at_end(expr.span, err);
4336 hir::StmtKind::Semi(ref expr) => {
4337 self.check_expr(&expr);
4341 // Combine the diverging and `has_error` flags.
4342 self.diverges.set(self.diverges.get() | old_diverges);
4343 self.has_errors.set(self.has_errors.get() | old_has_errors);
4346 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
4347 let unit = self.tcx.mk_unit();
4348 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4350 // if the block produces a `!` value, that can always be
4351 // (effectively) coerced to unit.
4353 self.demand_suptype(blk.span, unit, ty);
4357 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4358 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4359 /// when given code like the following:
4361 /// if false { return 0i32; } else { 1u32 }
4362 /// // ^^^^ point at this instead of the whole `if` expression
4364 fn get_expr_coercion_span(&self, expr: &hir::Expr) -> syntax_pos::Span {
4365 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4366 let arm_spans: Vec<Span> = arms.iter().filter_map(|arm| {
4367 self.in_progress_tables
4368 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4369 .and_then(|arm_ty| {
4370 if arm_ty.is_never() {
4373 Some(match &arm.body.kind {
4374 // Point at the tail expression when possible.
4375 hir::ExprKind::Block(block, _) => block.expr
4378 .unwrap_or(block.span),
4384 if arm_spans.len() == 1 {
4385 return arm_spans[0];
4391 fn check_block_with_expected(
4393 blk: &'tcx hir::Block,
4394 expected: Expectation<'tcx>,
4397 let mut fcx_ps = self.ps.borrow_mut();
4398 let unsafety_state = fcx_ps.recurse(blk);
4399 replace(&mut *fcx_ps, unsafety_state)
4402 // In some cases, blocks have just one exit, but other blocks
4403 // can be targeted by multiple breaks. This can happen both
4404 // with labeled blocks as well as when we desugar
4405 // a `try { ... }` expression.
4409 // 'a: { if true { break 'a Err(()); } Ok(()) }
4411 // Here we would wind up with two coercions, one from
4412 // `Err(())` and the other from the tail expression
4413 // `Ok(())`. If the tail expression is omitted, that's a
4414 // "forced unit" -- unless the block diverges, in which
4415 // case we can ignore the tail expression (e.g., `'a: {
4416 // break 'a 22; }` would not force the type of the block
4418 let tail_expr = blk.expr.as_ref();
4419 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4420 let coerce = if blk.targeted_by_break {
4421 CoerceMany::new(coerce_to_ty)
4423 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4424 Some(e) => slice::from_ref(e),
4427 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4430 let prev_diverges = self.diverges.get();
4431 let ctxt = BreakableCtxt {
4432 coerce: Some(coerce),
4436 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4437 for s in &blk.stmts {
4441 // check the tail expression **without** holding the
4442 // `enclosing_breakables` lock below.
4443 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4445 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4446 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4447 let coerce = ctxt.coerce.as_mut().unwrap();
4448 if let Some(tail_expr_ty) = tail_expr_ty {
4449 let tail_expr = tail_expr.unwrap();
4450 let span = self.get_expr_coercion_span(tail_expr);
4451 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4452 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4454 // Subtle: if there is no explicit tail expression,
4455 // that is typically equivalent to a tail expression
4456 // of `()` -- except if the block diverges. In that
4457 // case, there is no value supplied from the tail
4458 // expression (assuming there are no other breaks,
4459 // this implies that the type of the block will be
4462 // #41425 -- label the implicit `()` as being the
4463 // "found type" here, rather than the "expected type".
4464 if !self.diverges.get().is_always() {
4465 // #50009 -- Do not point at the entire fn block span, point at the return type
4466 // span, as it is the cause of the requirement, and
4467 // `consider_hint_about_removing_semicolon` will point at the last expression
4468 // if it were a relevant part of the error. This improves usability in editors
4469 // that highlight errors inline.
4470 let mut sp = blk.span;
4471 let mut fn_span = None;
4472 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4473 let ret_sp = decl.output.span();
4474 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4475 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4476 // output would otherwise be incorrect and even misleading. Make sure
4477 // the span we're aiming at correspond to a `fn` body.
4478 if block_sp == blk.span {
4480 fn_span = Some(ident.span);
4484 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4485 if let Some(expected_ty) = expected.only_has_type(self) {
4486 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4488 if let Some(fn_span) = fn_span {
4491 "implicitly returns `()` as its body has no tail or `return` \
4501 // If we can break from the block, then the block's exit is always reachable
4502 // (... as long as the entry is reachable) - regardless of the tail of the block.
4503 self.diverges.set(prev_diverges);
4506 let mut ty = ctxt.coerce.unwrap().complete(self);
4508 if self.has_errors.get() || ty.references_error() {
4509 ty = self.tcx.types.err
4512 self.write_ty(blk.hir_id, ty);
4514 *self.ps.borrow_mut() = prev;
4518 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4519 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4521 Node::Item(&hir::Item {
4522 kind: hir::ItemKind::Fn(_, _, body_id), ..
4524 Node::ImplItem(&hir::ImplItem {
4525 kind: hir::ImplItemKind::Method(_, body_id), ..
4527 let body = self.tcx.hir().body(body_id);
4528 if let ExprKind::Block(block, _) = &body.value.kind {
4529 return Some(block.span);
4537 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4538 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
4539 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4540 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4543 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4544 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
4546 Node::Item(&hir::Item {
4547 ident, kind: hir::ItemKind::Fn(ref sig, ..), ..
4549 // This is less than ideal, it will not suggest a return type span on any
4550 // method called `main`, regardless of whether it is actually the entry point,
4551 // but it will still present it as the reason for the expected type.
4552 Some((&sig.decl, ident, ident.name != sym::main))
4554 Node::TraitItem(&hir::TraitItem {
4555 ident, kind: hir::TraitItemKind::Method(ref sig, ..), ..
4556 }) => Some((&sig.decl, ident, true)),
4557 Node::ImplItem(&hir::ImplItem {
4558 ident, kind: hir::ImplItemKind::Method(ref sig, ..), ..
4559 }) => Some((&sig.decl, ident, false)),
4564 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4565 /// suggestion can be made, `None` otherwise.
4566 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
4567 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4568 // `while` before reaching it, as block tail returns are not available in them.
4569 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4570 let parent = self.tcx.hir().get(blk_id);
4571 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4575 /// On implicit return expressions with mismatched types, provides the following suggestions:
4577 /// - Points out the method's return type as the reason for the expected type.
4578 /// - Possible missing semicolon.
4579 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4580 pub fn suggest_mismatched_types_on_tail(
4582 err: &mut DiagnosticBuilder<'_>,
4583 expr: &'tcx hir::Expr,
4589 let expr = expr.peel_drop_temps();
4590 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4591 let mut pointing_at_return_type = false;
4592 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4593 pointing_at_return_type = self.suggest_missing_return_type(
4594 err, &fn_decl, expected, found, can_suggest);
4596 pointing_at_return_type
4599 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4600 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4602 /// fn foo(x: usize) -> usize { x }
4603 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4607 err: &mut DiagnosticBuilder<'_>,
4612 let hir = self.tcx.hir();
4613 let (def_id, sig) = match found.kind {
4614 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4615 ty::Closure(def_id, substs) => {
4616 // We don't use `closure_sig` to account for malformed closures like
4617 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4618 let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
4619 (def_id, match closure_sig_ty.kind {
4620 ty::FnPtr(sig) => sig,
4628 .replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig)
4630 let sig = self.normalize_associated_types_in(expr.span, &sig);
4631 if self.can_coerce(sig.output(), expected) {
4632 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4633 (String::new(), Applicability::MachineApplicable)
4635 ("...".to_string(), Applicability::HasPlaceholders)
4637 let mut msg = "call this function";
4638 match hir.get_if_local(def_id) {
4639 Some(Node::Item(hir::Item {
4640 kind: ItemKind::Fn(.., body_id),
4643 Some(Node::ImplItem(hir::ImplItem {
4644 kind: hir::ImplItemKind::Method(_, body_id),
4647 Some(Node::TraitItem(hir::TraitItem {
4648 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4651 let body = hir.body(*body_id);
4652 sugg_call = body.params.iter()
4653 .map(|param| match ¶m.pat.kind {
4654 hir::PatKind::Binding(_, _, ident, None)
4655 if ident.name != kw::SelfLower => ident.to_string(),
4656 _ => "_".to_string(),
4657 }).collect::<Vec<_>>().join(", ");
4659 Some(Node::Expr(hir::Expr {
4660 kind: ExprKind::Closure(_, _, body_id, closure_span, _),
4661 span: full_closure_span,
4664 if *full_closure_span == expr.span {
4667 err.span_label(*closure_span, "closure defined here");
4668 msg = "call this closure";
4669 let body = hir.body(*body_id);
4670 sugg_call = body.params.iter()
4671 .map(|param| match ¶m.pat.kind {
4672 hir::PatKind::Binding(_, _, ident, None)
4673 if ident.name != kw::SelfLower => ident.to_string(),
4674 _ => "_".to_string(),
4675 }).collect::<Vec<_>>().join(", ");
4677 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4678 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4679 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4680 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4681 msg = "instantiate this tuple variant";
4683 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4684 msg = "instantiate this tuple struct";
4689 Some(Node::ForeignItem(hir::ForeignItem {
4690 kind: hir::ForeignItemKind::Fn(_, idents, _),
4692 })) => sugg_call = idents.iter()
4693 .map(|ident| if ident.name != kw::SelfLower {
4697 }).collect::<Vec<_>>()
4699 Some(Node::TraitItem(hir::TraitItem {
4700 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4702 })) => sugg_call = idents.iter()
4703 .map(|ident| if ident.name != kw::SelfLower {
4707 }).collect::<Vec<_>>()
4711 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4712 err.span_suggestion(
4714 &format!("use parentheses to {}", msg),
4715 format!("{}({})", code, sugg_call),
4724 pub fn suggest_ref_or_into(
4726 err: &mut DiagnosticBuilder<'_>,
4731 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4732 err.span_suggestion(
4736 Applicability::MachineApplicable,
4738 } else if let (ty::FnDef(def_id, ..), true) = (
4740 self.suggest_fn_call(err, expr, expected, found),
4742 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4743 let sp = self.sess().source_map().def_span(sp);
4744 err.span_label(sp, &format!("{} defined here", found));
4746 } else if !self.check_for_cast(err, expr, found, expected) {
4747 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
4751 let methods = self.get_conversion_methods(expr.span, expected, found);
4752 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4753 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4754 .filter_map(|(receiver, method)| {
4755 let method_call = format!(".{}()", method.ident);
4756 if receiver.ends_with(&method_call) {
4757 None // do not suggest code that is already there (#53348)
4759 let method_call_list = [".to_vec()", ".to_string()"];
4760 let sugg = if receiver.ends_with(".clone()")
4761 && method_call_list.contains(&method_call.as_str()) {
4762 let max_len = receiver.rfind(".").unwrap();
4763 format!("{}{}", &receiver[..max_len], method_call)
4765 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
4766 format!("({}){}", receiver, method_call)
4768 format!("{}{}", receiver, method_call)
4771 Some(if is_struct_pat_shorthand_field {
4772 format!("{}: {}", receiver, sugg)
4778 if suggestions.peek().is_some() {
4779 err.span_suggestions(
4781 "try using a conversion method",
4783 Applicability::MaybeIncorrect,
4790 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4791 /// in the heap by calling `Box::new()`.
4792 fn suggest_boxing_when_appropriate(
4794 err: &mut DiagnosticBuilder<'_>,
4799 if self.tcx.hir().is_const_context(expr.hir_id) {
4800 // Do not suggest `Box::new` in const context.
4803 if !expected.is_box() || found.is_box() {
4806 let boxed_found = self.tcx.mk_box(found);
4807 if let (true, Ok(snippet)) = (
4808 self.can_coerce(boxed_found, expected),
4809 self.sess().source_map().span_to_snippet(expr.span),
4811 err.span_suggestion(
4813 "store this in the heap by calling `Box::new`",
4814 format!("Box::new({})", snippet),
4815 Applicability::MachineApplicable,
4817 err.note("for more on the distinction between the stack and the \
4818 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4819 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4820 https://doc.rust-lang.org/std/boxed/index.html");
4825 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4829 /// bar_that_returns_u32()
4833 /// This routine checks if the return expression in a block would make sense on its own as a
4834 /// statement and the return type has been left as default or has been specified as `()`. If so,
4835 /// it suggests adding a semicolon.
4836 fn suggest_missing_semicolon(
4838 err: &mut DiagnosticBuilder<'_>,
4839 expression: &'tcx hir::Expr,
4843 if expected.is_unit() {
4844 // `BlockTailExpression` only relevant if the tail expr would be
4845 // useful on its own.
4846 match expression.kind {
4847 ExprKind::Call(..) |
4848 ExprKind::MethodCall(..) |
4849 ExprKind::Loop(..) |
4850 ExprKind::Match(..) |
4851 ExprKind::Block(..) => {
4852 let sp = self.tcx.sess.source_map().next_point(cause_span);
4853 err.span_suggestion(
4855 "try adding a semicolon",
4857 Applicability::MachineApplicable);
4864 /// A possible error is to forget to add a return type that is needed:
4868 /// bar_that_returns_u32()
4872 /// This routine checks if the return type is left as default, the method is not part of an
4873 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4875 fn suggest_missing_return_type(
4877 err: &mut DiagnosticBuilder<'_>,
4878 fn_decl: &hir::FnDecl,
4883 // Only suggest changing the return type for methods that
4884 // haven't set a return type at all (and aren't `fn main()` or an impl).
4885 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4886 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4887 err.span_suggestion(
4889 "try adding a return type",
4890 format!("-> {} ", self.resolve_vars_with_obligations(found)),
4891 Applicability::MachineApplicable);
4894 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4895 err.span_label(span, "possibly return type missing here?");
4898 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4899 // `fn main()` must return `()`, do not suggest changing return type
4900 err.span_label(span, "expected `()` because of default return type");
4903 // expectation was caused by something else, not the default return
4904 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
4905 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4906 // Only point to return type if the expected type is the return type, as if they
4907 // are not, the expectation must have been caused by something else.
4908 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
4910 let ty = AstConv::ast_ty_to_ty(self, ty);
4911 debug!("suggest_missing_return_type: return type {:?}", ty);
4912 debug!("suggest_missing_return_type: expected type {:?}", ty);
4913 if ty.kind == expected.kind {
4914 err.span_label(sp, format!("expected `{}` because of return type",
4923 /// A possible error is to forget to add `.await` when using futures:
4926 /// async fn make_u32() -> u32 {
4930 /// fn take_u32(x: u32) {}
4932 /// async fn foo() {
4933 /// let x = make_u32();
4938 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
4939 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
4940 /// `.await` to the tail of the expression.
4941 fn suggest_missing_await(
4943 err: &mut DiagnosticBuilder<'_>,
4948 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
4949 // body isn't `async`.
4950 let item_id = self.tcx().hir().get_parent_node(self.body_id);
4951 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
4952 let body = self.tcx().hir().body(body_id);
4953 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
4955 // Check for `Future` implementations by constructing a predicate to
4956 // prove: `<T as Future>::Output == U`
4957 let future_trait = self.tcx.lang_items().future_trait().unwrap();
4958 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
4959 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
4960 // `<T as Future>::Output`
4961 projection_ty: ty::ProjectionTy {
4963 substs: self.tcx.mk_substs_trait(
4965 self.fresh_substs_for_item(sp, item_def_id)
4972 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4973 debug!("suggest_missing_await: trying obligation {:?}", obligation);
4974 if self.infcx.predicate_may_hold(&obligation) {
4975 debug!("suggest_missing_await: obligation held: {:?}", obligation);
4976 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4977 err.span_suggestion(
4979 "consider using `.await` here",
4980 format!("{}.await", code),
4981 Applicability::MaybeIncorrect,
4984 debug!("suggest_missing_await: no snippet for {:?}", sp);
4987 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
4993 /// A common error is to add an extra semicolon:
4996 /// fn foo() -> usize {
5001 /// This routine checks if the final statement in a block is an
5002 /// expression with an explicit semicolon whose type is compatible
5003 /// with `expected_ty`. If so, it suggests removing the semicolon.
5004 fn consider_hint_about_removing_semicolon(
5006 blk: &'tcx hir::Block,
5007 expected_ty: Ty<'tcx>,
5008 err: &mut DiagnosticBuilder<'_>,
5010 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5011 err.span_suggestion(
5013 "consider removing this semicolon",
5015 Applicability::MachineApplicable,
5020 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
5021 // Be helpful when the user wrote `{... expr;}` and
5022 // taking the `;` off is enough to fix the error.
5023 let last_stmt = blk.stmts.last()?;
5024 let last_expr = match last_stmt.kind {
5025 hir::StmtKind::Semi(ref e) => e,
5028 let last_expr_ty = self.node_ty(last_expr.hir_id);
5029 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5032 let original_span = original_sp(last_stmt.span, blk.span);
5033 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5036 // Instantiates the given path, which must refer to an item with the given
5037 // number of type parameters and type.
5038 pub fn instantiate_value_path(&self,
5039 segments: &[hir::PathSegment],
5040 self_ty: Option<Ty<'tcx>>,
5044 -> (Ty<'tcx>, Res) {
5046 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5055 let path_segs = match res {
5056 Res::Local(_) | Res::SelfCtor(_) => vec![],
5057 Res::Def(kind, def_id) =>
5058 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5059 _ => bug!("instantiate_value_path on {:?}", res),
5062 let mut user_self_ty = None;
5063 let mut is_alias_variant_ctor = false;
5065 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5066 if let Some(self_ty) = self_ty {
5067 let adt_def = self_ty.ty_adt_def().unwrap();
5068 user_self_ty = Some(UserSelfTy {
5069 impl_def_id: adt_def.did,
5072 is_alias_variant_ctor = true;
5075 Res::Def(DefKind::Method, def_id)
5076 | Res::Def(DefKind::AssocConst, def_id) => {
5077 let container = tcx.associated_item(def_id).container;
5078 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5080 ty::TraitContainer(trait_did) => {
5081 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5083 ty::ImplContainer(impl_def_id) => {
5084 if segments.len() == 1 {
5085 // `<T>::assoc` will end up here, and so
5086 // can `T::assoc`. It this came from an
5087 // inherent impl, we need to record the
5088 // `T` for posterity (see `UserSelfTy` for
5090 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5091 user_self_ty = Some(UserSelfTy {
5102 // Now that we have categorized what space the parameters for each
5103 // segment belong to, let's sort out the parameters that the user
5104 // provided (if any) into their appropriate spaces. We'll also report
5105 // errors if type parameters are provided in an inappropriate place.
5107 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5108 let generics_has_err = AstConv::prohibit_generics(
5109 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5110 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5117 if let Res::Local(hid) = res {
5118 let ty = self.local_ty(span, hid).decl_ty;
5119 let ty = self.normalize_associated_types_in(span, &ty);
5120 self.write_ty(hir_id, ty);
5124 if generics_has_err {
5125 // Don't try to infer type parameters when prohibited generic arguments were given.
5126 user_self_ty = None;
5129 // Now we have to compare the types that the user *actually*
5130 // provided against the types that were *expected*. If the user
5131 // did not provide any types, then we want to substitute inference
5132 // variables. If the user provided some types, we may still need
5133 // to add defaults. If the user provided *too many* types, that's
5136 let mut infer_args_for_err = FxHashSet::default();
5137 for &PathSeg(def_id, index) in &path_segs {
5138 let seg = &segments[index];
5139 let generics = tcx.generics_of(def_id);
5140 // Argument-position `impl Trait` is treated as a normal generic
5141 // parameter internally, but we don't allow users to specify the
5142 // parameter's value explicitly, so we have to do some error-
5144 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5149 false, // `is_method_call`
5151 if suppress_errors {
5152 infer_args_for_err.insert(index);
5153 self.set_tainted_by_errors(); // See issue #53251.
5157 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5158 tcx.generics_of(*def_id).has_self
5159 }).unwrap_or(false);
5161 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5162 let ty = self.impl_self_ty(span, impl_def_id).ty;
5163 let adt_def = ty.ty_adt_def();
5166 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5167 let variant = adt_def.non_enum_variant();
5168 let ctor_def_id = variant.ctor_def_id.unwrap();
5170 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5175 let mut err = tcx.sess.struct_span_err(span,
5176 "the `Self` constructor can only be used with tuple or unit structs");
5177 if let Some(adt_def) = adt_def {
5178 match adt_def.adt_kind() {
5180 err.help("did you mean to use one of the enum's variants?");
5184 err.span_suggestion(
5186 "use curly brackets",
5187 String::from("Self { /* fields */ }"),
5188 Applicability::HasPlaceholders,
5195 return (tcx.types.err, res)
5201 let def_id = res.def_id();
5203 // The things we are substituting into the type should not contain
5204 // escaping late-bound regions, and nor should the base type scheme.
5205 let ty = tcx.type_of(def_id);
5207 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
5213 // Provide the generic args, and whether types should be inferred.
5215 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5218 // If we've encountered an `impl Trait`-related error, we're just
5219 // going to infer the arguments for better error messages.
5220 if !infer_args_for_err.contains(&index) {
5221 // Check whether the user has provided generic arguments.
5222 if let Some(ref data) = segments[index].args {
5223 return (Some(data), segments[index].infer_args);
5226 return (None, segments[index].infer_args);
5231 // Provide substitutions for parameters for which (valid) arguments have been provided.
5233 match (¶m.kind, arg) {
5234 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5235 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5237 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5238 self.to_ty(ty).into()
5240 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5241 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5243 _ => unreachable!(),
5246 // Provide substitutions for parameters for which arguments are inferred.
5247 |substs, param, infer_args| {
5249 GenericParamDefKind::Lifetime => {
5250 self.re_infer(Some(param), span).unwrap().into()
5252 GenericParamDefKind::Type { has_default, .. } => {
5253 if !infer_args && has_default {
5254 // If we have a default, then we it doesn't matter that we're not
5255 // inferring the type arguments: we provide the default where any
5257 let default = tcx.type_of(param.def_id);
5260 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5263 // If no type arguments were provided, we have to infer them.
5264 // This case also occurs as a result of some malformed input, e.g.
5265 // a lifetime argument being given instead of a type parameter.
5266 // Using inference instead of `Error` gives better error messages.
5267 self.var_for_def(span, param)
5270 GenericParamDefKind::Const => {
5271 // FIXME(const_generics:defaults)
5272 // No const parameters were provided, we have to infer them.
5273 self.var_for_def(span, param)
5278 assert!(!substs.has_escaping_bound_vars());
5279 assert!(!ty.has_escaping_bound_vars());
5281 // First, store the "user substs" for later.
5282 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5284 self.add_required_obligations(span, def_id, &substs);
5286 // Substitute the values for the type parameters into the type of
5287 // the referenced item.
5288 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5290 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5291 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5292 // is inherent, there is no `Self` parameter; instead, the impl needs
5293 // type parameters, which we can infer by unifying the provided `Self`
5294 // with the substituted impl type.
5295 // This also occurs for an enum variant on a type alias.
5296 let ty = tcx.type_of(impl_def_id);
5298 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5299 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5300 Ok(ok) => self.register_infer_ok_obligations(ok),
5302 self.tcx.sess.delay_span_bug(span, &format!(
5303 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5311 self.check_rustc_args_require_const(def_id, hir_id, span);
5313 debug!("instantiate_value_path: type of {:?} is {:?}",
5316 self.write_substs(hir_id, substs);
5318 (ty_substituted, res)
5321 /// Add all the obligations that are required, substituting and normalized appropriately.
5322 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5323 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5325 for (i, mut obligation) in traits::predicates_for_generics(
5326 traits::ObligationCause::new(
5329 traits::ItemObligation(def_id),
5333 ).into_iter().enumerate() {
5334 // This makes the error point at the bound, but we want to point at the argument
5335 if let Some(span) = spans.get(i) {
5336 obligation.cause.code = traits::BindingObligation(def_id, *span);
5338 self.register_predicate(obligation);
5342 fn check_rustc_args_require_const(&self,
5346 // We're only interested in functions tagged with
5347 // #[rustc_args_required_const], so ignore anything that's not.
5348 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5352 // If our calling expression is indeed the function itself, we're good!
5353 // If not, generate an error that this can only be called directly.
5354 if let Node::Expr(expr) = self.tcx.hir().get(
5355 self.tcx.hir().get_parent_node(hir_id))
5357 if let ExprKind::Call(ref callee, ..) = expr.kind {
5358 if callee.hir_id == hir_id {
5364 self.tcx.sess.span_err(span, "this function can only be invoked \
5365 directly, not through a function pointer");
5368 /// Resolves `typ` by a single level if `typ` is a type variable.
5369 /// If no resolution is possible, then an error is reported.
5370 /// Numeric inference variables may be left unresolved.
5371 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5372 let ty = self.resolve_vars_with_obligations(ty);
5373 if !ty.is_ty_var() {
5376 if !self.is_tainted_by_errors() {
5377 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5378 .note("type must be known at this point")
5381 self.demand_suptype(sp, self.tcx.types.err, ty);
5386 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5389 ctxt: BreakableCtxt<'tcx>,
5391 ) -> (BreakableCtxt<'tcx>, R) {
5394 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5395 index = enclosing_breakables.stack.len();
5396 enclosing_breakables.by_id.insert(id, index);
5397 enclosing_breakables.stack.push(ctxt);
5401 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5402 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5403 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5404 enclosing_breakables.stack.pop().expect("missing breakable context")
5409 /// Instantiate a QueryResponse in a probe context, without a
5410 /// good ObligationCause.
5411 fn probe_instantiate_query_response(
5414 original_values: &OriginalQueryValues<'tcx>,
5415 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5416 ) -> InferResult<'tcx, Ty<'tcx>>
5418 self.instantiate_query_response_and_region_obligations(
5419 &traits::ObligationCause::misc(span, self.body_id),
5425 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5426 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5427 let mut contained_in_place = false;
5429 while let hir::Node::Expr(parent_expr) =
5430 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5432 match &parent_expr.kind {
5433 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5434 if lhs.hir_id == expr_id {
5435 contained_in_place = true;
5441 expr_id = parent_expr.hir_id;
5448 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5449 let own_counts = generics.own_counts();
5451 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5457 if own_counts.types == 0 {
5461 // Make a vector of booleans initially `false`; set to `true` when used.
5462 let mut types_used = vec![false; own_counts.types];
5464 for leaf_ty in ty.walk() {
5465 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5466 debug!("found use of ty param num {}", index);
5467 types_used[index as usize - own_counts.lifetimes] = true;
5468 } else if let ty::Error = leaf_ty.kind {
5469 // If there is already another error, do not emit
5470 // an error for not using a type parameter.
5471 assert!(tcx.sess.has_errors());
5476 let types = generics.params.iter().filter(|param| match param.kind {
5477 ty::GenericParamDefKind::Type { .. } => true,
5480 for (&used, param) in types_used.iter().zip(types) {
5482 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5483 let span = tcx.hir().span(id);
5484 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5485 .span_label(span, "unused type parameter")
5491 fn fatally_break_rust(sess: &Session) {
5492 let handler = sess.diagnostic();
5493 handler.span_bug_no_panic(
5495 "It looks like you're trying to break rust; would you like some ICE?",
5497 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5498 handler.note_without_error(
5499 "we would appreciate a joke overview: \
5500 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5502 handler.note_without_error(&format!("rustc {} running on {}",
5503 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5504 crate::session::config::host_triple(),
5508 fn potentially_plural_count(count: usize, word: &str) -> String {
5509 format!("{} {}{}", count, word, pluralize!(count))