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::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
107 use rustc::middle::region;
108 use rustc::mir::interpret::{ConstValue, GlobalId};
109 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
111 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
112 ToPolyTraitRef, ToPredicate, RegionKind, UserType
114 use rustc::ty::adjustment::{
115 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
117 use rustc::ty::fold::{TypeFoldable, TypeFolder};
118 use rustc::ty::query::Providers;
119 use rustc::ty::subst::{
120 GenericArgKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts,
122 use rustc::ty::util::{Representability, IntTypeExt, Discr};
123 use rustc::ty::layout::VariantIdx;
124 use syntax_pos::{self, BytePos, Span, MultiSpan};
125 use syntax_pos::hygiene::DesugaringKind;
128 use syntax::feature_gate::{GateIssue, emit_feature_err};
129 use syntax::source_map::{DUMMY_SP, original_sp};
130 use syntax::symbol::{kw, sym, Ident};
131 use syntax::util::parser::ExprPrecedence;
133 use rustc_error_codes::*;
135 use std::cell::{Cell, RefCell, Ref, RefMut};
136 use std::collections::hash_map::Entry;
139 use std::mem::replace;
140 use std::ops::{self, Deref};
143 use crate::require_c_abi_if_c_variadic;
144 use crate::session::Session;
145 use crate::session::config::EntryFnType;
146 use crate::TypeAndSubsts;
148 use crate::util::captures::Captures;
149 use crate::util::common::{ErrorReported, indenter};
150 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap};
152 pub use self::Expectation::*;
153 use self::autoderef::Autoderef;
154 use self::callee::DeferredCallResolution;
155 use self::coercion::{CoerceMany, DynamicCoerceMany};
156 pub use self::compare_method::{compare_impl_method, compare_const_impl};
157 use self::method::{MethodCallee, SelfSource};
158 use self::TupleArgumentsFlag::*;
160 /// The type of a local binding, including the revealed type for anon types.
161 #[derive(Copy, Clone, Debug)]
162 pub struct LocalTy<'tcx> {
164 revealed_ty: Ty<'tcx>
167 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
168 #[derive(Copy, Clone)]
169 struct MaybeInProgressTables<'a, 'tcx> {
170 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
173 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
174 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
175 match self.maybe_tables {
176 Some(tables) => tables.borrow(),
178 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
183 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
184 match self.maybe_tables {
185 Some(tables) => tables.borrow_mut(),
187 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
193 /// Closures defined within the function. For example:
196 /// bar(move|| { ... })
199 /// Here, the function `foo()` and the closure passed to
200 /// `bar()` will each have their own `FnCtxt`, but they will
201 /// share the inherited fields.
202 pub struct Inherited<'a, 'tcx> {
203 infcx: InferCtxt<'a, 'tcx>,
205 tables: MaybeInProgressTables<'a, 'tcx>,
207 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
209 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
211 // Some additional `Sized` obligations badly affect type inference.
212 // These obligations are added in a later stage of typeck.
213 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
215 // When we process a call like `c()` where `c` is a closure type,
216 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
217 // `FnOnce` closure. In that case, we defer full resolution of the
218 // call until upvar inference can kick in and make the
219 // decision. We keep these deferred resolutions grouped by the
220 // def-id of the closure, so that once we decide, we can easily go
221 // back and process them.
222 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
224 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
226 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
228 // Opaque types found in explicit return types and their
229 // associated fresh inference variable. Writeback resolves these
230 // variables to get the concrete type, which can be used to
231 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
232 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
234 /// A map from inference variables created from opaque
235 /// type instantiations (`ty::Infer`) to the actual opaque
236 /// type (`ty::Opaque`). Used during fallback to map unconstrained
237 /// opaque type inference variables to their corresponding
239 opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
241 /// Each type parameter has an implicit region bound that
242 /// indicates it must outlive at least the function body (the user
243 /// may specify stronger requirements). This field indicates the
244 /// region of the callee. If it is `None`, then the parameter
245 /// environment is for an item or something where the "callee" is
247 implicit_region_bound: Option<ty::Region<'tcx>>,
249 body_id: Option<hir::BodyId>,
252 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
253 type Target = InferCtxt<'a, 'tcx>;
254 fn deref(&self) -> &Self::Target {
259 /// When type-checking an expression, we propagate downward
260 /// whatever type hint we are able in the form of an `Expectation`.
261 #[derive(Copy, Clone, Debug)]
262 pub enum Expectation<'tcx> {
263 /// We know nothing about what type this expression should have.
266 /// This expression should have the type given (or some subtype).
267 ExpectHasType(Ty<'tcx>),
269 /// This expression will be cast to the `Ty`.
270 ExpectCastableToType(Ty<'tcx>),
272 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
273 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
274 ExpectRvalueLikeUnsized(Ty<'tcx>),
277 impl<'a, 'tcx> Expectation<'tcx> {
278 // Disregard "castable to" expectations because they
279 // can lead us astray. Consider for example `if cond
280 // {22} else {c} as u8` -- if we propagate the
281 // "castable to u8" constraint to 22, it will pick the
282 // type 22u8, which is overly constrained (c might not
283 // be a u8). In effect, the problem is that the
284 // "castable to" expectation is not the tightest thing
285 // we can say, so we want to drop it in this case.
286 // The tightest thing we can say is "must unify with
287 // else branch". Note that in the case of a "has type"
288 // constraint, this limitation does not hold.
290 // If the expected type is just a type variable, then don't use
291 // an expected type. Otherwise, we might write parts of the type
292 // when checking the 'then' block which are incompatible with the
294 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
296 ExpectHasType(ety) => {
297 let ety = fcx.shallow_resolve(ety);
298 if !ety.is_ty_var() {
304 ExpectRvalueLikeUnsized(ety) => {
305 ExpectRvalueLikeUnsized(ety)
311 /// Provides an expectation for an rvalue expression given an *optional*
312 /// hint, which is not required for type safety (the resulting type might
313 /// be checked higher up, as is the case with `&expr` and `box expr`), but
314 /// is useful in determining the concrete type.
316 /// The primary use case is where the expected type is a fat pointer,
317 /// like `&[isize]`. For example, consider the following statement:
319 /// let x: &[isize] = &[1, 2, 3];
321 /// In this case, the expected type for the `&[1, 2, 3]` expression is
322 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
323 /// expectation `ExpectHasType([isize])`, that would be too strong --
324 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
325 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
326 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
327 /// which still is useful, because it informs integer literals and the like.
328 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
329 /// for examples of where this comes up,.
330 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
331 match fcx.tcx.struct_tail_without_normalization(ty).kind {
332 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
333 ExpectRvalueLikeUnsized(ty)
335 _ => ExpectHasType(ty)
339 // Resolves `expected` by a single level if it is a variable. If
340 // there is no expected type or resolution is not possible (e.g.,
341 // no constraints yet present), just returns `None`.
342 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
344 NoExpectation => NoExpectation,
345 ExpectCastableToType(t) => {
346 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
348 ExpectHasType(t) => {
349 ExpectHasType(fcx.resolve_vars_if_possible(&t))
351 ExpectRvalueLikeUnsized(t) => {
352 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
357 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
358 match self.resolve(fcx) {
359 NoExpectation => None,
360 ExpectCastableToType(ty) |
362 ExpectRvalueLikeUnsized(ty) => Some(ty),
366 /// It sometimes happens that we want to turn an expectation into
367 /// a **hard constraint** (i.e., something that must be satisfied
368 /// for the program to type-check). `only_has_type` will return
369 /// such a constraint, if it exists.
370 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
371 match self.resolve(fcx) {
372 ExpectHasType(ty) => Some(ty),
373 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
377 /// Like `only_has_type`, but instead of returning `None` if no
378 /// hard constraint exists, creates a fresh type variable.
379 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
380 self.only_has_type(fcx)
382 fcx.next_ty_var(TypeVariableOrigin {
383 kind: TypeVariableOriginKind::MiscVariable,
390 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
397 fn maybe_mut_place(m: hir::Mutability) -> Self {
399 hir::Mutability::Mutable => Needs::MutPlace,
400 hir::Mutability::Immutable => Needs::None,
405 #[derive(Copy, Clone)]
406 pub struct UnsafetyState {
408 pub unsafety: hir::Unsafety,
409 pub unsafe_push_count: u32,
414 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
415 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
418 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
419 match self.unsafety {
420 // If this unsafe, then if the outer function was already marked as
421 // unsafe we shouldn't attribute the unsafe'ness to the block. This
422 // way the block can be warned about instead of ignoring this
423 // extraneous block (functions are never warned about).
424 hir::Unsafety::Unsafe if self.from_fn => *self,
427 let (unsafety, def, count) = match blk.rules {
428 hir::PushUnsafeBlock(..) =>
429 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
430 hir::PopUnsafeBlock(..) =>
431 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
432 hir::UnsafeBlock(..) =>
433 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
435 (unsafety, self.def, self.unsafe_push_count),
439 unsafe_push_count: count,
446 #[derive(Debug, Copy, Clone)]
452 /// Tracks whether executing a node may exit normally (versus
453 /// return/break/panic, which "diverge", leaving dead code in their
454 /// wake). Tracked semi-automatically (through type variables marked
455 /// as diverging), with some manual adjustments for control-flow
456 /// primitives (approximating a CFG).
457 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
459 /// Potentially unknown, some cases converge,
460 /// others require a CFG to determine them.
463 /// Definitely known to diverge and therefore
464 /// not reach the next sibling or its parent.
466 /// The `Span` points to the expression
467 /// that caused us to diverge
468 /// (e.g. `return`, `break`, etc).
470 /// In some cases (e.g. a `match` expression
471 /// where all arms diverge), we may be
472 /// able to provide a more informative
473 /// message to the user.
474 /// If this is `None`, a default messsage
475 /// will be generated, which is suitable
477 custom_note: Option<&'static str>
480 /// Same as `Always` but with a reachability
481 /// warning already emitted.
485 // Convenience impls for combining `Diverges`.
487 impl ops::BitAnd for Diverges {
489 fn bitand(self, other: Self) -> Self {
490 cmp::min(self, other)
494 impl ops::BitOr for Diverges {
496 fn bitor(self, other: Self) -> Self {
497 cmp::max(self, other)
501 impl ops::BitAndAssign for Diverges {
502 fn bitand_assign(&mut self, other: Self) {
503 *self = *self & other;
507 impl ops::BitOrAssign for Diverges {
508 fn bitor_assign(&mut self, other: Self) {
509 *self = *self | other;
514 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
515 fn always(span: Span) -> Diverges {
522 fn is_always(self) -> bool {
523 // Enum comparison ignores the
524 // contents of fields, so we just
525 // fill them in with garbage here.
526 self >= Diverges::Always {
533 pub struct BreakableCtxt<'tcx> {
536 // this is `null` for loops where break with a value is illegal,
537 // such as `while`, `for`, and `while let`
538 coerce: Option<DynamicCoerceMany<'tcx>>,
541 pub struct EnclosingBreakables<'tcx> {
542 stack: Vec<BreakableCtxt<'tcx>>,
543 by_id: HirIdMap<usize>,
546 impl<'tcx> EnclosingBreakables<'tcx> {
547 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
548 self.opt_find_breakable(target_id).unwrap_or_else(|| {
549 bug!("could not find enclosing breakable with id {}", target_id);
553 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
554 match self.by_id.get(&target_id) {
555 Some(ix) => Some(&mut self.stack[*ix]),
561 pub struct FnCtxt<'a, 'tcx> {
564 /// The parameter environment used for proving trait obligations
565 /// in this function. This can change when we descend into
566 /// closures (as they bring new things into scope), hence it is
567 /// not part of `Inherited` (as of the time of this writing,
568 /// closures do not yet change the environment, but they will
570 param_env: ty::ParamEnv<'tcx>,
572 /// Number of errors that had been reported when we started
573 /// checking this function. On exit, if we find that *more* errors
574 /// have been reported, we will skip regionck and other work that
575 /// expects the types within the function to be consistent.
576 // FIXME(matthewjasper) This should not exist, and it's not correct
577 // if type checking is run in parallel.
578 err_count_on_creation: usize,
580 /// If `Some`, this stores coercion information for returned
581 /// expressions. If `None`, this is in a context where return is
582 /// inappropriate, such as a const expression.
584 /// This is a `RefCell<DynamicCoerceMany>`, which means that we
585 /// can track all the return expressions and then use them to
586 /// compute a useful coercion from the set, similar to a match
587 /// expression or other branching context. You can use methods
588 /// like `expected_ty` to access the declared return type (if
590 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
592 /// First span of a return site that we find. Used in error messages.
593 ret_coercion_span: RefCell<Option<Span>>,
595 yield_ty: Option<Ty<'tcx>>,
597 ps: RefCell<UnsafetyState>,
599 /// Whether the last checked node generates a divergence (e.g.,
600 /// `return` will set this to `Always`). In general, when entering
601 /// an expression or other node in the tree, the initial value
602 /// indicates whether prior parts of the containing expression may
603 /// have diverged. It is then typically set to `Maybe` (and the
604 /// old value remembered) for processing the subparts of the
605 /// current expression. As each subpart is processed, they may set
606 /// the flag to `Always`, etc. Finally, at the end, we take the
607 /// result and "union" it with the original value, so that when we
608 /// return the flag indicates if any subpart of the parent
609 /// expression (up to and including this part) has diverged. So,
610 /// if you read it after evaluating a subexpression `X`, the value
611 /// you get indicates whether any subexpression that was
612 /// evaluating up to and including `X` diverged.
614 /// We currently use this flag only for diagnostic purposes:
616 /// - To warn about unreachable code: if, after processing a
617 /// sub-expression but before we have applied the effects of the
618 /// current node, we see that the flag is set to `Always`, we
619 /// can issue a warning. This corresponds to something like
620 /// `foo(return)`; we warn on the `foo()` expression. (We then
621 /// update the flag to `WarnedAlways` to suppress duplicate
622 /// reports.) Similarly, if we traverse to a fresh statement (or
623 /// tail expression) from a `Always` setting, we will issue a
624 /// warning. This corresponds to something like `{return;
625 /// foo();}` or `{return; 22}`, where we would warn on the
628 /// An expression represents dead code if, after checking it,
629 /// the diverges flag is set to something other than `Maybe`.
630 diverges: Cell<Diverges>,
632 /// Whether any child nodes have any type errors.
633 has_errors: Cell<bool>,
635 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
637 inh: &'a Inherited<'a, 'tcx>,
640 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
641 type Target = Inherited<'a, 'tcx>;
642 fn deref(&self) -> &Self::Target {
647 /// Helper type of a temporary returned by `Inherited::build(...)`.
648 /// Necessary because we can't write the following bound:
649 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
650 pub struct InheritedBuilder<'tcx> {
651 infcx: infer::InferCtxtBuilder<'tcx>,
655 impl Inherited<'_, 'tcx> {
656 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
657 let hir_id_root = if def_id.is_local() {
658 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
659 DefId::local(hir_id.owner)
665 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
671 impl<'tcx> InheritedBuilder<'tcx> {
672 fn enter<F, R>(&mut self, f: F) -> R
674 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
676 let def_id = self.def_id;
677 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
681 impl Inherited<'a, 'tcx> {
682 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
684 let item_id = tcx.hir().as_local_hir_id(def_id);
685 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
686 let implicit_region_bound = body_id.map(|body_id| {
687 let body = tcx.hir().body(body_id);
688 tcx.mk_region(ty::ReScope(region::Scope {
689 id: body.value.hir_id.local_id,
690 data: region::ScopeData::CallSite
695 tables: MaybeInProgressTables {
696 maybe_tables: infcx.in_progress_tables,
699 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
700 locals: RefCell::new(Default::default()),
701 deferred_sized_obligations: RefCell::new(Vec::new()),
702 deferred_call_resolutions: RefCell::new(Default::default()),
703 deferred_cast_checks: RefCell::new(Vec::new()),
704 deferred_generator_interiors: RefCell::new(Vec::new()),
705 opaque_types: RefCell::new(Default::default()),
706 opaque_types_vars: RefCell::new(Default::default()),
707 implicit_region_bound,
712 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
713 debug!("register_predicate({:?})", obligation);
714 if obligation.has_escaping_bound_vars() {
715 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
720 .register_predicate_obligation(self, obligation);
723 fn register_predicates<I>(&self, obligations: I)
724 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
726 for obligation in obligations {
727 self.register_predicate(obligation);
731 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
732 self.register_predicates(infer_ok.obligations);
736 fn normalize_associated_types_in<T>(&self,
739 param_env: ty::ParamEnv<'tcx>,
741 where T : TypeFoldable<'tcx>
743 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
744 self.register_infer_ok_obligations(ok)
748 struct CheckItemTypesVisitor<'tcx> {
752 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
753 fn visit_item(&mut self, i: &'tcx hir::Item) {
754 check_item_type(self.tcx, i);
756 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
757 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
760 pub fn check_wf_new(tcx: TyCtxt<'_>) {
761 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
762 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
765 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
766 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
769 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
770 debug_assert!(crate_num == LOCAL_CRATE);
771 tcx.par_body_owners(|body_owner_def_id| {
772 tcx.ensure().typeck_tables_of(body_owner_def_id);
776 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
777 wfcheck::check_item_well_formed(tcx, def_id);
780 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
781 wfcheck::check_trait_item(tcx, def_id);
784 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
785 wfcheck::check_impl_item(tcx, def_id);
788 pub fn provide(providers: &mut Providers<'_>) {
789 method::provide(providers);
790 *providers = Providers {
796 check_item_well_formed,
797 check_trait_item_well_formed,
798 check_impl_item_well_formed,
799 check_mod_item_types,
804 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
805 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
808 /// If this `DefId` is a "primary tables entry", returns
809 /// `Some((body_id, header, decl))` with information about
810 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
813 /// If this function returns `Some`, then `typeck_tables(def_id)` will
814 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
815 /// may not succeed. In some cases where this function returns `None`
816 /// (notably closures), `typeck_tables(def_id)` would wind up
817 /// redirecting to the owning function.
821 ) -> Option<(hir::BodyId, Option<&hir::Ty>, Option<&hir::FnHeader>, Option<&hir::FnDecl>)> {
822 match tcx.hir().get(id) {
823 Node::Item(item) => {
825 hir::ItemKind::Const(ref ty, body) |
826 hir::ItemKind::Static(ref ty, _, body) =>
827 Some((body, Some(ty), None, None)),
828 hir::ItemKind::Fn(ref sig, .., body) =>
829 Some((body, None, Some(&sig.header), Some(&sig.decl))),
834 Node::TraitItem(item) => {
836 hir::TraitItemKind::Const(ref ty, Some(body)) =>
837 Some((body, Some(ty), None, None)),
838 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
839 Some((body, None, Some(&sig.header), Some(&sig.decl))),
844 Node::ImplItem(item) => {
846 hir::ImplItemKind::Const(ref ty, body) =>
847 Some((body, Some(ty), None, None)),
848 hir::ImplItemKind::Method(ref sig, body) =>
849 Some((body, None, Some(&sig.header), Some(&sig.decl))),
854 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
859 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
860 // Closures' tables come from their outermost function,
861 // as they are part of the same "inference environment".
862 let outer_def_id = tcx.closure_base_def_id(def_id);
863 if outer_def_id != def_id {
864 return tcx.has_typeck_tables(outer_def_id);
867 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
868 primary_body_of(tcx, id).is_some()
871 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
872 &*tcx.typeck_tables_of(def_id).used_trait_imports
875 /// Inspects the substs of opaque types, replacing any inference variables
876 /// with proper generic parameter from the identity substs.
878 /// This is run after we normalize the function signature, to fix any inference
879 /// variables introduced by the projection of associated types. This ensures that
880 /// any opaque types used in the signature continue to refer to generic parameters,
881 /// allowing them to be considered for defining uses in the function body
883 /// For example, consider this code.
888 /// fn use_it(self) -> Self::MyItem
890 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
891 /// type MyItem = impl Iterator<Item = I>;
892 /// fn use_it(self) -> Self::MyItem {
898 /// When we normalize the signature of `use_it` from the impl block,
899 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
900 /// However, this projection result may contain inference variables, due
901 /// to the way that projection works. We didn't have any inference variables
902 /// in the signature to begin with - leaving them in will cause us to incorrectly
903 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
904 /// variables back to the actual generic parameters, we will correctly see that
905 /// we have a defining use of `MyItem`
906 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T where T: TypeFoldable<'tcx> {
907 struct FixupFolder<'tcx> {
911 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
912 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
916 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
918 ty::Opaque(def_id, substs) => {
919 debug!("fixup_opaque_types: found type {:?}", ty);
920 // Here, we replace any inference variables that occur within
921 // the substs of an opaque type. By definition, any type occuring
922 // in the substs has a corresponding generic parameter, which is what
923 // we replace it with.
924 // This replacement is only run on the function signature, so any
925 // inference variables that we come across must be the rust of projection
926 // (there's no other way for a user to get inference variables into
927 // a function signature).
928 if ty.needs_infer() {
929 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
930 let old_param = substs[param.index as usize];
931 match old_param.unpack() {
932 GenericArgKind::Type(old_ty) => {
933 if let ty::Infer(_) = old_ty.kind {
934 // Replace inference type with a generic parameter
935 self.tcx.mk_param_from_def(param)
937 old_param.fold_with(self)
940 GenericArgKind::Const(old_const) => {
941 if let ty::ConstKind::Infer(_) = old_const.val {
942 // This should never happen - we currently do not support
943 // 'const projections', e.g.:
944 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
945 // which should be the only way for us to end up with a const inference
946 // variable after projection. If Rust ever gains support for this kind
947 // of projection, this should *probably* be changed to
948 // `self.tcx.mk_param_from_def(param)`
949 bug!("Found infer const: `{:?}` in opaque type: {:?}",
952 old_param.fold_with(self)
955 GenericArgKind::Lifetime(old_region) => {
956 if let RegionKind::ReVar(_) = old_region {
957 self.tcx.mk_param_from_def(param)
959 old_param.fold_with(self)
964 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
965 debug!("fixup_opaque_types: new type: {:?}", new_ty);
971 _ => ty.super_fold_with(self)
976 debug!("fixup_opaque_types({:?})", val);
977 val.fold_with(&mut FixupFolder { tcx })
980 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
981 // Closures' tables come from their outermost function,
982 // as they are part of the same "inference environment".
983 let outer_def_id = tcx.closure_base_def_id(def_id);
984 if outer_def_id != def_id {
985 return tcx.typeck_tables_of(outer_def_id);
988 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
989 let span = tcx.hir().span(id);
991 // Figure out what primary body this item has.
992 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id)
994 span_bug!(span, "can't type-check body of {:?}", def_id);
996 let body = tcx.hir().body(body_id);
998 let tables = Inherited::build(tcx, def_id).enter(|inh| {
999 let param_env = tcx.param_env(def_id);
1000 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
1001 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
1002 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1003 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl)
1008 check_abi(tcx, span, fn_sig.abi());
1010 // Compute the fty from point of view of inside the fn.
1012 tcx.liberate_late_bound_regions(def_id, &fn_sig);
1014 inh.normalize_associated_types_in(body.value.span,
1019 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1021 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1024 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1025 let expected_type = body_ty.and_then(|ty| match ty.kind {
1026 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1028 }).unwrap_or_else(|| tcx.type_of(def_id));
1029 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1030 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1032 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1033 fcx.instantiate_opaque_types_from_value(
1042 // Gather locals in statics (because of block expressions).
1043 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
1045 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
1047 fcx.write_ty(id, revealed_ty);
1052 // All type checking constraints were added, try to fallback unsolved variables.
1053 fcx.select_obligations_where_possible(false, |_| {});
1054 let mut fallback_has_occurred = false;
1056 // We do fallback in two passes, to try to generate
1057 // better error messages.
1058 // The first time, we do *not* replace opaque types.
1059 for ty in &fcx.unsolved_variables() {
1060 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1062 // We now see if we can make progress. This might
1063 // cause us to unify inference variables for opaque types,
1064 // since we may have unified some other type variables
1065 // during the first phase of fallback.
1066 // This means that we only replace inference variables with their underlying
1067 // opaque types as a last resort.
1069 // In code like this:
1072 // type MyType = impl Copy;
1073 // fn produce() -> MyType { true }
1074 // fn bad_produce() -> MyType { panic!() }
1077 // we want to unify the opaque inference variable in `bad_produce`
1078 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1079 // This will produce a nice error message about conflicting concrete
1080 // types for `MyType`.
1082 // If we had tried to fallback the opaque inference variable to `MyType`,
1083 // we will generate a confusing type-check error that does not explicitly
1084 // refer to opaque types.
1085 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1087 // We now run fallback again, but this time we allow it to replace
1088 // unconstrained opaque type variables, in addition to performing
1089 // other kinds of fallback.
1090 for ty in &fcx.unsolved_variables() {
1091 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1094 // See if we can make any more progress.
1095 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1097 // Even though coercion casts provide type hints, we check casts after fallback for
1098 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1101 // Closure and generator analysis may run after fallback
1102 // because they don't constrain other type variables.
1103 fcx.closure_analyze(body);
1104 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1105 fcx.resolve_generator_interiors(def_id);
1107 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1108 let ty = fcx.normalize_ty(span, ty);
1109 fcx.require_type_is_sized(ty, span, code);
1111 fcx.select_all_obligations_or_error();
1113 if fn_decl.is_some() {
1114 fcx.regionck_fn(id, body);
1116 fcx.regionck_expr(body);
1119 fcx.resolve_type_vars_in_body(body)
1122 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1123 // it will need to hold.
1124 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
1129 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1130 if !tcx.sess.target.target.is_abi_supported(abi) {
1131 struct_span_err!(tcx.sess, span, E0570,
1132 "The ABI `{}` is not supported for the current target", abi).emit()
1136 struct GatherLocalsVisitor<'a, 'tcx> {
1137 fcx: &'a FnCtxt<'a, 'tcx>,
1138 parent_id: hir::HirId,
1141 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1142 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1145 // infer the variable's type
1146 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1147 kind: TypeVariableOriginKind::TypeInference,
1150 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
1157 // take type that the user specified
1158 self.fcx.locals.borrow_mut().insert(nid, typ);
1165 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1166 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
1167 NestedVisitorMap::None
1170 // Add explicitly-declared locals.
1171 fn visit_local(&mut self, local: &'tcx hir::Local) {
1172 let local_ty = match local.ty {
1174 let o_ty = self.fcx.to_ty(&ty);
1176 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1177 self.fcx.instantiate_opaque_types_from_value(
1186 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
1187 &UserType::Ty(revealed_ty)
1189 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1190 ty.hir_id, o_ty, revealed_ty, c_ty);
1191 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1193 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1197 self.assign(local.span, local.hir_id, local_ty);
1199 debug!("local variable {:?} is assigned type {}",
1201 self.fcx.ty_to_string(
1202 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
1203 intravisit::walk_local(self, local);
1206 // Add pattern bindings.
1207 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
1208 if let PatKind::Binding(_, _, ident, _) = p.kind {
1209 let var_ty = self.assign(p.span, p.hir_id, None);
1211 if !self.fcx.tcx.features().unsized_locals {
1212 self.fcx.require_type_is_sized(var_ty, p.span,
1213 traits::VariableType(p.hir_id));
1216 debug!("pattern binding {} is assigned to {} with type {:?}",
1218 self.fcx.ty_to_string(
1219 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1222 intravisit::walk_pat(self, p);
1225 // Don't descend into the bodies of nested closures
1228 _: intravisit::FnKind<'tcx>,
1229 _: &'tcx hir::FnDecl,
1236 /// When `check_fn` is invoked on a generator (i.e., a body that
1237 /// includes yield), it returns back some information about the yield
1239 struct GeneratorTypes<'tcx> {
1240 /// Type of value that is yielded.
1243 /// Types that are captured (see `GeneratorInterior` for more).
1246 /// Indicates if the generator is movable or static (immovable).
1247 movability: hir::Movability,
1250 /// Helper used for fns and closures. Does the grungy work of checking a function
1251 /// body and returns the function context used for that purpose, since in the case of a fn item
1252 /// there is still a bit more to do.
1255 /// * inherited: other fields inherited from the enclosing fn (if any)
1256 fn check_fn<'a, 'tcx>(
1257 inherited: &'a Inherited<'a, 'tcx>,
1258 param_env: ty::ParamEnv<'tcx>,
1259 fn_sig: ty::FnSig<'tcx>,
1260 decl: &'tcx hir::FnDecl,
1262 body: &'tcx hir::Body,
1263 can_be_generator: Option<hir::Movability>,
1264 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1265 let mut fn_sig = fn_sig.clone();
1267 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1269 // Create the function context. This is either derived from scratch or,
1270 // in the case of closures, based on the outer context.
1271 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1272 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1274 let declared_ret_ty = fn_sig.output();
1275 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1276 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1281 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1282 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1283 fn_sig = fcx.tcx.mk_fn_sig(
1284 fn_sig.inputs().iter().cloned(),
1291 let span = body.value.span;
1293 fn_maybe_err(fcx.tcx, span, fn_sig.abi);
1295 if body.generator_kind.is_some() && can_be_generator.is_some() {
1296 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1297 kind: TypeVariableOriginKind::TypeInference,
1300 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1301 fcx.yield_ty = Some(yield_ty);
1304 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1305 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1306 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1308 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1309 // (as it's created inside the body itself, not passed in from outside).
1310 let maybe_va_list = if fn_sig.c_variadic {
1311 let va_list_did = fcx.tcx.require_lang_item(
1312 lang_items::VaListTypeLangItem,
1313 Some(body.params.last().unwrap().span),
1315 let region = fcx.tcx.mk_region(ty::ReScope(region::Scope {
1316 id: body.value.hir_id.local_id,
1317 data: region::ScopeData::CallSite
1320 Some(fcx.tcx.type_of(va_list_did).subst(fcx.tcx, &[region.into()]))
1325 // Add formal parameters.
1326 for (param_ty, param) in
1327 fn_sig.inputs().iter().copied()
1328 .chain(maybe_va_list)
1331 // Check the pattern.
1332 fcx.check_pat_top(¶m.pat, param_ty, None);
1334 // Check that argument is Sized.
1335 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1336 // for simple cases like `fn foo(x: Trait)`,
1337 // where we would error once on the parameter as a whole, and once on the binding `x`.
1338 if param.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1339 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1342 fcx.write_ty(param.hir_id, param_ty);
1345 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1347 fcx.check_return_expr(&body.value);
1349 // We insert the deferred_generator_interiors entry after visiting the body.
1350 // This ensures that all nested generators appear before the entry of this generator.
1351 // resolve_generator_interiors relies on this property.
1352 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1353 let interior = fcx.next_ty_var(TypeVariableOrigin {
1354 kind: TypeVariableOriginKind::MiscVariable,
1357 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1358 Some(GeneratorTypes {
1359 yield_ty: fcx.yield_ty.unwrap(),
1361 movability: can_be_generator.unwrap(),
1367 // Finalize the return check by taking the LUB of the return types
1368 // we saw and assigning it to the expected return type. This isn't
1369 // really expected to fail, since the coercions would have failed
1370 // earlier when trying to find a LUB.
1372 // However, the behavior around `!` is sort of complex. In the
1373 // event that the `actual_return_ty` comes back as `!`, that
1374 // indicates that the fn either does not return or "returns" only
1375 // values of type `!`. In this case, if there is an expected
1376 // return type that is *not* `!`, that should be ok. But if the
1377 // return type is being inferred, we want to "fallback" to `!`:
1379 // let x = move || panic!();
1381 // To allow for that, I am creating a type variable with diverging
1382 // fallback. This was deemed ever so slightly better than unifying
1383 // the return value with `!` because it allows for the caller to
1384 // make more assumptions about the return type (e.g., they could do
1386 // let y: Option<u32> = Some(x());
1388 // which would then cause this return type to become `u32`, not
1390 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1391 let mut actual_return_ty = coercion.complete(&fcx);
1392 if actual_return_ty.is_never() {
1393 actual_return_ty = fcx.next_diverging_ty_var(
1394 TypeVariableOrigin {
1395 kind: TypeVariableOriginKind::DivergingFn,
1400 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1402 // Check that the main return type implements the termination trait.
1403 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1404 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1405 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1406 if main_id == fn_id {
1407 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1408 let trait_ref = ty::TraitRef::new(term_id, substs);
1409 let return_ty_span = decl.output.span();
1410 let cause = traits::ObligationCause::new(
1411 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1413 inherited.register_predicate(
1414 traits::Obligation::new(
1415 cause, param_env, trait_ref.to_predicate()));
1420 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1421 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1422 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1423 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1424 if declared_ret_ty.kind != ty::Never {
1425 fcx.tcx.sess.span_err(
1427 "return type should be `!`",
1431 let inputs = fn_sig.inputs();
1432 let span = fcx.tcx.hir().span(fn_id);
1433 if inputs.len() == 1 {
1434 let arg_is_panic_info = match inputs[0].kind {
1435 ty::Ref(region, ty, mutbl) => match ty.kind {
1436 ty::Adt(ref adt, _) => {
1437 adt.did == panic_info_did &&
1438 mutbl == hir::Mutability::Immutable &&
1439 *region != RegionKind::ReStatic
1446 if !arg_is_panic_info {
1447 fcx.tcx.sess.span_err(
1448 decl.inputs[0].span,
1449 "argument should be `&PanicInfo`",
1453 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1454 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1455 if !generics.params.is_empty() {
1456 fcx.tcx.sess.span_err(
1458 "should have no type parameters",
1464 let span = fcx.tcx.sess.source_map().def_span(span);
1465 fcx.tcx.sess.span_err(span, "function should have one argument");
1468 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1473 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1474 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1475 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1476 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1477 if declared_ret_ty.kind != ty::Never {
1478 fcx.tcx.sess.span_err(
1480 "return type should be `!`",
1484 let inputs = fn_sig.inputs();
1485 let span = fcx.tcx.hir().span(fn_id);
1486 if inputs.len() == 1 {
1487 let arg_is_alloc_layout = match inputs[0].kind {
1488 ty::Adt(ref adt, _) => {
1489 adt.did == alloc_layout_did
1494 if !arg_is_alloc_layout {
1495 fcx.tcx.sess.span_err(
1496 decl.inputs[0].span,
1497 "argument should be `Layout`",
1501 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1502 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1503 if !generics.params.is_empty() {
1504 fcx.tcx.sess.span_err(
1506 "`#[alloc_error_handler]` function should have no type \
1513 let span = fcx.tcx.sess.source_map().def_span(span);
1514 fcx.tcx.sess.span_err(span, "function should have one argument");
1517 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1525 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1526 let def_id = tcx.hir().local_def_id(id);
1527 let def = tcx.adt_def(def_id);
1528 def.destructor(tcx); // force the destructor to be evaluated
1529 check_representable(tcx, span, def_id);
1531 if def.repr.simd() {
1532 check_simd(tcx, span, def_id);
1535 check_transparent(tcx, span, def_id);
1536 check_packed(tcx, span, def_id);
1539 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1540 let def_id = tcx.hir().local_def_id(id);
1541 let def = tcx.adt_def(def_id);
1542 def.destructor(tcx); // force the destructor to be evaluated
1543 check_representable(tcx, span, def_id);
1544 check_transparent(tcx, span, def_id);
1545 check_union_fields(tcx, span, def_id);
1546 check_packed(tcx, span, def_id);
1549 /// When the `#![feature(untagged_unions)]` gate is active,
1550 /// check that the fields of the `union` does not contain fields that need dropping.
1551 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool {
1552 let item_type = tcx.type_of(item_def_id);
1553 if let ty::Adt(def, substs) = item_type.kind {
1554 assert!(def.is_union());
1555 let fields = &def.non_enum_variant().fields;
1556 for field in fields {
1557 let field_ty = field.ty(tcx, substs);
1558 // We are currently checking the type this field came from, so it must be local.
1559 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1560 let param_env = tcx.param_env(field.did);
1561 if field_ty.needs_drop(tcx, param_env) {
1562 struct_span_err!(tcx.sess, field_span, E0740,
1563 "unions may not contain fields that need dropping")
1564 .span_note(field_span,
1565 "`std::mem::ManuallyDrop` can be used to wrap the type")
1571 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1576 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1577 /// projections that would result in "inheriting lifetimes".
1578 fn check_opaque<'tcx>(
1581 substs: SubstsRef<'tcx>,
1583 origin: &hir::OpaqueTyOrigin,
1585 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1586 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1589 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1590 /// in "inheriting lifetimes".
1591 fn check_opaque_for_inheriting_lifetimes(
1596 let item = tcx.hir().expect_item(
1597 tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1598 debug!("check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1599 def_id, span, item);
1602 struct ProhibitOpaqueVisitor<'tcx> {
1603 opaque_identity_ty: Ty<'tcx>,
1604 generics: &'tcx ty::Generics,
1607 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1608 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1609 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1610 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1613 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1614 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1615 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1616 return *index < self.generics.parent_count as u32;
1619 r.super_visit_with(self)
1623 let prohibit_opaque = match item.kind {
1624 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. }) |
1625 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1626 let mut visitor = ProhibitOpaqueVisitor {
1627 opaque_identity_ty: tcx.mk_opaque(
1628 def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1629 generics: tcx.generics_of(def_id),
1631 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1633 tcx.predicates_of(def_id).predicates.iter().any(
1634 |(predicate, _)| predicate.visit_with(&mut visitor))
1639 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1640 if prohibit_opaque {
1641 let is_async = match item.kind {
1642 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1643 hir::OpaqueTyOrigin::AsyncFn => true,
1646 _ => unreachable!(),
1649 tcx.sess.span_err(span, &format!(
1650 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1652 if is_async { "async fn" } else { "impl Trait" },
1657 /// Checks that an opaque type does not contain cycles.
1658 fn check_opaque_for_cycles<'tcx>(
1661 substs: SubstsRef<'tcx>,
1663 origin: &hir::OpaqueTyOrigin,
1665 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1666 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1668 tcx.sess, span, E0733,
1669 "recursion in an `async fn` requires boxing",
1671 .span_label(span, "recursive `async fn`")
1672 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
1675 let mut err = struct_span_err!(
1676 tcx.sess, span, E0720,
1677 "opaque type expands to a recursive type",
1679 err.span_label(span, "expands to a recursive type");
1680 if let ty::Opaque(..) = partially_expanded_type.kind {
1681 err.note("type resolves to itself");
1683 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1690 // Forbid defining intrinsics in Rust code,
1691 // as they must always be defined by the compiler.
1692 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1693 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1694 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1698 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1700 "check_item_type(it.hir_id={}, it.name={})",
1702 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1704 let _indenter = indenter();
1706 // Consts can play a role in type-checking, so they are included here.
1707 hir::ItemKind::Static(..) => {
1708 let def_id = tcx.hir().local_def_id(it.hir_id);
1709 tcx.typeck_tables_of(def_id);
1710 maybe_check_static_with_link_section(tcx, def_id, it.span);
1712 hir::ItemKind::Const(..) => {
1713 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1715 hir::ItemKind::Enum(ref enum_definition, _) => {
1716 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1718 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1719 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1720 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1721 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1722 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1723 check_impl_items_against_trait(
1730 let trait_def_id = impl_trait_ref.def_id;
1731 check_on_unimplemented(tcx, trait_def_id, it);
1734 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1735 let def_id = tcx.hir().local_def_id(it.hir_id);
1736 check_on_unimplemented(tcx, def_id, it);
1738 for item in items.iter() {
1739 let item = tcx.hir().trait_item(item.id);
1740 if let hir::TraitItemKind::Method(sig, _) = &item.kind {
1741 let abi = sig.header.abi;
1742 fn_maybe_err(tcx, item.ident.span, abi);
1746 hir::ItemKind::Struct(..) => {
1747 check_struct(tcx, it.hir_id, it.span);
1749 hir::ItemKind::Union(..) => {
1750 check_union(tcx, it.hir_id, it.span);
1752 hir::ItemKind::OpaqueTy(hir::OpaqueTy{origin, ..}) => {
1753 let def_id = tcx.hir().local_def_id(it.hir_id);
1755 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1756 check_opaque(tcx, def_id, substs, it.span, &origin);
1758 hir::ItemKind::TyAlias(..) => {
1759 let def_id = tcx.hir().local_def_id(it.hir_id);
1760 let pty_ty = tcx.type_of(def_id);
1761 let generics = tcx.generics_of(def_id);
1762 check_bounds_are_used(tcx, &generics, pty_ty);
1764 hir::ItemKind::ForeignMod(ref m) => {
1765 check_abi(tcx, it.span, m.abi);
1767 if m.abi == Abi::RustIntrinsic {
1768 for item in &m.items {
1769 intrinsic::check_intrinsic_type(tcx, item);
1771 } else if m.abi == Abi::PlatformIntrinsic {
1772 for item in &m.items {
1773 intrinsic::check_platform_intrinsic_type(tcx, item);
1776 for item in &m.items {
1777 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1778 let own_counts = generics.own_counts();
1779 if generics.params.len() - own_counts.lifetimes != 0 {
1780 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1781 (_, 0) => ("type", "types", Some("u32")),
1782 // We don't specify an example value, because we can't generate
1783 // a valid value for any type.
1784 (0, _) => ("const", "consts", None),
1785 _ => ("type or const", "types or consts", None),
1791 "foreign items may not have {} parameters",
1795 &format!("can't have {} parameters", kinds),
1797 // FIXME: once we start storing spans for type arguments, turn this
1798 // into a suggestion.
1800 "replace the {} parameters with concrete {}{}",
1803 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1808 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1809 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1814 _ => { /* nothing to do */ }
1818 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1819 // Only restricted on wasm32 target for now
1820 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1824 // If `#[link_section]` is missing, then nothing to verify
1825 let attrs = tcx.codegen_fn_attrs(id);
1826 if attrs.link_section.is_none() {
1830 // For the wasm32 target statics with `#[link_section]` are placed into custom
1831 // sections of the final output file, but this isn't link custom sections of
1832 // other executable formats. Namely we can only embed a list of bytes,
1833 // nothing with pointers to anything else or relocations. If any relocation
1834 // show up, reject them here.
1835 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1836 // the consumer's responsibility to ensure all bytes that have been read
1837 // have defined values.
1838 let instance = ty::Instance::mono(tcx, id);
1839 let cid = GlobalId {
1843 let param_env = ty::ParamEnv::reveal_all();
1844 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1845 let alloc = if let ty::ConstKind::Value(ConstValue::ByRef { alloc, .. }) = static_.val {
1848 bug!("Matching on non-ByRef static")
1850 if alloc.relocations().len() != 0 {
1851 let msg = "statics with a custom `#[link_section]` must be a \
1852 simple list of bytes on the wasm target with no \
1853 extra levels of indirection such as references";
1854 tcx.sess.span_err(span, msg);
1859 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1860 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1861 // an error would be reported if this fails.
1862 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1865 fn report_forbidden_specialization(
1867 impl_item: &hir::ImplItem,
1870 let mut err = struct_span_err!(
1871 tcx.sess, impl_item.span, E0520,
1872 "`{}` specializes an item from a parent `impl`, but \
1873 that item is not marked `default`",
1875 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1878 match tcx.span_of_impl(parent_impl) {
1880 err.span_label(span, "parent `impl` is here");
1881 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1885 err.note(&format!("parent implementation is in crate `{}`", cname));
1892 fn check_specialization_validity<'tcx>(
1894 trait_def: &ty::TraitDef,
1895 trait_item: &ty::AssocItem,
1897 impl_item: &hir::ImplItem,
1899 let kind = match impl_item.kind {
1900 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1901 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1902 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1903 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1906 let mut ancestor_impls = trait_def.ancestors(tcx, impl_id)
1908 .filter_map(|parent| {
1909 if parent.is_from_trait() {
1912 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
1917 if ancestor_impls.peek().is_none() {
1918 // No parent, nothing to specialize.
1922 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1924 // Parent impl exists, and contains the parent item we're trying to specialize, but
1925 // doesn't mark it `default`.
1926 Some(parent_item) if tcx.impl_item_is_final(&parent_item) => {
1927 Some(Err(parent_impl.def_id()))
1930 // Parent impl contains item and makes it specializable.
1935 // Parent impl doesn't mention the item. This means it's inherited from the
1936 // grandparent. In that case, if parent is a `default impl`, inherited items use the
1937 // "defaultness" from the grandparent, else they are final.
1938 None => if tcx.impl_is_default(parent_impl.def_id()) {
1941 Some(Err(parent_impl.def_id()))
1946 // If `opt_result` is `None`, we have only encoutered `default impl`s that don't contain the
1947 // item. This is allowed, the item isn't actually getting specialized here.
1948 let result = opt_result.unwrap_or(Ok(()));
1950 if let Err(parent_impl) = result {
1951 report_forbidden_specialization(tcx, impl_item, parent_impl);
1955 fn check_impl_items_against_trait<'tcx>(
1957 full_impl_span: Span,
1959 impl_trait_ref: ty::TraitRef<'tcx>,
1960 impl_item_refs: &[hir::ImplItemRef],
1962 let impl_span = tcx.sess.source_map().def_span(full_impl_span);
1964 // If the trait reference itself is erroneous (so the compilation is going
1965 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1966 // isn't populated for such impls.
1967 if impl_trait_ref.references_error() { return; }
1969 // Locate trait definition and items
1970 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1971 let mut overridden_associated_type = None;
1973 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1975 // Check existing impl methods to see if they are both present in trait
1976 // and compatible with trait signature
1977 for impl_item in impl_items() {
1978 let ty_impl_item = tcx.associated_item(
1979 tcx.hir().local_def_id(impl_item.hir_id));
1980 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1981 .find(|ac| Namespace::from(&impl_item.kind) == Namespace::from(ac.kind) &&
1982 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1984 // Not compatible, but needed for the error message
1985 tcx.associated_items(impl_trait_ref.def_id)
1986 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1989 // Check that impl definition matches trait definition
1990 if let Some(ty_trait_item) = ty_trait_item {
1991 match impl_item.kind {
1992 hir::ImplItemKind::Const(..) => {
1993 // Find associated const definition.
1994 if ty_trait_item.kind == ty::AssocKind::Const {
1995 compare_const_impl(tcx,
2001 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
2002 "item `{}` is an associated const, \
2003 which doesn't match its trait `{}`",
2006 err.span_label(impl_item.span, "does not match trait");
2007 // We can only get the spans from local trait definition
2008 // Same for E0324 and E0325
2009 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2010 err.span_label(trait_span, "item in trait");
2015 hir::ImplItemKind::Method(..) => {
2016 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2017 if ty_trait_item.kind == ty::AssocKind::Method {
2018 compare_impl_method(tcx,
2025 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
2026 "item `{}` is an associated method, \
2027 which doesn't match its trait `{}`",
2030 err.span_label(impl_item.span, "does not match trait");
2031 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2032 err.span_label(trait_span, "item in trait");
2037 hir::ImplItemKind::OpaqueTy(..) |
2038 hir::ImplItemKind::TyAlias(_) => {
2039 if ty_trait_item.kind == ty::AssocKind::Type {
2040 if ty_trait_item.defaultness.has_value() {
2041 overridden_associated_type = Some(impl_item);
2044 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
2045 "item `{}` is an associated type, \
2046 which doesn't match its trait `{}`",
2049 err.span_label(impl_item.span, "does not match trait");
2050 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2051 err.span_label(trait_span, "item in trait");
2058 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
2062 // Check for missing items from trait
2063 let mut missing_items = Vec::new();
2064 let mut invalidated_items = Vec::new();
2065 let associated_type_overridden = overridden_associated_type.is_some();
2066 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
2067 let is_implemented = trait_def.ancestors(tcx, impl_id)
2068 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2069 .map(|node_item| !node_item.node.is_from_trait())
2072 if !is_implemented && !tcx.impl_is_default(impl_id) {
2073 if !trait_item.defaultness.has_value() {
2074 missing_items.push(trait_item);
2075 } else if associated_type_overridden {
2076 invalidated_items.push(trait_item.ident);
2081 if !missing_items.is_empty() {
2082 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2085 if !invalidated_items.is_empty() {
2086 let invalidator = overridden_associated_type.unwrap();
2091 "the following trait items need to be reimplemented as `{}` was overridden: `{}`",
2093 invalidated_items.iter()
2094 .map(|name| name.to_string())
2095 .collect::<Vec<_>>().join("`, `")
2100 fn missing_items_err(
2103 missing_items: &[ty::AssocItem],
2104 full_impl_span: Span,
2106 let missing_items_msg = missing_items.iter()
2107 .map(|trait_item| trait_item.ident.to_string())
2108 .collect::<Vec<_>>().join("`, `");
2110 let mut err = struct_span_err!(
2114 "not all trait items implemented, missing: `{}`",
2117 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2119 // `Span` before impl block closing brace.
2120 let hi = full_impl_span.hi() - BytePos(1);
2121 // Point at the place right before the closing brace of the relevant `impl` to suggest
2122 // adding the associated item at the end of its body.
2123 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2124 // Obtain the level of indentation ending in `sugg_sp`.
2125 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2126 // Make the whitespace that will make the suggestion have the right indentation.
2127 let padding: String = (0..indentation).map(|_| " ").collect();
2129 for trait_item in missing_items {
2130 let snippet = suggestion_signature(&trait_item, tcx);
2131 let code = format!("{}{}\n{}", padding, snippet, padding);
2132 let msg = format!("implement the missing item: `{}`", snippet);
2133 let appl = Applicability::HasPlaceholders;
2134 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2135 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2136 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2138 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2144 /// Return placeholder code for the given function.
2145 fn fn_sig_suggestion(sig: &ty::FnSig<'_>, ident: Ident) -> String {
2146 let args = sig.inputs()
2148 .map(|ty| Some(match ty.kind {
2149 ty::Param(param) if param.name == kw::SelfUpper => "self".to_string(),
2150 ty::Ref(reg, ref_ty, mutability) => {
2151 let reg = match &format!("{}", reg)[..] {
2152 "'_" | "" => String::new(),
2153 reg => format!("{} ", reg),
2156 ty::Param(param) if param.name == kw::SelfUpper => {
2157 format!("&{}{}self", reg, mutability.prefix_str())
2159 _ => format!("_: {:?}", ty),
2162 _ => format!("_: {:?}", ty),
2164 .chain(std::iter::once(if sig.c_variadic {
2165 Some("...".to_string())
2169 .filter_map(|arg| arg)
2170 .collect::<Vec<String>>()
2172 let output = sig.output();
2173 let output = if !output.is_unit() {
2174 format!(" -> {:?}", output)
2179 let unsafety = sig.unsafety.prefix_str();
2180 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2181 // not be present in the `fn` definition, not will we account for renamed
2182 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2183 // fill in a significant portion of the missing code, and other subsequent
2184 // suggestions can help the user fix the code.
2185 format!("{}fn {}({}){} {{ unimplemented!() }}", unsafety, ident, args, output)
2188 /// Return placeholder code for the given associated item.
2189 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2190 /// structured suggestion.
2191 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2193 ty::AssocKind::Method => {
2194 // We skip the binder here because the binder would deanonymize all
2195 // late-bound regions, and we don't want method signatures to show up
2196 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2197 // regions just fine, showing `fn(&MyType)`.
2198 fn_sig_suggestion(tcx.fn_sig(assoc.def_id).skip_binder(), assoc.ident)
2200 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2201 // FIXME(type_alias_impl_trait): we should print bounds here too.
2202 ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident),
2203 ty::AssocKind::Const => {
2204 let ty = tcx.type_of(assoc.def_id);
2205 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2206 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2211 /// Checks whether a type can be represented in memory. In particular, it
2212 /// identifies types that contain themselves without indirection through a
2213 /// pointer, which would mean their size is unbounded.
2214 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
2215 let rty = tcx.type_of(item_def_id);
2217 // Check that it is possible to represent this type. This call identifies
2218 // (1) types that contain themselves and (2) types that contain a different
2219 // recursive type. It is only necessary to throw an error on those that
2220 // contain themselves. For case 2, there must be an inner type that will be
2221 // caught by case 1.
2222 match rty.is_representable(tcx, sp) {
2223 Representability::SelfRecursive(spans) => {
2224 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
2226 err.span_label(span, "recursive without indirection");
2231 Representability::Representable | Representability::ContainsRecursive => (),
2236 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2237 let t = tcx.type_of(def_id);
2238 if let ty::Adt(def, substs) = t.kind {
2239 if def.is_struct() {
2240 let fields = &def.non_enum_variant().fields;
2241 if fields.is_empty() {
2242 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
2245 let e = fields[0].ty(tcx, substs);
2246 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2247 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2248 .span_label(sp, "SIMD elements must have the same type")
2253 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2254 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2256 span_err!(tcx.sess, sp, E0077,
2257 "SIMD vector element type should be machine type");
2265 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2266 let repr = tcx.adt_def(def_id).repr;
2268 for attr in tcx.get_attrs(def_id).iter() {
2269 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2270 if let attr::ReprPacked(pack) = r {
2271 if let Some(repr_pack) = repr.pack {
2272 if pack as u64 != repr_pack.bytes() {
2274 tcx.sess, sp, E0634,
2275 "type has conflicting packed representation hints"
2282 if repr.align.is_some() {
2283 struct_span_err!(tcx.sess, sp, E0587,
2284 "type has conflicting packed and align representation hints").emit();
2286 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
2287 struct_span_err!(tcx.sess, sp, E0588,
2288 "packed type cannot transitively contain a `[repr(align)]` type").emit();
2293 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
2294 let t = tcx.type_of(def_id);
2295 if stack.contains(&def_id) {
2296 debug!("check_packed_inner: {:?} is recursive", t);
2299 if let ty::Adt(def, substs) = t.kind {
2300 if def.is_struct() || def.is_union() {
2301 if tcx.adt_def(def.did).repr.align.is_some() {
2304 // push struct def_id before checking fields
2306 for field in &def.non_enum_variant().fields {
2307 let f = field.ty(tcx, substs);
2308 if let ty::Adt(def, _) = f.kind {
2309 if check_packed_inner(tcx, def.did, stack) {
2314 // only need to pop if not early out
2321 /// Emit an error when encountering more or less than one variant in a transparent enum.
2322 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2323 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
2324 tcx.hir().span_if_local(variant.def_id).unwrap()
2327 "needs exactly one variant, but has {}",
2330 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2331 err.span_label(sp, &msg);
2332 if let &[ref start @ .., ref end] = &variant_spans[..] {
2333 for variant_span in start {
2334 err.span_label(*variant_span, "");
2336 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2341 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2343 fn bad_non_zero_sized_fields<'tcx>(
2345 adt: &'tcx ty::AdtDef,
2347 field_spans: impl Iterator<Item = Span>,
2350 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2351 let mut err = struct_span_err!(
2355 "{}transparent {} {}",
2356 if adt.is_enum() { "the variant of a " } else { "" },
2360 err.span_label(sp, &msg);
2361 for sp in field_spans {
2362 err.span_label(sp, "this field is non-zero-sized");
2367 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2368 let adt = tcx.adt_def(def_id);
2369 if !adt.repr.transparent() {
2372 let sp = tcx.sess.source_map().def_span(sp);
2375 if !tcx.features().transparent_enums {
2377 &tcx.sess.parse_sess,
2378 sym::transparent_enums,
2380 GateIssue::Language,
2381 "transparent enums are unstable",
2384 if adt.variants.len() != 1 {
2385 bad_variant_count(tcx, adt, sp, def_id);
2386 if adt.variants.is_empty() {
2387 // Don't bother checking the fields. No variants (and thus no fields) exist.
2393 if adt.is_union() && !tcx.features().transparent_unions {
2394 emit_feature_err(&tcx.sess.parse_sess,
2395 sym::transparent_unions,
2397 GateIssue::Language,
2398 "transparent unions are unstable");
2401 // For each field, figure out if it's known to be a ZST and align(1)
2402 let field_infos = adt.all_fields().map(|field| {
2403 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2404 let param_env = tcx.param_env(field.did);
2405 let layout = tcx.layout_of(param_env.and(ty));
2406 // We are currently checking the type this field came from, so it must be local
2407 let span = tcx.hir().span_if_local(field.did).unwrap();
2408 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2409 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2413 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
2418 let non_zst_count = non_zst_fields.clone().count();
2419 if non_zst_count != 1 {
2420 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2422 for (span, zst, align1) in field_infos {
2428 "zero-sized field in transparent {} has alignment larger than 1",
2430 ).span_label(span, "has alignment larger than 1").emit();
2435 #[allow(trivial_numeric_casts)]
2436 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
2437 let def_id = tcx.hir().local_def_id(id);
2438 let def = tcx.adt_def(def_id);
2439 def.destructor(tcx); // force the destructor to be evaluated
2442 let attributes = tcx.get_attrs(def_id);
2443 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2445 tcx.sess, attr.span, E0084,
2446 "unsupported representation for zero-variant enum")
2447 .span_label(sp, "zero-variant enum")
2452 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2453 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2454 if !tcx.features().repr128 {
2455 emit_feature_err(&tcx.sess.parse_sess,
2458 GateIssue::Language,
2459 "repr with 128-bit type is unstable");
2464 if let Some(ref e) = v.disr_expr {
2465 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2469 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2471 |var: &hir::Variant| match var.data {
2472 hir::VariantData::Unit(..) => true,
2476 let has_disr = |var: &hir::Variant| var.disr_expr.is_some();
2477 let has_non_units = vs.iter().any(|var| !is_unit(var));
2478 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2479 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2481 if disr_non_unit || (disr_units && has_non_units) {
2482 let mut err = struct_span_err!(tcx.sess, sp, E0732,
2483 "`#[repr(inttype)]` must be specified");
2488 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2489 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2490 // Check for duplicate discriminant values
2491 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2492 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2493 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2494 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2495 let i_span = match variant_i.disr_expr {
2496 Some(ref expr) => tcx.hir().span(expr.hir_id),
2497 None => tcx.hir().span(variant_i_hir_id)
2499 let span = match v.disr_expr {
2500 Some(ref expr) => tcx.hir().span(expr.hir_id),
2503 struct_span_err!(tcx.sess, span, E0081,
2504 "discriminant value `{}` already exists", disr_vals[i])
2505 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2506 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
2509 disr_vals.push(discr);
2512 check_representable(tcx, sp, def_id);
2513 check_transparent(tcx, sp, def_id);
2516 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2517 span_err!(tcx.sess, span, E0533,
2518 "expected unit struct, unit variant or constant, found {} `{}`",
2520 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2523 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2524 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2528 fn item_def_id(&self) -> Option<DefId> {
2532 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2534 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2535 let item_id = tcx.hir().ty_param_owner(hir_id);
2536 let item_def_id = tcx.hir().local_def_id(item_id);
2537 let generics = tcx.generics_of(item_def_id);
2538 let index = generics.param_def_id_to_index[&def_id];
2539 ty::GenericPredicates {
2541 predicates: tcx.arena.alloc_from_iter(
2542 self.param_env.caller_bounds.iter().filter_map(|&predicate| match predicate {
2543 ty::Predicate::Trait(ref data)
2544 if data.skip_binder().self_ty().is_param(index) => {
2545 // HACK(eddyb) should get the original `Span`.
2546 let span = tcx.def_span(def_id);
2547 Some((predicate, span))
2557 def: Option<&ty::GenericParamDef>,
2559 ) -> Option<ty::Region<'tcx>> {
2561 Some(def) => infer::EarlyBoundRegion(span, def.name),
2562 None => infer::MiscVariable(span)
2564 Some(self.next_region_var(v))
2567 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2568 if let Some(param) = param {
2569 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2574 self.next_ty_var(TypeVariableOrigin {
2575 kind: TypeVariableOriginKind::TypeInference,
2584 param: Option<&ty::GenericParamDef>,
2586 ) -> &'tcx Const<'tcx> {
2587 if let Some(param) = param {
2588 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2593 self.next_const_var(ty, ConstVariableOrigin {
2594 kind: ConstVariableOriginKind::ConstInference,
2600 fn projected_ty_from_poly_trait_ref(&self,
2603 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2606 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2608 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2612 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2615 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2616 if ty.has_escaping_bound_vars() {
2617 ty // FIXME: normalization and escaping regions
2619 self.normalize_associated_types_in(span, &ty)
2623 fn set_tainted_by_errors(&self) {
2624 self.infcx.set_tainted_by_errors()
2627 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2628 self.write_ty(hir_id, ty)
2632 /// Controls whether the arguments are tupled. This is used for the call
2635 /// Tupling means that all call-side arguments are packed into a tuple and
2636 /// passed as a single parameter. For example, if tupling is enabled, this
2639 /// fn f(x: (isize, isize))
2641 /// Can be called as:
2648 #[derive(Clone, Eq, PartialEq)]
2649 enum TupleArgumentsFlag {
2654 /// Controls how we perform fallback for unconstrained
2657 /// Do not fallback type variables to opaque types.
2659 /// Perform all possible kinds of fallback, including
2660 /// turning type variables to opaque types.
2664 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2666 inh: &'a Inherited<'a, 'tcx>,
2667 param_env: ty::ParamEnv<'tcx>,
2668 body_id: hir::HirId,
2669 ) -> FnCtxt<'a, 'tcx> {
2673 err_count_on_creation: inh.tcx.sess.err_count(),
2675 ret_coercion_span: RefCell::new(None),
2677 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2678 hir::CRATE_HIR_ID)),
2679 diverges: Cell::new(Diverges::Maybe),
2680 has_errors: Cell::new(false),
2681 enclosing_breakables: RefCell::new(EnclosingBreakables {
2683 by_id: Default::default(),
2689 pub fn sess(&self) -> &Session {
2693 pub fn errors_reported_since_creation(&self) -> bool {
2694 self.tcx.sess.err_count() > self.err_count_on_creation
2697 /// Produces warning on the given node, if the current point in the
2698 /// function is unreachable, and there hasn't been another warning.
2699 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2700 // FIXME: Combine these two 'if' expressions into one once
2701 // let chains are implemented
2702 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2703 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2704 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2705 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2706 if !span.is_desugaring(DesugaringKind::CondTemporary) &&
2707 !span.is_desugaring(DesugaringKind::Async) &&
2708 !orig_span.is_desugaring(DesugaringKind::Await)
2710 self.diverges.set(Diverges::WarnedAlways);
2712 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2714 let msg = format!("unreachable {}", kind);
2715 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2716 .span_label(span, &msg)
2719 custom_note.unwrap_or("any code following this expression is unreachable"),
2728 code: ObligationCauseCode<'tcx>)
2729 -> ObligationCause<'tcx> {
2730 ObligationCause::new(span, self.body_id, code)
2733 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2734 self.cause(span, ObligationCauseCode::MiscObligation)
2737 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
2738 /// version (resolve_vars_if_possible), this version will
2739 /// also select obligations if it seems useful, in an effort
2740 /// to get more type information.
2741 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2742 debug!("resolve_vars_with_obligations(ty={:?})", ty);
2744 // No Infer()? Nothing needs doing.
2745 if !ty.has_infer_types() && !ty.has_infer_consts() {
2746 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2750 // If `ty` is a type variable, see whether we already know what it is.
2751 ty = self.resolve_vars_if_possible(&ty);
2752 if !ty.has_infer_types() && !ty.has_infer_consts() {
2753 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2757 // If not, try resolving pending obligations as much as
2758 // possible. This can help substantially when there are
2759 // indirect dependencies that don't seem worth tracking
2761 self.select_obligations_where_possible(false, |_| {});
2762 ty = self.resolve_vars_if_possible(&ty);
2764 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2768 fn record_deferred_call_resolution(
2770 closure_def_id: DefId,
2771 r: DeferredCallResolution<'tcx>,
2773 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2774 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2777 fn remove_deferred_call_resolutions(
2779 closure_def_id: DefId,
2780 ) -> Vec<DeferredCallResolution<'tcx>> {
2781 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2782 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2785 pub fn tag(&self) -> String {
2786 format!("{:p}", self)
2789 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2790 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2791 span_bug!(span, "no type for local variable {}",
2792 self.tcx.hir().node_to_string(nid))
2797 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2798 debug!("write_ty({:?}, {:?}) in fcx {}",
2799 id, self.resolve_vars_if_possible(&ty), self.tag());
2800 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2802 if ty.references_error() {
2803 self.has_errors.set(true);
2804 self.set_tainted_by_errors();
2808 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2809 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2812 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2813 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2816 pub fn write_method_call(&self,
2818 method: MethodCallee<'tcx>) {
2819 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2820 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2821 self.write_substs(hir_id, method.substs);
2823 // When the method is confirmed, the `method.substs` includes
2824 // parameters from not just the method, but also the impl of
2825 // the method -- in particular, the `Self` type will be fully
2826 // resolved. However, those are not something that the "user
2827 // specified" -- i.e., those types come from the inferred type
2828 // of the receiver, not something the user wrote. So when we
2829 // create the user-substs, we want to replace those earlier
2830 // types with just the types that the user actually wrote --
2831 // that is, those that appear on the *method itself*.
2833 // As an example, if the user wrote something like
2834 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2835 // type of `foo` (possibly adjusted), but we don't want to
2836 // include that. We want just the `[_, u32]` part.
2837 if !method.substs.is_noop() {
2838 let method_generics = self.tcx.generics_of(method.def_id);
2839 if !method_generics.params.is_empty() {
2840 let user_type_annotation = self.infcx.probe(|_| {
2841 let user_substs = UserSubsts {
2842 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2843 let i = param.index as usize;
2844 if i < method_generics.parent_count {
2845 self.infcx.var_for_def(DUMMY_SP, param)
2850 user_self_ty: None, // not relevant here
2853 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2859 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2860 self.write_user_type_annotation(hir_id, user_type_annotation);
2865 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2866 if !substs.is_noop() {
2867 debug!("write_substs({:?}, {:?}) in fcx {}",
2872 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2876 /// Given the substs that we just converted from the HIR, try to
2877 /// canonicalize them and store them as user-given substitutions
2878 /// (i.e., substitutions that must be respected by the NLL check).
2880 /// This should be invoked **before any unifications have
2881 /// occurred**, so that annotations like `Vec<_>` are preserved
2883 pub fn write_user_type_annotation_from_substs(
2887 substs: SubstsRef<'tcx>,
2888 user_self_ty: Option<UserSelfTy<'tcx>>,
2891 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2892 user_self_ty={:?} in fcx {}",
2893 hir_id, def_id, substs, user_self_ty, self.tag(),
2896 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2897 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2898 &UserType::TypeOf(def_id, UserSubsts {
2903 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2904 self.write_user_type_annotation(hir_id, canonicalized);
2908 pub fn write_user_type_annotation(
2911 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2914 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2915 hir_id, canonical_user_type_annotation, self.tag(),
2918 if !canonical_user_type_annotation.is_identity() {
2919 self.tables.borrow_mut().user_provided_types_mut().insert(
2920 hir_id, canonical_user_type_annotation
2923 debug!("write_user_type_annotation: skipping identity substs");
2927 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2928 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2934 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2935 Entry::Vacant(entry) => { entry.insert(adj); },
2936 Entry::Occupied(mut entry) => {
2937 debug!(" - composing on top of {:?}", entry.get());
2938 match (&entry.get()[..], &adj[..]) {
2939 // Applying any adjustment on top of a NeverToAny
2940 // is a valid NeverToAny adjustment, because it can't
2942 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2944 Adjustment { kind: Adjust::Deref(_), .. },
2945 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2947 Adjustment { kind: Adjust::Deref(_), .. },
2948 .. // Any following adjustments are allowed.
2950 // A reborrow has no effect before a dereference.
2952 // FIXME: currently we never try to compose autoderefs
2953 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2955 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2956 expr, entry.get(), adj)
2958 *entry.get_mut() = adj;
2963 /// Basically whenever we are converting from a type scheme into
2964 /// the fn body space, we always want to normalize associated
2965 /// types as well. This function combines the two.
2966 fn instantiate_type_scheme<T>(&self,
2968 substs: SubstsRef<'tcx>,
2971 where T : TypeFoldable<'tcx>
2973 let value = value.subst(self.tcx, substs);
2974 let result = self.normalize_associated_types_in(span, &value);
2975 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2982 /// As `instantiate_type_scheme`, but for the bounds found in a
2983 /// generic type scheme.
2984 fn instantiate_bounds(
2988 substs: SubstsRef<'tcx>,
2989 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
2990 let bounds = self.tcx.predicates_of(def_id);
2991 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
2992 let result = bounds.instantiate(self.tcx, substs);
2993 let result = self.normalize_associated_types_in(span, &result);
2995 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3004 /// Replaces the opaque types from the given value with type variables,
3005 /// and records the `OpaqueTypeMap` for later use during writeback. See
3006 /// `InferCtxt::instantiate_opaque_types` for more details.
3007 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3009 parent_id: hir::HirId,
3013 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3014 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3018 let (value, opaque_type_map) = self.register_infer_ok_obligations(
3019 self.instantiate_opaque_types(
3028 let mut opaque_types = self.opaque_types.borrow_mut();
3029 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3030 for (ty, decl) in opaque_type_map {
3031 let _ = opaque_types.insert(ty, decl);
3032 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3038 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3039 where T : TypeFoldable<'tcx>
3041 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3044 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
3046 where T : TypeFoldable<'tcx>
3048 self.inh.partially_normalize_associated_types_in(span,
3054 pub fn require_type_meets(&self,
3057 code: traits::ObligationCauseCode<'tcx>,
3060 self.register_bound(
3063 traits::ObligationCause::new(span, self.body_id, code));
3066 pub fn require_type_is_sized(
3070 code: traits::ObligationCauseCode<'tcx>,
3072 if !ty.references_error() {
3073 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
3074 self.require_type_meets(ty, span, code, lang_item);
3078 pub fn require_type_is_sized_deferred(
3082 code: traits::ObligationCauseCode<'tcx>,
3084 if !ty.references_error() {
3085 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3089 pub fn register_bound(
3093 cause: traits::ObligationCause<'tcx>,
3095 if !ty.references_error() {
3096 self.fulfillment_cx.borrow_mut()
3097 .register_bound(self, self.param_env, ty, def_id, cause);
3101 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
3102 let t = AstConv::ast_ty_to_ty(self, ast_t);
3103 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
3107 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
3108 let ty = self.to_ty(ast_ty);
3109 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3111 if Self::can_contain_user_lifetime_bounds(ty) {
3112 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3113 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3114 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3120 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
3121 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
3122 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
3125 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
3126 AstConv::ast_const_to_const(self, ast_c, ty)
3129 // If the type given by the user has free regions, save it for later, since
3130 // NLL would like to enforce those. Also pass in types that involve
3131 // projections, since those can resolve to `'static` bounds (modulo #54940,
3132 // which hopefully will be fixed by the time you see this comment, dear
3133 // reader, although I have my doubts). Also pass in types with inference
3134 // types, because they may be repeated. Other sorts of things are already
3135 // sufficiently enforced with erased regions. =)
3136 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3138 T: TypeFoldable<'tcx>
3140 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3143 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3144 match self.tables.borrow().node_types().get(id) {
3146 None if self.is_tainted_by_errors() => self.tcx.types.err,
3148 bug!("no type for node {}: {} in fcx {}",
3149 id, self.tcx.hir().node_to_string(id),
3155 /// Registers an obligation for checking later, during regionck, that the type `ty` must
3156 /// outlive the region `r`.
3157 pub fn register_wf_obligation(
3161 code: traits::ObligationCauseCode<'tcx>,
3163 // WF obligations never themselves fail, so no real need to give a detailed cause:
3164 let cause = traits::ObligationCause::new(span, self.body_id, code);
3165 self.register_predicate(
3166 traits::Obligation::new(cause, self.param_env, ty::Predicate::WellFormed(ty)),
3170 /// Registers obligations that all types appearing in `substs` are well-formed.
3171 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
3172 for ty in substs.types() {
3173 if !ty.references_error() {
3174 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
3179 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3180 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3181 /// trait/region obligations.
3183 /// For example, if there is a function:
3186 /// fn foo<'a,T:'a>(...)
3189 /// and a reference:
3195 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3196 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3197 pub fn add_obligations_for_parameters(&self,
3198 cause: traits::ObligationCause<'tcx>,
3199 predicates: &ty::InstantiatedPredicates<'tcx>)
3201 assert!(!predicates.has_escaping_bound_vars());
3203 debug!("add_obligations_for_parameters(predicates={:?})",
3206 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3207 self.register_predicate(obligation);
3211 // FIXME(arielb1): use this instead of field.ty everywhere
3212 // Only for fields! Returns <none> for methods>
3213 // Indifferent to privacy flags
3217 field: &'tcx ty::FieldDef,
3218 substs: SubstsRef<'tcx>,
3220 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3223 fn check_casts(&self) {
3224 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3225 for cast in deferred_cast_checks.drain(..) {
3230 fn resolve_generator_interiors(&self, def_id: DefId) {
3231 let mut generators = self.deferred_generator_interiors.borrow_mut();
3232 for (body_id, interior, kind) in generators.drain(..) {
3233 self.select_obligations_where_possible(false, |_| {});
3234 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3238 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3240 // - Unconstrained ints are replaced with `i32`.
3242 // - Unconstrained floats are replaced with with `f64`.
3244 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3245 // is enabled. Otherwise, they are replaced with `()`.
3247 // Fallback becomes very dubious if we have encountered type-checking errors.
3248 // In that case, fallback to Error.
3249 // The return value indicates whether fallback has occurred.
3250 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3251 use rustc::ty::error::UnconstrainedNumeric::Neither;
3252 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
3254 assert!(ty.is_ty_infer());
3255 let fallback = match self.type_is_unconstrained_numeric(ty) {
3256 _ if self.is_tainted_by_errors() => self.tcx().types.err,
3257 UnconstrainedInt => self.tcx.types.i32,
3258 UnconstrainedFloat => self.tcx.types.f64,
3259 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3261 // This type variable was created from the instantiation of an opaque
3262 // type. The fact that we're attempting to perform fallback for it
3263 // means that the function neither constrained it to a concrete
3264 // type, nor to the opaque type itself.
3266 // For example, in this code:
3269 // type MyType = impl Copy;
3270 // fn defining_use() -> MyType { true }
3271 // fn other_use() -> MyType { defining_use() }
3274 // `defining_use` will constrain the instantiated inference
3275 // variable to `bool`, while `other_use` will constrain
3276 // the instantiated inference variable to `MyType`.
3278 // When we process opaque types during writeback, we
3279 // will handle cases like `other_use`, and not count
3280 // them as defining usages
3282 // However, we also need to handle cases like this:
3285 // pub type Foo = impl Copy;
3286 // fn produce() -> Option<Foo> {
3291 // In the above snippet, the inference varaible created by
3292 // instantiating `Option<Foo>` will be completely unconstrained.
3293 // We treat this as a non-defining use by making the inference
3294 // variable fall back to the opaque type itself.
3295 if let FallbackMode::All = mode {
3296 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3297 debug!("fallback_if_possible: falling back opaque type var {:?} to {:?}",
3308 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3309 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
3313 fn select_all_obligations_or_error(&self) {
3314 debug!("select_all_obligations_or_error");
3315 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3316 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3320 /// Select as many obligations as we can at present.
3321 fn select_obligations_where_possible(
3323 fallback_has_occurred: bool,
3324 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3326 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3327 if let Err(mut errors) = result {
3328 mutate_fullfillment_errors(&mut errors);
3329 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3333 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3334 /// returns a type of `&T`, but the actual type we assign to the
3335 /// *expression* is `T`. So this function just peels off the return
3336 /// type by one layer to yield `T`.
3337 fn make_overloaded_place_return_type(&self,
3338 method: MethodCallee<'tcx>)
3339 -> ty::TypeAndMut<'tcx>
3341 // extract method return type, which will be &T;
3342 let ret_ty = method.sig.output();
3344 // method returns &T, but the type as visible to user is T, so deref
3345 ret_ty.builtin_deref(true).unwrap()
3351 base_expr: &'tcx hir::Expr,
3355 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3356 // FIXME(#18741) -- this is almost but not quite the same as the
3357 // autoderef that normal method probing does. They could likely be
3360 let mut autoderef = self.autoderef(base_expr.span, base_ty);
3361 let mut result = None;
3362 while result.is_none() && autoderef.next().is_some() {
3363 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
3365 autoderef.finalize(self);
3369 /// To type-check `base_expr[index_expr]`, we progressively autoderef
3370 /// (and otherwise adjust) `base_expr`, looking for a type which either
3371 /// supports builtin indexing or overloaded indexing.
3372 /// This loop implements one step in that search; the autoderef loop
3373 /// is implemented by `lookup_indexing`.
3377 base_expr: &hir::Expr,
3378 autoderef: &Autoderef<'a, 'tcx>,
3381 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3382 let adjusted_ty = autoderef.unambiguous_final_ty(self);
3383 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
3390 for &unsize in &[false, true] {
3391 let mut self_ty = adjusted_ty;
3393 // We only unsize arrays here.
3394 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3395 self_ty = self.tcx.mk_slice(element_ty);
3401 // If some lookup succeeds, write callee into table and extract index/element
3402 // type from the method signature.
3403 // If some lookup succeeded, install method in table
3404 let input_ty = self.next_ty_var(TypeVariableOrigin {
3405 kind: TypeVariableOriginKind::AutoDeref,
3406 span: base_expr.span,
3408 let method = self.try_overloaded_place_op(
3409 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
3411 let result = method.map(|ok| {
3412 debug!("try_index_step: success, using overloaded indexing");
3413 let method = self.register_infer_ok_obligations(ok);
3415 let mut adjustments = autoderef.adjust_steps(self, needs);
3416 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3417 let mutbl = match r_mutbl {
3418 hir::Mutability::Immutable => AutoBorrowMutability::Immutable,
3419 hir::Mutability::Mutable => AutoBorrowMutability::Mutable {
3420 // Indexing can be desugared to a method call,
3421 // so maybe we could use two-phase here.
3422 // See the documentation of AllowTwoPhase for why that's
3423 // not the case today.
3424 allow_two_phase_borrow: AllowTwoPhase::No,
3427 adjustments.push(Adjustment {
3428 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3429 target: self.tcx.mk_ref(region, ty::TypeAndMut {
3436 adjustments.push(Adjustment {
3437 kind: Adjust::Pointer(PointerCast::Unsize),
3438 target: method.sig.inputs()[0]
3441 self.apply_adjustments(base_expr, adjustments);
3443 self.write_method_call(expr.hir_id, method);
3444 (input_ty, self.make_overloaded_place_return_type(method).ty)
3446 if result.is_some() {
3454 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3455 let (tr, name) = match (op, is_mut) {
3456 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3457 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3458 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3459 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3461 (tr, ast::Ident::with_dummy_span(name))
3464 fn try_overloaded_place_op(&self,
3467 arg_tys: &[Ty<'tcx>],
3470 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
3472 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
3478 // Try Mut first, if needed.
3479 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3480 let method = match (needs, mut_tr) {
3481 (Needs::MutPlace, Some(trait_did)) => {
3482 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3487 // Otherwise, fall back to the immutable version.
3488 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3489 let method = match (method, imm_tr) {
3490 (None, Some(trait_did)) => {
3491 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3493 (method, _) => method,
3499 fn check_method_argument_types(
3502 expr: &'tcx hir::Expr,
3503 method: Result<MethodCallee<'tcx>, ()>,
3504 args_no_rcvr: &'tcx [hir::Expr],
3505 tuple_arguments: TupleArgumentsFlag,
3506 expected: Expectation<'tcx>,
3509 let has_error = match method {
3511 method.substs.references_error() || method.sig.references_error()
3516 let err_inputs = self.err_args(args_no_rcvr.len());
3518 let err_inputs = match tuple_arguments {
3519 DontTupleArguments => err_inputs,
3520 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3523 self.check_argument_types(
3533 return self.tcx.types.err;
3536 let method = method.unwrap();
3537 // HACK(eddyb) ignore self in the definition (see above).
3538 let expected_arg_tys = self.expected_inputs_for_expected_output(
3541 method.sig.output(),
3542 &method.sig.inputs()[1..]
3544 self.check_argument_types(
3547 &method.sig.inputs()[1..],
3548 &expected_arg_tys[..],
3550 method.sig.c_variadic,
3552 self.tcx.hir().span_if_local(method.def_id),
3557 fn self_type_matches_expected_vid(
3559 trait_ref: ty::PolyTraitRef<'tcx>,
3560 expected_vid: ty::TyVid,
3562 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3564 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3565 trait_ref, self_ty, expected_vid
3567 match self_ty.kind {
3568 ty::Infer(ty::TyVar(found_vid)) => {
3569 // FIXME: consider using `sub_root_var` here so we
3570 // can see through subtyping.
3571 let found_vid = self.root_var(found_vid);
3572 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3573 expected_vid == found_vid
3579 fn obligations_for_self_ty<'b>(
3582 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3585 // FIXME: consider using `sub_root_var` here so we
3586 // can see through subtyping.
3587 let ty_var_root = self.root_var(self_ty);
3588 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3589 self_ty, ty_var_root,
3590 self.fulfillment_cx.borrow().pending_obligations());
3594 .pending_obligations()
3596 .filter_map(move |obligation| match obligation.predicate {
3597 ty::Predicate::Projection(ref data) =>
3598 Some((data.to_poly_trait_ref(self.tcx), obligation)),
3599 ty::Predicate::Trait(ref data) =>
3600 Some((data.to_poly_trait_ref(), obligation)),
3601 ty::Predicate::Subtype(..) => None,
3602 ty::Predicate::RegionOutlives(..) => None,
3603 ty::Predicate::TypeOutlives(..) => None,
3604 ty::Predicate::WellFormed(..) => None,
3605 ty::Predicate::ObjectSafe(..) => None,
3606 ty::Predicate::ConstEvaluatable(..) => None,
3607 // N.B., this predicate is created by breaking down a
3608 // `ClosureType: FnFoo()` predicate, where
3609 // `ClosureType` represents some `Closure`. It can't
3610 // possibly be referring to the current closure,
3611 // because we haven't produced the `Closure` for
3612 // this closure yet; this is exactly why the other
3613 // code is looking for a self type of a unresolved
3614 // inference variable.
3615 ty::Predicate::ClosureKind(..) => None,
3616 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3619 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3620 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
3621 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
3625 /// Generic function that factors out common logic from function calls,
3626 /// method calls and overloaded operators.
3627 fn check_argument_types(
3630 expr: &'tcx hir::Expr,
3631 fn_inputs: &[Ty<'tcx>],
3632 expected_arg_tys: &[Ty<'tcx>],
3633 args: &'tcx [hir::Expr],
3635 tuple_arguments: TupleArgumentsFlag,
3636 def_span: Option<Span>,
3639 // Grab the argument types, supplying fresh type variables
3640 // if the wrong number of arguments were supplied
3641 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3647 // All the input types from the fn signature must outlive the call
3648 // so as to validate implied bounds.
3649 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3650 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3653 let expected_arg_count = fn_inputs.len();
3655 let param_count_error = |expected_count: usize,
3660 let mut err = tcx.sess.struct_span_err_with_code(sp,
3661 &format!("this function takes {}{} but {} {} supplied",
3662 if c_variadic { "at least " } else { "" },
3663 potentially_plural_count(expected_count, "parameter"),
3664 potentially_plural_count(arg_count, "parameter"),
3665 if arg_count == 1 {"was"} else {"were"}),
3666 DiagnosticId::Error(error_code.to_owned()));
3668 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3669 err.span_label(def_s, "defined here");
3672 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3673 // remove closing `)` from the span
3674 let sugg_span = sugg_span.shrink_to_lo();
3675 err.span_suggestion(
3677 "expected the unit value `()`; create it with empty parentheses",
3679 Applicability::MachineApplicable);
3681 err.span_label(sp, format!("expected {}{}",
3682 if c_variadic { "at least " } else { "" },
3683 potentially_plural_count(expected_count, "parameter")));
3688 let mut expected_arg_tys = expected_arg_tys.to_vec();
3690 let formal_tys = if tuple_arguments == TupleArguments {
3691 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3692 match tuple_type.kind {
3693 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3694 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3695 expected_arg_tys = vec![];
3696 self.err_args(args.len())
3698 ty::Tuple(arg_types) => {
3699 expected_arg_tys = match expected_arg_tys.get(0) {
3700 Some(&ty) => match ty.kind {
3701 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3706 arg_types.iter().map(|k| k.expect_ty()).collect()
3709 span_err!(tcx.sess, sp, E0059,
3710 "cannot use call notation; the first type parameter \
3711 for the function trait is neither a tuple nor unit");
3712 expected_arg_tys = vec![];
3713 self.err_args(args.len())
3716 } else if expected_arg_count == supplied_arg_count {
3718 } else if c_variadic {
3719 if supplied_arg_count >= expected_arg_count {
3722 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3723 expected_arg_tys = vec![];
3724 self.err_args(supplied_arg_count)
3727 // is the missing argument of type `()`?
3728 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3729 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3730 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3731 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3735 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3737 expected_arg_tys = vec![];
3738 self.err_args(supplied_arg_count)
3741 debug!("check_argument_types: formal_tys={:?}",
3742 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3744 // If there is no expectation, expect formal_tys.
3745 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3751 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
3753 // Check the arguments.
3754 // We do this in a pretty awful way: first we type-check any arguments
3755 // that are not closures, then we type-check the closures. This is so
3756 // that we have more information about the types of arguments when we
3757 // type-check the functions. This isn't really the right way to do this.
3758 for &check_closures in &[false, true] {
3759 debug!("check_closures={}", check_closures);
3761 // More awful hacks: before we check argument types, try to do
3762 // an "opportunistic" vtable resolution of any trait bounds on
3763 // the call. This helps coercions.
3765 self.select_obligations_where_possible(false, |errors| {
3766 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3767 self.point_at_arg_instead_of_call_if_possible(
3769 &final_arg_types[..],
3776 // For C-variadic functions, we don't have a declared type for all of
3777 // the arguments hence we only do our usual type checking with
3778 // the arguments who's types we do know.
3779 let t = if c_variadic {
3781 } else if tuple_arguments == TupleArguments {
3786 for (i, arg) in args.iter().take(t).enumerate() {
3787 // Warn only for the first loop (the "no closures" one).
3788 // Closure arguments themselves can't be diverging, but
3789 // a previous argument can, e.g., `foo(panic!(), || {})`.
3790 if !check_closures {
3791 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3794 let is_closure = match arg.kind {
3795 ExprKind::Closure(..) => true,
3799 if is_closure != check_closures {
3803 debug!("checking the argument");
3804 let formal_ty = formal_tys[i];
3806 // The special-cased logic below has three functions:
3807 // 1. Provide as good of an expected type as possible.
3808 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3810 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3812 // 2. Coerce to the most detailed type that could be coerced
3813 // to, which is `expected_ty` if `rvalue_hint` returns an
3814 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3815 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3816 // We're processing function arguments so we definitely want to use
3817 // two-phase borrows.
3818 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3819 final_arg_types.push((i, checked_ty, coerce_ty));
3821 // 3. Relate the expected type and the formal one,
3822 // if the expected type was used for the coercion.
3823 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3827 // We also need to make sure we at least write the ty of the other
3828 // arguments which we skipped above.
3830 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3831 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3832 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3835 for arg in args.iter().skip(expected_arg_count) {
3836 let arg_ty = self.check_expr(&arg);
3838 // There are a few types which get autopromoted when passed via varargs
3839 // in C but we just error out instead and require explicit casts.
3840 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3842 ty::Float(ast::FloatTy::F32) => {
3843 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3845 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3846 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3848 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3849 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3852 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3853 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3854 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3862 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3863 vec![self.tcx.types.err; len]
3866 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
3867 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
3868 /// reference a type argument. The reason to walk also the checked type is that the coerced type
3869 /// can be not easily comparable with predicate type (because of coercion). If the types match
3870 /// for either checked or coerced type, and there's only *one* argument that does, we point at
3871 /// the corresponding argument's expression span instead of the `fn` call path span.
3872 fn point_at_arg_instead_of_call_if_possible(
3874 errors: &mut Vec<traits::FulfillmentError<'_>>,
3875 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
3877 args: &'tcx [hir::Expr],
3879 if !call_sp.desugaring_kind().is_some() {
3880 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3881 // the `?` operator.
3882 for error in errors {
3883 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3884 // Collect the argument position for all arguments that could have caused this
3885 // `FulfillmentError`.
3886 let mut referenced_in = final_arg_types.iter()
3887 .map(|(i, checked_ty, _)| (i, checked_ty))
3888 .chain(final_arg_types.iter().map(|(i, _, coerced_ty)| (i, coerced_ty)))
3889 .flat_map(|(i, ty)| {
3890 let ty = self.resolve_vars_if_possible(ty);
3891 // We walk the argument type because the argument's type could have
3892 // been `Option<T>`, but the `FulfillmentError` references `T`.
3894 .filter(|&ty| ty == predicate.skip_binder().self_ty())
3897 .collect::<Vec<_>>();
3899 // Both checked and coerced types could have matched, thus we need to remove
3901 referenced_in.dedup();
3903 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
3904 // We make sure that only *one* argument matches the obligation failure
3905 // and we assign the obligation's span to its expression's.
3906 error.obligation.cause.span = args[ref_in].span;
3907 error.points_at_arg_span = true;
3914 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
3915 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
3916 /// were caused by them. If they were, we point at the corresponding type argument's span
3917 /// instead of the `fn` call path span.
3918 fn point_at_type_arg_instead_of_call_if_possible(
3920 errors: &mut Vec<traits::FulfillmentError<'_>>,
3921 call_expr: &'tcx hir::Expr,
3923 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
3924 if let hir::ExprKind::Path(qpath) = &path.kind {
3925 if let hir::QPath::Resolved(_, path) = &qpath {
3926 for error in errors {
3927 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3928 // If any of the type arguments in this path segment caused the
3929 // `FullfillmentError`, point at its span (#61860).
3930 for arg in path.segments.iter()
3931 .filter_map(|seg| seg.args.as_ref())
3932 .flat_map(|a| a.args.iter())
3934 if let hir::GenericArg::Type(hir_ty) = &arg {
3935 if let hir::TyKind::Path(
3936 hir::QPath::TypeRelative(..),
3938 // Avoid ICE with associated types. As this is best
3939 // effort only, it's ok to ignore the case. It
3940 // would trigger in `is_send::<T::AssocType>();`
3941 // from `typeck-default-trait-impl-assoc-type.rs`.
3943 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
3944 let ty = self.resolve_vars_if_possible(&ty);
3945 if ty == predicate.skip_binder().self_ty() {
3946 error.obligation.cause.span = hir_ty.span;
3958 // AST fragment checking
3961 expected: Expectation<'tcx>)
3967 ast::LitKind::Str(..) => tcx.mk_static_str(),
3968 ast::LitKind::ByteStr(ref v) => {
3969 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3970 tcx.mk_array(tcx.types.u8, v.len() as u64))
3972 ast::LitKind::Byte(_) => tcx.types.u8,
3973 ast::LitKind::Char(_) => tcx.types.char,
3974 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3975 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3976 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3977 let opt_ty = expected.to_option(self).and_then(|ty| {
3979 ty::Int(_) | ty::Uint(_) => Some(ty),
3980 ty::Char => Some(tcx.types.u8),
3981 ty::RawPtr(..) => Some(tcx.types.usize),
3982 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3986 opt_ty.unwrap_or_else(|| self.next_int_var())
3988 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
3989 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
3990 let opt_ty = expected.to_option(self).and_then(|ty| {
3992 ty::Float(_) => Some(ty),
3996 opt_ty.unwrap_or_else(|| self.next_float_var())
3998 ast::LitKind::Bool(_) => tcx.types.bool,
3999 ast::LitKind::Err(_) => tcx.types.err,
4003 // Determine the `Self` type, using fresh variables for all variables
4004 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
4005 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
4007 pub fn impl_self_ty(&self,
4008 span: Span, // (potential) receiver for this impl
4010 -> TypeAndSubsts<'tcx> {
4011 let ity = self.tcx.type_of(did);
4012 debug!("impl_self_ty: ity={:?}", ity);
4014 let substs = self.fresh_substs_for_item(span, did);
4015 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
4017 TypeAndSubsts { substs: substs, ty: substd_ty }
4020 /// Unifies the output type with the expected type early, for more coercions
4021 /// and forward type information on the input expressions.
4022 fn expected_inputs_for_expected_output(&self,
4024 expected_ret: Expectation<'tcx>,
4025 formal_ret: Ty<'tcx>,
4026 formal_args: &[Ty<'tcx>])
4028 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4029 let ret_ty = match expected_ret.only_has_type(self) {
4031 None => return Vec::new()
4033 let expect_args = self.fudge_inference_if_ok(|| {
4034 // Attempt to apply a subtyping relationship between the formal
4035 // return type (likely containing type variables if the function
4036 // is polymorphic) and the expected return type.
4037 // No argument expectations are produced if unification fails.
4038 let origin = self.misc(call_span);
4039 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4041 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4042 // to identity so the resulting type is not constrained.
4045 // Process any obligations locally as much as
4046 // we can. We don't care if some things turn
4047 // out unconstrained or ambiguous, as we're
4048 // just trying to get hints here.
4049 self.save_and_restore_in_snapshot_flag(|_| {
4050 let mut fulfill = TraitEngine::new(self.tcx);
4051 for obligation in ok.obligations {
4052 fulfill.register_predicate_obligation(self, obligation);
4054 fulfill.select_where_possible(self)
4055 }).map_err(|_| ())?;
4057 Err(_) => return Err(()),
4060 // Record all the argument types, with the substitutions
4061 // produced from the above subtyping unification.
4062 Ok(formal_args.iter().map(|ty| {
4063 self.resolve_vars_if_possible(ty)
4065 }).unwrap_or_default();
4066 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4067 formal_args, formal_ret,
4068 expect_args, expected_ret);
4072 pub fn check_struct_path(&self,
4075 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4076 let path_span = match *qpath {
4077 QPath::Resolved(_, ref path) => path.span,
4078 QPath::TypeRelative(ref qself, _) => qself.span
4080 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4081 let variant = match def {
4083 self.set_tainted_by_errors();
4086 Res::Def(DefKind::Variant, _) => {
4088 ty::Adt(adt, substs) => {
4089 Some((adt.variant_of_res(def), adt.did, substs))
4091 _ => bug!("unexpected type: {:?}", ty)
4094 Res::Def(DefKind::Struct, _)
4095 | Res::Def(DefKind::Union, _)
4096 | Res::Def(DefKind::TyAlias, _)
4097 | Res::Def(DefKind::AssocTy, _)
4098 | Res::SelfTy(..) => {
4100 ty::Adt(adt, substs) if !adt.is_enum() => {
4101 Some((adt.non_enum_variant(), adt.did, substs))
4106 _ => bug!("unexpected definition: {:?}", def)
4109 if let Some((variant, did, substs)) = variant {
4110 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4111 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4113 // Check bounds on type arguments used in the path.
4114 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4115 let cause = traits::ObligationCause::new(
4118 traits::ItemObligation(did),
4120 self.add_obligations_for_parameters(cause, &bounds);
4124 struct_span_err!(self.tcx.sess, path_span, E0071,
4125 "expected struct, variant or union type, found {}",
4126 ty.sort_string(self.tcx))
4127 .span_label(path_span, "not a struct")
4133 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4134 // The newly resolved definition is written into `type_dependent_defs`.
4135 fn finish_resolving_struct_path(&self,
4142 QPath::Resolved(ref maybe_qself, ref path) => {
4143 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4144 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4147 QPath::TypeRelative(ref qself, ref segment) => {
4148 let ty = self.to_ty(qself);
4150 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4155 let result = AstConv::associated_path_to_ty(
4164 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4165 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4167 // Write back the new resolution.
4168 self.write_resolution(hir_id, result);
4170 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4175 /// Resolves an associated value path into a base type and associated constant, or method
4176 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4177 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4181 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4183 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4184 let (ty, qself, item_segment) = match *qpath {
4185 QPath::Resolved(ref opt_qself, ref path) => {
4187 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4188 &path.segments[..]);
4190 QPath::TypeRelative(ref qself, ref segment) => {
4191 (self.to_ty(qself), qself, segment)
4194 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4195 // Return directly on cache hit. This is useful to avoid doubly reporting
4196 // errors with default match binding modes. See #44614.
4197 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4198 .unwrap_or(Res::Err);
4199 return (def, Some(ty), slice::from_ref(&**item_segment));
4201 let item_name = item_segment.ident;
4202 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4203 let result = match error {
4204 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4205 _ => Err(ErrorReported),
4207 if item_name.name != kw::Invalid {
4208 self.report_method_error(
4212 SelfSource::QPath(qself),
4215 ).map(|mut e| e.emit());
4220 // Write back the new resolution.
4221 self.write_resolution(hir_id, result);
4223 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4225 slice::from_ref(&**item_segment),
4229 pub fn check_decl_initializer(
4231 local: &'tcx hir::Local,
4232 init: &'tcx hir::Expr,
4234 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4235 // for #42640 (default match binding modes).
4238 let ref_bindings = local.pat.contains_explicit_ref_binding();
4240 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4241 if let Some(m) = ref_bindings {
4242 // Somewhat subtle: if we have a `ref` binding in the pattern,
4243 // we want to avoid introducing coercions for the RHS. This is
4244 // both because it helps preserve sanity and, in the case of
4245 // ref mut, for soundness (issue #23116). In particular, in
4246 // the latter case, we need to be clear that the type of the
4247 // referent for the reference that results is *equal to* the
4248 // type of the place it is referencing, and not some
4249 // supertype thereof.
4250 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4251 self.demand_eqtype(init.span, local_ty, init_ty);
4254 self.check_expr_coercable_to_type(init, local_ty)
4258 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
4259 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4260 self.write_ty(local.hir_id, t);
4262 if let Some(ref init) = local.init {
4263 let init_ty = self.check_decl_initializer(local, &init);
4264 self.overwrite_local_ty_if_err(local, t, init_ty);
4267 self.check_pat_top(&local.pat, t, None);
4268 let pat_ty = self.node_ty(local.pat.hir_id);
4269 self.overwrite_local_ty_if_err(local, t, pat_ty);
4272 fn overwrite_local_ty_if_err(&self, local: &'tcx hir::Local, decl_ty: Ty<'tcx>, ty: Ty<'tcx>) {
4273 if ty.references_error() {
4274 // Override the types everywhere with `types.err` to avoid knock down errors.
4275 self.write_ty(local.hir_id, ty);
4276 self.write_ty(local.pat.hir_id, ty);
4277 let local_ty = LocalTy {
4281 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4282 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4286 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4287 err.span_suggestion_short(
4288 span.shrink_to_hi(),
4289 "consider using a semicolon here",
4291 Applicability::MachineApplicable,
4295 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
4296 // Don't do all the complex logic below for `DeclItem`.
4298 hir::StmtKind::Item(..) => return,
4299 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4302 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4304 // Hide the outer diverging and `has_errors` flags.
4305 let old_diverges = self.diverges.get();
4306 let old_has_errors = self.has_errors.get();
4307 self.diverges.set(Diverges::Maybe);
4308 self.has_errors.set(false);
4311 hir::StmtKind::Local(ref l) => {
4312 self.check_decl_local(&l);
4315 hir::StmtKind::Item(_) => {}
4316 hir::StmtKind::Expr(ref expr) => {
4317 // Check with expected type of `()`.
4319 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4320 self.suggest_semicolon_at_end(expr.span, err);
4323 hir::StmtKind::Semi(ref expr) => {
4324 self.check_expr(&expr);
4328 // Combine the diverging and `has_error` flags.
4329 self.diverges.set(self.diverges.get() | old_diverges);
4330 self.has_errors.set(self.has_errors.get() | old_has_errors);
4333 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
4334 let unit = self.tcx.mk_unit();
4335 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4337 // if the block produces a `!` value, that can always be
4338 // (effectively) coerced to unit.
4340 self.demand_suptype(blk.span, unit, ty);
4344 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4345 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4346 /// when given code like the following:
4348 /// if false { return 0i32; } else { 1u32 }
4349 /// // ^^^^ point at this instead of the whole `if` expression
4351 fn get_expr_coercion_span(&self, expr: &hir::Expr) -> syntax_pos::Span {
4352 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4353 let arm_spans: Vec<Span> = arms.iter().filter_map(|arm| {
4354 self.in_progress_tables
4355 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4356 .and_then(|arm_ty| {
4357 if arm_ty.is_never() {
4360 Some(match &arm.body.kind {
4361 // Point at the tail expression when possible.
4362 hir::ExprKind::Block(block, _) => block.expr
4365 .unwrap_or(block.span),
4371 if arm_spans.len() == 1 {
4372 return arm_spans[0];
4378 fn check_block_with_expected(
4380 blk: &'tcx hir::Block,
4381 expected: Expectation<'tcx>,
4384 let mut fcx_ps = self.ps.borrow_mut();
4385 let unsafety_state = fcx_ps.recurse(blk);
4386 replace(&mut *fcx_ps, unsafety_state)
4389 // In some cases, blocks have just one exit, but other blocks
4390 // can be targeted by multiple breaks. This can happen both
4391 // with labeled blocks as well as when we desugar
4392 // a `try { ... }` expression.
4396 // 'a: { if true { break 'a Err(()); } Ok(()) }
4398 // Here we would wind up with two coercions, one from
4399 // `Err(())` and the other from the tail expression
4400 // `Ok(())`. If the tail expression is omitted, that's a
4401 // "forced unit" -- unless the block diverges, in which
4402 // case we can ignore the tail expression (e.g., `'a: {
4403 // break 'a 22; }` would not force the type of the block
4405 let tail_expr = blk.expr.as_ref();
4406 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4407 let coerce = if blk.targeted_by_break {
4408 CoerceMany::new(coerce_to_ty)
4410 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4411 Some(e) => slice::from_ref(e),
4414 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4417 let prev_diverges = self.diverges.get();
4418 let ctxt = BreakableCtxt {
4419 coerce: Some(coerce),
4423 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4424 for s in &blk.stmts {
4428 // check the tail expression **without** holding the
4429 // `enclosing_breakables` lock below.
4430 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4432 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4433 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4434 let coerce = ctxt.coerce.as_mut().unwrap();
4435 if let Some(tail_expr_ty) = tail_expr_ty {
4436 let tail_expr = tail_expr.unwrap();
4437 let span = self.get_expr_coercion_span(tail_expr);
4438 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4439 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4441 // Subtle: if there is no explicit tail expression,
4442 // that is typically equivalent to a tail expression
4443 // of `()` -- except if the block diverges. In that
4444 // case, there is no value supplied from the tail
4445 // expression (assuming there are no other breaks,
4446 // this implies that the type of the block will be
4449 // #41425 -- label the implicit `()` as being the
4450 // "found type" here, rather than the "expected type".
4451 if !self.diverges.get().is_always() {
4452 // #50009 -- Do not point at the entire fn block span, point at the return type
4453 // span, as it is the cause of the requirement, and
4454 // `consider_hint_about_removing_semicolon` will point at the last expression
4455 // if it were a relevant part of the error. This improves usability in editors
4456 // that highlight errors inline.
4457 let mut sp = blk.span;
4458 let mut fn_span = None;
4459 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4460 let ret_sp = decl.output.span();
4461 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4462 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4463 // output would otherwise be incorrect and even misleading. Make sure
4464 // the span we're aiming at correspond to a `fn` body.
4465 if block_sp == blk.span {
4467 fn_span = Some(ident.span);
4471 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4472 if let Some(expected_ty) = expected.only_has_type(self) {
4473 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4475 if let Some(fn_span) = fn_span {
4478 "implicitly returns `()` as its body has no tail or `return` \
4488 // If we can break from the block, then the block's exit is always reachable
4489 // (... as long as the entry is reachable) - regardless of the tail of the block.
4490 self.diverges.set(prev_diverges);
4493 let mut ty = ctxt.coerce.unwrap().complete(self);
4495 if self.has_errors.get() || ty.references_error() {
4496 ty = self.tcx.types.err
4499 self.write_ty(blk.hir_id, ty);
4501 *self.ps.borrow_mut() = prev;
4505 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4506 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4508 Node::Item(&hir::Item {
4509 kind: hir::ItemKind::Fn(_, _, body_id), ..
4511 Node::ImplItem(&hir::ImplItem {
4512 kind: hir::ImplItemKind::Method(_, body_id), ..
4514 let body = self.tcx.hir().body(body_id);
4515 if let ExprKind::Block(block, _) = &body.value.kind {
4516 return Some(block.span);
4524 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4525 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
4526 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4527 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4530 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4531 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
4533 Node::Item(&hir::Item {
4534 ident, kind: hir::ItemKind::Fn(ref sig, ..), ..
4536 // This is less than ideal, it will not suggest a return type span on any
4537 // method called `main`, regardless of whether it is actually the entry point,
4538 // but it will still present it as the reason for the expected type.
4539 Some((&sig.decl, ident, ident.name != sym::main))
4541 Node::TraitItem(&hir::TraitItem {
4542 ident, kind: hir::TraitItemKind::Method(ref sig, ..), ..
4543 }) => Some((&sig.decl, ident, true)),
4544 Node::ImplItem(&hir::ImplItem {
4545 ident, kind: hir::ImplItemKind::Method(ref sig, ..), ..
4546 }) => Some((&sig.decl, ident, false)),
4551 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4552 /// suggestion can be made, `None` otherwise.
4553 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
4554 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4555 // `while` before reaching it, as block tail returns are not available in them.
4556 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4557 let parent = self.tcx.hir().get(blk_id);
4558 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4562 /// On implicit return expressions with mismatched types, provides the following suggestions:
4564 /// - Points out the method's return type as the reason for the expected type.
4565 /// - Possible missing semicolon.
4566 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4567 pub fn suggest_mismatched_types_on_tail(
4569 err: &mut DiagnosticBuilder<'_>,
4570 expr: &'tcx hir::Expr,
4576 let expr = expr.peel_drop_temps();
4577 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4578 let mut pointing_at_return_type = false;
4579 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4580 pointing_at_return_type = self.suggest_missing_return_type(
4581 err, &fn_decl, expected, found, can_suggest);
4583 self.suggest_ref_or_into(err, expr, expected, found);
4584 self.suggest_boxing_when_appropriate(err, expr, expected, found);
4585 pointing_at_return_type
4588 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4589 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4591 /// fn foo(x: usize) -> usize { x }
4592 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4596 err: &mut DiagnosticBuilder<'_>,
4601 let hir = self.tcx.hir();
4602 let (def_id, sig) = match found.kind {
4603 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4604 ty::Closure(def_id, substs) => {
4605 // We don't use `closure_sig` to account for malformed closures like
4606 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4607 let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
4608 (def_id, match closure_sig_ty.kind {
4609 ty::FnPtr(sig) => sig,
4617 .replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig)
4619 let sig = self.normalize_associated_types_in(expr.span, &sig);
4620 if self.can_coerce(sig.output(), expected) {
4621 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4622 (String::new(), Applicability::MachineApplicable)
4624 ("...".to_string(), Applicability::HasPlaceholders)
4626 let mut msg = "call this function";
4627 match hir.get_if_local(def_id) {
4628 Some(Node::Item(hir::Item {
4629 kind: ItemKind::Fn(.., body_id),
4632 Some(Node::ImplItem(hir::ImplItem {
4633 kind: hir::ImplItemKind::Method(_, body_id),
4636 Some(Node::TraitItem(hir::TraitItem {
4637 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4640 let body = hir.body(*body_id);
4641 sugg_call = body.params.iter()
4642 .map(|param| match ¶m.pat.kind {
4643 hir::PatKind::Binding(_, _, ident, None)
4644 if ident.name != kw::SelfLower => ident.to_string(),
4645 _ => "_".to_string(),
4646 }).collect::<Vec<_>>().join(", ");
4648 Some(Node::Expr(hir::Expr {
4649 kind: ExprKind::Closure(_, _, body_id, closure_span, _),
4650 span: full_closure_span,
4653 if *full_closure_span == expr.span {
4656 err.span_label(*closure_span, "closure defined here");
4657 msg = "call this closure";
4658 let body = hir.body(*body_id);
4659 sugg_call = body.params.iter()
4660 .map(|param| match ¶m.pat.kind {
4661 hir::PatKind::Binding(_, _, ident, None)
4662 if ident.name != kw::SelfLower => ident.to_string(),
4663 _ => "_".to_string(),
4664 }).collect::<Vec<_>>().join(", ");
4666 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4667 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4668 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4669 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4670 msg = "instantiate this tuple variant";
4672 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4673 msg = "instantiate this tuple struct";
4678 Some(Node::ForeignItem(hir::ForeignItem {
4679 kind: hir::ForeignItemKind::Fn(_, idents, _),
4682 Some(Node::TraitItem(hir::TraitItem {
4683 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4685 })) => sugg_call = idents.iter()
4686 .map(|ident| if ident.name != kw::SelfLower {
4690 }).collect::<Vec<_>>()
4694 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4695 err.span_suggestion(
4697 &format!("use parentheses to {}", msg),
4698 format!("{}({})", code, sugg_call),
4707 pub fn suggest_ref_or_into(
4709 err: &mut DiagnosticBuilder<'_>,
4714 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4715 err.span_suggestion(
4719 Applicability::MachineApplicable,
4721 } else if let (ty::FnDef(def_id, ..), true) = (
4723 self.suggest_fn_call(err, expr, expected, found),
4725 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4726 let sp = self.sess().source_map().def_span(sp);
4727 err.span_label(sp, &format!("{} defined here", found));
4729 } else if !self.check_for_cast(err, expr, found, expected) {
4730 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
4734 let methods = self.get_conversion_methods(expr.span, expected, found);
4735 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4736 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4737 .filter_map(|(receiver, method)| {
4738 let method_call = format!(".{}()", method.ident);
4739 if receiver.ends_with(&method_call) {
4740 None // do not suggest code that is already there (#53348)
4742 let method_call_list = [".to_vec()", ".to_string()"];
4743 let sugg = if receiver.ends_with(".clone()")
4744 && method_call_list.contains(&method_call.as_str()) {
4745 let max_len = receiver.rfind(".").unwrap();
4746 format!("{}{}", &receiver[..max_len], method_call)
4748 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
4749 format!("({}){}", receiver, method_call)
4751 format!("{}{}", receiver, method_call)
4754 Some(if is_struct_pat_shorthand_field {
4755 format!("{}: {}", receiver, sugg)
4761 if suggestions.peek().is_some() {
4762 err.span_suggestions(
4764 "try using a conversion method",
4766 Applicability::MaybeIncorrect,
4773 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4774 /// in the heap by calling `Box::new()`.
4775 fn suggest_boxing_when_appropriate(
4777 err: &mut DiagnosticBuilder<'_>,
4782 if self.tcx.hir().is_const_context(expr.hir_id) {
4783 // Do not suggest `Box::new` in const context.
4786 if !expected.is_box() || found.is_box() {
4789 let boxed_found = self.tcx.mk_box(found);
4790 if let (true, Ok(snippet)) = (
4791 self.can_coerce(boxed_found, expected),
4792 self.sess().source_map().span_to_snippet(expr.span),
4794 err.span_suggestion(
4796 "store this in the heap by calling `Box::new`",
4797 format!("Box::new({})", snippet),
4798 Applicability::MachineApplicable,
4800 err.note("for more on the distinction between the stack and the \
4801 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4802 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4803 https://doc.rust-lang.org/std/boxed/index.html");
4808 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4812 /// bar_that_returns_u32()
4816 /// This routine checks if the return expression in a block would make sense on its own as a
4817 /// statement and the return type has been left as default or has been specified as `()`. If so,
4818 /// it suggests adding a semicolon.
4819 fn suggest_missing_semicolon(
4821 err: &mut DiagnosticBuilder<'_>,
4822 expression: &'tcx hir::Expr,
4826 if expected.is_unit() {
4827 // `BlockTailExpression` only relevant if the tail expr would be
4828 // useful on its own.
4829 match expression.kind {
4830 ExprKind::Call(..) |
4831 ExprKind::MethodCall(..) |
4832 ExprKind::Loop(..) |
4833 ExprKind::Match(..) |
4834 ExprKind::Block(..) => {
4835 let sp = self.tcx.sess.source_map().next_point(cause_span);
4836 err.span_suggestion(
4838 "try adding a semicolon",
4840 Applicability::MachineApplicable);
4847 /// A possible error is to forget to add a return type that is needed:
4851 /// bar_that_returns_u32()
4855 /// This routine checks if the return type is left as default, the method is not part of an
4856 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4858 fn suggest_missing_return_type(
4860 err: &mut DiagnosticBuilder<'_>,
4861 fn_decl: &hir::FnDecl,
4866 // Only suggest changing the return type for methods that
4867 // haven't set a return type at all (and aren't `fn main()` or an impl).
4868 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4869 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4870 err.span_suggestion(
4872 "try adding a return type",
4873 format!("-> {} ", self.resolve_vars_with_obligations(found)),
4874 Applicability::MachineApplicable);
4877 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4878 err.span_label(span, "possibly return type missing here?");
4881 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4882 // `fn main()` must return `()`, do not suggest changing return type
4883 err.span_label(span, "expected `()` because of default return type");
4886 // expectation was caused by something else, not the default return
4887 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
4888 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4889 // Only point to return type if the expected type is the return type, as if they
4890 // are not, the expectation must have been caused by something else.
4891 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
4893 let ty = AstConv::ast_ty_to_ty(self, ty);
4894 debug!("suggest_missing_return_type: return type {:?}", ty);
4895 debug!("suggest_missing_return_type: expected type {:?}", ty);
4896 if ty.kind == expected.kind {
4897 err.span_label(sp, format!("expected `{}` because of return type",
4906 /// A possible error is to forget to add `.await` when using futures:
4909 /// async fn make_u32() -> u32 {
4913 /// fn take_u32(x: u32) {}
4915 /// async fn foo() {
4916 /// let x = make_u32();
4921 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
4922 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
4923 /// `.await` to the tail of the expression.
4924 fn suggest_missing_await(
4926 err: &mut DiagnosticBuilder<'_>,
4931 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
4932 // body isn't `async`.
4933 let item_id = self.tcx().hir().get_parent_node(self.body_id);
4934 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
4935 let body = self.tcx().hir().body(body_id);
4936 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
4938 // Check for `Future` implementations by constructing a predicate to
4939 // prove: `<T as Future>::Output == U`
4940 let future_trait = self.tcx.lang_items().future_trait().unwrap();
4941 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
4942 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
4943 // `<T as Future>::Output`
4944 projection_ty: ty::ProjectionTy {
4946 substs: self.tcx.mk_substs_trait(
4948 self.fresh_substs_for_item(sp, item_def_id)
4955 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4956 if self.infcx.predicate_may_hold(&obligation) {
4957 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4958 err.span_suggestion(
4960 "consider using `.await` here",
4961 format!("{}.await", code),
4962 Applicability::MaybeIncorrect,
4970 /// A common error is to add an extra semicolon:
4973 /// fn foo() -> usize {
4978 /// This routine checks if the final statement in a block is an
4979 /// expression with an explicit semicolon whose type is compatible
4980 /// with `expected_ty`. If so, it suggests removing the semicolon.
4981 fn consider_hint_about_removing_semicolon(
4983 blk: &'tcx hir::Block,
4984 expected_ty: Ty<'tcx>,
4985 err: &mut DiagnosticBuilder<'_>,
4987 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4988 err.span_suggestion(
4990 "consider removing this semicolon",
4992 Applicability::MachineApplicable,
4997 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4998 // Be helpful when the user wrote `{... expr;}` and
4999 // taking the `;` off is enough to fix the error.
5000 let last_stmt = blk.stmts.last()?;
5001 let last_expr = match last_stmt.kind {
5002 hir::StmtKind::Semi(ref e) => e,
5005 let last_expr_ty = self.node_ty(last_expr.hir_id);
5006 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5009 let original_span = original_sp(last_stmt.span, blk.span);
5010 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5013 // Instantiates the given path, which must refer to an item with the given
5014 // number of type parameters and type.
5015 pub fn instantiate_value_path(&self,
5016 segments: &[hir::PathSegment],
5017 self_ty: Option<Ty<'tcx>>,
5021 -> (Ty<'tcx>, Res) {
5023 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5032 let path_segs = match res {
5033 Res::Local(_) | Res::SelfCtor(_) => vec![],
5034 Res::Def(kind, def_id) =>
5035 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5036 _ => bug!("instantiate_value_path on {:?}", res),
5039 let mut user_self_ty = None;
5040 let mut is_alias_variant_ctor = false;
5042 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5043 if let Some(self_ty) = self_ty {
5044 let adt_def = self_ty.ty_adt_def().unwrap();
5045 user_self_ty = Some(UserSelfTy {
5046 impl_def_id: adt_def.did,
5049 is_alias_variant_ctor = true;
5052 Res::Def(DefKind::Method, def_id)
5053 | Res::Def(DefKind::AssocConst, def_id) => {
5054 let container = tcx.associated_item(def_id).container;
5055 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5057 ty::TraitContainer(trait_did) => {
5058 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5060 ty::ImplContainer(impl_def_id) => {
5061 if segments.len() == 1 {
5062 // `<T>::assoc` will end up here, and so
5063 // can `T::assoc`. It this came from an
5064 // inherent impl, we need to record the
5065 // `T` for posterity (see `UserSelfTy` for
5067 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5068 user_self_ty = Some(UserSelfTy {
5079 // Now that we have categorized what space the parameters for each
5080 // segment belong to, let's sort out the parameters that the user
5081 // provided (if any) into their appropriate spaces. We'll also report
5082 // errors if type parameters are provided in an inappropriate place.
5084 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5085 let generics_has_err = AstConv::prohibit_generics(
5086 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5087 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5094 if let Res::Local(hid) = res {
5095 let ty = self.local_ty(span, hid).decl_ty;
5096 let ty = self.normalize_associated_types_in(span, &ty);
5097 self.write_ty(hir_id, ty);
5101 if generics_has_err {
5102 // Don't try to infer type parameters when prohibited generic arguments were given.
5103 user_self_ty = None;
5106 // Now we have to compare the types that the user *actually*
5107 // provided against the types that were *expected*. If the user
5108 // did not provide any types, then we want to substitute inference
5109 // variables. If the user provided some types, we may still need
5110 // to add defaults. If the user provided *too many* types, that's
5113 let mut infer_args_for_err = FxHashSet::default();
5114 for &PathSeg(def_id, index) in &path_segs {
5115 let seg = &segments[index];
5116 let generics = tcx.generics_of(def_id);
5117 // Argument-position `impl Trait` is treated as a normal generic
5118 // parameter internally, but we don't allow users to specify the
5119 // parameter's value explicitly, so we have to do some error-
5121 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5126 false, // `is_method_call`
5128 if suppress_errors {
5129 infer_args_for_err.insert(index);
5130 self.set_tainted_by_errors(); // See issue #53251.
5134 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5135 tcx.generics_of(*def_id).has_self
5136 }).unwrap_or(false);
5138 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5139 let ty = self.impl_self_ty(span, impl_def_id).ty;
5140 let adt_def = ty.ty_adt_def();
5143 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5144 let variant = adt_def.non_enum_variant();
5145 let ctor_def_id = variant.ctor_def_id.unwrap();
5147 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5152 let mut err = tcx.sess.struct_span_err(span,
5153 "the `Self` constructor can only be used with tuple or unit structs");
5154 if let Some(adt_def) = adt_def {
5155 match adt_def.adt_kind() {
5157 err.help("did you mean to use one of the enum's variants?");
5161 err.span_suggestion(
5163 "use curly brackets",
5164 String::from("Self { /* fields */ }"),
5165 Applicability::HasPlaceholders,
5172 return (tcx.types.err, res)
5178 let def_id = res.def_id();
5180 // The things we are substituting into the type should not contain
5181 // escaping late-bound regions, and nor should the base type scheme.
5182 let ty = tcx.type_of(def_id);
5184 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
5190 // Provide the generic args, and whether types should be inferred.
5192 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5195 // If we've encountered an `impl Trait`-related error, we're just
5196 // going to infer the arguments for better error messages.
5197 if !infer_args_for_err.contains(&index) {
5198 // Check whether the user has provided generic arguments.
5199 if let Some(ref data) = segments[index].args {
5200 return (Some(data), segments[index].infer_args);
5203 return (None, segments[index].infer_args);
5208 // Provide substitutions for parameters for which (valid) arguments have been provided.
5210 match (¶m.kind, arg) {
5211 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5212 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5214 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5215 self.to_ty(ty).into()
5217 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5218 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5220 _ => unreachable!(),
5223 // Provide substitutions for parameters for which arguments are inferred.
5224 |substs, param, infer_args| {
5226 GenericParamDefKind::Lifetime => {
5227 self.re_infer(Some(param), span).unwrap().into()
5229 GenericParamDefKind::Type { has_default, .. } => {
5230 if !infer_args && has_default {
5231 // If we have a default, then we it doesn't matter that we're not
5232 // inferring the type arguments: we provide the default where any
5234 let default = tcx.type_of(param.def_id);
5237 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5240 // If no type arguments were provided, we have to infer them.
5241 // This case also occurs as a result of some malformed input, e.g.
5242 // a lifetime argument being given instead of a type parameter.
5243 // Using inference instead of `Error` gives better error messages.
5244 self.var_for_def(span, param)
5247 GenericParamDefKind::Const => {
5248 // FIXME(const_generics:defaults)
5249 // No const parameters were provided, we have to infer them.
5250 self.var_for_def(span, param)
5255 assert!(!substs.has_escaping_bound_vars());
5256 assert!(!ty.has_escaping_bound_vars());
5258 // First, store the "user substs" for later.
5259 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5261 self.add_required_obligations(span, def_id, &substs);
5263 // Substitute the values for the type parameters into the type of
5264 // the referenced item.
5265 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5267 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5268 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5269 // is inherent, there is no `Self` parameter; instead, the impl needs
5270 // type parameters, which we can infer by unifying the provided `Self`
5271 // with the substituted impl type.
5272 // This also occurs for an enum variant on a type alias.
5273 let ty = tcx.type_of(impl_def_id);
5275 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5276 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5277 Ok(ok) => self.register_infer_ok_obligations(ok),
5279 self.tcx.sess.delay_span_bug(span, &format!(
5280 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5288 self.check_rustc_args_require_const(def_id, hir_id, span);
5290 debug!("instantiate_value_path: type of {:?} is {:?}",
5293 self.write_substs(hir_id, substs);
5295 (ty_substituted, res)
5298 /// Add all the obligations that are required, substituting and normalized appropriately.
5299 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5300 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5302 for (i, mut obligation) in traits::predicates_for_generics(
5303 traits::ObligationCause::new(
5306 traits::ItemObligation(def_id),
5310 ).into_iter().enumerate() {
5311 // This makes the error point at the bound, but we want to point at the argument
5312 if let Some(span) = spans.get(i) {
5313 obligation.cause.code = traits::BindingObligation(def_id, *span);
5315 self.register_predicate(obligation);
5319 fn check_rustc_args_require_const(&self,
5323 // We're only interested in functions tagged with
5324 // #[rustc_args_required_const], so ignore anything that's not.
5325 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5329 // If our calling expression is indeed the function itself, we're good!
5330 // If not, generate an error that this can only be called directly.
5331 if let Node::Expr(expr) = self.tcx.hir().get(
5332 self.tcx.hir().get_parent_node(hir_id))
5334 if let ExprKind::Call(ref callee, ..) = expr.kind {
5335 if callee.hir_id == hir_id {
5341 self.tcx.sess.span_err(span, "this function can only be invoked \
5342 directly, not through a function pointer");
5345 // Resolves `typ` by a single level if `typ` is a type variable.
5346 // If no resolution is possible, then an error is reported.
5347 // Numeric inference variables may be left unresolved.
5348 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5349 let ty = self.resolve_vars_with_obligations(ty);
5350 if !ty.is_ty_var() {
5353 if !self.is_tainted_by_errors() {
5354 self.need_type_info_err((**self).body_id, sp, ty)
5355 .note("type must be known at this point")
5358 self.demand_suptype(sp, self.tcx.types.err, ty);
5363 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5366 ctxt: BreakableCtxt<'tcx>,
5368 ) -> (BreakableCtxt<'tcx>, R) {
5371 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5372 index = enclosing_breakables.stack.len();
5373 enclosing_breakables.by_id.insert(id, index);
5374 enclosing_breakables.stack.push(ctxt);
5378 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5379 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5380 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5381 enclosing_breakables.stack.pop().expect("missing breakable context")
5386 /// Instantiate a QueryResponse in a probe context, without a
5387 /// good ObligationCause.
5388 fn probe_instantiate_query_response(
5391 original_values: &OriginalQueryValues<'tcx>,
5392 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5393 ) -> InferResult<'tcx, Ty<'tcx>>
5395 self.instantiate_query_response_and_region_obligations(
5396 &traits::ObligationCause::misc(span, self.body_id),
5402 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5403 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5404 let mut contained_in_place = false;
5406 while let hir::Node::Expr(parent_expr) =
5407 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5409 match &parent_expr.kind {
5410 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5411 if lhs.hir_id == expr_id {
5412 contained_in_place = true;
5418 expr_id = parent_expr.hir_id;
5425 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5426 let own_counts = generics.own_counts();
5428 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5434 if own_counts.types == 0 {
5438 // Make a vector of booleans initially `false`; set to `true` when used.
5439 let mut types_used = vec![false; own_counts.types];
5441 for leaf_ty in ty.walk() {
5442 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5443 debug!("found use of ty param num {}", index);
5444 types_used[index as usize - own_counts.lifetimes] = true;
5445 } else if let ty::Error = leaf_ty.kind {
5446 // If there is already another error, do not emit
5447 // an error for not using a type parameter.
5448 assert!(tcx.sess.has_errors());
5453 let types = generics.params.iter().filter(|param| match param.kind {
5454 ty::GenericParamDefKind::Type { .. } => true,
5457 for (&used, param) in types_used.iter().zip(types) {
5459 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5460 let span = tcx.hir().span(id);
5461 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5462 .span_label(span, "unused type parameter")
5468 fn fatally_break_rust(sess: &Session) {
5469 let handler = sess.diagnostic();
5470 handler.span_bug_no_panic(
5472 "It looks like you're trying to break rust; would you like some ICE?",
5474 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5475 handler.note_without_error(
5476 "we would appreciate a joke overview: \
5477 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5479 handler.note_without_error(&format!("rustc {} running on {}",
5480 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5481 crate::session::config::host_triple(),
5485 fn potentially_plural_count(count: usize, word: &str) -> String {
5486 format!("{} {}{}", count, word, pluralize!(count))