5 Within the check phase of type check, we check each item one at a time
6 (bodies of function expressions are checked as part of the containing
7 function). Inference is used to supply types wherever they are unknown.
9 By far the most complex case is checking the body of a function. This
10 can be broken down into several distinct phases:
12 - gather: creates type variables to represent the type of each local
13 variable and pattern binding.
15 - main: the main pass does the lion's share of the work: it
16 determines the types of all expressions, resolves
17 methods, checks for most invalid conditions, and so forth. In
18 some cases, where a type is unknown, it may create a type or region
19 variable and use that as the type of an expression.
21 In the process of checking, various constraints will be placed on
22 these type variables through the subtyping relationships requested
23 through the `demand` module. The `infer` module is in charge
24 of resolving those constraints.
26 - regionck: after main is complete, the regionck pass goes over all
27 types looking for regions and making sure that they did not escape
28 into places they are not in scope. This may also influence the
29 final assignments of the various region variables if there is some
32 - vtable: find and records the impls to use for each trait bound that
33 appears on a type parameter.
35 - writeback: writes the final types within a function body, replacing
36 type variables with their final inferred types. These final types
37 are written into the `tcx.node_types` table, which should *never* contain
38 any reference to a type variable.
42 While type checking a function, the intermediate types for the
43 expressions, blocks, and so forth contained within the function are
44 stored in `fcx.node_types` and `fcx.node_substs`. These types
45 may contain unresolved type variables. After type checking is
46 complete, the functions in the writeback module are used to take the
47 types from this table, resolve them, and then write them into their
48 permanent home in the type context `tcx`.
50 This means that during inferencing you should use `fcx.write_ty()`
51 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
52 nodes within the function.
54 The types of top-level items, which never contain unbound type
55 variables, are stored directly into the `tcx` tables.
57 N.B., a type variable is not the same thing as a type parameter. A
58 type variable is rather an "instance" of a type parameter: that is,
59 given a generic function `fn foo<T>(t: T)`: while checking the
60 function `foo`, the type `ty_param(0)` refers to the type `T`, which
61 is treated in abstract. When `foo()` is called, however, `T` will be
62 substituted for a fresh type variable `N`. This variable will
63 eventually be resolved to some concrete type (which might itself be
82 mod generator_interior;
86 use astconv::{AstConv, PathSeg};
87 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
88 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
89 use rustc::hir::def::{CtorKind, Def};
90 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
92 use rustc::hir::itemlikevisit::ItemLikeVisitor;
93 use middle::lang_items;
94 use namespace::Namespace;
95 use rustc::infer::{self, InferCtxt, InferOk, InferResult, RegionVariableOrigin};
96 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
97 use rustc_data_structures::indexed_vec::Idx;
98 use rustc_data_structures::sync::Lrc;
99 use rustc_target::spec::abi::Abi;
100 use rustc::infer::opaque_types::OpaqueTypeDecl;
101 use rustc::infer::type_variable::{TypeVariableOrigin};
102 use rustc::middle::region;
103 use rustc::mir::interpret::{ConstValue, GlobalId};
104 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
106 self, AdtKind, CanonicalUserTypeAnnotation, Ty, TyCtxt, GenericParamDefKind, Visibility,
107 ToPolyTraitRef, ToPredicate, RegionKind, UserTypeAnnotation
109 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
110 use rustc::ty::fold::TypeFoldable;
111 use rustc::ty::query::Providers;
112 use rustc::ty::subst::{UnpackedKind, Subst, Substs, UserSelfTy, UserSubsts};
113 use rustc::ty::util::{Representability, IntTypeExt, Discr};
114 use rustc::ty::layout::VariantIdx;
115 use syntax_pos::{self, BytePos, Span, MultiSpan};
118 use syntax::feature_gate::{GateIssue, emit_feature_err};
120 use syntax::source_map::{DUMMY_SP, original_sp};
121 use syntax::symbol::{Symbol, LocalInternedString, keywords};
122 use syntax::util::lev_distance::find_best_match_for_name;
124 use std::cell::{Cell, RefCell, Ref, RefMut};
125 use std::collections::hash_map::Entry;
127 use std::fmt::Display;
129 use std::mem::replace;
130 use std::ops::{self, Deref};
133 use require_c_abi_if_variadic;
134 use session::{CompileIncomplete, config, Session};
137 use util::captures::Captures;
138 use util::common::{ErrorReported, indenter};
139 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
141 pub use self::Expectation::*;
142 use self::autoderef::Autoderef;
143 use self::callee::DeferredCallResolution;
144 use self::coercion::{CoerceMany, DynamicCoerceMany};
145 pub use self::compare_method::{compare_impl_method, compare_const_impl};
146 use self::method::{MethodCallee, SelfSource};
147 use self::TupleArgumentsFlag::*;
149 /// The type of a local binding, including the revealed type for anon types.
150 #[derive(Copy, Clone)]
151 pub struct LocalTy<'tcx> {
153 revealed_ty: Ty<'tcx>
156 /// A wrapper for InferCtxt's `in_progress_tables` field.
157 #[derive(Copy, Clone)]
158 struct MaybeInProgressTables<'a, 'tcx: 'a> {
159 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
162 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
163 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
164 match self.maybe_tables {
165 Some(tables) => tables.borrow(),
167 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
172 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
173 match self.maybe_tables {
174 Some(tables) => tables.borrow_mut(),
176 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
182 /// closures defined within the function. For example:
185 /// bar(move|| { ... })
188 /// Here, the function `foo()` and the closure passed to
189 /// `bar()` will each have their own `FnCtxt`, but they will
190 /// share the inherited fields.
191 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
192 infcx: InferCtxt<'a, 'gcx, 'tcx>,
194 tables: MaybeInProgressTables<'a, 'tcx>,
196 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
198 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
200 // Some additional `Sized` obligations badly affect type inference.
201 // These obligations are added in a later stage of typeck.
202 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
204 // When we process a call like `c()` where `c` is a closure type,
205 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
206 // `FnOnce` closure. In that case, we defer full resolution of the
207 // call until upvar inference can kick in and make the
208 // decision. We keep these deferred resolutions grouped by the
209 // def-id of the closure, so that once we decide, we can easily go
210 // back and process them.
211 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
213 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
215 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
217 // Opaque types found in explicit return types and their
218 // associated fresh inference variable. Writeback resolves these
219 // variables to get the concrete type, which can be used to
220 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
221 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
223 /// Each type parameter has an implicit region bound that
224 /// indicates it must outlive at least the function body (the user
225 /// may specify stronger requirements). This field indicates the
226 /// region of the callee. If it is `None`, then the parameter
227 /// environment is for an item or something where the "callee" is
229 implicit_region_bound: Option<ty::Region<'tcx>>,
231 body_id: Option<hir::BodyId>,
234 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
235 type Target = InferCtxt<'a, 'gcx, 'tcx>;
236 fn deref(&self) -> &Self::Target {
241 /// When type-checking an expression, we propagate downward
242 /// whatever type hint we are able in the form of an `Expectation`.
243 #[derive(Copy, Clone, Debug)]
244 pub enum Expectation<'tcx> {
245 /// We know nothing about what type this expression should have.
248 /// This expression is an `if` condition, it must resolve to `bool`.
251 /// This expression should have the type given (or some subtype)
252 ExpectHasType(Ty<'tcx>),
254 /// This expression will be cast to the `Ty`
255 ExpectCastableToType(Ty<'tcx>),
257 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
258 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
259 ExpectRvalueLikeUnsized(Ty<'tcx>),
262 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
263 // Disregard "castable to" expectations because they
264 // can lead us astray. Consider for example `if cond
265 // {22} else {c} as u8` -- if we propagate the
266 // "castable to u8" constraint to 22, it will pick the
267 // type 22u8, which is overly constrained (c might not
268 // be a u8). In effect, the problem is that the
269 // "castable to" expectation is not the tightest thing
270 // we can say, so we want to drop it in this case.
271 // The tightest thing we can say is "must unify with
272 // else branch". Note that in the case of a "has type"
273 // constraint, this limitation does not hold.
275 // If the expected type is just a type variable, then don't use
276 // an expected type. Otherwise, we might write parts of the type
277 // when checking the 'then' block which are incompatible with the
279 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
281 ExpectHasType(ety) => {
282 let ety = fcx.shallow_resolve(ety);
283 if !ety.is_ty_var() {
289 ExpectRvalueLikeUnsized(ety) => {
290 ExpectRvalueLikeUnsized(ety)
296 /// Provide an expectation for an rvalue expression given an *optional*
297 /// hint, which is not required for type safety (the resulting type might
298 /// be checked higher up, as is the case with `&expr` and `box expr`), but
299 /// is useful in determining the concrete type.
301 /// The primary use case is where the expected type is a fat pointer,
302 /// like `&[isize]`. For example, consider the following statement:
304 /// let x: &[isize] = &[1, 2, 3];
306 /// In this case, the expected type for the `&[1, 2, 3]` expression is
307 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
308 /// expectation `ExpectHasType([isize])`, that would be too strong --
309 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
310 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
311 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
312 /// which still is useful, because it informs integer literals and the like.
313 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
314 /// for examples of where this comes up,.
315 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
316 match fcx.tcx.struct_tail(ty).sty {
317 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
318 ExpectRvalueLikeUnsized(ty)
320 _ => ExpectHasType(ty)
324 // Resolves `expected` by a single level if it is a variable. If
325 // there is no expected type or resolution is not possible (e.g.,
326 // no constraints yet present), just returns `None`.
327 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
329 NoExpectation => NoExpectation,
330 ExpectIfCondition => ExpectIfCondition,
331 ExpectCastableToType(t) => {
332 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
334 ExpectHasType(t) => {
335 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
337 ExpectRvalueLikeUnsized(t) => {
338 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
343 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
344 match self.resolve(fcx) {
345 NoExpectation => None,
346 ExpectIfCondition => Some(fcx.tcx.types.bool),
347 ExpectCastableToType(ty) |
349 ExpectRvalueLikeUnsized(ty) => Some(ty),
353 /// It sometimes happens that we want to turn an expectation into
354 /// a **hard constraint** (i.e., something that must be satisfied
355 /// for the program to type-check). `only_has_type` will return
356 /// such a constraint, if it exists.
357 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
358 match self.resolve(fcx) {
359 ExpectHasType(ty) => Some(ty),
360 ExpectIfCondition => Some(fcx.tcx.types.bool),
361 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
365 /// Like `only_has_type`, but instead of returning `None` if no
366 /// hard constraint exists, creates a fresh type variable.
367 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
368 self.only_has_type(fcx)
369 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
373 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
380 fn maybe_mut_place(m: hir::Mutability) -> Self {
382 hir::MutMutable => Needs::MutPlace,
383 hir::MutImmutable => Needs::None,
388 #[derive(Copy, Clone)]
389 pub struct UnsafetyState {
390 pub def: ast::NodeId,
391 pub unsafety: hir::Unsafety,
392 pub unsafe_push_count: u32,
397 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
398 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
401 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
402 match self.unsafety {
403 // If this unsafe, then if the outer function was already marked as
404 // unsafe we shouldn't attribute the unsafe'ness to the block. This
405 // way the block can be warned about instead of ignoring this
406 // extraneous block (functions are never warned about).
407 hir::Unsafety::Unsafe if self.from_fn => *self,
410 let (unsafety, def, count) = match blk.rules {
411 hir::PushUnsafeBlock(..) =>
412 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
413 hir::PopUnsafeBlock(..) =>
414 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
415 hir::UnsafeBlock(..) =>
416 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
418 (unsafety, self.def, self.unsafe_push_count),
422 unsafe_push_count: count,
429 #[derive(Debug, Copy, Clone)]
435 /// Tracks whether executing a node may exit normally (versus
436 /// return/break/panic, which "diverge", leaving dead code in their
437 /// wake). Tracked semi-automatically (through type variables marked
438 /// as diverging), with some manual adjustments for control-flow
439 /// primitives (approximating a CFG).
440 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
442 /// Potentially unknown, some cases converge,
443 /// others require a CFG to determine them.
446 /// Definitely known to diverge and therefore
447 /// not reach the next sibling or its parent.
450 /// Same as `Always` but with a reachability
451 /// warning already emitted
455 // Convenience impls for combinig `Diverges`.
457 impl ops::BitAnd for Diverges {
459 fn bitand(self, other: Self) -> Self {
460 cmp::min(self, other)
464 impl ops::BitOr for Diverges {
466 fn bitor(self, other: Self) -> Self {
467 cmp::max(self, other)
471 impl ops::BitAndAssign for Diverges {
472 fn bitand_assign(&mut self, other: Self) {
473 *self = *self & other;
477 impl ops::BitOrAssign for Diverges {
478 fn bitor_assign(&mut self, other: Self) {
479 *self = *self | other;
484 fn always(self) -> bool {
485 self >= Diverges::Always
489 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
492 // this is `null` for loops where break with a value is illegal,
493 // such as `while`, `for`, and `while let`
494 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
497 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
498 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
499 by_id: NodeMap<usize>,
502 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
503 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
504 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
505 bug!("could not find enclosing breakable with id {}", target_id);
511 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
512 body_id: ast::NodeId,
514 /// The parameter environment used for proving trait obligations
515 /// in this function. This can change when we descend into
516 /// closures (as they bring new things into scope), hence it is
517 /// not part of `Inherited` (as of the time of this writing,
518 /// closures do not yet change the environment, but they will
520 param_env: ty::ParamEnv<'tcx>,
522 // Number of errors that had been reported when we started
523 // checking this function. On exit, if we find that *more* errors
524 // have been reported, we will skip regionck and other work that
525 // expects the types within the function to be consistent.
526 err_count_on_creation: usize,
528 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
529 ret_coercion_span: RefCell<Option<Span>>,
531 yield_ty: Option<Ty<'tcx>>,
533 ps: RefCell<UnsafetyState>,
535 /// Whether the last checked node generates a divergence (e.g.,
536 /// `return` will set this to Always). In general, when entering
537 /// an expression or other node in the tree, the initial value
538 /// indicates whether prior parts of the containing expression may
539 /// have diverged. It is then typically set to `Maybe` (and the
540 /// old value remembered) for processing the subparts of the
541 /// current expression. As each subpart is processed, they may set
542 /// the flag to `Always` etc. Finally, at the end, we take the
543 /// result and "union" it with the original value, so that when we
544 /// return the flag indicates if any subpart of the parent
545 /// expression (up to and including this part) has diverged. So,
546 /// if you read it after evaluating a subexpression `X`, the value
547 /// you get indicates whether any subexpression that was
548 /// evaluating up to and including `X` diverged.
550 /// We currently use this flag only for diagnostic purposes:
552 /// - To warn about unreachable code: if, after processing a
553 /// sub-expression but before we have applied the effects of the
554 /// current node, we see that the flag is set to `Always`, we
555 /// can issue a warning. This corresponds to something like
556 /// `foo(return)`; we warn on the `foo()` expression. (We then
557 /// update the flag to `WarnedAlways` to suppress duplicate
558 /// reports.) Similarly, if we traverse to a fresh statement (or
559 /// tail expression) from a `Always` setting, we will issue a
560 /// warning. This corresponds to something like `{return;
561 /// foo();}` or `{return; 22}`, where we would warn on the
564 /// An expression represents dead-code if, after checking it,
565 /// the diverges flag is set to something other than `Maybe`.
566 diverges: Cell<Diverges>,
568 /// Whether any child nodes have any type errors.
569 has_errors: Cell<bool>,
571 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
573 inh: &'a Inherited<'a, 'gcx, 'tcx>,
576 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
577 type Target = Inherited<'a, 'gcx, 'tcx>;
578 fn deref(&self) -> &Self::Target {
583 /// Helper type of a temporary returned by Inherited::build(...).
584 /// Necessary because we can't write the following bound:
585 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
586 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
587 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
591 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
592 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
593 -> InheritedBuilder<'a, 'gcx, 'tcx> {
594 let hir_id_root = if def_id.is_local() {
595 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
596 let hir_id = tcx.hir().definitions().node_to_hir_id(node_id);
597 DefId::local(hir_id.owner)
603 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
609 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
610 fn enter<F, R>(&'tcx mut self, f: F) -> R
611 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
613 let def_id = self.def_id;
614 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
618 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
619 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
621 let item_id = tcx.hir().as_local_node_id(def_id);
622 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
623 let implicit_region_bound = body_id.map(|body_id| {
624 let body = tcx.hir().body(body_id);
625 tcx.mk_region(ty::ReScope(region::Scope {
626 id: body.value.hir_id.local_id,
627 data: region::ScopeData::CallSite
632 tables: MaybeInProgressTables {
633 maybe_tables: infcx.in_progress_tables,
636 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
637 locals: RefCell::new(Default::default()),
638 deferred_sized_obligations: RefCell::new(Vec::new()),
639 deferred_call_resolutions: RefCell::new(Default::default()),
640 deferred_cast_checks: RefCell::new(Vec::new()),
641 deferred_generator_interiors: RefCell::new(Vec::new()),
642 opaque_types: RefCell::new(Default::default()),
643 implicit_region_bound,
648 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
649 debug!("register_predicate({:?})", obligation);
650 if obligation.has_escaping_bound_vars() {
651 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
656 .register_predicate_obligation(self, obligation);
659 fn register_predicates<I>(&self, obligations: I)
660 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
662 for obligation in obligations {
663 self.register_predicate(obligation);
667 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
668 self.register_predicates(infer_ok.obligations);
672 fn normalize_associated_types_in<T>(&self,
674 body_id: ast::NodeId,
675 param_env: ty::ParamEnv<'tcx>,
677 where T : TypeFoldable<'tcx>
679 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
680 self.register_infer_ok_obligations(ok)
684 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
686 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
687 fn visit_item(&mut self, i: &'tcx hir::Item) {
688 check_item_type(self.tcx, i);
690 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
691 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
694 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
695 tcx.sess.track_errors(|| {
696 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
697 tcx.hir().krate().visit_all_item_likes(&mut visit.as_deep_visitor());
701 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
702 tcx.sess.track_errors(|| {
703 tcx.hir().krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
707 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
708 tcx.typeck_item_bodies(LOCAL_CRATE)
711 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
712 -> Result<(), CompileIncomplete>
714 debug_assert!(crate_num == LOCAL_CRATE);
715 Ok(tcx.sess.track_errors(|| {
716 tcx.par_body_owners(|body_owner_def_id| {
717 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
722 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
723 wfcheck::check_item_well_formed(tcx, def_id);
726 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
727 wfcheck::check_trait_item(tcx, def_id);
730 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
731 wfcheck::check_impl_item(tcx, def_id);
734 pub fn provide(providers: &mut Providers) {
735 method::provide(providers);
736 *providers = Providers {
742 check_item_well_formed,
743 check_trait_item_well_formed,
744 check_impl_item_well_formed,
749 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
751 -> Option<ty::Destructor> {
752 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
755 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
756 /// with information about it's body-id and fn-decl (if any). Otherwise,
759 /// If this function returns "some", then `typeck_tables(def_id)` will
760 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
761 /// may not succeed. In some cases where this function returns `None`
762 /// (notably closures), `typeck_tables(def_id)` would wind up
763 /// redirecting to the owning function.
764 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
766 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
768 match tcx.hir().get(id) {
769 Node::Item(item) => {
771 hir::ItemKind::Const(_, body) |
772 hir::ItemKind::Static(_, _, body) =>
774 hir::ItemKind::Fn(ref decl, .., body) =>
775 Some((body, Some(decl))),
780 Node::TraitItem(item) => {
782 hir::TraitItemKind::Const(_, Some(body)) =>
784 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
785 Some((body, Some(&sig.decl))),
790 Node::ImplItem(item) => {
792 hir::ImplItemKind::Const(_, body) =>
794 hir::ImplItemKind::Method(ref sig, body) =>
795 Some((body, Some(&sig.decl))),
800 Node::AnonConst(constant) => Some((constant.body, None)),
805 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
808 // Closures' tables come from their outermost function,
809 // as they are part of the same "inference environment".
810 let outer_def_id = tcx.closure_base_def_id(def_id);
811 if outer_def_id != def_id {
812 return tcx.has_typeck_tables(outer_def_id);
815 let id = tcx.hir().as_local_node_id(def_id).unwrap();
816 primary_body_of(tcx, id).is_some()
819 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
822 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
825 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
827 -> &'tcx ty::TypeckTables<'tcx> {
828 // Closures' tables come from their outermost function,
829 // as they are part of the same "inference environment".
830 let outer_def_id = tcx.closure_base_def_id(def_id);
831 if outer_def_id != def_id {
832 return tcx.typeck_tables_of(outer_def_id);
835 let id = tcx.hir().as_local_node_id(def_id).unwrap();
836 let span = tcx.hir().span(id);
838 // Figure out what primary body this item has.
839 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
840 span_bug!(span, "can't type-check body of {:?}", def_id);
842 let body = tcx.hir().body(body_id);
844 let tables = Inherited::build(tcx, def_id).enter(|inh| {
845 let param_env = tcx.param_env(def_id);
846 let fcx = if let Some(decl) = fn_decl {
847 let fn_sig = tcx.fn_sig(def_id);
849 check_abi(tcx, span, fn_sig.abi());
851 // Compute the fty from point of view of inside the fn.
853 tcx.liberate_late_bound_regions(def_id, &fn_sig);
855 inh.normalize_associated_types_in(body.value.span,
860 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
863 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
864 let expected_type = tcx.type_of(def_id);
865 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
866 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
868 let revealed_ty = if tcx.features().impl_trait_in_bindings {
869 fcx.instantiate_opaque_types_from_value(
877 // Gather locals in statics (because of block expressions).
878 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
880 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
885 // All type checking constraints were added, try to fallback unsolved variables.
886 fcx.select_obligations_where_possible(false);
887 let mut fallback_has_occurred = false;
888 for ty in &fcx.unsolved_variables() {
889 fallback_has_occurred |= fcx.fallback_if_possible(ty);
891 fcx.select_obligations_where_possible(fallback_has_occurred);
893 // Even though coercion casts provide type hints, we check casts after fallback for
894 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
897 // Closure and generator analysis may run after fallback
898 // because they don't constrain other type variables.
899 fcx.closure_analyze(body);
900 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
901 fcx.resolve_generator_interiors(def_id);
903 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
904 let ty = fcx.normalize_ty(span, ty);
905 fcx.require_type_is_sized(ty, span, code);
907 fcx.select_all_obligations_or_error();
909 if fn_decl.is_some() {
910 fcx.regionck_fn(id, body);
912 fcx.regionck_expr(body);
915 fcx.resolve_type_vars_in_body(body)
918 // Consistency check our TypeckTables instance can hold all ItemLocalIds
919 // it will need to hold.
920 assert_eq!(tables.local_id_root,
921 Some(DefId::local(tcx.hir().definitions().node_to_hir_id(id).owner)));
925 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
926 if !tcx.sess.target.target.is_abi_supported(abi) {
927 struct_span_err!(tcx.sess, span, E0570,
928 "The ABI `{}` is not supported for the current target", abi).emit()
932 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
933 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
934 parent_id: ast::NodeId,
937 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
938 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
941 // infer the variable's type
942 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
943 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
950 // take type that the user specified
951 self.fcx.locals.borrow_mut().insert(nid, typ);
958 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
959 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
960 NestedVisitorMap::None
963 // Add explicitly-declared locals.
964 fn visit_local(&mut self, local: &'gcx hir::Local) {
965 let local_ty = match local.ty {
967 let o_ty = self.fcx.to_ty(&ty);
969 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
970 self.fcx.instantiate_opaque_types_from_value(
978 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
979 &UserTypeAnnotation::Ty(revealed_ty)
981 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
982 ty.hir_id, o_ty, revealed_ty, c_ty);
983 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
985 Some(LocalTy { decl_ty: o_ty, revealed_ty })
989 self.assign(local.span, local.id, local_ty);
991 debug!("Local variable {:?} is assigned type {}",
993 self.fcx.ty_to_string(
994 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
995 intravisit::walk_local(self, local);
998 // Add pattern bindings.
999 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1000 if let PatKind::Binding(_, _, ident, _) = p.node {
1001 let var_ty = self.assign(p.span, p.id, None);
1003 if !self.fcx.tcx.features().unsized_locals {
1004 self.fcx.require_type_is_sized(var_ty, p.span,
1005 traits::VariableType(p.id));
1008 debug!("Pattern binding {} is assigned to {} with type {:?}",
1010 self.fcx.ty_to_string(
1011 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1014 intravisit::walk_pat(self, p);
1017 // Don't descend into the bodies of nested closures
1018 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1019 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1022 /// When `check_fn` is invoked on a generator (i.e., a body that
1023 /// includes yield), it returns back some information about the yield
1025 struct GeneratorTypes<'tcx> {
1026 /// Type of value that is yielded.
1027 yield_ty: ty::Ty<'tcx>,
1029 /// Types that are captured (see `GeneratorInterior` for more).
1030 interior: ty::Ty<'tcx>,
1032 /// Indicates if the generator is movable or static (immovable)
1033 movability: hir::GeneratorMovability,
1036 /// Helper used for fns and closures. Does the grungy work of checking a function
1037 /// body and returns the function context used for that purpose, since in the case of a fn item
1038 /// there is still a bit more to do.
1041 /// * inherited: other fields inherited from the enclosing fn (if any)
1042 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1043 param_env: ty::ParamEnv<'tcx>,
1044 fn_sig: ty::FnSig<'tcx>,
1045 decl: &'gcx hir::FnDecl,
1047 body: &'gcx hir::Body,
1048 can_be_generator: Option<hir::GeneratorMovability>)
1049 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1051 let mut fn_sig = fn_sig.clone();
1053 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1055 // Create the function context. This is either derived from scratch or,
1056 // in the case of closures, based on the outer context.
1057 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1058 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1060 let declared_ret_ty = fn_sig.output();
1061 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1062 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1063 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1064 fn_sig = fcx.tcx.mk_fn_sig(
1065 fn_sig.inputs().iter().cloned(),
1072 let span = body.value.span;
1074 if body.is_generator && can_be_generator.is_some() {
1075 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1076 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1077 fcx.yield_ty = Some(yield_ty);
1080 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1081 let outer_node_id = fcx.tcx.hir().as_local_node_id(outer_def_id).unwrap();
1082 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1084 // Add formal parameters.
1085 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1086 // Check the pattern.
1087 fcx.check_pat_walk(&arg.pat, arg_ty,
1088 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1090 // Check that argument is Sized.
1091 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1092 // for simple cases like `fn foo(x: Trait)`,
1093 // where we would error once on the parameter as a whole, and once on the binding `x`.
1094 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1095 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1098 fcx.write_ty(arg.hir_id, arg_ty);
1101 let fn_hir_id = fcx.tcx.hir().node_to_hir_id(fn_id);
1102 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1104 fcx.check_return_expr(&body.value);
1106 // We insert the deferred_generator_interiors entry after visiting the body.
1107 // This ensures that all nested generators appear before the entry of this generator.
1108 // resolve_generator_interiors relies on this property.
1109 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1110 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1111 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1112 Some(GeneratorTypes {
1113 yield_ty: fcx.yield_ty.unwrap(),
1115 movability: can_be_generator.unwrap(),
1121 // Finalize the return check by taking the LUB of the return types
1122 // we saw and assigning it to the expected return type. This isn't
1123 // really expected to fail, since the coercions would have failed
1124 // earlier when trying to find a LUB.
1126 // However, the behavior around `!` is sort of complex. In the
1127 // event that the `actual_return_ty` comes back as `!`, that
1128 // indicates that the fn either does not return or "returns" only
1129 // values of type `!`. In this case, if there is an expected
1130 // return type that is *not* `!`, that should be ok. But if the
1131 // return type is being inferred, we want to "fallback" to `!`:
1133 // let x = move || panic!();
1135 // To allow for that, I am creating a type variable with diverging
1136 // fallback. This was deemed ever so slightly better than unifying
1137 // the return value with `!` because it allows for the caller to
1138 // make more assumptions about the return type (e.g., they could do
1140 // let y: Option<u32> = Some(x());
1142 // which would then cause this return type to become `u32`, not
1144 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1145 let mut actual_return_ty = coercion.complete(&fcx);
1146 if actual_return_ty.is_never() {
1147 actual_return_ty = fcx.next_diverging_ty_var(
1148 TypeVariableOrigin::DivergingFn(span));
1150 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1152 // Check that the main return type implements the termination trait.
1153 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1154 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1156 if let config::EntryFnType::Main = entry_type {
1157 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1158 let trait_ref = ty::TraitRef::new(term_id, substs);
1159 let return_ty_span = decl.output.span();
1160 let cause = traits::ObligationCause::new(
1161 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1163 inherited.register_predicate(
1164 traits::Obligation::new(
1165 cause, param_env, trait_ref.to_predicate()));
1171 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1172 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1173 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1174 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1175 // at this point we don't care if there are duplicate handlers or if the handler has
1176 // the wrong signature as this value we'll be used when writing metadata and that
1177 // only happens if compilation succeeded
1178 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1180 if declared_ret_ty.sty != ty::Never {
1181 fcx.tcx.sess.span_err(
1183 "return type should be `!`",
1187 let inputs = fn_sig.inputs();
1188 let span = fcx.tcx.hir().span(fn_id);
1189 if inputs.len() == 1 {
1190 let arg_is_panic_info = match inputs[0].sty {
1191 ty::Ref(region, ty, mutbl) => match ty.sty {
1192 ty::Adt(ref adt, _) => {
1193 adt.did == panic_info_did &&
1194 mutbl == hir::Mutability::MutImmutable &&
1195 *region != RegionKind::ReStatic
1202 if !arg_is_panic_info {
1203 fcx.tcx.sess.span_err(
1204 decl.inputs[0].span,
1205 "argument should be `&PanicInfo`",
1209 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1210 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1211 if !generics.params.is_empty() {
1212 fcx.tcx.sess.span_err(
1214 "should have no type parameters",
1220 let span = fcx.tcx.sess.source_map().def_span(span);
1221 fcx.tcx.sess.span_err(span, "function should have one argument");
1224 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1229 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1230 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1231 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1232 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1233 if declared_ret_ty.sty != ty::Never {
1234 fcx.tcx.sess.span_err(
1236 "return type should be `!`",
1240 let inputs = fn_sig.inputs();
1241 let span = fcx.tcx.hir().span(fn_id);
1242 if inputs.len() == 1 {
1243 let arg_is_alloc_layout = match inputs[0].sty {
1244 ty::Adt(ref adt, _) => {
1245 adt.did == alloc_layout_did
1250 if !arg_is_alloc_layout {
1251 fcx.tcx.sess.span_err(
1252 decl.inputs[0].span,
1253 "argument should be `Layout`",
1257 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1258 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1259 if !generics.params.is_empty() {
1260 fcx.tcx.sess.span_err(
1262 "`#[alloc_error_handler]` function should have no type \
1269 let span = fcx.tcx.sess.source_map().def_span(span);
1270 fcx.tcx.sess.span_err(span, "function should have one argument");
1273 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1281 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1284 let def_id = tcx.hir().local_def_id(id);
1285 let def = tcx.adt_def(def_id);
1286 def.destructor(tcx); // force the destructor to be evaluated
1287 check_representable(tcx, span, def_id);
1289 if def.repr.simd() {
1290 check_simd(tcx, span, def_id);
1293 check_transparent(tcx, span, def_id);
1294 check_packed(tcx, span, def_id);
1297 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1300 let def_id = tcx.hir().local_def_id(id);
1301 let def = tcx.adt_def(def_id);
1302 def.destructor(tcx); // force the destructor to be evaluated
1303 check_representable(tcx, span, def_id);
1305 check_packed(tcx, span, def_id);
1308 fn check_opaque<'a, 'tcx>(
1309 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1311 substs: &'tcx Substs<'tcx>,
1314 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1315 let mut err = struct_span_err!(
1316 tcx.sess, span, E0720,
1317 "opaque type expands to a recursive type",
1319 err.span_label(span, "expands to self-referential type");
1320 if let ty::Opaque(..) = partially_expanded_type.sty {
1321 err.note("type resolves to itself");
1323 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1329 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1331 "check_item_type(it.id={}, it.name={})",
1333 tcx.item_path_str(tcx.hir().local_def_id(it.id))
1335 let _indenter = indenter();
1337 // Consts can play a role in type-checking, so they are included here.
1338 hir::ItemKind::Static(..) => {
1339 let def_id = tcx.hir().local_def_id(it.id);
1340 tcx.typeck_tables_of(def_id);
1341 maybe_check_static_with_link_section(tcx, def_id, it.span);
1343 hir::ItemKind::Const(..) => {
1344 tcx.typeck_tables_of(tcx.hir().local_def_id(it.id));
1346 hir::ItemKind::Enum(ref enum_definition, _) => {
1347 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1349 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1350 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1351 debug!("ItemKind::Impl {} with id {}", it.ident, it.id);
1352 let impl_def_id = tcx.hir().local_def_id(it.id);
1353 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1354 check_impl_items_against_trait(
1361 let trait_def_id = impl_trait_ref.def_id;
1362 check_on_unimplemented(tcx, trait_def_id, it);
1365 hir::ItemKind::Trait(..) => {
1366 let def_id = tcx.hir().local_def_id(it.id);
1367 check_on_unimplemented(tcx, def_id, it);
1369 hir::ItemKind::Struct(..) => {
1370 check_struct(tcx, it.id, it.span);
1372 hir::ItemKind::Union(..) => {
1373 check_union(tcx, it.id, it.span);
1375 hir::ItemKind::Existential(..) => {
1376 let def_id = tcx.hir().local_def_id(it.id);
1377 let pty_ty = tcx.type_of(def_id);
1378 let generics = tcx.generics_of(def_id);
1380 check_bounds_are_used(tcx, &generics, pty_ty);
1381 let substs = Substs::identity_for_item(tcx, def_id);
1382 check_opaque(tcx, def_id, substs, it.span);
1384 hir::ItemKind::Ty(..) => {
1385 let def_id = tcx.hir().local_def_id(it.id);
1386 let pty_ty = tcx.type_of(def_id);
1387 let generics = tcx.generics_of(def_id);
1388 check_bounds_are_used(tcx, &generics, pty_ty);
1390 hir::ItemKind::ForeignMod(ref m) => {
1391 check_abi(tcx, it.span, m.abi);
1393 if m.abi == Abi::RustIntrinsic {
1394 for item in &m.items {
1395 intrinsic::check_intrinsic_type(tcx, item);
1397 } else if m.abi == Abi::PlatformIntrinsic {
1398 for item in &m.items {
1399 intrinsic::check_platform_intrinsic_type(tcx, item);
1402 for item in &m.items {
1403 let generics = tcx.generics_of(tcx.hir().local_def_id(item.id));
1404 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1405 let mut err = struct_span_err!(
1409 "foreign items may not have type parameters"
1411 err.span_label(item.span, "can't have type parameters");
1412 // FIXME: once we start storing spans for type arguments, turn this into a
1415 "use specialization instead of type parameters by replacing them \
1416 with concrete types like `u32`",
1421 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1422 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1427 _ => { /* nothing to do */ }
1431 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1432 // Only restricted on wasm32 target for now
1433 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1437 // If `#[link_section]` is missing, then nothing to verify
1438 let attrs = tcx.codegen_fn_attrs(id);
1439 if attrs.link_section.is_none() {
1443 // For the wasm32 target statics with #[link_section] are placed into custom
1444 // sections of the final output file, but this isn't link custom sections of
1445 // other executable formats. Namely we can only embed a list of bytes,
1446 // nothing with pointers to anything else or relocations. If any relocation
1447 // show up, reject them here.
1448 let instance = ty::Instance::mono(tcx, id);
1449 let cid = GlobalId {
1453 let param_env = ty::ParamEnv::reveal_all();
1454 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1455 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1458 bug!("Matching on non-ByRef static")
1460 if alloc.relocations.len() != 0 {
1461 let msg = "statics with a custom `#[link_section]` must be a \
1462 simple list of bytes on the wasm target with no \
1463 extra levels of indirection such as references";
1464 tcx.sess.span_err(span, msg);
1469 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1470 trait_def_id: DefId,
1472 let item_def_id = tcx.hir().local_def_id(item.id);
1473 // an error would be reported if this fails.
1474 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1477 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1478 impl_item: &hir::ImplItem,
1481 let mut err = struct_span_err!(
1482 tcx.sess, impl_item.span, E0520,
1483 "`{}` specializes an item from a parent `impl`, but \
1484 that item is not marked `default`",
1486 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1489 match tcx.span_of_impl(parent_impl) {
1491 err.span_label(span, "parent `impl` is here");
1492 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1496 err.note(&format!("parent implementation is in crate `{}`", cname));
1503 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1504 trait_def: &ty::TraitDef,
1505 trait_item: &ty::AssociatedItem,
1507 impl_item: &hir::ImplItem)
1509 let ancestors = trait_def.ancestors(tcx, impl_id);
1511 let kind = match impl_item.node {
1512 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1513 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1514 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1515 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1518 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1519 .map(|node_item| node_item.map(|parent| parent.defaultness));
1521 if let Some(parent) = parent {
1522 if tcx.impl_item_is_final(&parent) {
1523 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1529 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1532 impl_trait_ref: ty::TraitRef<'tcx>,
1533 impl_item_refs: &[hir::ImplItemRef]) {
1534 let impl_span = tcx.sess.source_map().def_span(impl_span);
1536 // If the trait reference itself is erroneous (so the compilation is going
1537 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1538 // isn't populated for such impls.
1539 if impl_trait_ref.references_error() { return; }
1541 // Locate trait definition and items
1542 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1543 let mut overridden_associated_type = None;
1545 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1547 // Check existing impl methods to see if they are both present in trait
1548 // and compatible with trait signature
1549 for impl_item in impl_items() {
1550 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.id));
1551 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1552 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1553 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1555 // Not compatible, but needed for the error message
1556 tcx.associated_items(impl_trait_ref.def_id)
1557 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1560 // Check that impl definition matches trait definition
1561 if let Some(ty_trait_item) = ty_trait_item {
1562 match impl_item.node {
1563 hir::ImplItemKind::Const(..) => {
1564 // Find associated const definition.
1565 if ty_trait_item.kind == ty::AssociatedKind::Const {
1566 compare_const_impl(tcx,
1572 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1573 "item `{}` is an associated const, \
1574 which doesn't match its trait `{}`",
1577 err.span_label(impl_item.span, "does not match trait");
1578 // We can only get the spans from local trait definition
1579 // Same for E0324 and E0325
1580 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1581 err.span_label(trait_span, "item in trait");
1586 hir::ImplItemKind::Method(..) => {
1587 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1588 if ty_trait_item.kind == ty::AssociatedKind::Method {
1589 compare_impl_method(tcx,
1596 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1597 "item `{}` is an associated method, \
1598 which doesn't match its trait `{}`",
1601 err.span_label(impl_item.span, "does not match trait");
1602 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1603 err.span_label(trait_span, "item in trait");
1608 hir::ImplItemKind::Existential(..) |
1609 hir::ImplItemKind::Type(_) => {
1610 if ty_trait_item.kind == ty::AssociatedKind::Type {
1611 if ty_trait_item.defaultness.has_value() {
1612 overridden_associated_type = Some(impl_item);
1615 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1616 "item `{}` is an associated type, \
1617 which doesn't match its trait `{}`",
1620 err.span_label(impl_item.span, "does not match trait");
1621 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1622 err.span_label(trait_span, "item in trait");
1629 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1633 // Check for missing items from trait
1634 let mut missing_items = Vec::new();
1635 let mut invalidated_items = Vec::new();
1636 let associated_type_overridden = overridden_associated_type.is_some();
1637 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1638 let is_implemented = trait_def.ancestors(tcx, impl_id)
1639 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1641 .map(|node_item| !node_item.node.is_from_trait())
1644 if !is_implemented && !tcx.impl_is_default(impl_id) {
1645 if !trait_item.defaultness.has_value() {
1646 missing_items.push(trait_item);
1647 } else if associated_type_overridden {
1648 invalidated_items.push(trait_item.ident);
1653 if !missing_items.is_empty() {
1654 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1655 "not all trait items implemented, missing: `{}`",
1656 missing_items.iter()
1657 .map(|trait_item| trait_item.ident.to_string())
1658 .collect::<Vec<_>>().join("`, `"));
1659 err.span_label(impl_span, format!("missing `{}` in implementation",
1660 missing_items.iter()
1661 .map(|trait_item| trait_item.ident.to_string())
1662 .collect::<Vec<_>>().join("`, `")));
1663 for trait_item in missing_items {
1664 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1665 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1667 err.note_trait_signature(trait_item.ident.to_string(),
1668 trait_item.signature(&tcx));
1674 if !invalidated_items.is_empty() {
1675 let invalidator = overridden_associated_type.unwrap();
1676 span_err!(tcx.sess, invalidator.span, E0399,
1677 "the following trait items need to be reimplemented \
1678 as `{}` was overridden: `{}`",
1680 invalidated_items.iter()
1681 .map(|name| name.to_string())
1682 .collect::<Vec<_>>().join("`, `"))
1686 /// Checks whether a type can be represented in memory. In particular, it
1687 /// identifies types that contain themselves without indirection through a
1688 /// pointer, which would mean their size is unbounded.
1689 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1693 let rty = tcx.type_of(item_def_id);
1695 // Check that it is possible to represent this type. This call identifies
1696 // (1) types that contain themselves and (2) types that contain a different
1697 // recursive type. It is only necessary to throw an error on those that
1698 // contain themselves. For case 2, there must be an inner type that will be
1699 // caught by case 1.
1700 match rty.is_representable(tcx, sp) {
1701 Representability::SelfRecursive(spans) => {
1702 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1704 err.span_label(span, "recursive without indirection");
1709 Representability::Representable | Representability::ContainsRecursive => (),
1714 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1715 let t = tcx.type_of(def_id);
1716 if let ty::Adt(def, substs) = t.sty {
1717 if def.is_struct() {
1718 let fields = &def.non_enum_variant().fields;
1719 if fields.is_empty() {
1720 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1723 let e = fields[0].ty(tcx, substs);
1724 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1725 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1726 .span_label(sp, "SIMD elements must have the same type")
1731 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1732 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1734 span_err!(tcx.sess, sp, E0077,
1735 "SIMD vector element type should be machine type");
1743 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1744 let repr = tcx.adt_def(def_id).repr;
1746 for attr in tcx.get_attrs(def_id).iter() {
1747 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1748 if let attr::ReprPacked(pack) = r {
1749 if pack != repr.pack {
1750 struct_span_err!(tcx.sess, sp, E0634,
1751 "type has conflicting packed representation hints").emit();
1757 struct_span_err!(tcx.sess, sp, E0587,
1758 "type has conflicting packed and align representation hints").emit();
1760 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1761 struct_span_err!(tcx.sess, sp, E0588,
1762 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1767 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1769 stack: &mut Vec<DefId>) -> bool {
1770 let t = tcx.type_of(def_id);
1771 if stack.contains(&def_id) {
1772 debug!("check_packed_inner: {:?} is recursive", t);
1775 if let ty::Adt(def, substs) = t.sty {
1776 if def.is_struct() || def.is_union() {
1777 if tcx.adt_def(def.did).repr.align > 0 {
1780 // push struct def_id before checking fields
1782 for field in &def.non_enum_variant().fields {
1783 let f = field.ty(tcx, substs);
1784 if let ty::Adt(def, _) = f.sty {
1785 if check_packed_inner(tcx, def.did, stack) {
1790 // only need to pop if not early out
1797 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1798 let adt = tcx.adt_def(def_id);
1799 if !adt.repr.transparent() {
1803 // For each field, figure out if it's known to be a ZST and align(1)
1804 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1805 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1806 let param_env = tcx.param_env(field.did);
1807 let layout = tcx.layout_of(param_env.and(ty));
1808 // We are currently checking the type this field came from, so it must be local
1809 let span = tcx.hir().span_if_local(field.did).unwrap();
1810 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1811 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1815 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1816 let non_zst_count = non_zst_fields.clone().count();
1817 if non_zst_count != 1 {
1818 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1819 struct_span_err!(tcx.sess, sp, E0690,
1820 "transparent struct needs exactly one non-zero-sized field, but has {}",
1822 .span_note(field_spans, "non-zero-sized field")
1825 for (span, zst, align1) in field_infos {
1827 span_err!(tcx.sess, span, E0691,
1828 "zero-sized field in transparent struct has alignment larger than 1");
1833 #[allow(trivial_numeric_casts)]
1834 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1836 vs: &'tcx [hir::Variant],
1838 let def_id = tcx.hir().local_def_id(id);
1839 let def = tcx.adt_def(def_id);
1840 def.destructor(tcx); // force the destructor to be evaluated
1843 let attributes = tcx.get_attrs(def_id);
1844 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1846 tcx.sess, attr.span, E0084,
1847 "unsupported representation for zero-variant enum")
1848 .span_label(sp, "zero-variant enum")
1853 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1854 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1855 if !tcx.features().repr128 {
1856 emit_feature_err(&tcx.sess.parse_sess,
1859 GateIssue::Language,
1860 "repr with 128-bit type is unstable");
1865 if let Some(ref e) = v.node.disr_expr {
1866 tcx.typeck_tables_of(tcx.hir().local_def_id(e.id));
1870 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1871 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1872 // Check for duplicate discriminant values
1873 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1874 let variant_did = def.variants[VariantIdx::new(i)].did;
1875 let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap();
1876 let variant_i = tcx.hir().expect_variant(variant_i_node_id);
1877 let i_span = match variant_i.node.disr_expr {
1878 Some(ref expr) => tcx.hir().span(expr.id),
1879 None => tcx.hir().span(variant_i_node_id)
1881 let span = match v.node.disr_expr {
1882 Some(ref expr) => tcx.hir().span(expr.id),
1885 struct_span_err!(tcx.sess, span, E0081,
1886 "discriminant value `{}` already exists", disr_vals[i])
1887 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1888 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1891 disr_vals.push(discr);
1894 check_representable(tcx, sp, def_id);
1897 fn report_unexpected_variant_def<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1901 span_err!(tcx.sess, span, E0533,
1902 "expected unit struct/variant or constant, found {} `{}`",
1904 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1907 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1908 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1910 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1911 -> Lrc<ty::GenericPredicates<'tcx>>
1914 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
1915 let item_id = tcx.hir().ty_param_owner(node_id);
1916 let item_def_id = tcx.hir().local_def_id(item_id);
1917 let generics = tcx.generics_of(item_def_id);
1918 let index = generics.param_def_id_to_index[&def_id];
1919 Lrc::new(ty::GenericPredicates {
1921 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1923 ty::Predicate::Trait(ref data)
1924 if data.skip_binder().self_ty().is_param(index) => {
1925 // HACK(eddyb) should get the original `Span`.
1926 let span = tcx.def_span(def_id);
1927 Some((predicate, span))
1935 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1936 -> Option<ty::Region<'tcx>> {
1938 Some(def) => infer::EarlyBoundRegion(span, def.name),
1939 None => infer::MiscVariable(span)
1941 Some(self.next_region_var(v))
1944 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1945 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1948 fn ty_infer_for_def(&self,
1949 ty_param_def: &ty::GenericParamDef,
1950 span: Span) -> Ty<'tcx> {
1951 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1957 fn projected_ty_from_poly_trait_ref(&self,
1960 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1963 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1965 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1969 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1972 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1973 if ty.has_escaping_bound_vars() {
1974 ty // FIXME: normalization and escaping regions
1976 self.normalize_associated_types_in(span, &ty)
1980 fn set_tainted_by_errors(&self) {
1981 self.infcx.set_tainted_by_errors()
1984 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1985 self.write_ty(hir_id, ty)
1989 /// Controls whether the arguments are tupled. This is used for the call
1992 /// Tupling means that all call-side arguments are packed into a tuple and
1993 /// passed as a single parameter. For example, if tupling is enabled, this
1996 /// fn f(x: (isize, isize))
1998 /// Can be called as:
2005 #[derive(Clone, Eq, PartialEq)]
2006 enum TupleArgumentsFlag {
2011 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2012 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2013 param_env: ty::ParamEnv<'tcx>,
2014 body_id: ast::NodeId)
2015 -> FnCtxt<'a, 'gcx, 'tcx> {
2019 err_count_on_creation: inh.tcx.sess.err_count(),
2021 ret_coercion_span: RefCell::new(None),
2023 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2024 ast::CRATE_NODE_ID)),
2025 diverges: Cell::new(Diverges::Maybe),
2026 has_errors: Cell::new(false),
2027 enclosing_breakables: RefCell::new(EnclosingBreakables {
2029 by_id: Default::default(),
2035 pub fn sess(&self) -> &Session {
2039 pub fn err_count_since_creation(&self) -> usize {
2040 self.tcx.sess.err_count() - self.err_count_on_creation
2043 /// Produce warning on the given node, if the current point in the
2044 /// function is unreachable, and there hasn't been another warning.
2045 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2046 if self.diverges.get() == Diverges::Always {
2047 self.diverges.set(Diverges::WarnedAlways);
2049 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2051 self.tcx().lint_node(
2052 lint::builtin::UNREACHABLE_CODE,
2054 &format!("unreachable {}", kind));
2060 code: ObligationCauseCode<'tcx>)
2061 -> ObligationCause<'tcx> {
2062 ObligationCause::new(span, self.body_id, code)
2065 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2066 self.cause(span, ObligationCauseCode::MiscObligation)
2069 /// Resolves type variables in `ty` if possible. Unlike the infcx
2070 /// version (resolve_type_vars_if_possible), this version will
2071 /// also select obligations if it seems useful, in an effort
2072 /// to get more type information.
2073 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2074 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2076 // No Infer()? Nothing needs doing.
2077 if !ty.has_infer_types() {
2078 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2082 // If `ty` is a type variable, see whether we already know what it is.
2083 ty = self.resolve_type_vars_if_possible(&ty);
2084 if !ty.has_infer_types() {
2085 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2089 // If not, try resolving pending obligations as much as
2090 // possible. This can help substantially when there are
2091 // indirect dependencies that don't seem worth tracking
2093 self.select_obligations_where_possible(false);
2094 ty = self.resolve_type_vars_if_possible(&ty);
2096 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2100 fn record_deferred_call_resolution(&self,
2101 closure_def_id: DefId,
2102 r: DeferredCallResolution<'gcx, 'tcx>) {
2103 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2104 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2107 fn remove_deferred_call_resolutions(&self,
2108 closure_def_id: DefId)
2109 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2111 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2112 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2115 pub fn tag(&self) -> String {
2116 let self_ptr: *const FnCtxt = self;
2117 format!("{:?}", self_ptr)
2120 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2121 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2122 span_bug!(span, "no type for local variable {}",
2123 self.tcx.hir().node_to_string(nid))
2128 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2129 debug!("write_ty({:?}, {:?}) in fcx {}",
2130 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2131 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2133 if ty.references_error() {
2134 self.has_errors.set(true);
2135 self.set_tainted_by_errors();
2139 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2140 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
2141 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2144 pub fn write_method_call(&self,
2146 method: MethodCallee<'tcx>) {
2147 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2150 .type_dependent_defs_mut()
2151 .insert(hir_id, Def::Method(method.def_id));
2153 self.write_substs(hir_id, method.substs);
2155 // When the method is confirmed, the `method.substs` includes
2156 // parameters from not just the method, but also the impl of
2157 // the method -- in particular, the `Self` type will be fully
2158 // resolved. However, those are not something that the "user
2159 // specified" -- i.e., those types come from the inferred type
2160 // of the receiver, not something the user wrote. So when we
2161 // create the user-substs, we want to replace those earlier
2162 // types with just the types that the user actually wrote --
2163 // that is, those that appear on the *method itself*.
2165 // As an example, if the user wrote something like
2166 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2167 // type of `foo` (possibly adjusted), but we don't want to
2168 // include that. We want just the `[_, u32]` part.
2169 if !method.substs.is_noop() {
2170 let method_generics = self.tcx.generics_of(method.def_id);
2171 if !method_generics.params.is_empty() {
2172 let user_type_annotation = self.infcx.probe(|_| {
2173 let user_substs = UserSubsts {
2174 substs: Substs::for_item(self.tcx, method.def_id, |param, _| {
2175 let i = param.index as usize;
2176 if i < method_generics.parent_count {
2177 self.infcx.var_for_def(DUMMY_SP, param)
2182 user_self_ty: None, // not relevant here
2185 self.infcx.canonicalize_user_type_annotation(&UserTypeAnnotation::TypeOf(
2191 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2192 self.write_user_type_annotation(hir_id, user_type_annotation);
2197 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2198 if !substs.is_noop() {
2199 debug!("write_substs({:?}, {:?}) in fcx {}",
2204 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2208 /// Given the substs that we just converted from the HIR, try to
2209 /// canonicalize them and store them as user-given substitutions
2210 /// (i.e., substitutions that must be respected by the NLL check).
2212 /// This should be invoked **before any unifications have
2213 /// occurred**, so that annotations like `Vec<_>` are preserved
2215 pub fn write_user_type_annotation_from_substs(
2219 substs: &'tcx Substs<'tcx>,
2220 user_self_ty: Option<UserSelfTy<'tcx>>,
2223 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2224 user_self_ty={:?} in fcx {}",
2225 hir_id, def_id, substs, user_self_ty, self.tag(),
2228 if !substs.is_noop() {
2229 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2230 &UserTypeAnnotation::TypeOf(def_id, UserSubsts {
2235 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2236 self.write_user_type_annotation(hir_id, canonicalized);
2240 pub fn write_user_type_annotation(
2243 canonical_user_type_annotation: CanonicalUserTypeAnnotation<'tcx>,
2246 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2247 hir_id, canonical_user_type_annotation, self.tag(),
2250 if !canonical_user_type_annotation.is_identity() {
2251 self.tables.borrow_mut().user_provided_types_mut().insert(
2252 hir_id, canonical_user_type_annotation
2255 debug!("write_user_type_annotation: skipping identity substs");
2259 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2260 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2266 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2267 Entry::Vacant(entry) => { entry.insert(adj); },
2268 Entry::Occupied(mut entry) => {
2269 debug!(" - composing on top of {:?}", entry.get());
2270 match (&entry.get()[..], &adj[..]) {
2271 // Applying any adjustment on top of a NeverToAny
2272 // is a valid NeverToAny adjustment, because it can't
2274 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2276 Adjustment { kind: Adjust::Deref(_), .. },
2277 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2279 Adjustment { kind: Adjust::Deref(_), .. },
2280 .. // Any following adjustments are allowed.
2282 // A reborrow has no effect before a dereference.
2284 // FIXME: currently we never try to compose autoderefs
2285 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2287 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2288 expr, entry.get(), adj)
2290 *entry.get_mut() = adj;
2295 /// Basically whenever we are converting from a type scheme into
2296 /// the fn body space, we always want to normalize associated
2297 /// types as well. This function combines the two.
2298 fn instantiate_type_scheme<T>(&self,
2300 substs: &Substs<'tcx>,
2303 where T : TypeFoldable<'tcx>
2305 let value = value.subst(self.tcx, substs);
2306 let result = self.normalize_associated_types_in(span, &value);
2307 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2314 /// As `instantiate_type_scheme`, but for the bounds found in a
2315 /// generic type scheme.
2316 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2317 -> ty::InstantiatedPredicates<'tcx> {
2318 let bounds = self.tcx.predicates_of(def_id);
2319 let result = bounds.instantiate(self.tcx, substs);
2320 let result = self.normalize_associated_types_in(span, &result);
2321 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2328 /// Replace the opaque types from the given value with type variables,
2329 /// and records the `OpaqueTypeMap` for later use during writeback. See
2330 /// `InferCtxt::instantiate_opaque_types` for more details.
2331 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2333 parent_id: ast::NodeId,
2336 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2337 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2341 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2342 self.instantiate_opaque_types(
2350 let mut opaque_types = self.opaque_types.borrow_mut();
2351 for (ty, decl) in opaque_type_map {
2352 let old_value = opaque_types.insert(ty, decl);
2353 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2359 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2360 where T : TypeFoldable<'tcx>
2362 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2365 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2367 where T : TypeFoldable<'tcx>
2369 self.inh.partially_normalize_associated_types_in(span,
2375 pub fn require_type_meets(&self,
2378 code: traits::ObligationCauseCode<'tcx>,
2381 self.register_bound(
2384 traits::ObligationCause::new(span, self.body_id, code));
2387 pub fn require_type_is_sized(&self,
2390 code: traits::ObligationCauseCode<'tcx>)
2392 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2393 self.require_type_meets(ty, span, code, lang_item);
2396 pub fn require_type_is_sized_deferred(&self,
2399 code: traits::ObligationCauseCode<'tcx>)
2401 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2404 pub fn register_bound(&self,
2407 cause: traits::ObligationCause<'tcx>)
2409 self.fulfillment_cx.borrow_mut()
2410 .register_bound(self, self.param_env, ty, def_id, cause);
2413 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2414 let t = AstConv::ast_ty_to_ty(self, ast_t);
2415 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2419 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2420 let ty = self.to_ty(ast_ty);
2421 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2423 // If the type given by the user has free regions, save it for
2424 // later, since NLL would like to enforce those. Also pass in
2425 // types that involve projections, since those can resolve to
2426 // `'static` bounds (modulo #54940, which hopefully will be
2427 // fixed by the time you see this comment, dear reader,
2428 // although I have my doubts). Other sorts of things are
2429 // already sufficiently enforced with erased regions. =)
2430 if ty.has_free_regions() || ty.has_projections() {
2431 let c_ty = self.infcx.canonicalize_response(&UserTypeAnnotation::Ty(ty));
2432 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2433 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2439 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2440 match self.tables.borrow().node_types().get(id) {
2442 None if self.is_tainted_by_errors() => self.tcx.types.err,
2444 let node_id = self.tcx.hir().hir_to_node_id(id);
2445 bug!("no type for node {}: {} in fcx {}",
2446 node_id, self.tcx.hir().node_to_string(node_id),
2452 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2453 /// outlive the region `r`.
2454 pub fn register_wf_obligation(&self,
2457 code: traits::ObligationCauseCode<'tcx>)
2459 // WF obligations never themselves fail, so no real need to give a detailed cause:
2460 let cause = traits::ObligationCause::new(span, self.body_id, code);
2461 self.register_predicate(traits::Obligation::new(cause,
2463 ty::Predicate::WellFormed(ty)));
2466 /// Registers obligations that all types appearing in `substs` are well-formed.
2467 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2468 for ty in substs.types() {
2469 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2473 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2474 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2475 /// trait/region obligations.
2477 /// For example, if there is a function:
2480 /// fn foo<'a,T:'a>(...)
2483 /// and a reference:
2489 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2490 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2491 pub fn add_obligations_for_parameters(&self,
2492 cause: traits::ObligationCause<'tcx>,
2493 predicates: &ty::InstantiatedPredicates<'tcx>)
2495 assert!(!predicates.has_escaping_bound_vars());
2497 debug!("add_obligations_for_parameters(predicates={:?})",
2500 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2501 self.register_predicate(obligation);
2505 // FIXME(arielb1): use this instead of field.ty everywhere
2506 // Only for fields! Returns <none> for methods>
2507 // Indifferent to privacy flags
2508 pub fn field_ty(&self,
2510 field: &'tcx ty::FieldDef,
2511 substs: &Substs<'tcx>)
2514 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2517 fn check_casts(&self) {
2518 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2519 for cast in deferred_cast_checks.drain(..) {
2524 fn resolve_generator_interiors(&self, def_id: DefId) {
2525 let mut generators = self.deferred_generator_interiors.borrow_mut();
2526 for (body_id, interior) in generators.drain(..) {
2527 self.select_obligations_where_possible(false);
2528 generator_interior::resolve_interior(self, def_id, body_id, interior);
2532 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2533 // Non-numerics get replaced with ! or () (depending on whether
2534 // feature(never_type) is enabled, unconstrained ints with i32,
2535 // unconstrained floats with f64.
2536 // Fallback becomes very dubious if we have encountered type-checking errors.
2537 // In that case, fallback to Error.
2538 // The return value indicates whether fallback has occurred.
2539 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2540 use rustc::ty::error::UnconstrainedNumeric::Neither;
2541 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2543 assert!(ty.is_ty_infer());
2544 let fallback = match self.type_is_unconstrained_numeric(ty) {
2545 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2546 UnconstrainedInt => self.tcx.types.i32,
2547 UnconstrainedFloat => self.tcx.types.f64,
2548 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2549 Neither => return false,
2551 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2552 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2556 fn select_all_obligations_or_error(&self) {
2557 debug!("select_all_obligations_or_error");
2558 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2559 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2563 /// Select as many obligations as we can at present.
2564 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2565 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2566 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2570 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2571 /// returns a type of `&T`, but the actual type we assign to the
2572 /// *expression* is `T`. So this function just peels off the return
2573 /// type by one layer to yield `T`.
2574 fn make_overloaded_place_return_type(&self,
2575 method: MethodCallee<'tcx>)
2576 -> ty::TypeAndMut<'tcx>
2578 // extract method return type, which will be &T;
2579 let ret_ty = method.sig.output();
2581 // method returns &T, but the type as visible to user is T, so deref
2582 ret_ty.builtin_deref(true).unwrap()
2585 fn lookup_indexing(&self,
2587 base_expr: &'gcx hir::Expr,
2591 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2593 // FIXME(#18741) -- this is almost but not quite the same as the
2594 // autoderef that normal method probing does. They could likely be
2597 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2598 let mut result = None;
2599 while result.is_none() && autoderef.next().is_some() {
2600 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2602 autoderef.finalize(self);
2606 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2607 /// (and otherwise adjust) `base_expr`, looking for a type which either
2608 /// supports builtin indexing or overloaded indexing.
2609 /// This loop implements one step in that search; the autoderef loop
2610 /// is implemented by `lookup_indexing`.
2611 fn try_index_step(&self,
2613 base_expr: &hir::Expr,
2614 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2617 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2619 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2620 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2627 for &unsize in &[false, true] {
2628 let mut self_ty = adjusted_ty;
2630 // We only unsize arrays here.
2631 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2632 self_ty = self.tcx.mk_slice(element_ty);
2638 // If some lookup succeeds, write callee into table and extract index/element
2639 // type from the method signature.
2640 // If some lookup succeeded, install method in table
2641 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2642 let method = self.try_overloaded_place_op(
2643 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2645 let result = method.map(|ok| {
2646 debug!("try_index_step: success, using overloaded indexing");
2647 let method = self.register_infer_ok_obligations(ok);
2649 let mut adjustments = autoderef.adjust_steps(self, needs);
2650 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2651 let mutbl = match r_mutbl {
2652 hir::MutImmutable => AutoBorrowMutability::Immutable,
2653 hir::MutMutable => AutoBorrowMutability::Mutable {
2654 // Indexing can be desugared to a method call,
2655 // so maybe we could use two-phase here.
2656 // See the documentation of AllowTwoPhase for why that's
2657 // not the case today.
2658 allow_two_phase_borrow: AllowTwoPhase::No,
2661 adjustments.push(Adjustment {
2662 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2663 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2670 adjustments.push(Adjustment {
2671 kind: Adjust::Unsize,
2672 target: method.sig.inputs()[0]
2675 self.apply_adjustments(base_expr, adjustments);
2677 self.write_method_call(expr.hir_id, method);
2678 (input_ty, self.make_overloaded_place_return_type(method).ty)
2680 if result.is_some() {
2688 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2689 let (tr, name) = match (op, is_mut) {
2690 (PlaceOp::Deref, false) =>
2691 (self.tcx.lang_items().deref_trait(), "deref"),
2692 (PlaceOp::Deref, true) =>
2693 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2694 (PlaceOp::Index, false) =>
2695 (self.tcx.lang_items().index_trait(), "index"),
2696 (PlaceOp::Index, true) =>
2697 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2699 (tr, ast::Ident::from_str(name))
2702 fn try_overloaded_place_op(&self,
2705 arg_tys: &[Ty<'tcx>],
2708 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2710 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2716 // Try Mut first, if needed.
2717 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2718 let method = match (needs, mut_tr) {
2719 (Needs::MutPlace, Some(trait_did)) => {
2720 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2725 // Otherwise, fall back to the immutable version.
2726 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2727 let method = match (method, imm_tr) {
2728 (None, Some(trait_did)) => {
2729 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2731 (method, _) => method,
2737 fn check_method_argument_types(&self,
2740 method: Result<MethodCallee<'tcx>, ()>,
2741 args_no_rcvr: &'gcx [hir::Expr],
2742 tuple_arguments: TupleArgumentsFlag,
2743 expected: Expectation<'tcx>)
2745 let has_error = match method {
2747 method.substs.references_error() || method.sig.references_error()
2752 let err_inputs = self.err_args(args_no_rcvr.len());
2754 let err_inputs = match tuple_arguments {
2755 DontTupleArguments => err_inputs,
2756 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2759 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2760 false, tuple_arguments, None);
2761 return self.tcx.types.err;
2764 let method = method.unwrap();
2765 // HACK(eddyb) ignore self in the definition (see above).
2766 let expected_arg_tys = self.expected_inputs_for_expected_output(
2769 method.sig.output(),
2770 &method.sig.inputs()[1..]
2772 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2773 args_no_rcvr, method.sig.variadic, tuple_arguments,
2774 self.tcx.hir().span_if_local(method.def_id));
2778 fn self_type_matches_expected_vid(
2780 trait_ref: ty::PolyTraitRef<'tcx>,
2781 expected_vid: ty::TyVid,
2783 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2785 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2786 trait_ref, self_ty, expected_vid
2789 ty::Infer(ty::TyVar(found_vid)) => {
2790 // FIXME: consider using `sub_root_var` here so we
2791 // can see through subtyping.
2792 let found_vid = self.root_var(found_vid);
2793 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2794 expected_vid == found_vid
2800 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2801 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2802 + Captures<'gcx> + 'b
2804 // FIXME: consider using `sub_root_var` here so we
2805 // can see through subtyping.
2806 let ty_var_root = self.root_var(self_ty);
2807 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2808 self_ty, ty_var_root,
2809 self.fulfillment_cx.borrow().pending_obligations());
2813 .pending_obligations()
2815 .filter_map(move |obligation| match obligation.predicate {
2816 ty::Predicate::Projection(ref data) =>
2817 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2818 ty::Predicate::Trait(ref data) =>
2819 Some((data.to_poly_trait_ref(), obligation)),
2820 ty::Predicate::Subtype(..) => None,
2821 ty::Predicate::RegionOutlives(..) => None,
2822 ty::Predicate::TypeOutlives(..) => None,
2823 ty::Predicate::WellFormed(..) => None,
2824 ty::Predicate::ObjectSafe(..) => None,
2825 ty::Predicate::ConstEvaluatable(..) => None,
2826 // N.B., this predicate is created by breaking down a
2827 // `ClosureType: FnFoo()` predicate, where
2828 // `ClosureType` represents some `Closure`. It can't
2829 // possibly be referring to the current closure,
2830 // because we haven't produced the `Closure` for
2831 // this closure yet; this is exactly why the other
2832 // code is looking for a self type of a unresolved
2833 // inference variable.
2834 ty::Predicate::ClosureKind(..) => None,
2835 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2838 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2839 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2840 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2844 /// Generic function that factors out common logic from function calls,
2845 /// method calls and overloaded operators.
2846 fn check_argument_types(&self,
2849 fn_inputs: &[Ty<'tcx>],
2850 mut expected_arg_tys: &[Ty<'tcx>],
2851 args: &'gcx [hir::Expr],
2853 tuple_arguments: TupleArgumentsFlag,
2854 def_span: Option<Span>) {
2857 // Grab the argument types, supplying fresh type variables
2858 // if the wrong number of arguments were supplied
2859 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2865 // All the input types from the fn signature must outlive the call
2866 // so as to validate implied bounds.
2867 for &fn_input_ty in fn_inputs {
2868 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2871 let expected_arg_count = fn_inputs.len();
2873 let param_count_error = |expected_count: usize,
2878 let mut err = tcx.sess.struct_span_err_with_code(sp,
2879 &format!("this function takes {}{} but {} {} supplied",
2880 if variadic {"at least "} else {""},
2881 potentially_plural_count(expected_count, "parameter"),
2882 potentially_plural_count(arg_count, "parameter"),
2883 if arg_count == 1 {"was"} else {"were"}),
2884 DiagnosticId::Error(error_code.to_owned()));
2886 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2887 err.span_label(def_s, "defined here");
2890 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2891 // remove closing `)` from the span
2892 let sugg_span = sugg_span.shrink_to_lo();
2893 err.span_suggestion_with_applicability(
2895 "expected the unit value `()`; create it with empty parentheses",
2897 Applicability::MachineApplicable);
2899 err.span_label(sp, format!("expected {}{}",
2900 if variadic {"at least "} else {""},
2901 potentially_plural_count(expected_count, "parameter")));
2906 let formal_tys = if tuple_arguments == TupleArguments {
2907 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2908 match tuple_type.sty {
2909 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2910 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2911 expected_arg_tys = &[];
2912 self.err_args(args.len())
2914 ty::Tuple(arg_types) => {
2915 expected_arg_tys = match expected_arg_tys.get(0) {
2916 Some(&ty) => match ty.sty {
2917 ty::Tuple(ref tys) => &tys,
2925 span_err!(tcx.sess, sp, E0059,
2926 "cannot use call notation; the first type parameter \
2927 for the function trait is neither a tuple nor unit");
2928 expected_arg_tys = &[];
2929 self.err_args(args.len())
2932 } else if expected_arg_count == supplied_arg_count {
2934 } else if variadic {
2935 if supplied_arg_count >= expected_arg_count {
2938 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2939 expected_arg_tys = &[];
2940 self.err_args(supplied_arg_count)
2943 // is the missing argument of type `()`?
2944 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2945 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2946 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2947 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2951 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2953 expected_arg_tys = &[];
2954 self.err_args(supplied_arg_count)
2956 // If there is no expectation, expect formal_tys.
2957 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2963 debug!("check_argument_types: formal_tys={:?}",
2964 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2966 // Check the arguments.
2967 // We do this in a pretty awful way: first we type-check any arguments
2968 // that are not closures, then we type-check the closures. This is so
2969 // that we have more information about the types of arguments when we
2970 // type-check the functions. This isn't really the right way to do this.
2971 for &check_closures in &[false, true] {
2972 debug!("check_closures={}", check_closures);
2974 // More awful hacks: before we check argument types, try to do
2975 // an "opportunistic" vtable resolution of any trait bounds on
2976 // the call. This helps coercions.
2978 self.select_obligations_where_possible(false);
2981 // For variadic functions, we don't have a declared type for all of
2982 // the arguments hence we only do our usual type checking with
2983 // the arguments who's types we do know.
2984 let t = if variadic {
2986 } else if tuple_arguments == TupleArguments {
2991 for (i, arg) in args.iter().take(t).enumerate() {
2992 // Warn only for the first loop (the "no closures" one).
2993 // Closure arguments themselves can't be diverging, but
2994 // a previous argument can, e.g., `foo(panic!(), || {})`.
2995 if !check_closures {
2996 self.warn_if_unreachable(arg.id, arg.span, "expression");
2999 let is_closure = match arg.node {
3000 ExprKind::Closure(..) => true,
3004 if is_closure != check_closures {
3008 debug!("checking the argument");
3009 let formal_ty = formal_tys[i];
3011 // The special-cased logic below has three functions:
3012 // 1. Provide as good of an expected type as possible.
3013 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3015 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3017 // 2. Coerce to the most detailed type that could be coerced
3018 // to, which is `expected_ty` if `rvalue_hint` returns an
3019 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3020 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3021 // We're processing function arguments so we definitely want to use
3022 // two-phase borrows.
3023 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3025 // 3. Relate the expected type and the formal one,
3026 // if the expected type was used for the coercion.
3027 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3031 // We also need to make sure we at least write the ty of the other
3032 // arguments which we skipped above.
3034 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3035 use structured_errors::{VariadicError, StructuredDiagnostic};
3036 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3039 for arg in args.iter().skip(expected_arg_count) {
3040 let arg_ty = self.check_expr(&arg);
3042 // There are a few types which get autopromoted when passed via varargs
3043 // in C but we just error out instead and require explicit casts.
3044 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3046 ty::Float(ast::FloatTy::F32) => {
3047 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3049 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3050 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3052 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3053 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3056 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3057 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3058 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3066 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3067 vec![self.tcx.types.err; len]
3070 // AST fragment checking
3073 expected: Expectation<'tcx>)
3079 ast::LitKind::Str(..) => tcx.mk_static_str(),
3080 ast::LitKind::ByteStr(ref v) => {
3081 tcx.mk_imm_ref(tcx.types.re_static,
3082 tcx.mk_array(tcx.types.u8, v.len() as u64))
3084 ast::LitKind::Byte(_) => tcx.types.u8,
3085 ast::LitKind::Char(_) => tcx.types.char,
3086 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3087 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3088 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3089 let opt_ty = expected.to_option(self).and_then(|ty| {
3091 ty::Int(_) | ty::Uint(_) => Some(ty),
3092 ty::Char => Some(tcx.types.u8),
3093 ty::RawPtr(..) => Some(tcx.types.usize),
3094 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3098 opt_ty.unwrap_or_else(
3099 || tcx.mk_int_var(self.next_int_var_id()))
3101 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3102 ast::LitKind::FloatUnsuffixed(_) => {
3103 let opt_ty = expected.to_option(self).and_then(|ty| {
3105 ty::Float(_) => Some(ty),
3109 opt_ty.unwrap_or_else(
3110 || tcx.mk_float_var(self.next_float_var_id()))
3112 ast::LitKind::Bool(_) => tcx.types.bool
3116 fn check_expr_eq_type(&self,
3117 expr: &'gcx hir::Expr,
3118 expected: Ty<'tcx>) {
3119 let ty = self.check_expr_with_hint(expr, expected);
3120 self.demand_eqtype(expr.span, expected, ty);
3123 pub fn check_expr_has_type_or_error(&self,
3124 expr: &'gcx hir::Expr,
3125 expected: Ty<'tcx>) -> Ty<'tcx> {
3126 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3129 fn check_expr_meets_expectation_or_error(&self,
3130 expr: &'gcx hir::Expr,
3131 expected: Expectation<'tcx>) -> Ty<'tcx> {
3132 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3133 let mut ty = self.check_expr_with_expectation(expr, expected);
3135 // While we don't allow *arbitrary* coercions here, we *do* allow
3136 // coercions from ! to `expected`.
3138 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3139 "expression with never type wound up being adjusted");
3140 let adj_ty = self.next_diverging_ty_var(
3141 TypeVariableOrigin::AdjustmentType(expr.span));
3142 self.apply_adjustments(expr, vec![Adjustment {
3143 kind: Adjust::NeverToAny,
3149 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3150 // Add help to type error if this is an `if` condition with an assignment.
3151 if let (ExpectIfCondition, &ExprKind::Assign(ref lhs, ref rhs))
3152 = (expected, &expr.node)
3154 let msg = "try comparing for equality";
3155 if let (Ok(left), Ok(right)) = (
3156 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3157 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3159 err.span_suggestion_with_applicability(
3162 format!("{} == {}", left, right),
3163 Applicability::MaybeIncorrect);
3173 fn check_expr_coercable_to_type(&self,
3174 expr: &'gcx hir::Expr,
3175 expected: Ty<'tcx>) -> Ty<'tcx> {
3176 let ty = self.check_expr_with_hint(expr, expected);
3177 // checks don't need two phase
3178 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3181 fn check_expr_with_hint(&self,
3182 expr: &'gcx hir::Expr,
3183 expected: Ty<'tcx>) -> Ty<'tcx> {
3184 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3187 fn check_expr_with_expectation(&self,
3188 expr: &'gcx hir::Expr,
3189 expected: Expectation<'tcx>) -> Ty<'tcx> {
3190 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3193 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3194 self.check_expr_with_expectation(expr, NoExpectation)
3197 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3198 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3201 // Determine the `Self` type, using fresh variables for all variables
3202 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3203 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3205 pub fn impl_self_ty(&self,
3206 span: Span, // (potential) receiver for this impl
3208 -> TypeAndSubsts<'tcx> {
3209 let ity = self.tcx.type_of(did);
3210 debug!("impl_self_ty: ity={:?}", ity);
3212 let substs = self.fresh_substs_for_item(span, did);
3213 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3215 TypeAndSubsts { substs: substs, ty: substd_ty }
3218 /// Unifies the output type with the expected type early, for more coercions
3219 /// and forward type information on the input expressions.
3220 fn expected_inputs_for_expected_output(&self,
3222 expected_ret: Expectation<'tcx>,
3223 formal_ret: Ty<'tcx>,
3224 formal_args: &[Ty<'tcx>])
3226 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3227 let ret_ty = match expected_ret.only_has_type(self) {
3229 None => return Vec::new()
3231 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3232 // Attempt to apply a subtyping relationship between the formal
3233 // return type (likely containing type variables if the function
3234 // is polymorphic) and the expected return type.
3235 // No argument expectations are produced if unification fails.
3236 let origin = self.misc(call_span);
3237 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3239 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3240 // to identity so the resulting type is not constrained.
3243 // Process any obligations locally as much as
3244 // we can. We don't care if some things turn
3245 // out unconstrained or ambiguous, as we're
3246 // just trying to get hints here.
3247 self.save_and_restore_in_snapshot_flag(|_| {
3248 let mut fulfill = TraitEngine::new(self.tcx);
3249 for obligation in ok.obligations {
3250 fulfill.register_predicate_obligation(self, obligation);
3252 fulfill.select_where_possible(self)
3253 }).map_err(|_| ())?;
3255 Err(_) => return Err(()),
3258 // Record all the argument types, with the substitutions
3259 // produced from the above subtyping unification.
3260 Ok(formal_args.iter().map(|ty| {
3261 self.resolve_type_vars_if_possible(ty)
3263 }).unwrap_or_default();
3264 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3265 formal_args, formal_ret,
3266 expect_args, expected_ret);
3270 // Checks a method call.
3271 fn check_method_call(&self,
3272 expr: &'gcx hir::Expr,
3273 segment: &hir::PathSegment,
3275 args: &'gcx [hir::Expr],
3276 expected: Expectation<'tcx>,
3277 needs: Needs) -> Ty<'tcx> {
3278 let rcvr = &args[0];
3279 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3280 // no need to check for bot/err -- callee does that
3281 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3283 let method = match self.lookup_method(rcvr_t,
3289 self.write_method_call(expr.hir_id, method);
3293 if segment.ident.name != keywords::Invalid.name() {
3294 self.report_method_error(span,
3297 SelfSource::MethodCall(rcvr),
3305 // Call the generic checker.
3306 self.check_method_argument_types(span,
3314 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3318 .unwrap_or_else(|| span_bug!(return_expr.span,
3319 "check_return_expr called outside fn body"));
3321 let ret_ty = ret_coercion.borrow().expected_ty();
3322 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3323 ret_coercion.borrow_mut()
3325 &self.cause(return_expr.span,
3326 ObligationCauseCode::ReturnType(return_expr.id)),
3331 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3332 // or 'if-else' expression.
3333 fn check_then_else(&self,
3334 cond_expr: &'gcx hir::Expr,
3335 then_expr: &'gcx hir::Expr,
3336 opt_else_expr: Option<&'gcx hir::Expr>,
3338 expected: Expectation<'tcx>) -> Ty<'tcx> {
3339 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3340 let cond_diverges = self.diverges.get();
3341 self.diverges.set(Diverges::Maybe);
3343 let expected = expected.adjust_for_branches(self);
3344 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3345 let then_diverges = self.diverges.get();
3346 self.diverges.set(Diverges::Maybe);
3348 // We've already taken the expected type's preferences
3349 // into account when typing the `then` branch. To figure
3350 // out the initial shot at a LUB, we thus only consider
3351 // `expected` if it represents a *hard* constraint
3352 // (`only_has_type`); otherwise, we just go with a
3353 // fresh type variable.
3354 let coerce_to_ty = expected.coercion_target_type(self, sp);
3355 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3357 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3358 coerce.coerce(self, &if_cause, then_expr, then_ty);
3360 if let Some(else_expr) = opt_else_expr {
3361 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3362 let else_diverges = self.diverges.get();
3364 coerce.coerce(self, &if_cause, else_expr, else_ty);
3366 // We won't diverge unless both branches do (or the condition does).
3367 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3369 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3370 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3372 // If the condition is false we can't diverge.
3373 self.diverges.set(cond_diverges);
3376 let result_ty = coerce.complete(self);
3377 if cond_ty.references_error() {
3384 // Check field access expressions
3385 fn check_field(&self,
3386 expr: &'gcx hir::Expr,
3388 base: &'gcx hir::Expr,
3389 field: ast::Ident) -> Ty<'tcx> {
3390 let expr_t = self.check_expr_with_needs(base, needs);
3391 let expr_t = self.structurally_resolved_type(base.span,
3393 let mut private_candidate = None;
3394 let mut autoderef = self.autoderef(expr.span, expr_t);
3395 while let Some((base_t, _)) = autoderef.next() {
3397 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3398 debug!("struct named {:?}", base_t);
3399 let (ident, def_scope) =
3400 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3401 let fields = &base_def.non_enum_variant().fields;
3402 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3403 let field = &fields[index];
3404 let field_ty = self.field_ty(expr.span, field, substs);
3405 // Save the index of all fields regardless of their visibility in case
3406 // of error recovery.
3407 self.write_field_index(expr.id, index);
3408 if field.vis.is_accessible_from(def_scope, self.tcx) {
3409 let adjustments = autoderef.adjust_steps(self, needs);
3410 self.apply_adjustments(base, adjustments);
3411 autoderef.finalize(self);
3413 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3416 private_candidate = Some((base_def.did, field_ty));
3419 ty::Tuple(ref tys) => {
3420 let fstr = field.as_str();
3421 if let Ok(index) = fstr.parse::<usize>() {
3422 if fstr == index.to_string() {
3423 if let Some(field_ty) = tys.get(index) {
3424 let adjustments = autoderef.adjust_steps(self, needs);
3425 self.apply_adjustments(base, adjustments);
3426 autoderef.finalize(self);
3428 self.write_field_index(expr.id, index);
3437 autoderef.unambiguous_final_ty(self);
3439 if let Some((did, field_ty)) = private_candidate {
3440 let struct_path = self.tcx().item_path_str(did);
3441 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3442 "field `{}` of struct `{}` is private",
3443 field, struct_path);
3444 // Also check if an accessible method exists, which is often what is meant.
3445 if self.method_exists(field, expr_t, expr.id, false) {
3446 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3450 } else if field.name == keywords::Invalid.name() {
3451 self.tcx().types.err
3452 } else if self.method_exists(field, expr_t, expr.id, true) {
3453 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3454 "attempted to take value of method `{}` on type `{}`",
3456 .help("maybe a `()` to call it is missing?")
3458 self.tcx().types.err
3460 if !expr_t.is_primitive_ty() {
3461 let mut err = self.no_such_field_err(field.span, field, expr_t);
3464 ty::Adt(def, _) if !def.is_enum() => {
3465 if let Some(suggested_field_name) =
3466 Self::suggest_field_name(def.non_enum_variant(),
3467 &field.as_str(), vec![]) {
3468 err.span_suggestion_with_applicability(
3470 "a field with a similar name exists",
3471 suggested_field_name.to_string(),
3472 Applicability::MaybeIncorrect,
3475 err.span_label(field.span, "unknown field");
3476 let struct_variant_def = def.non_enum_variant();
3477 let field_names = self.available_field_names(struct_variant_def);
3478 if !field_names.is_empty() {
3479 err.note(&format!("available fields are: {}",
3480 self.name_series_display(field_names)));
3484 ty::Array(_, len) => {
3485 if let (Some(len), Ok(user_index)) = (
3486 len.assert_usize(self.tcx),
3487 field.as_str().parse::<u64>()
3489 let base = self.tcx.sess.source_map()
3490 .span_to_snippet(base.span)
3491 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3492 let help = "instead of using tuple indexing, use array indexing";
3493 let suggestion = format!("{}[{}]", base, field);
3494 let applicability = if len < user_index {
3495 Applicability::MachineApplicable
3497 Applicability::MaybeIncorrect
3499 err.span_suggestion_with_applicability(
3500 expr.span, help, suggestion, applicability
3505 let base = self.tcx.sess.source_map()
3506 .span_to_snippet(base.span)
3507 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3508 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3509 let suggestion = format!("(*{}).{}", base, field);
3510 err.span_suggestion_with_applicability(
3514 Applicability::MaybeIncorrect,
3521 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3522 "`{}` is a primitive type and therefore doesn't have fields",
3525 self.tcx().types.err
3529 // Return an hint about the closest match in field names
3530 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3532 skip: Vec<LocalInternedString>)
3534 let names = variant.fields.iter().filter_map(|field| {
3535 // ignore already set fields and private fields from non-local crates
3536 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3537 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3540 Some(&field.ident.name)
3544 find_best_match_for_name(names, field, None)
3547 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3548 variant.fields.iter().filter(|field| {
3549 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3550 field.vis.is_accessible_from(def_scope, self.tcx)
3552 .map(|field| field.ident.name)
3556 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3557 // dynamic limit, to never omit just one field
3558 let limit = if names.len() == 6 { 6 } else { 5 };
3559 let mut display = names.iter().take(limit)
3560 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3561 if names.len() > limit {
3562 display = format!("{} ... and {} others", display, names.len() - limit);
3567 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3568 -> DiagnosticBuilder {
3569 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3570 "no field `{}` on type `{}`",
3574 fn report_unknown_field(&self,
3576 variant: &'tcx ty::VariantDef,
3578 skip_fields: &[hir::Field],
3580 let mut err = self.type_error_struct_with_diag(
3582 |actual| match ty.sty {
3583 ty::Adt(adt, ..) if adt.is_enum() => {
3584 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3585 "{} `{}::{}` has no field named `{}`",
3586 kind_name, actual, variant.ident, field.ident)
3589 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3590 "{} `{}` has no field named `{}`",
3591 kind_name, actual, field.ident)
3595 // prevent all specified fields from being suggested
3596 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3597 if let Some(field_name) = Self::suggest_field_name(variant,
3598 &field.ident.as_str(),
3599 skip_fields.collect()) {
3600 err.span_suggestion_with_applicability(
3602 "a field with a similar name exists",
3603 field_name.to_string(),
3604 Applicability::MaybeIncorrect,
3608 ty::Adt(adt, ..) => {
3610 err.span_label(field.ident.span,
3611 format!("`{}::{}` does not have this field",
3612 ty, variant.ident));
3614 err.span_label(field.ident.span,
3615 format!("`{}` does not have this field", ty));
3617 let available_field_names = self.available_field_names(variant);
3618 if !available_field_names.is_empty() {
3619 err.note(&format!("available fields are: {}",
3620 self.name_series_display(available_field_names)));
3623 _ => bug!("non-ADT passed to report_unknown_field")
3629 fn check_expr_struct_fields(&self,
3631 expected: Expectation<'tcx>,
3632 expr_id: ast::NodeId,
3634 variant: &'tcx ty::VariantDef,
3635 ast_fields: &'gcx [hir::Field],
3636 check_completeness: bool) -> bool {
3640 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3641 .get(0).cloned().unwrap_or(adt_ty);
3642 // re-link the regions that EIfEO can erase.
3643 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3645 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3646 &ty::Adt(adt, substs) => {
3647 (substs, adt.adt_kind(), adt.variant_descr())
3649 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3652 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3653 (field.ident.modern(), (i, field))
3654 ).collect::<FxHashMap<_, _>>();
3656 let mut seen_fields = FxHashMap::default();
3658 let mut error_happened = false;
3660 // Type-check each field.
3661 for field in ast_fields {
3662 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3663 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3664 seen_fields.insert(ident, field.span);
3665 self.write_field_index(field.id, i);
3667 // We don't look at stability attributes on
3668 // struct-like enums (yet...), but it's definitely not
3669 // a bug to have constructed one.
3670 if adt_kind != AdtKind::Enum {
3671 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3674 self.field_ty(field.span, v_field, substs)
3676 error_happened = true;
3677 if let Some(prev_span) = seen_fields.get(&ident) {
3678 let mut err = struct_span_err!(self.tcx.sess,
3681 "field `{}` specified more than once",
3684 err.span_label(field.ident.span, "used more than once");
3685 err.span_label(*prev_span, format!("first use of `{}`", ident));
3689 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3695 // Make sure to give a type to the field even if there's
3696 // an error, so we can continue type-checking.
3697 self.check_expr_coercable_to_type(&field.expr, field_type);
3700 // Make sure the programmer specified correct number of fields.
3701 if kind_name == "union" {
3702 if ast_fields.len() != 1 {
3703 tcx.sess.span_err(span, "union expressions should have exactly one field");
3705 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3706 let len = remaining_fields.len();
3708 let mut displayable_field_names = remaining_fields
3710 .map(|ident| ident.as_str())
3711 .collect::<Vec<_>>();
3713 displayable_field_names.sort();
3715 let truncated_fields_error = if len <= 3 {
3718 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3721 let remaining_fields_names = displayable_field_names.iter().take(3)
3722 .map(|n| format!("`{}`", n))
3723 .collect::<Vec<_>>()
3726 struct_span_err!(tcx.sess, span, E0063,
3727 "missing field{} {}{} in initializer of `{}`",
3728 if remaining_fields.len() == 1 { "" } else { "s" },
3729 remaining_fields_names,
3730 truncated_fields_error,
3732 .span_label(span, format!("missing {}{}",
3733 remaining_fields_names,
3734 truncated_fields_error))
3740 fn check_struct_fields_on_error(&self,
3741 fields: &'gcx [hir::Field],
3742 base_expr: &'gcx Option<P<hir::Expr>>) {
3743 for field in fields {
3744 self.check_expr(&field.expr);
3746 if let Some(ref base) = *base_expr {
3747 self.check_expr(&base);
3751 pub fn check_struct_path(&self,
3753 node_id: ast::NodeId)
3754 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3755 let path_span = match *qpath {
3756 QPath::Resolved(_, ref path) => path.span,
3757 QPath::TypeRelative(ref qself, _) => qself.span
3759 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3760 let variant = match def {
3762 self.set_tainted_by_errors();
3765 Def::Variant(..) => {
3767 ty::Adt(adt, substs) => {
3768 Some((adt.variant_of_def(def), adt.did, substs))
3770 _ => bug!("unexpected type: {:?}", ty.sty)
3773 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3774 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3776 ty::Adt(adt, substs) if !adt.is_enum() => {
3777 Some((adt.non_enum_variant(), adt.did, substs))
3782 _ => bug!("unexpected definition: {:?}", def)
3785 if let Some((variant, did, substs)) = variant {
3786 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3787 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
3788 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3790 // Check bounds on type arguments used in the path.
3791 let bounds = self.instantiate_bounds(path_span, did, substs);
3792 let cause = traits::ObligationCause::new(path_span, self.body_id,
3793 traits::ItemObligation(did));
3794 self.add_obligations_for_parameters(cause, &bounds);
3798 struct_span_err!(self.tcx.sess, path_span, E0071,
3799 "expected struct, variant or union type, found {}",
3800 ty.sort_string(self.tcx))
3801 .span_label(path_span, "not a struct")
3807 fn check_expr_struct(&self,
3809 expected: Expectation<'tcx>,
3811 fields: &'gcx [hir::Field],
3812 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3814 // Find the relevant variant
3815 let (variant, adt_ty) =
3816 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3819 self.check_struct_fields_on_error(fields, base_expr);
3820 return self.tcx.types.err;
3823 let path_span = match *qpath {
3824 QPath::Resolved(_, ref path) => path.span,
3825 QPath::TypeRelative(ref qself, _) => qself.span
3828 // Prohibit struct expressions when non-exhaustive flag is set.
3829 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3830 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3831 span_err!(self.tcx.sess, expr.span, E0639,
3832 "cannot create non-exhaustive {} using struct expression",
3833 adt.variant_descr());
3836 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3837 variant, fields, base_expr.is_none());
3838 if let &Some(ref base_expr) = base_expr {
3839 // If check_expr_struct_fields hit an error, do not attempt to populate
3840 // the fields with the base_expr. This could cause us to hit errors later
3841 // when certain fields are assumed to exist that in fact do not.
3842 if !error_happened {
3843 self.check_expr_has_type_or_error(base_expr, adt_ty);
3845 ty::Adt(adt, substs) if adt.is_struct() => {
3846 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3847 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3852 .fru_field_types_mut()
3853 .insert(expr.hir_id, fru_field_types);
3856 span_err!(self.tcx.sess, base_expr.span, E0436,
3857 "functional record update syntax requires a struct");
3862 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3868 /// If an expression has any sub-expressions that result in a type error,
3869 /// inspecting that expression's type with `ty.references_error()` will return
3870 /// true. Likewise, if an expression is known to diverge, inspecting its
3871 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3872 /// strict, _|_ can appear in the type of an expression that does not,
3873 /// itself, diverge: for example, fn() -> _|_.)
3874 /// Note that inspecting a type's structure *directly* may expose the fact
3875 /// that there are actually multiple representations for `Error`, so avoid
3876 /// that when err needs to be handled differently.
3877 fn check_expr_with_expectation_and_needs(&self,
3878 expr: &'gcx hir::Expr,
3879 expected: Expectation<'tcx>,
3880 needs: Needs) -> Ty<'tcx> {
3881 debug!(">> type-checking: expr={:?} expected={:?}",
3884 // Warn for expressions after diverging siblings.
3885 self.warn_if_unreachable(expr.id, expr.span, "expression");
3887 // Hide the outer diverging and has_errors flags.
3888 let old_diverges = self.diverges.get();
3889 let old_has_errors = self.has_errors.get();
3890 self.diverges.set(Diverges::Maybe);
3891 self.has_errors.set(false);
3893 let ty = self.check_expr_kind(expr, expected, needs);
3895 // Warn for non-block expressions with diverging children.
3897 ExprKind::Block(..) |
3898 ExprKind::Loop(..) | ExprKind::While(..) |
3899 ExprKind::If(..) | ExprKind::Match(..) => {}
3901 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3904 // Any expression that produces a value of type `!` must have diverged
3906 self.diverges.set(self.diverges.get() | Diverges::Always);
3909 // Record the type, which applies it effects.
3910 // We need to do this after the warning above, so that
3911 // we don't warn for the diverging expression itself.
3912 self.write_ty(expr.hir_id, ty);
3914 // Combine the diverging and has_error flags.
3915 self.diverges.set(self.diverges.get() | old_diverges);
3916 self.has_errors.set(self.has_errors.get() | old_has_errors);
3918 debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
3919 debug!("... {:?}, expected is {:?}", ty, expected);
3926 expr: &'gcx hir::Expr,
3927 expected: Expectation<'tcx>,
3931 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3940 ExprKind::Box(ref subexpr) => {
3941 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3943 ty::Adt(def, _) if def.is_box()
3944 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3948 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3949 tcx.mk_box(referent_ty)
3952 ExprKind::Lit(ref lit) => {
3953 self.check_lit(&lit, expected)
3955 ExprKind::Binary(op, ref lhs, ref rhs) => {
3956 self.check_binop(expr, op, lhs, rhs)
3958 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3959 self.check_binop_assign(expr, op, lhs, rhs)
3961 ExprKind::Unary(unop, ref oprnd) => {
3962 let expected_inner = match unop {
3963 hir::UnNot | hir::UnNeg => {
3970 let needs = match unop {
3971 hir::UnDeref => needs,
3974 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3978 if !oprnd_t.references_error() {
3979 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3982 if let Some(mt) = oprnd_t.builtin_deref(true) {
3984 } else if let Some(ok) = self.try_overloaded_deref(
3985 expr.span, oprnd_t, needs) {
3986 let method = self.register_infer_ok_obligations(ok);
3987 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3988 let mutbl = match mutbl {
3989 hir::MutImmutable => AutoBorrowMutability::Immutable,
3990 hir::MutMutable => AutoBorrowMutability::Mutable {
3991 // (It shouldn't actually matter for unary ops whether
3992 // we enable two-phase borrows or not, since a unary
3993 // op has no additional operands.)
3994 allow_two_phase_borrow: AllowTwoPhase::No,
3997 self.apply_adjustments(oprnd, vec![Adjustment {
3998 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3999 target: method.sig.inputs()[0]
4002 oprnd_t = self.make_overloaded_place_return_type(method).ty;
4003 self.write_method_call(expr.hir_id, method);
4005 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
4006 "type `{}` cannot be dereferenced",
4008 oprnd_t = tcx.types.err;
4012 let result = self.check_user_unop(expr, oprnd_t, unop);
4013 // If it's builtin, we can reuse the type, this helps inference.
4014 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4019 let result = self.check_user_unop(expr, oprnd_t, unop);
4020 // If it's builtin, we can reuse the type, this helps inference.
4021 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4029 ExprKind::AddrOf(mutbl, ref oprnd) => {
4030 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4032 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4033 if oprnd.is_place_expr() {
4034 // Places may legitimately have unsized types.
4035 // For example, dereferences of a fat pointer and
4036 // the last field of a struct can be unsized.
4039 Expectation::rvalue_hint(self, ty)
4045 let needs = Needs::maybe_mut_place(mutbl);
4046 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4048 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4049 if tm.ty.references_error() {
4052 // Note: at this point, we cannot say what the best lifetime
4053 // is to use for resulting pointer. We want to use the
4054 // shortest lifetime possible so as to avoid spurious borrowck
4055 // errors. Moreover, the longest lifetime will depend on the
4056 // precise details of the value whose address is being taken
4057 // (and how long it is valid), which we don't know yet until type
4058 // inference is complete.
4060 // Therefore, here we simply generate a region variable. The
4061 // region inferencer will then select the ultimate value.
4062 // Finally, borrowck is charged with guaranteeing that the
4063 // value whose address was taken can actually be made to live
4064 // as long as it needs to live.
4065 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4066 tcx.mk_ref(region, tm)
4069 ExprKind::Path(ref qpath) => {
4070 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
4071 let ty = match def {
4073 self.set_tainted_by_errors();
4076 Def::VariantCtor(_, CtorKind::Fictive) => {
4077 report_unexpected_variant_def(tcx, &def, expr.span, qpath);
4080 _ => self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0,
4083 if let ty::FnDef(..) = ty.sty {
4084 let fn_sig = ty.fn_sig(tcx);
4085 if !tcx.features().unsized_locals {
4086 // We want to remove some Sized bounds from std functions,
4087 // but don't want to expose the removal to stable Rust.
4088 // i.e., we don't want to allow
4094 // to work in stable even if the Sized bound on `drop` is relaxed.
4095 for i in 0..fn_sig.inputs().skip_binder().len() {
4096 // We just want to check sizedness, so instead of introducing
4097 // placeholder lifetimes with probing, we just replace higher lifetimes
4099 let input = self.replace_bound_vars_with_fresh_vars(
4101 infer::LateBoundRegionConversionTime::FnCall,
4102 &fn_sig.input(i)).0;
4103 self.require_type_is_sized_deferred(input, expr.span,
4104 traits::SizedArgumentType);
4107 // Here we want to prevent struct constructors from returning unsized types.
4108 // There were two cases this happened: fn pointer coercion in stable
4109 // and usual function call in presense of unsized_locals.
4110 // Also, as we just want to check sizedness, instead of introducing
4111 // placeholder lifetimes with probing, we just replace higher lifetimes
4113 let output = self.replace_bound_vars_with_fresh_vars(
4115 infer::LateBoundRegionConversionTime::FnCall,
4116 &fn_sig.output()).0;
4117 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4120 // We always require that the type provided as the value for
4121 // a type parameter outlives the moment of instantiation.
4122 let substs = self.tables.borrow().node_substs(expr.hir_id);
4123 self.add_wf_bounds(substs, expr);
4127 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4128 for expr in outputs.iter().chain(inputs.iter()) {
4129 self.check_expr(expr);
4133 ExprKind::Break(destination, ref expr_opt) => {
4134 if let Ok(target_id) = destination.target_id {
4136 if let Some(ref e) = *expr_opt {
4137 // If this is a break with a value, we need to type-check
4138 // the expression. Get an expected type from the loop context.
4139 let opt_coerce_to = {
4140 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4141 enclosing_breakables.find_breakable(target_id)
4144 .map(|coerce| coerce.expected_ty())
4147 // If the loop context is not a `loop { }`, then break with
4148 // a value is illegal, and `opt_coerce_to` will be `None`.
4149 // Just set expectation to error in that case.
4150 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4152 // Recurse without `enclosing_breakables` borrowed.
4153 e_ty = self.check_expr_with_hint(e, coerce_to);
4154 cause = self.misc(e.span);
4156 // Otherwise, this is a break *without* a value. That's
4157 // always legal, and is equivalent to `break ()`.
4158 e_ty = tcx.mk_unit();
4159 cause = self.misc(expr.span);
4162 // Now that we have type-checked `expr_opt`, borrow
4163 // the `enclosing_loops` field and let's coerce the
4164 // type of `expr_opt` into what is expected.
4165 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4166 let ctxt = enclosing_breakables.find_breakable(target_id);
4167 if let Some(ref mut coerce) = ctxt.coerce {
4168 if let Some(ref e) = *expr_opt {
4169 coerce.coerce(self, &cause, e, e_ty);
4171 assert!(e_ty.is_unit());
4172 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4175 // If `ctxt.coerce` is `None`, we can just ignore
4176 // the type of the expresison. This is because
4177 // either this was a break *without* a value, in
4178 // which case it is always a legal type (`()`), or
4179 // else an error would have been flagged by the
4180 // `loops` pass for using break with an expression
4181 // where you are not supposed to.
4182 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4185 ctxt.may_break = true;
4187 // the type of a `break` is always `!`, since it diverges
4190 // Otherwise, we failed to find the enclosing loop;
4191 // this can only happen if the `break` was not
4192 // inside a loop at all, which is caught by the
4193 // loop-checking pass.
4194 if self.tcx.sess.err_count() == 0 {
4195 self.tcx.sess.delay_span_bug(expr.span,
4196 "break was outside loop, but no error was emitted");
4199 // We still need to assign a type to the inner expression to
4200 // prevent the ICE in #43162.
4201 if let Some(ref e) = *expr_opt {
4202 self.check_expr_with_hint(e, tcx.types.err);
4204 // ... except when we try to 'break rust;'.
4205 // ICE this expression in particular (see #43162).
4206 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4207 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4208 fatally_break_rust(self.tcx.sess);
4212 // There was an error; make type-check fail.
4217 ExprKind::Continue(destination) => {
4218 if destination.target_id.is_ok() {
4221 // There was an error; make type-check fail.
4225 ExprKind::Ret(ref expr_opt) => {
4226 if self.ret_coercion.is_none() {
4227 struct_span_err!(self.tcx.sess, expr.span, E0572,
4228 "return statement outside of function body").emit();
4229 } else if let Some(ref e) = *expr_opt {
4230 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4231 self.check_return_expr(e);
4233 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4234 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4235 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4236 if let Some((fn_decl, _)) = self.get_fn_decl(expr.id) {
4237 coercion.coerce_forced_unit(
4242 fn_decl.output.span(),
4244 "expected `{}` because of this return type",
4252 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4257 ExprKind::Assign(ref lhs, ref rhs) => {
4258 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4260 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4263 ExpectIfCondition => {
4264 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4265 expected error elsehwere");
4268 // Only check this if not in an `if` condition, as the
4269 // mistyped comparison help is more appropriate.
4270 if !lhs.is_place_expr() {
4271 struct_span_err!(self.tcx.sess, expr.span, E0070,
4272 "invalid left-hand side expression")
4273 .span_label(expr.span, "left-hand of expression not valid")
4279 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4281 if lhs_ty.references_error() || rhs_ty.references_error() {
4287 ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4288 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4289 expr.span, expected)
4291 ExprKind::While(ref cond, ref body, _) => {
4292 let ctxt = BreakableCtxt {
4293 // cannot use break with a value from a while loop
4295 may_break: false, // Will get updated if/when we find a `break`.
4298 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4299 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4300 let cond_diverging = self.diverges.get();
4301 self.check_block_no_value(&body);
4303 // We may never reach the body so it diverging means nothing.
4304 self.diverges.set(cond_diverging);
4308 // No way to know whether it's diverging because
4309 // of a `break` or an outer `break` or `return`.
4310 self.diverges.set(Diverges::Maybe);
4315 ExprKind::Loop(ref body, _, source) => {
4316 let coerce = match source {
4317 // you can only use break with a value from a normal `loop { }`
4318 hir::LoopSource::Loop => {
4319 let coerce_to = expected.coercion_target_type(self, body.span);
4320 Some(CoerceMany::new(coerce_to))
4323 hir::LoopSource::WhileLet |
4324 hir::LoopSource::ForLoop => {
4329 let ctxt = BreakableCtxt {
4331 may_break: false, // Will get updated if/when we find a `break`.
4334 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4335 self.check_block_no_value(&body);
4339 // No way to know whether it's diverging because
4340 // of a `break` or an outer `break` or `return`.
4341 self.diverges.set(Diverges::Maybe);
4344 // If we permit break with a value, then result type is
4345 // the LUB of the breaks (possibly ! if none); else, it
4346 // is nil. This makes sense because infinite loops
4347 // (which would have type !) are only possible iff we
4348 // permit break with a value [1].
4349 if ctxt.coerce.is_none() && !ctxt.may_break {
4351 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4353 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4355 ExprKind::Match(ref discrim, ref arms, match_src) => {
4356 self.check_match(expr, &discrim, arms, expected, match_src)
4358 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4359 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4361 ExprKind::Block(ref body, _) => {
4362 self.check_block_with_expected(&body, expected)
4364 ExprKind::Call(ref callee, ref args) => {
4365 self.check_call(expr, &callee, args, expected)
4367 ExprKind::MethodCall(ref segment, span, ref args) => {
4368 self.check_method_call(expr, segment, span, args, expected, needs)
4370 ExprKind::Cast(ref e, ref t) => {
4371 // Find the type of `e`. Supply hints based on the type we are casting to,
4373 let t_cast = self.to_ty_saving_user_provided_ty(t);
4374 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4375 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4376 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4378 // Eagerly check for some obvious errors.
4379 if t_expr.references_error() || t_cast.references_error() {
4382 // Defer other checks until we're done type checking.
4383 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4384 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4386 deferred_cast_checks.push(cast_check);
4389 Err(ErrorReported) => {
4395 ExprKind::Type(ref e, ref t) => {
4396 let ty = self.to_ty_saving_user_provided_ty(&t);
4397 self.check_expr_eq_type(&e, ty);
4400 ExprKind::Array(ref args) => {
4401 let uty = expected.to_option(self).and_then(|uty| {
4403 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4408 let element_ty = if !args.is_empty() {
4409 let coerce_to = uty.unwrap_or_else(
4410 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4411 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4412 assert_eq!(self.diverges.get(), Diverges::Maybe);
4414 let e_ty = self.check_expr_with_hint(e, coerce_to);
4415 let cause = self.misc(e.span);
4416 coerce.coerce(self, &cause, e, e_ty);
4418 coerce.complete(self)
4420 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4422 tcx.mk_array(element_ty, args.len() as u64)
4424 ExprKind::Repeat(ref element, ref count) => {
4425 let count_def_id = tcx.hir().local_def_id(count.id);
4426 let param_env = ty::ParamEnv::empty();
4427 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4428 let instance = ty::Instance::resolve(
4434 let global_id = GlobalId {
4438 let count = tcx.const_eval(param_env.and(global_id));
4440 let uty = match expected {
4441 ExpectHasType(uty) => {
4443 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4450 let (element_ty, t) = match uty {
4452 self.check_expr_coercable_to_type(&element, uty);
4456 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4457 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4462 if let Ok(count) = count {
4463 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4465 // For [foo, ..n] where n > 1, `foo` must have
4467 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4468 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4472 if element_ty.references_error() {
4474 } else if let Ok(count) = count {
4475 tcx.mk_ty(ty::Array(t, tcx.intern_lazy_const(ty::LazyConst::Evaluated(count))))
4480 ExprKind::Tup(ref elts) => {
4481 let flds = expected.only_has_type(self).and_then(|ty| {
4482 let ty = self.resolve_type_vars_with_obligations(ty);
4484 ty::Tuple(ref flds) => Some(&flds[..]),
4489 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4490 let t = match flds {
4491 Some(ref fs) if i < fs.len() => {
4493 self.check_expr_coercable_to_type(&e, ety);
4497 self.check_expr_with_expectation(&e, NoExpectation)
4502 let tuple = tcx.mk_tup(elt_ts_iter);
4503 if tuple.references_error() {
4506 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4510 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4511 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4513 ExprKind::Field(ref base, field) => {
4514 self.check_field(expr, needs, &base, field)
4516 ExprKind::Index(ref base, ref idx) => {
4517 let base_t = self.check_expr_with_needs(&base, needs);
4518 let idx_t = self.check_expr(&idx);
4520 if base_t.references_error() {
4522 } else if idx_t.references_error() {
4525 let base_t = self.structurally_resolved_type(base.span, base_t);
4526 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4527 Some((index_ty, element_ty)) => {
4528 // two-phase not needed because index_ty is never mutable
4529 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4534 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4535 "cannot index into a value of type `{}`",
4537 // Try to give some advice about indexing tuples.
4538 if let ty::Tuple(..) = base_t.sty {
4539 let mut needs_note = true;
4540 // If the index is an integer, we can show the actual
4541 // fixed expression:
4542 if let ExprKind::Lit(ref lit) = idx.node {
4543 if let ast::LitKind::Int(i,
4544 ast::LitIntType::Unsuffixed) = lit.node {
4545 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4546 if let Ok(snip) = snip {
4547 err.span_suggestion_with_applicability(
4549 "to access tuple elements, use",
4550 format!("{}.{}", snip, i),
4551 Applicability::MachineApplicable);
4557 err.help("to access tuple elements, use tuple indexing \
4558 syntax (e.g., `tuple.0`)");
4567 ExprKind::Yield(ref value) => {
4568 match self.yield_ty {
4570 self.check_expr_coercable_to_type(&value, ty);
4573 struct_span_err!(self.tcx.sess, expr.span, E0627,
4574 "yield statement outside of generator literal").emit();
4579 hir::ExprKind::Err => {
4585 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4586 // The newly resolved definition is written into `type_dependent_defs`.
4587 fn finish_resolving_struct_path(&self,
4590 node_id: ast::NodeId)
4594 QPath::Resolved(ref maybe_qself, ref path) => {
4595 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4596 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4599 QPath::TypeRelative(ref qself, ref segment) => {
4600 let ty = self.to_ty(qself);
4602 let def = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4607 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4610 // Write back the new resolution.
4611 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4612 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4619 // Resolve associated value path into a base type and associated constant or method definition.
4620 // The newly resolved definition is written into `type_dependent_defs`.
4621 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4623 node_id: ast::NodeId,
4625 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4627 debug!("resolve_ty_and_def_ufcs: qpath={:?} node_id={:?} span={:?}", qpath, node_id, span);
4628 let (ty, qself, item_segment) = match *qpath {
4629 QPath::Resolved(ref opt_qself, ref path) => {
4631 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4632 &path.segments[..]);
4634 QPath::TypeRelative(ref qself, ref segment) => {
4635 (self.to_ty(qself), qself, segment)
4638 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4639 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4640 // Return directly on cache hit. This is useful to avoid doubly reporting
4641 // errors with default match binding modes. See #44614.
4642 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4644 let item_name = item_segment.ident;
4645 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4648 let def = match error {
4649 method::MethodError::PrivateMatch(def, _) => def,
4652 if item_name.name != keywords::Invalid.name() {
4653 self.report_method_error(span,
4656 SelfSource::QPath(qself),
4664 // Write back the new resolution.
4665 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4666 (def, Some(ty), slice::from_ref(&**item_segment))
4669 pub fn check_decl_initializer(&self,
4670 local: &'gcx hir::Local,
4671 init: &'gcx hir::Expr) -> Ty<'tcx>
4673 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4674 // for #42640 (default match binding modes).
4677 let ref_bindings = local.pat.contains_explicit_ref_binding();
4679 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4680 if let Some(m) = ref_bindings {
4681 // Somewhat subtle: if we have a `ref` binding in the pattern,
4682 // we want to avoid introducing coercions for the RHS. This is
4683 // both because it helps preserve sanity and, in the case of
4684 // ref mut, for soundness (issue #23116). In particular, in
4685 // the latter case, we need to be clear that the type of the
4686 // referent for the reference that results is *equal to* the
4687 // type of the place it is referencing, and not some
4688 // supertype thereof.
4689 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4690 self.demand_eqtype(init.span, local_ty, init_ty);
4693 self.check_expr_coercable_to_type(init, local_ty)
4697 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4698 let t = self.local_ty(local.span, local.id).decl_ty;
4699 self.write_ty(local.hir_id, t);
4701 if let Some(ref init) = local.init {
4702 let init_ty = self.check_decl_initializer(local, &init);
4703 if init_ty.references_error() {
4704 self.write_ty(local.hir_id, init_ty);
4708 self.check_pat_walk(&local.pat, t,
4709 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4711 let pat_ty = self.node_ty(local.pat.hir_id);
4712 if pat_ty.references_error() {
4713 self.write_ty(local.hir_id, pat_ty);
4717 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4718 // Don't do all the complex logic below for `DeclItem`.
4720 hir::StmtKind::Decl(ref decl, _) => {
4721 if let hir::DeclKind::Item(_) = decl.node {
4725 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4728 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4730 // Hide the outer diverging and `has_errors` flags.
4731 let old_diverges = self.diverges.get();
4732 let old_has_errors = self.has_errors.get();
4733 self.diverges.set(Diverges::Maybe);
4734 self.has_errors.set(false);
4737 hir::StmtKind::Decl(ref decl, _) => {
4739 hir::DeclKind::Local(ref l) => {
4740 self.check_decl_local(&l);
4743 hir::DeclKind::Item(_) => ()
4746 hir::StmtKind::Expr(ref expr, _) => {
4747 // Check with expected type of `()`.
4748 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4750 hir::StmtKind::Semi(ref expr, _) => {
4751 self.check_expr(&expr);
4755 // Combine the diverging and `has_error` flags.
4756 self.diverges.set(self.diverges.get() | old_diverges);
4757 self.has_errors.set(self.has_errors.get() | old_has_errors);
4760 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4761 let unit = self.tcx.mk_unit();
4762 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4764 // if the block produces a `!` value, that can always be
4765 // (effectively) coerced to unit.
4767 self.demand_suptype(blk.span, unit, ty);
4771 fn check_block_with_expected(&self,
4772 blk: &'gcx hir::Block,
4773 expected: Expectation<'tcx>) -> Ty<'tcx> {
4775 let mut fcx_ps = self.ps.borrow_mut();
4776 let unsafety_state = fcx_ps.recurse(blk);
4777 replace(&mut *fcx_ps, unsafety_state)
4780 // In some cases, blocks have just one exit, but other blocks
4781 // can be targeted by multiple breaks. This can happen both
4782 // with labeled blocks as well as when we desugar
4783 // a `try { ... }` expression.
4787 // 'a: { if true { break 'a Err(()); } Ok(()) }
4789 // Here we would wind up with two coercions, one from
4790 // `Err(())` and the other from the tail expression
4791 // `Ok(())`. If the tail expression is omitted, that's a
4792 // "forced unit" -- unless the block diverges, in which
4793 // case we can ignore the tail expression (e.g., `'a: {
4794 // break 'a 22; }` would not force the type of the block
4796 let tail_expr = blk.expr.as_ref();
4797 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4798 let coerce = if blk.targeted_by_break {
4799 CoerceMany::new(coerce_to_ty)
4801 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4802 Some(e) => slice::from_ref(e),
4805 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4808 let prev_diverges = self.diverges.get();
4809 let ctxt = BreakableCtxt {
4810 coerce: Some(coerce),
4814 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4815 for s in &blk.stmts {
4819 // check the tail expression **without** holding the
4820 // `enclosing_breakables` lock below.
4821 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4823 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4824 let ctxt = enclosing_breakables.find_breakable(blk.id);
4825 let coerce = ctxt.coerce.as_mut().unwrap();
4826 if let Some(tail_expr_ty) = tail_expr_ty {
4827 let tail_expr = tail_expr.unwrap();
4828 let cause = self.cause(tail_expr.span,
4829 ObligationCauseCode::BlockTailExpression(blk.id));
4835 // Subtle: if there is no explicit tail expression,
4836 // that is typically equivalent to a tail expression
4837 // of `()` -- except if the block diverges. In that
4838 // case, there is no value supplied from the tail
4839 // expression (assuming there are no other breaks,
4840 // this implies that the type of the block will be
4843 // #41425 -- label the implicit `()` as being the
4844 // "found type" here, rather than the "expected type".
4845 if !self.diverges.get().always() {
4846 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4847 if let Some(expected_ty) = expected.only_has_type(self) {
4848 self.consider_hint_about_removing_semicolon(blk,
4858 // If we can break from the block, then the block's exit is always reachable
4859 // (... as long as the entry is reachable) - regardless of the tail of the block.
4860 self.diverges.set(prev_diverges);
4863 let mut ty = ctxt.coerce.unwrap().complete(self);
4865 if self.has_errors.get() || ty.references_error() {
4866 ty = self.tcx.types.err
4869 self.write_ty(blk.hir_id, ty);
4871 *self.ps.borrow_mut() = prev;
4875 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4876 /// suggestion can be made, `None` otherwise.
4877 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4878 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4879 // `while` before reaching it, as block tail returns are not available in them.
4880 if let Some(fn_id) = self.tcx.hir().get_return_block(blk_id) {
4881 let parent = self.tcx.hir().get(fn_id);
4883 if let Node::Item(&hir::Item {
4884 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4886 decl.clone().and_then(|decl| {
4887 // This is less than ideal, it will not suggest a return type span on any
4888 // method called `main`, regardless of whether it is actually the entry point,
4889 // but it will still present it as the reason for the expected type.
4890 Some((decl, ident.name != Symbol::intern("main")))
4892 } else if let Node::TraitItem(&hir::TraitItem {
4893 node: hir::TraitItemKind::Method(hir::MethodSig {
4897 decl.clone().and_then(|decl| {
4900 } else if let Node::ImplItem(&hir::ImplItem {
4901 node: hir::ImplItemKind::Method(hir::MethodSig {
4905 decl.clone().and_then(|decl| {
4916 /// On implicit return expressions with mismatched types, provide the following suggestions:
4918 /// - Point out the method's return type as the reason for the expected type
4919 /// - Possible missing semicolon
4920 /// - Possible missing return type if the return type is the default, and not `fn main()`
4921 pub fn suggest_mismatched_types_on_tail(&self,
4922 err: &mut DiagnosticBuilder<'tcx>,
4923 expression: &'gcx hir::Expr,
4927 blk_id: ast::NodeId) {
4928 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4929 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4930 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4932 self.suggest_ref_or_into(err, expression, expected, found);
4935 pub fn suggest_ref_or_into(
4937 err: &mut DiagnosticBuilder<'tcx>,
4942 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4943 err.span_suggestion_with_applicability(
4947 Applicability::MachineApplicable,
4949 } else if !self.check_for_cast(err, expr, found, expected) {
4950 let methods = self.get_conversion_methods(expr.span, expected, found);
4951 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4952 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4953 .filter_map(|(receiver, method)| {
4954 let method_call = format!(".{}()", method.ident);
4955 if receiver.ends_with(&method_call) {
4956 None // do not suggest code that is already there (#53348)
4958 let method_call_list = [".to_vec()", ".to_string()"];
4959 if receiver.ends_with(".clone()")
4960 && method_call_list.contains(&method_call.as_str()) {
4961 let max_len = receiver.rfind(".").unwrap();
4962 Some(format!("{}{}", &receiver[..max_len], method_call))
4965 Some(format!("{}{}", receiver, method_call))
4969 if suggestions.peek().is_some() {
4970 err.span_suggestions_with_applicability(
4972 "try using a conversion method",
4974 Applicability::MaybeIncorrect,
4981 /// A common error is to forget to add a semicolon at the end of a block:
4985 /// bar_that_returns_u32()
4989 /// This routine checks if the return expression in a block would make sense on its own as a
4990 /// statement and the return type has been left as default or has been specified as `()`. If so,
4991 /// it suggests adding a semicolon.
4992 fn suggest_missing_semicolon(&self,
4993 err: &mut DiagnosticBuilder<'tcx>,
4994 expression: &'gcx hir::Expr,
4997 if expected.is_unit() {
4998 // `BlockTailExpression` only relevant if the tail expr would be
4999 // useful on its own.
5000 match expression.node {
5001 ExprKind::Call(..) |
5002 ExprKind::MethodCall(..) |
5004 ExprKind::While(..) |
5005 ExprKind::Loop(..) |
5006 ExprKind::Match(..) |
5007 ExprKind::Block(..) => {
5008 let sp = self.tcx.sess.source_map().next_point(cause_span);
5009 err.span_suggestion_with_applicability(
5011 "try adding a semicolon",
5013 Applicability::MachineApplicable);
5020 /// A possible error is to forget to add a return type that is needed:
5024 /// bar_that_returns_u32()
5028 /// This routine checks if the return type is left as default, the method is not part of an
5029 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5031 fn suggest_missing_return_type(&self,
5032 err: &mut DiagnosticBuilder<'tcx>,
5033 fn_decl: &hir::FnDecl,
5036 can_suggest: bool) {
5037 // Only suggest changing the return type for methods that
5038 // haven't set a return type at all (and aren't `fn main()` or an impl).
5039 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5040 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5041 err.span_suggestion_with_applicability(
5043 "try adding a return type",
5044 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5045 Applicability::MachineApplicable);
5047 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5048 err.span_label(span, "possibly return type missing here?");
5050 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5051 // `fn main()` must return `()`, do not suggest changing return type
5052 err.span_label(span, "expected `()` because of default return type");
5054 // expectation was caused by something else, not the default return
5055 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
5056 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5057 // Only point to return type if the expected type is the return type, as if they
5058 // are not, the expectation must have been caused by something else.
5059 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5061 let ty = AstConv::ast_ty_to_ty(self, ty);
5062 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
5063 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
5064 if ty.sty == expected.sty {
5065 err.span_label(sp, format!("expected `{}` because of return type",
5073 /// A common error is to add an extra semicolon:
5076 /// fn foo() -> usize {
5081 /// This routine checks if the final statement in a block is an
5082 /// expression with an explicit semicolon whose type is compatible
5083 /// with `expected_ty`. If so, it suggests removing the semicolon.
5084 fn consider_hint_about_removing_semicolon(&self,
5085 blk: &'gcx hir::Block,
5086 expected_ty: Ty<'tcx>,
5087 err: &mut DiagnosticBuilder) {
5088 // Be helpful when the user wrote `{... expr;}` and
5089 // taking the `;` off is enough to fix the error.
5090 let last_stmt = match blk.stmts.last() {
5094 let last_expr = match last_stmt.node {
5095 hir::StmtKind::Semi(ref e, _) => e,
5098 let last_expr_ty = self.node_ty(last_expr.hir_id);
5099 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5102 let original_span = original_sp(last_stmt.span, blk.span);
5103 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
5104 err.span_suggestion_with_applicability(
5106 "consider removing this semicolon",
5108 Applicability::MachineApplicable);
5111 // Instantiates the given path, which must refer to an item with the given
5112 // number of type parameters and type.
5113 pub fn instantiate_value_path(&self,
5114 segments: &[hir::PathSegment],
5115 self_ty: Option<Ty<'tcx>>,
5118 node_id: ast::NodeId)
5119 -> (Ty<'tcx>, Def) {
5121 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5130 let path_segs = AstConv::def_ids_for_path_segments(self, segments, self_ty, def);
5132 let mut user_self_ty = None;
5133 let mut is_alias_variant_ctor = false;
5135 Def::VariantCtor(_, _) => {
5136 if let Some(self_ty) = self_ty {
5137 let adt_def = self_ty.ty_adt_def().unwrap();
5138 user_self_ty = Some(UserSelfTy {
5139 impl_def_id: adt_def.did,
5142 is_alias_variant_ctor = true;
5145 Def::Method(def_id) |
5146 Def::AssociatedConst(def_id) => {
5147 let container = tcx.associated_item(def_id).container;
5148 debug!("instantiate_value_path: def={:?} container={:?}", def, container);
5150 ty::TraitContainer(trait_did) => {
5151 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5153 ty::ImplContainer(impl_def_id) => {
5154 if segments.len() == 1 {
5155 // `<T>::assoc` will end up here, and so
5156 // can `T::assoc`. It this came from an
5157 // inherent impl, we need to record the
5158 // `T` for posterity (see `UserSelfTy` for
5160 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5161 user_self_ty = Some(UserSelfTy {
5172 // Now that we have categorized what space the parameters for each
5173 // segment belong to, let's sort out the parameters that the user
5174 // provided (if any) into their appropriate spaces. We'll also report
5175 // errors if type parameters are provided in an inappropriate place.
5177 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5178 let generics_has_err = AstConv::prohibit_generics(
5179 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5180 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5186 if generics_has_err {
5187 // Don't try to infer type parameters when prohibited generic arguments were given.
5188 user_self_ty = None;
5192 Def::Local(nid) | Def::Upvar(nid, ..) => {
5193 let ty = self.local_ty(span, nid).decl_ty;
5194 let ty = self.normalize_associated_types_in(span, &ty);
5195 self.write_ty(tcx.hir().node_to_hir_id(node_id), ty);
5201 // Now we have to compare the types that the user *actually*
5202 // provided against the types that were *expected*. If the user
5203 // did not provide any types, then we want to substitute inference
5204 // variables. If the user provided some types, we may still need
5205 // to add defaults. If the user provided *too many* types, that's
5208 let mut infer_args_for_err = FxHashSet::default();
5209 for &PathSeg(def_id, index) in &path_segs {
5210 let seg = &segments[index];
5211 let generics = tcx.generics_of(def_id);
5212 // Argument-position `impl Trait` is treated as a normal generic
5213 // parameter internally, but we don't allow users to specify the
5214 // parameter's value explicitly, so we have to do some error-
5216 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5221 false, // `is_method_call`
5223 if suppress_errors {
5224 infer_args_for_err.insert(index);
5225 self.set_tainted_by_errors(); // See issue #53251.
5229 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5230 tcx.generics_of(*def_id).has_self
5231 }).unwrap_or(false);
5233 let mut new_def = def;
5234 let (def_id, ty) = match def {
5235 Def::SelfCtor(impl_def_id) => {
5236 let ty = self.impl_self_ty(span, impl_def_id).ty;
5237 let adt_def = ty.ty_adt_def();
5240 Some(adt_def) if adt_def.has_ctor() => {
5241 let variant = adt_def.non_enum_variant();
5242 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5243 (variant.did, tcx.type_of(variant.did))
5246 let mut err = tcx.sess.struct_span_err(span,
5247 "the `Self` constructor can only be used with tuple or unit structs");
5248 if let Some(adt_def) = adt_def {
5249 match adt_def.adt_kind() {
5251 err.help("did you mean to use one of the enum's variants?");
5255 err.span_suggestion_with_applicability(
5257 "use curly brackets",
5258 String::from("Self { /* fields */ }"),
5259 Applicability::HasPlaceholders,
5266 (impl_def_id, tcx.types.err)
5271 let def_id = def.def_id();
5273 // The things we are substituting into the type should not contain
5274 // escaping late-bound regions, and nor should the base type scheme.
5275 let ty = tcx.type_of(def_id);
5280 let substs = AstConv::create_substs_for_generic_args(
5286 // Provide the generic args, and whether types should be inferred.
5288 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5291 // If we've encountered an `impl Trait`-related error, we're just
5292 // going to infer the arguments for better error messages.
5293 if !infer_args_for_err.contains(&index) {
5294 // Check whether the user has provided generic arguments.
5295 if let Some(ref data) = segments[index].args {
5296 return (Some(data), segments[index].infer_types);
5299 return (None, segments[index].infer_types);
5304 // Provide substitutions for parameters for which (valid) arguments have been provided.
5306 match (¶m.kind, arg) {
5307 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5308 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5310 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5311 self.to_ty(ty).into()
5313 _ => unreachable!(),
5316 // Provide substitutions for parameters for which arguments are inferred.
5317 |substs, param, infer_types| {
5319 GenericParamDefKind::Lifetime => {
5320 self.re_infer(span, Some(param)).unwrap().into()
5322 GenericParamDefKind::Type { has_default, .. } => {
5323 if !infer_types && has_default {
5324 // If we have a default, then we it doesn't matter that we're not
5325 // inferring the type arguments: we provide the default where any
5327 let default = tcx.type_of(param.def_id);
5330 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5333 // If no type arguments were provided, we have to infer them.
5334 // This case also occurs as a result of some malformed input, e.g.
5335 // a lifetime argument being given instead of a type parameter.
5336 // Using inference instead of `Error` gives better error messages.
5337 self.var_for_def(span, param)
5343 assert!(!substs.has_escaping_bound_vars());
5344 assert!(!ty.has_escaping_bound_vars());
5346 // First, store the "user substs" for later.
5347 let hir_id = tcx.hir().node_to_hir_id(node_id);
5348 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5350 // Add all the obligations that are required, substituting and
5351 // normalized appropriately.
5352 let bounds = self.instantiate_bounds(span, def_id, &substs);
5353 self.add_obligations_for_parameters(
5354 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5357 // Substitute the values for the type parameters into the type of
5358 // the referenced item.
5359 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5361 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5362 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5363 // is inherent, there is no `Self` parameter; instead, the impl needs
5364 // type parameters, which we can infer by unifying the provided `Self`
5365 // with the substituted impl type.
5366 // This also occurs for an enum variant on a type alias.
5367 let ty = tcx.type_of(impl_def_id);
5369 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5370 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5371 Ok(ok) => self.register_infer_ok_obligations(ok),
5374 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5381 self.check_rustc_args_require_const(def_id, node_id, span);
5383 debug!("instantiate_value_path: type of {:?} is {:?}",
5386 self.write_substs(hir_id, substs);
5388 (ty_substituted, new_def)
5391 fn check_rustc_args_require_const(&self,
5393 node_id: ast::NodeId,
5395 // We're only interested in functions tagged with
5396 // #[rustc_args_required_const], so ignore anything that's not.
5397 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5401 // If our calling expression is indeed the function itself, we're good!
5402 // If not, generate an error that this can only be called directly.
5403 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
5404 if let ExprKind::Call(ref callee, ..) = expr.node {
5405 if callee.id == node_id {
5411 self.tcx.sess.span_err(span, "this function can only be invoked \
5412 directly, not through a function pointer");
5415 // Resolves `typ` by a single level if `typ` is a type variable.
5416 // If no resolution is possible, then an error is reported.
5417 // Numeric inference variables may be left unresolved.
5418 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5419 let ty = self.resolve_type_vars_with_obligations(ty);
5420 if !ty.is_ty_var() {
5423 if !self.is_tainted_by_errors() {
5424 self.need_type_info_err((**self).body_id, sp, ty)
5425 .note("type must be known at this point")
5428 self.demand_suptype(sp, self.tcx.types.err, ty);
5433 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5434 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5435 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5438 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5439 index = enclosing_breakables.stack.len();
5440 enclosing_breakables.by_id.insert(id, index);
5441 enclosing_breakables.stack.push(ctxt);
5445 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5446 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5447 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5448 enclosing_breakables.stack.pop().expect("missing breakable context")
5453 /// Instantiate a QueryResponse in a probe context, without a
5454 /// good ObligationCause.
5455 fn probe_instantiate_query_response(
5458 original_values: &OriginalQueryValues<'tcx>,
5459 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5460 ) -> InferResult<'tcx, Ty<'tcx>>
5462 self.instantiate_query_response_and_region_obligations(
5463 &traits::ObligationCause::misc(span, self.body_id),
5470 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5471 generics: &ty::Generics,
5473 let own_counts = generics.own_counts();
5474 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5476 if own_counts.types == 0 {
5479 // Make a vector of booleans initially false, set to true when used.
5480 let mut types_used = vec![false; own_counts.types];
5482 for leaf_ty in ty.walk() {
5483 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5484 debug!("Found use of ty param num {}", idx);
5485 types_used[idx as usize - own_counts.lifetimes] = true;
5486 } else if let ty::Error = leaf_ty.sty {
5487 // If there is already another error, do not emit
5488 // an error for not using a type Parameter.
5489 assert!(tcx.sess.err_count() > 0);
5494 let types = generics.params.iter().filter(|param| match param.kind {
5495 ty::GenericParamDefKind::Type { .. } => true,
5498 for (&used, param) in types_used.iter().zip(types) {
5500 let id = tcx.hir().as_local_node_id(param.def_id).unwrap();
5501 let span = tcx.hir().span(id);
5502 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5503 .span_label(span, "unused type parameter")
5509 fn fatally_break_rust(sess: &Session) {
5510 let handler = sess.diagnostic();
5511 handler.span_bug_no_panic(
5513 "It looks like you're trying to break rust; would you like some ICE?",
5515 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5516 handler.note_without_error(
5517 "we would appreciate a joke overview: \
5518 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5520 handler.note_without_error(&format!("rustc {} running on {}",
5521 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5522 ::session::config::host_triple(),
5526 fn potentially_plural_count(count: usize, word: &str) -> String {
5527 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })