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 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1310 "check_item_type(it.id={}, it.name={})",
1312 tcx.item_path_str(tcx.hir().local_def_id(it.id))
1314 let _indenter = indenter();
1316 // Consts can play a role in type-checking, so they are included here.
1317 hir::ItemKind::Static(..) => {
1318 let def_id = tcx.hir().local_def_id(it.id);
1319 tcx.typeck_tables_of(def_id);
1320 maybe_check_static_with_link_section(tcx, def_id, it.span);
1322 hir::ItemKind::Const(..) => {
1323 tcx.typeck_tables_of(tcx.hir().local_def_id(it.id));
1325 hir::ItemKind::Enum(ref enum_definition, _) => {
1326 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1328 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1329 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1330 debug!("ItemKind::Impl {} with id {}", it.ident, it.id);
1331 let impl_def_id = tcx.hir().local_def_id(it.id);
1332 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1333 check_impl_items_against_trait(
1340 let trait_def_id = impl_trait_ref.def_id;
1341 check_on_unimplemented(tcx, trait_def_id, it);
1344 hir::ItemKind::Trait(..) => {
1345 let def_id = tcx.hir().local_def_id(it.id);
1346 check_on_unimplemented(tcx, def_id, it);
1348 hir::ItemKind::Struct(..) => {
1349 check_struct(tcx, it.id, it.span);
1351 hir::ItemKind::Union(..) => {
1352 check_union(tcx, it.id, it.span);
1354 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1355 let def_id = tcx.hir().local_def_id(it.id);
1356 let pty_ty = tcx.type_of(def_id);
1357 let generics = tcx.generics_of(def_id);
1358 check_bounds_are_used(tcx, &generics, pty_ty);
1360 hir::ItemKind::ForeignMod(ref m) => {
1361 check_abi(tcx, it.span, m.abi);
1363 if m.abi == Abi::RustIntrinsic {
1364 for item in &m.items {
1365 intrinsic::check_intrinsic_type(tcx, item);
1367 } else if m.abi == Abi::PlatformIntrinsic {
1368 for item in &m.items {
1369 intrinsic::check_platform_intrinsic_type(tcx, item);
1372 for item in &m.items {
1373 let generics = tcx.generics_of(tcx.hir().local_def_id(item.id));
1374 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1375 let mut err = struct_span_err!(
1379 "foreign items may not have type parameters"
1381 err.span_label(item.span, "can't have type parameters");
1382 // FIXME: once we start storing spans for type arguments, turn this into a
1385 "use specialization instead of type parameters by replacing them \
1386 with concrete types like `u32`",
1391 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1392 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1397 _ => { /* nothing to do */ }
1401 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1402 // Only restricted on wasm32 target for now
1403 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1407 // If `#[link_section]` is missing, then nothing to verify
1408 let attrs = tcx.codegen_fn_attrs(id);
1409 if attrs.link_section.is_none() {
1413 // For the wasm32 target statics with #[link_section] are placed into custom
1414 // sections of the final output file, but this isn't link custom sections of
1415 // other executable formats. Namely we can only embed a list of bytes,
1416 // nothing with pointers to anything else or relocations. If any relocation
1417 // show up, reject them here.
1418 let instance = ty::Instance::mono(tcx, id);
1419 let cid = GlobalId {
1423 let param_env = ty::ParamEnv::reveal_all();
1424 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1425 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1428 bug!("Matching on non-ByRef static")
1430 if alloc.relocations.len() != 0 {
1431 let msg = "statics with a custom `#[link_section]` must be a \
1432 simple list of bytes on the wasm target with no \
1433 extra levels of indirection such as references";
1434 tcx.sess.span_err(span, msg);
1439 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1440 trait_def_id: DefId,
1442 let item_def_id = tcx.hir().local_def_id(item.id);
1443 // an error would be reported if this fails.
1444 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1447 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1448 impl_item: &hir::ImplItem,
1451 let mut err = struct_span_err!(
1452 tcx.sess, impl_item.span, E0520,
1453 "`{}` specializes an item from a parent `impl`, but \
1454 that item is not marked `default`",
1456 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1459 match tcx.span_of_impl(parent_impl) {
1461 err.span_label(span, "parent `impl` is here");
1462 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1466 err.note(&format!("parent implementation is in crate `{}`", cname));
1473 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1474 trait_def: &ty::TraitDef,
1475 trait_item: &ty::AssociatedItem,
1477 impl_item: &hir::ImplItem)
1479 let ancestors = trait_def.ancestors(tcx, impl_id);
1481 let kind = match impl_item.node {
1482 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1483 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1484 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1485 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1488 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1489 .map(|node_item| node_item.map(|parent| parent.defaultness));
1491 if let Some(parent) = parent {
1492 if tcx.impl_item_is_final(&parent) {
1493 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1499 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1502 impl_trait_ref: ty::TraitRef<'tcx>,
1503 impl_item_refs: &[hir::ImplItemRef]) {
1504 let impl_span = tcx.sess.source_map().def_span(impl_span);
1506 // If the trait reference itself is erroneous (so the compilation is going
1507 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1508 // isn't populated for such impls.
1509 if impl_trait_ref.references_error() { return; }
1511 // Locate trait definition and items
1512 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1513 let mut overridden_associated_type = None;
1515 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1517 // Check existing impl methods to see if they are both present in trait
1518 // and compatible with trait signature
1519 for impl_item in impl_items() {
1520 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.id));
1521 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1522 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1523 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1525 // Not compatible, but needed for the error message
1526 tcx.associated_items(impl_trait_ref.def_id)
1527 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1530 // Check that impl definition matches trait definition
1531 if let Some(ty_trait_item) = ty_trait_item {
1532 match impl_item.node {
1533 hir::ImplItemKind::Const(..) => {
1534 // Find associated const definition.
1535 if ty_trait_item.kind == ty::AssociatedKind::Const {
1536 compare_const_impl(tcx,
1542 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1543 "item `{}` is an associated const, \
1544 which doesn't match its trait `{}`",
1547 err.span_label(impl_item.span, "does not match trait");
1548 // We can only get the spans from local trait definition
1549 // Same for E0324 and E0325
1550 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1551 err.span_label(trait_span, "item in trait");
1556 hir::ImplItemKind::Method(..) => {
1557 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1558 if ty_trait_item.kind == ty::AssociatedKind::Method {
1559 compare_impl_method(tcx,
1566 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1567 "item `{}` is an associated method, \
1568 which doesn't match its trait `{}`",
1571 err.span_label(impl_item.span, "does not match trait");
1572 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1573 err.span_label(trait_span, "item in trait");
1578 hir::ImplItemKind::Existential(..) |
1579 hir::ImplItemKind::Type(_) => {
1580 if ty_trait_item.kind == ty::AssociatedKind::Type {
1581 if ty_trait_item.defaultness.has_value() {
1582 overridden_associated_type = Some(impl_item);
1585 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1586 "item `{}` is an associated type, \
1587 which doesn't match its trait `{}`",
1590 err.span_label(impl_item.span, "does not match trait");
1591 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1592 err.span_label(trait_span, "item in trait");
1599 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1603 // Check for missing items from trait
1604 let mut missing_items = Vec::new();
1605 let mut invalidated_items = Vec::new();
1606 let associated_type_overridden = overridden_associated_type.is_some();
1607 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1608 let is_implemented = trait_def.ancestors(tcx, impl_id)
1609 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1611 .map(|node_item| !node_item.node.is_from_trait())
1614 if !is_implemented && !tcx.impl_is_default(impl_id) {
1615 if !trait_item.defaultness.has_value() {
1616 missing_items.push(trait_item);
1617 } else if associated_type_overridden {
1618 invalidated_items.push(trait_item.ident);
1623 if !missing_items.is_empty() {
1624 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1625 "not all trait items implemented, missing: `{}`",
1626 missing_items.iter()
1627 .map(|trait_item| trait_item.ident.to_string())
1628 .collect::<Vec<_>>().join("`, `"));
1629 err.span_label(impl_span, format!("missing `{}` in implementation",
1630 missing_items.iter()
1631 .map(|trait_item| trait_item.ident.to_string())
1632 .collect::<Vec<_>>().join("`, `")));
1633 for trait_item in missing_items {
1634 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1635 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1637 err.note_trait_signature(trait_item.ident.to_string(),
1638 trait_item.signature(&tcx));
1644 if !invalidated_items.is_empty() {
1645 let invalidator = overridden_associated_type.unwrap();
1646 span_err!(tcx.sess, invalidator.span, E0399,
1647 "the following trait items need to be reimplemented \
1648 as `{}` was overridden: `{}`",
1650 invalidated_items.iter()
1651 .map(|name| name.to_string())
1652 .collect::<Vec<_>>().join("`, `"))
1656 /// Checks whether a type can be represented in memory. In particular, it
1657 /// identifies types that contain themselves without indirection through a
1658 /// pointer, which would mean their size is unbounded.
1659 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1663 let rty = tcx.type_of(item_def_id);
1665 // Check that it is possible to represent this type. This call identifies
1666 // (1) types that contain themselves and (2) types that contain a different
1667 // recursive type. It is only necessary to throw an error on those that
1668 // contain themselves. For case 2, there must be an inner type that will be
1669 // caught by case 1.
1670 match rty.is_representable(tcx, sp) {
1671 Representability::SelfRecursive(spans) => {
1672 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1674 err.span_label(span, "recursive without indirection");
1679 Representability::Representable | Representability::ContainsRecursive => (),
1684 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1685 let t = tcx.type_of(def_id);
1686 if let ty::Adt(def, substs) = t.sty {
1687 if def.is_struct() {
1688 let fields = &def.non_enum_variant().fields;
1689 if fields.is_empty() {
1690 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1693 let e = fields[0].ty(tcx, substs);
1694 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1695 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1696 .span_label(sp, "SIMD elements must have the same type")
1701 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1702 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1704 span_err!(tcx.sess, sp, E0077,
1705 "SIMD vector element type should be machine type");
1713 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1714 let repr = tcx.adt_def(def_id).repr;
1716 for attr in tcx.get_attrs(def_id).iter() {
1717 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1718 if let attr::ReprPacked(pack) = r {
1719 if pack != repr.pack {
1720 struct_span_err!(tcx.sess, sp, E0634,
1721 "type has conflicting packed representation hints").emit();
1727 struct_span_err!(tcx.sess, sp, E0587,
1728 "type has conflicting packed and align representation hints").emit();
1730 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1731 struct_span_err!(tcx.sess, sp, E0588,
1732 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1737 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1739 stack: &mut Vec<DefId>) -> bool {
1740 let t = tcx.type_of(def_id);
1741 if stack.contains(&def_id) {
1742 debug!("check_packed_inner: {:?} is recursive", t);
1745 if let ty::Adt(def, substs) = t.sty {
1746 if def.is_struct() || def.is_union() {
1747 if tcx.adt_def(def.did).repr.align > 0 {
1750 // push struct def_id before checking fields
1752 for field in &def.non_enum_variant().fields {
1753 let f = field.ty(tcx, substs);
1754 if let ty::Adt(def, _) = f.sty {
1755 if check_packed_inner(tcx, def.did, stack) {
1760 // only need to pop if not early out
1767 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1768 let adt = tcx.adt_def(def_id);
1769 if !adt.repr.transparent() {
1773 // For each field, figure out if it's known to be a ZST and align(1)
1774 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1775 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1776 let param_env = tcx.param_env(field.did);
1777 let layout = tcx.layout_of(param_env.and(ty));
1778 // We are currently checking the type this field came from, so it must be local
1779 let span = tcx.hir().span_if_local(field.did).unwrap();
1780 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1781 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1785 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1786 let non_zst_count = non_zst_fields.clone().count();
1787 if non_zst_count != 1 {
1788 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1789 struct_span_err!(tcx.sess, sp, E0690,
1790 "transparent struct needs exactly one non-zero-sized field, but has {}",
1792 .span_note(field_spans, "non-zero-sized field")
1795 for (span, zst, align1) in field_infos {
1797 span_err!(tcx.sess, span, E0691,
1798 "zero-sized field in transparent struct has alignment larger than 1");
1803 #[allow(trivial_numeric_casts)]
1804 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1806 vs: &'tcx [hir::Variant],
1808 let def_id = tcx.hir().local_def_id(id);
1809 let def = tcx.adt_def(def_id);
1810 def.destructor(tcx); // force the destructor to be evaluated
1813 let attributes = tcx.get_attrs(def_id);
1814 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1816 tcx.sess, attr.span, E0084,
1817 "unsupported representation for zero-variant enum")
1818 .span_label(sp, "zero-variant enum")
1823 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1824 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1825 if !tcx.features().repr128 {
1826 emit_feature_err(&tcx.sess.parse_sess,
1829 GateIssue::Language,
1830 "repr with 128-bit type is unstable");
1835 if let Some(ref e) = v.node.disr_expr {
1836 tcx.typeck_tables_of(tcx.hir().local_def_id(e.id));
1840 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1841 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1842 // Check for duplicate discriminant values
1843 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1844 let variant_did = def.variants[VariantIdx::new(i)].did;
1845 let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap();
1846 let variant_i = tcx.hir().expect_variant(variant_i_node_id);
1847 let i_span = match variant_i.node.disr_expr {
1848 Some(ref expr) => tcx.hir().span(expr.id),
1849 None => tcx.hir().span(variant_i_node_id)
1851 let span = match v.node.disr_expr {
1852 Some(ref expr) => tcx.hir().span(expr.id),
1855 struct_span_err!(tcx.sess, span, E0081,
1856 "discriminant value `{}` already exists", disr_vals[i])
1857 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1858 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1861 disr_vals.push(discr);
1864 check_representable(tcx, sp, def_id);
1867 fn report_unexpected_variant_def<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1871 span_err!(tcx.sess, span, E0533,
1872 "expected unit struct/variant or constant, found {} `{}`",
1874 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1877 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1878 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1880 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1881 -> Lrc<ty::GenericPredicates<'tcx>>
1884 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
1885 let item_id = tcx.hir().ty_param_owner(node_id);
1886 let item_def_id = tcx.hir().local_def_id(item_id);
1887 let generics = tcx.generics_of(item_def_id);
1888 let index = generics.param_def_id_to_index[&def_id];
1889 Lrc::new(ty::GenericPredicates {
1891 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1893 ty::Predicate::Trait(ref data)
1894 if data.skip_binder().self_ty().is_param(index) => {
1895 // HACK(eddyb) should get the original `Span`.
1896 let span = tcx.def_span(def_id);
1897 Some((predicate, span))
1905 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1906 -> Option<ty::Region<'tcx>> {
1908 Some(def) => infer::EarlyBoundRegion(span, def.name),
1909 None => infer::MiscVariable(span)
1911 Some(self.next_region_var(v))
1914 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1915 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1918 fn ty_infer_for_def(&self,
1919 ty_param_def: &ty::GenericParamDef,
1920 span: Span) -> Ty<'tcx> {
1921 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1927 fn projected_ty_from_poly_trait_ref(&self,
1930 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1933 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1935 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1939 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1942 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1943 if ty.has_escaping_bound_vars() {
1944 ty // FIXME: normalization and escaping regions
1946 self.normalize_associated_types_in(span, &ty)
1950 fn set_tainted_by_errors(&self) {
1951 self.infcx.set_tainted_by_errors()
1954 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1955 self.write_ty(hir_id, ty)
1959 /// Controls whether the arguments are tupled. This is used for the call
1962 /// Tupling means that all call-side arguments are packed into a tuple and
1963 /// passed as a single parameter. For example, if tupling is enabled, this
1966 /// fn f(x: (isize, isize))
1968 /// Can be called as:
1975 #[derive(Clone, Eq, PartialEq)]
1976 enum TupleArgumentsFlag {
1981 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1982 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1983 param_env: ty::ParamEnv<'tcx>,
1984 body_id: ast::NodeId)
1985 -> FnCtxt<'a, 'gcx, 'tcx> {
1989 err_count_on_creation: inh.tcx.sess.err_count(),
1991 ret_coercion_span: RefCell::new(None),
1993 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1994 ast::CRATE_NODE_ID)),
1995 diverges: Cell::new(Diverges::Maybe),
1996 has_errors: Cell::new(false),
1997 enclosing_breakables: RefCell::new(EnclosingBreakables {
1999 by_id: Default::default(),
2005 pub fn sess(&self) -> &Session {
2009 pub fn err_count_since_creation(&self) -> usize {
2010 self.tcx.sess.err_count() - self.err_count_on_creation
2013 /// Produce warning on the given node, if the current point in the
2014 /// function is unreachable, and there hasn't been another warning.
2015 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2016 if self.diverges.get() == Diverges::Always {
2017 self.diverges.set(Diverges::WarnedAlways);
2019 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2021 self.tcx().lint_node(
2022 lint::builtin::UNREACHABLE_CODE,
2024 &format!("unreachable {}", kind));
2030 code: ObligationCauseCode<'tcx>)
2031 -> ObligationCause<'tcx> {
2032 ObligationCause::new(span, self.body_id, code)
2035 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2036 self.cause(span, ObligationCauseCode::MiscObligation)
2039 /// Resolves type variables in `ty` if possible. Unlike the infcx
2040 /// version (resolve_type_vars_if_possible), this version will
2041 /// also select obligations if it seems useful, in an effort
2042 /// to get more type information.
2043 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2044 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2046 // No Infer()? Nothing needs doing.
2047 if !ty.has_infer_types() {
2048 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2052 // If `ty` is a type variable, see whether we already know what it is.
2053 ty = self.resolve_type_vars_if_possible(&ty);
2054 if !ty.has_infer_types() {
2055 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2059 // If not, try resolving pending obligations as much as
2060 // possible. This can help substantially when there are
2061 // indirect dependencies that don't seem worth tracking
2063 self.select_obligations_where_possible(false);
2064 ty = self.resolve_type_vars_if_possible(&ty);
2066 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2070 fn record_deferred_call_resolution(&self,
2071 closure_def_id: DefId,
2072 r: DeferredCallResolution<'gcx, 'tcx>) {
2073 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2074 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2077 fn remove_deferred_call_resolutions(&self,
2078 closure_def_id: DefId)
2079 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2081 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2082 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2085 pub fn tag(&self) -> String {
2086 let self_ptr: *const FnCtxt = self;
2087 format!("{:?}", self_ptr)
2090 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2091 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2092 span_bug!(span, "no type for local variable {}",
2093 self.tcx.hir().node_to_string(nid))
2098 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2099 debug!("write_ty({:?}, {:?}) in fcx {}",
2100 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2101 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2103 if ty.references_error() {
2104 self.has_errors.set(true);
2105 self.set_tainted_by_errors();
2109 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2110 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
2111 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2114 pub fn write_method_call(&self,
2116 method: MethodCallee<'tcx>) {
2117 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2120 .type_dependent_defs_mut()
2121 .insert(hir_id, Def::Method(method.def_id));
2123 self.write_substs(hir_id, method.substs);
2125 // When the method is confirmed, the `method.substs` includes
2126 // parameters from not just the method, but also the impl of
2127 // the method -- in particular, the `Self` type will be fully
2128 // resolved. However, those are not something that the "user
2129 // specified" -- i.e., those types come from the inferred type
2130 // of the receiver, not something the user wrote. So when we
2131 // create the user-substs, we want to replace those earlier
2132 // types with just the types that the user actually wrote --
2133 // that is, those that appear on the *method itself*.
2135 // As an example, if the user wrote something like
2136 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2137 // type of `foo` (possibly adjusted), but we don't want to
2138 // include that. We want just the `[_, u32]` part.
2139 if !method.substs.is_noop() {
2140 let method_generics = self.tcx.generics_of(method.def_id);
2141 if !method_generics.params.is_empty() {
2142 let user_type_annotation = self.infcx.probe(|_| {
2143 let user_substs = UserSubsts {
2144 substs: Substs::for_item(self.tcx, method.def_id, |param, _| {
2145 let i = param.index as usize;
2146 if i < method_generics.parent_count {
2147 self.infcx.var_for_def(DUMMY_SP, param)
2152 user_self_ty: None, // not relevant here
2155 self.infcx.canonicalize_user_type_annotation(&UserTypeAnnotation::TypeOf(
2161 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2162 self.write_user_type_annotation(hir_id, user_type_annotation);
2167 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2168 if !substs.is_noop() {
2169 debug!("write_substs({:?}, {:?}) in fcx {}",
2174 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2178 /// Given the substs that we just converted from the HIR, try to
2179 /// canonicalize them and store them as user-given substitutions
2180 /// (i.e., substitutions that must be respected by the NLL check).
2182 /// This should be invoked **before any unifications have
2183 /// occurred**, so that annotations like `Vec<_>` are preserved
2185 pub fn write_user_type_annotation_from_substs(
2189 substs: &'tcx Substs<'tcx>,
2190 user_self_ty: Option<UserSelfTy<'tcx>>,
2193 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2194 user_self_ty={:?} in fcx {}",
2195 hir_id, def_id, substs, user_self_ty, self.tag(),
2198 if !substs.is_noop() {
2199 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2200 &UserTypeAnnotation::TypeOf(def_id, UserSubsts {
2205 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2206 self.write_user_type_annotation(hir_id, canonicalized);
2210 pub fn write_user_type_annotation(
2213 canonical_user_type_annotation: CanonicalUserTypeAnnotation<'tcx>,
2216 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2217 hir_id, canonical_user_type_annotation, self.tag(),
2220 if !canonical_user_type_annotation.is_identity() {
2221 self.tables.borrow_mut().user_provided_types_mut().insert(
2222 hir_id, canonical_user_type_annotation
2225 debug!("write_user_type_annotation: skipping identity substs");
2229 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2230 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2236 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2237 Entry::Vacant(entry) => { entry.insert(adj); },
2238 Entry::Occupied(mut entry) => {
2239 debug!(" - composing on top of {:?}", entry.get());
2240 match (&entry.get()[..], &adj[..]) {
2241 // Applying any adjustment on top of a NeverToAny
2242 // is a valid NeverToAny adjustment, because it can't
2244 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2246 Adjustment { kind: Adjust::Deref(_), .. },
2247 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2249 Adjustment { kind: Adjust::Deref(_), .. },
2250 .. // Any following adjustments are allowed.
2252 // A reborrow has no effect before a dereference.
2254 // FIXME: currently we never try to compose autoderefs
2255 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2257 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2258 expr, entry.get(), adj)
2260 *entry.get_mut() = adj;
2265 /// Basically whenever we are converting from a type scheme into
2266 /// the fn body space, we always want to normalize associated
2267 /// types as well. This function combines the two.
2268 fn instantiate_type_scheme<T>(&self,
2270 substs: &Substs<'tcx>,
2273 where T : TypeFoldable<'tcx>
2275 let value = value.subst(self.tcx, substs);
2276 let result = self.normalize_associated_types_in(span, &value);
2277 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2284 /// As `instantiate_type_scheme`, but for the bounds found in a
2285 /// generic type scheme.
2286 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2287 -> ty::InstantiatedPredicates<'tcx> {
2288 let bounds = self.tcx.predicates_of(def_id);
2289 let result = bounds.instantiate(self.tcx, substs);
2290 let result = self.normalize_associated_types_in(span, &result);
2291 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2298 /// Replace the opaque types from the given value with type variables,
2299 /// and records the `OpaqueTypeMap` for later use during writeback. See
2300 /// `InferCtxt::instantiate_opaque_types` for more details.
2301 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2303 parent_id: ast::NodeId,
2306 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2307 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2311 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2312 self.instantiate_opaque_types(
2320 let mut opaque_types = self.opaque_types.borrow_mut();
2321 for (ty, decl) in opaque_type_map {
2322 let old_value = opaque_types.insert(ty, decl);
2323 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2329 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2330 where T : TypeFoldable<'tcx>
2332 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2335 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2337 where T : TypeFoldable<'tcx>
2339 self.inh.partially_normalize_associated_types_in(span,
2345 pub fn require_type_meets(&self,
2348 code: traits::ObligationCauseCode<'tcx>,
2351 self.register_bound(
2354 traits::ObligationCause::new(span, self.body_id, code));
2357 pub fn require_type_is_sized(&self,
2360 code: traits::ObligationCauseCode<'tcx>)
2362 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2363 self.require_type_meets(ty, span, code, lang_item);
2366 pub fn require_type_is_sized_deferred(&self,
2369 code: traits::ObligationCauseCode<'tcx>)
2371 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2374 pub fn register_bound(&self,
2377 cause: traits::ObligationCause<'tcx>)
2379 self.fulfillment_cx.borrow_mut()
2380 .register_bound(self, self.param_env, ty, def_id, cause);
2383 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2384 let t = AstConv::ast_ty_to_ty(self, ast_t);
2385 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2389 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2390 let ty = self.to_ty(ast_ty);
2392 // If the type given by the user has free regions, save it for
2393 // later, since NLL would like to enforce those. Also pass in
2394 // types that involve projections, since those can resolve to
2395 // `'static` bounds (modulo #54940, which hopefully will be
2396 // fixed by the time you see this comment, dear reader,
2397 // although I have my doubts). Other sorts of things are
2398 // already sufficiently enforced with erased regions. =)
2399 if ty.has_free_regions() || ty.has_projections() {
2400 let c_ty = self.infcx.canonicalize_response(&UserTypeAnnotation::Ty(ty));
2401 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2407 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2408 match self.tables.borrow().node_types().get(id) {
2410 None if self.is_tainted_by_errors() => self.tcx.types.err,
2412 let node_id = self.tcx.hir().hir_to_node_id(id);
2413 bug!("no type for node {}: {} in fcx {}",
2414 node_id, self.tcx.hir().node_to_string(node_id),
2420 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2421 /// outlive the region `r`.
2422 pub fn register_wf_obligation(&self,
2425 code: traits::ObligationCauseCode<'tcx>)
2427 // WF obligations never themselves fail, so no real need to give a detailed cause:
2428 let cause = traits::ObligationCause::new(span, self.body_id, code);
2429 self.register_predicate(traits::Obligation::new(cause,
2431 ty::Predicate::WellFormed(ty)));
2434 /// Registers obligations that all types appearing in `substs` are well-formed.
2435 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2436 for ty in substs.types() {
2437 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2441 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2442 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2443 /// trait/region obligations.
2445 /// For example, if there is a function:
2448 /// fn foo<'a,T:'a>(...)
2451 /// and a reference:
2457 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2458 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2459 pub fn add_obligations_for_parameters(&self,
2460 cause: traits::ObligationCause<'tcx>,
2461 predicates: &ty::InstantiatedPredicates<'tcx>)
2463 assert!(!predicates.has_escaping_bound_vars());
2465 debug!("add_obligations_for_parameters(predicates={:?})",
2468 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2469 self.register_predicate(obligation);
2473 // FIXME(arielb1): use this instead of field.ty everywhere
2474 // Only for fields! Returns <none> for methods>
2475 // Indifferent to privacy flags
2476 pub fn field_ty(&self,
2478 field: &'tcx ty::FieldDef,
2479 substs: &Substs<'tcx>)
2482 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2485 fn check_casts(&self) {
2486 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2487 for cast in deferred_cast_checks.drain(..) {
2492 fn resolve_generator_interiors(&self, def_id: DefId) {
2493 let mut generators = self.deferred_generator_interiors.borrow_mut();
2494 for (body_id, interior) in generators.drain(..) {
2495 self.select_obligations_where_possible(false);
2496 generator_interior::resolve_interior(self, def_id, body_id, interior);
2500 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2501 // Non-numerics get replaced with ! or () (depending on whether
2502 // feature(never_type) is enabled, unconstrained ints with i32,
2503 // unconstrained floats with f64.
2504 // Fallback becomes very dubious if we have encountered type-checking errors.
2505 // In that case, fallback to Error.
2506 // The return value indicates whether fallback has occurred.
2507 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2508 use rustc::ty::error::UnconstrainedNumeric::Neither;
2509 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2511 assert!(ty.is_ty_infer());
2512 let fallback = match self.type_is_unconstrained_numeric(ty) {
2513 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2514 UnconstrainedInt => self.tcx.types.i32,
2515 UnconstrainedFloat => self.tcx.types.f64,
2516 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2517 Neither => return false,
2519 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2520 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2524 fn select_all_obligations_or_error(&self) {
2525 debug!("select_all_obligations_or_error");
2526 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2527 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2531 /// Select as many obligations as we can at present.
2532 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2533 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2534 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2538 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2539 /// returns a type of `&T`, but the actual type we assign to the
2540 /// *expression* is `T`. So this function just peels off the return
2541 /// type by one layer to yield `T`.
2542 fn make_overloaded_place_return_type(&self,
2543 method: MethodCallee<'tcx>)
2544 -> ty::TypeAndMut<'tcx>
2546 // extract method return type, which will be &T;
2547 let ret_ty = method.sig.output();
2549 // method returns &T, but the type as visible to user is T, so deref
2550 ret_ty.builtin_deref(true).unwrap()
2553 fn lookup_indexing(&self,
2555 base_expr: &'gcx hir::Expr,
2559 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2561 // FIXME(#18741) -- this is almost but not quite the same as the
2562 // autoderef that normal method probing does. They could likely be
2565 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2566 let mut result = None;
2567 while result.is_none() && autoderef.next().is_some() {
2568 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2570 autoderef.finalize(self);
2574 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2575 /// (and otherwise adjust) `base_expr`, looking for a type which either
2576 /// supports builtin indexing or overloaded indexing.
2577 /// This loop implements one step in that search; the autoderef loop
2578 /// is implemented by `lookup_indexing`.
2579 fn try_index_step(&self,
2581 base_expr: &hir::Expr,
2582 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2585 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2587 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2588 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2595 for &unsize in &[false, true] {
2596 let mut self_ty = adjusted_ty;
2598 // We only unsize arrays here.
2599 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2600 self_ty = self.tcx.mk_slice(element_ty);
2606 // If some lookup succeeds, write callee into table and extract index/element
2607 // type from the method signature.
2608 // If some lookup succeeded, install method in table
2609 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2610 let method = self.try_overloaded_place_op(
2611 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2613 let result = method.map(|ok| {
2614 debug!("try_index_step: success, using overloaded indexing");
2615 let method = self.register_infer_ok_obligations(ok);
2617 let mut adjustments = autoderef.adjust_steps(self, needs);
2618 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2619 let mutbl = match r_mutbl {
2620 hir::MutImmutable => AutoBorrowMutability::Immutable,
2621 hir::MutMutable => AutoBorrowMutability::Mutable {
2622 // Indexing can be desugared to a method call,
2623 // so maybe we could use two-phase here.
2624 // See the documentation of AllowTwoPhase for why that's
2625 // not the case today.
2626 allow_two_phase_borrow: AllowTwoPhase::No,
2629 adjustments.push(Adjustment {
2630 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2631 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2638 adjustments.push(Adjustment {
2639 kind: Adjust::Unsize,
2640 target: method.sig.inputs()[0]
2643 self.apply_adjustments(base_expr, adjustments);
2645 self.write_method_call(expr.hir_id, method);
2646 (input_ty, self.make_overloaded_place_return_type(method).ty)
2648 if result.is_some() {
2656 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2657 let (tr, name) = match (op, is_mut) {
2658 (PlaceOp::Deref, false) =>
2659 (self.tcx.lang_items().deref_trait(), "deref"),
2660 (PlaceOp::Deref, true) =>
2661 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2662 (PlaceOp::Index, false) =>
2663 (self.tcx.lang_items().index_trait(), "index"),
2664 (PlaceOp::Index, true) =>
2665 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2667 (tr, ast::Ident::from_str(name))
2670 fn try_overloaded_place_op(&self,
2673 arg_tys: &[Ty<'tcx>],
2676 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2678 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2684 // Try Mut first, if needed.
2685 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2686 let method = match (needs, mut_tr) {
2687 (Needs::MutPlace, Some(trait_did)) => {
2688 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2693 // Otherwise, fall back to the immutable version.
2694 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2695 let method = match (method, imm_tr) {
2696 (None, Some(trait_did)) => {
2697 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2699 (method, _) => method,
2705 fn check_method_argument_types(&self,
2708 method: Result<MethodCallee<'tcx>, ()>,
2709 args_no_rcvr: &'gcx [hir::Expr],
2710 tuple_arguments: TupleArgumentsFlag,
2711 expected: Expectation<'tcx>)
2713 let has_error = match method {
2715 method.substs.references_error() || method.sig.references_error()
2720 let err_inputs = self.err_args(args_no_rcvr.len());
2722 let err_inputs = match tuple_arguments {
2723 DontTupleArguments => err_inputs,
2724 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2727 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2728 false, tuple_arguments, None);
2729 return self.tcx.types.err;
2732 let method = method.unwrap();
2733 // HACK(eddyb) ignore self in the definition (see above).
2734 let expected_arg_tys = self.expected_inputs_for_expected_output(
2737 method.sig.output(),
2738 &method.sig.inputs()[1..]
2740 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2741 args_no_rcvr, method.sig.variadic, tuple_arguments,
2742 self.tcx.hir().span_if_local(method.def_id));
2746 fn self_type_matches_expected_vid(
2748 trait_ref: ty::PolyTraitRef<'tcx>,
2749 expected_vid: ty::TyVid,
2751 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2753 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2754 trait_ref, self_ty, expected_vid
2757 ty::Infer(ty::TyVar(found_vid)) => {
2758 // FIXME: consider using `sub_root_var` here so we
2759 // can see through subtyping.
2760 let found_vid = self.root_var(found_vid);
2761 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2762 expected_vid == found_vid
2768 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2769 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2770 + Captures<'gcx> + 'b
2772 // FIXME: consider using `sub_root_var` here so we
2773 // can see through subtyping.
2774 let ty_var_root = self.root_var(self_ty);
2775 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2776 self_ty, ty_var_root,
2777 self.fulfillment_cx.borrow().pending_obligations());
2781 .pending_obligations()
2783 .filter_map(move |obligation| match obligation.predicate {
2784 ty::Predicate::Projection(ref data) =>
2785 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2786 ty::Predicate::Trait(ref data) =>
2787 Some((data.to_poly_trait_ref(), obligation)),
2788 ty::Predicate::Subtype(..) => None,
2789 ty::Predicate::RegionOutlives(..) => None,
2790 ty::Predicate::TypeOutlives(..) => None,
2791 ty::Predicate::WellFormed(..) => None,
2792 ty::Predicate::ObjectSafe(..) => None,
2793 ty::Predicate::ConstEvaluatable(..) => None,
2794 // N.B., this predicate is created by breaking down a
2795 // `ClosureType: FnFoo()` predicate, where
2796 // `ClosureType` represents some `Closure`. It can't
2797 // possibly be referring to the current closure,
2798 // because we haven't produced the `Closure` for
2799 // this closure yet; this is exactly why the other
2800 // code is looking for a self type of a unresolved
2801 // inference variable.
2802 ty::Predicate::ClosureKind(..) => None,
2803 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2806 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2807 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2808 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2812 /// Generic function that factors out common logic from function calls,
2813 /// method calls and overloaded operators.
2814 fn check_argument_types(&self,
2817 fn_inputs: &[Ty<'tcx>],
2818 mut expected_arg_tys: &[Ty<'tcx>],
2819 args: &'gcx [hir::Expr],
2821 tuple_arguments: TupleArgumentsFlag,
2822 def_span: Option<Span>) {
2825 // Grab the argument types, supplying fresh type variables
2826 // if the wrong number of arguments were supplied
2827 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2833 // All the input types from the fn signature must outlive the call
2834 // so as to validate implied bounds.
2835 for &fn_input_ty in fn_inputs {
2836 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2839 let expected_arg_count = fn_inputs.len();
2841 let param_count_error = |expected_count: usize,
2846 let mut err = tcx.sess.struct_span_err_with_code(sp,
2847 &format!("this function takes {}{} but {} {} supplied",
2848 if variadic {"at least "} else {""},
2849 potentially_plural_count(expected_count, "parameter"),
2850 potentially_plural_count(arg_count, "parameter"),
2851 if arg_count == 1 {"was"} else {"were"}),
2852 DiagnosticId::Error(error_code.to_owned()));
2854 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2855 err.span_label(def_s, "defined here");
2858 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2859 // remove closing `)` from the span
2860 let sugg_span = sugg_span.shrink_to_lo();
2861 err.span_suggestion_with_applicability(
2863 "expected the unit value `()`; create it with empty parentheses",
2865 Applicability::MachineApplicable);
2867 err.span_label(sp, format!("expected {}{}",
2868 if variadic {"at least "} else {""},
2869 potentially_plural_count(expected_count, "parameter")));
2874 let formal_tys = if tuple_arguments == TupleArguments {
2875 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2876 match tuple_type.sty {
2877 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2878 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2879 expected_arg_tys = &[];
2880 self.err_args(args.len())
2882 ty::Tuple(arg_types) => {
2883 expected_arg_tys = match expected_arg_tys.get(0) {
2884 Some(&ty) => match ty.sty {
2885 ty::Tuple(ref tys) => &tys,
2893 span_err!(tcx.sess, sp, E0059,
2894 "cannot use call notation; the first type parameter \
2895 for the function trait is neither a tuple nor unit");
2896 expected_arg_tys = &[];
2897 self.err_args(args.len())
2900 } else if expected_arg_count == supplied_arg_count {
2902 } else if variadic {
2903 if supplied_arg_count >= expected_arg_count {
2906 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2907 expected_arg_tys = &[];
2908 self.err_args(supplied_arg_count)
2911 // is the missing argument of type `()`?
2912 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2913 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2914 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2915 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2919 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2921 expected_arg_tys = &[];
2922 self.err_args(supplied_arg_count)
2924 // If there is no expectation, expect formal_tys.
2925 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2931 debug!("check_argument_types: formal_tys={:?}",
2932 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2934 // Check the arguments.
2935 // We do this in a pretty awful way: first we type-check any arguments
2936 // that are not closures, then we type-check the closures. This is so
2937 // that we have more information about the types of arguments when we
2938 // type-check the functions. This isn't really the right way to do this.
2939 for &check_closures in &[false, true] {
2940 debug!("check_closures={}", check_closures);
2942 // More awful hacks: before we check argument types, try to do
2943 // an "opportunistic" vtable resolution of any trait bounds on
2944 // the call. This helps coercions.
2946 self.select_obligations_where_possible(false);
2949 // For variadic functions, we don't have a declared type for all of
2950 // the arguments hence we only do our usual type checking with
2951 // the arguments who's types we do know.
2952 let t = if variadic {
2954 } else if tuple_arguments == TupleArguments {
2959 for (i, arg) in args.iter().take(t).enumerate() {
2960 // Warn only for the first loop (the "no closures" one).
2961 // Closure arguments themselves can't be diverging, but
2962 // a previous argument can, e.g., `foo(panic!(), || {})`.
2963 if !check_closures {
2964 self.warn_if_unreachable(arg.id, arg.span, "expression");
2967 let is_closure = match arg.node {
2968 ExprKind::Closure(..) => true,
2972 if is_closure != check_closures {
2976 debug!("checking the argument");
2977 let formal_ty = formal_tys[i];
2979 // The special-cased logic below has three functions:
2980 // 1. Provide as good of an expected type as possible.
2981 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2983 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2985 // 2. Coerce to the most detailed type that could be coerced
2986 // to, which is `expected_ty` if `rvalue_hint` returns an
2987 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2988 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2989 // We're processing function arguments so we definitely want to use
2990 // two-phase borrows.
2991 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2993 // 3. Relate the expected type and the formal one,
2994 // if the expected type was used for the coercion.
2995 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2999 // We also need to make sure we at least write the ty of the other
3000 // arguments which we skipped above.
3002 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3003 use structured_errors::{VariadicError, StructuredDiagnostic};
3004 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3007 for arg in args.iter().skip(expected_arg_count) {
3008 let arg_ty = self.check_expr(&arg);
3010 // There are a few types which get autopromoted when passed via varargs
3011 // in C but we just error out instead and require explicit casts.
3012 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3014 ty::Float(ast::FloatTy::F32) => {
3015 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3017 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3018 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3020 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3021 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3024 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3025 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3026 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3034 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3035 vec![self.tcx.types.err; len]
3038 // AST fragment checking
3041 expected: Expectation<'tcx>)
3047 ast::LitKind::Str(..) => tcx.mk_static_str(),
3048 ast::LitKind::ByteStr(ref v) => {
3049 tcx.mk_imm_ref(tcx.types.re_static,
3050 tcx.mk_array(tcx.types.u8, v.len() as u64))
3052 ast::LitKind::Byte(_) => tcx.types.u8,
3053 ast::LitKind::Char(_) => tcx.types.char,
3054 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3055 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3056 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3057 let opt_ty = expected.to_option(self).and_then(|ty| {
3059 ty::Int(_) | ty::Uint(_) => Some(ty),
3060 ty::Char => Some(tcx.types.u8),
3061 ty::RawPtr(..) => Some(tcx.types.usize),
3062 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3066 opt_ty.unwrap_or_else(
3067 || tcx.mk_int_var(self.next_int_var_id()))
3069 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3070 ast::LitKind::FloatUnsuffixed(_) => {
3071 let opt_ty = expected.to_option(self).and_then(|ty| {
3073 ty::Float(_) => Some(ty),
3077 opt_ty.unwrap_or_else(
3078 || tcx.mk_float_var(self.next_float_var_id()))
3080 ast::LitKind::Bool(_) => tcx.types.bool
3084 fn check_expr_eq_type(&self,
3085 expr: &'gcx hir::Expr,
3086 expected: Ty<'tcx>) {
3087 let ty = self.check_expr_with_hint(expr, expected);
3088 self.demand_eqtype(expr.span, expected, ty);
3091 pub fn check_expr_has_type_or_error(&self,
3092 expr: &'gcx hir::Expr,
3093 expected: Ty<'tcx>) -> Ty<'tcx> {
3094 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3097 fn check_expr_meets_expectation_or_error(&self,
3098 expr: &'gcx hir::Expr,
3099 expected: Expectation<'tcx>) -> Ty<'tcx> {
3100 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3101 let mut ty = self.check_expr_with_expectation(expr, expected);
3103 // While we don't allow *arbitrary* coercions here, we *do* allow
3104 // coercions from ! to `expected`.
3106 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3107 "expression with never type wound up being adjusted");
3108 let adj_ty = self.next_diverging_ty_var(
3109 TypeVariableOrigin::AdjustmentType(expr.span));
3110 self.apply_adjustments(expr, vec![Adjustment {
3111 kind: Adjust::NeverToAny,
3117 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3118 // Add help to type error if this is an `if` condition with an assignment.
3119 if let (ExpectIfCondition, &ExprKind::Assign(ref lhs, ref rhs))
3120 = (expected, &expr.node)
3122 let msg = "try comparing for equality";
3123 if let (Ok(left), Ok(right)) = (
3124 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3125 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3127 err.span_suggestion_with_applicability(
3130 format!("{} == {}", left, right),
3131 Applicability::MaybeIncorrect);
3141 fn check_expr_coercable_to_type(&self,
3142 expr: &'gcx hir::Expr,
3143 expected: Ty<'tcx>) -> Ty<'tcx> {
3144 let ty = self.check_expr_with_hint(expr, expected);
3145 // checks don't need two phase
3146 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3149 fn check_expr_with_hint(&self,
3150 expr: &'gcx hir::Expr,
3151 expected: Ty<'tcx>) -> Ty<'tcx> {
3152 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3155 fn check_expr_with_expectation(&self,
3156 expr: &'gcx hir::Expr,
3157 expected: Expectation<'tcx>) -> Ty<'tcx> {
3158 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3161 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3162 self.check_expr_with_expectation(expr, NoExpectation)
3165 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3166 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3169 // Determine the `Self` type, using fresh variables for all variables
3170 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3171 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3173 pub fn impl_self_ty(&self,
3174 span: Span, // (potential) receiver for this impl
3176 -> TypeAndSubsts<'tcx> {
3177 let ity = self.tcx.type_of(did);
3178 debug!("impl_self_ty: ity={:?}", ity);
3180 let substs = self.fresh_substs_for_item(span, did);
3181 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3183 TypeAndSubsts { substs: substs, ty: substd_ty }
3186 /// Unifies the output type with the expected type early, for more coercions
3187 /// and forward type information on the input expressions.
3188 fn expected_inputs_for_expected_output(&self,
3190 expected_ret: Expectation<'tcx>,
3191 formal_ret: Ty<'tcx>,
3192 formal_args: &[Ty<'tcx>])
3194 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3195 let ret_ty = match expected_ret.only_has_type(self) {
3197 None => return Vec::new()
3199 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3200 // Attempt to apply a subtyping relationship between the formal
3201 // return type (likely containing type variables if the function
3202 // is polymorphic) and the expected return type.
3203 // No argument expectations are produced if unification fails.
3204 let origin = self.misc(call_span);
3205 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3207 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3208 // to identity so the resulting type is not constrained.
3211 // Process any obligations locally as much as
3212 // we can. We don't care if some things turn
3213 // out unconstrained or ambiguous, as we're
3214 // just trying to get hints here.
3215 self.save_and_restore_in_snapshot_flag(|_| {
3216 let mut fulfill = TraitEngine::new(self.tcx);
3217 for obligation in ok.obligations {
3218 fulfill.register_predicate_obligation(self, obligation);
3220 fulfill.select_where_possible(self)
3221 }).map_err(|_| ())?;
3223 Err(_) => return Err(()),
3226 // Record all the argument types, with the substitutions
3227 // produced from the above subtyping unification.
3228 Ok(formal_args.iter().map(|ty| {
3229 self.resolve_type_vars_if_possible(ty)
3231 }).unwrap_or_default();
3232 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3233 formal_args, formal_ret,
3234 expect_args, expected_ret);
3238 // Checks a method call.
3239 fn check_method_call(&self,
3240 expr: &'gcx hir::Expr,
3241 segment: &hir::PathSegment,
3243 args: &'gcx [hir::Expr],
3244 expected: Expectation<'tcx>,
3245 needs: Needs) -> Ty<'tcx> {
3246 let rcvr = &args[0];
3247 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3248 // no need to check for bot/err -- callee does that
3249 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3251 let method = match self.lookup_method(rcvr_t,
3257 self.write_method_call(expr.hir_id, method);
3261 if segment.ident.name != keywords::Invalid.name() {
3262 self.report_method_error(span,
3265 SelfSource::MethodCall(rcvr),
3273 // Call the generic checker.
3274 self.check_method_argument_types(span,
3282 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3286 .unwrap_or_else(|| span_bug!(return_expr.span,
3287 "check_return_expr called outside fn body"));
3289 let ret_ty = ret_coercion.borrow().expected_ty();
3290 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3291 ret_coercion.borrow_mut()
3293 &self.cause(return_expr.span,
3294 ObligationCauseCode::ReturnType(return_expr.id)),
3299 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3300 // or 'if-else' expression.
3301 fn check_then_else(&self,
3302 cond_expr: &'gcx hir::Expr,
3303 then_expr: &'gcx hir::Expr,
3304 opt_else_expr: Option<&'gcx hir::Expr>,
3306 expected: Expectation<'tcx>) -> Ty<'tcx> {
3307 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3308 let cond_diverges = self.diverges.get();
3309 self.diverges.set(Diverges::Maybe);
3311 let expected = expected.adjust_for_branches(self);
3312 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3313 let then_diverges = self.diverges.get();
3314 self.diverges.set(Diverges::Maybe);
3316 // We've already taken the expected type's preferences
3317 // into account when typing the `then` branch. To figure
3318 // out the initial shot at a LUB, we thus only consider
3319 // `expected` if it represents a *hard* constraint
3320 // (`only_has_type`); otherwise, we just go with a
3321 // fresh type variable.
3322 let coerce_to_ty = expected.coercion_target_type(self, sp);
3323 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3325 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3326 coerce.coerce(self, &if_cause, then_expr, then_ty);
3328 if let Some(else_expr) = opt_else_expr {
3329 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3330 let else_diverges = self.diverges.get();
3332 coerce.coerce(self, &if_cause, else_expr, else_ty);
3334 // We won't diverge unless both branches do (or the condition does).
3335 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3337 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3338 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3340 // If the condition is false we can't diverge.
3341 self.diverges.set(cond_diverges);
3344 let result_ty = coerce.complete(self);
3345 if cond_ty.references_error() {
3352 // Check field access expressions
3353 fn check_field(&self,
3354 expr: &'gcx hir::Expr,
3356 base: &'gcx hir::Expr,
3357 field: ast::Ident) -> Ty<'tcx> {
3358 let expr_t = self.check_expr_with_needs(base, needs);
3359 let expr_t = self.structurally_resolved_type(base.span,
3361 let mut private_candidate = None;
3362 let mut autoderef = self.autoderef(expr.span, expr_t);
3363 while let Some((base_t, _)) = autoderef.next() {
3365 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3366 debug!("struct named {:?}", base_t);
3367 let (ident, def_scope) =
3368 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3369 let fields = &base_def.non_enum_variant().fields;
3370 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3371 let field = &fields[index];
3372 let field_ty = self.field_ty(expr.span, field, substs);
3373 // Save the index of all fields regardless of their visibility in case
3374 // of error recovery.
3375 self.write_field_index(expr.id, index);
3376 if field.vis.is_accessible_from(def_scope, self.tcx) {
3377 let adjustments = autoderef.adjust_steps(self, needs);
3378 self.apply_adjustments(base, adjustments);
3379 autoderef.finalize(self);
3381 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3384 private_candidate = Some((base_def.did, field_ty));
3387 ty::Tuple(ref tys) => {
3388 let fstr = field.as_str();
3389 if let Ok(index) = fstr.parse::<usize>() {
3390 if fstr == index.to_string() {
3391 if let Some(field_ty) = tys.get(index) {
3392 let adjustments = autoderef.adjust_steps(self, needs);
3393 self.apply_adjustments(base, adjustments);
3394 autoderef.finalize(self);
3396 self.write_field_index(expr.id, index);
3405 autoderef.unambiguous_final_ty(self);
3407 if let Some((did, field_ty)) = private_candidate {
3408 let struct_path = self.tcx().item_path_str(did);
3409 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3410 "field `{}` of struct `{}` is private",
3411 field, struct_path);
3412 // Also check if an accessible method exists, which is often what is meant.
3413 if self.method_exists(field, expr_t, expr.id, false) {
3414 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3418 } else if field.name == keywords::Invalid.name() {
3419 self.tcx().types.err
3420 } else if self.method_exists(field, expr_t, expr.id, true) {
3421 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3422 "attempted to take value of method `{}` on type `{}`",
3424 .help("maybe a `()` to call it is missing?")
3426 self.tcx().types.err
3428 if !expr_t.is_primitive_ty() {
3429 let mut err = self.no_such_field_err(field.span, field, expr_t);
3432 ty::Adt(def, _) if !def.is_enum() => {
3433 if let Some(suggested_field_name) =
3434 Self::suggest_field_name(def.non_enum_variant(),
3435 &field.as_str(), vec![]) {
3436 err.span_label(field.span,
3437 format!("did you mean `{}`?", suggested_field_name));
3439 err.span_label(field.span, "unknown field");
3440 let struct_variant_def = def.non_enum_variant();
3441 let field_names = self.available_field_names(struct_variant_def);
3442 if !field_names.is_empty() {
3443 err.note(&format!("available fields are: {}",
3444 self.name_series_display(field_names)));
3448 ty::Array(_, len) => {
3449 if let (Some(len), Ok(user_index)) = (
3450 len.assert_usize(self.tcx),
3451 field.as_str().parse::<u64>()
3453 let base = self.tcx.sess.source_map()
3454 .span_to_snippet(base.span)
3455 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3456 let help = "instead of using tuple indexing, use array indexing";
3457 let suggestion = format!("{}[{}]", base, field);
3458 let applicability = if len < user_index {
3459 Applicability::MachineApplicable
3461 Applicability::MaybeIncorrect
3463 err.span_suggestion_with_applicability(
3464 expr.span, help, suggestion, applicability
3469 let base = self.tcx.sess.source_map()
3470 .span_to_snippet(base.span)
3471 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3472 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3473 let suggestion = format!("(*{}).{}", base, field);
3474 err.span_suggestion_with_applicability(
3478 Applicability::MaybeIncorrect,
3485 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3486 "`{}` is a primitive type and therefore doesn't have fields",
3489 self.tcx().types.err
3493 // Return an hint about the closest match in field names
3494 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3496 skip: Vec<LocalInternedString>)
3498 let names = variant.fields.iter().filter_map(|field| {
3499 // ignore already set fields and private fields from non-local crates
3500 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3501 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3504 Some(&field.ident.name)
3508 find_best_match_for_name(names, field, None)
3511 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3512 variant.fields.iter().filter(|field| {
3513 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3514 field.vis.is_accessible_from(def_scope, self.tcx)
3516 .map(|field| field.ident.name)
3520 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3521 // dynamic limit, to never omit just one field
3522 let limit = if names.len() == 6 { 6 } else { 5 };
3523 let mut display = names.iter().take(limit)
3524 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3525 if names.len() > limit {
3526 display = format!("{} ... and {} others", display, names.len() - limit);
3531 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3532 -> DiagnosticBuilder {
3533 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3534 "no field `{}` on type `{}`",
3538 fn report_unknown_field(&self,
3540 variant: &'tcx ty::VariantDef,
3542 skip_fields: &[hir::Field],
3544 let mut err = self.type_error_struct_with_diag(
3546 |actual| match ty.sty {
3547 ty::Adt(adt, ..) if adt.is_enum() => {
3548 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3549 "{} `{}::{}` has no field named `{}`",
3550 kind_name, actual, variant.ident, field.ident)
3553 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3554 "{} `{}` has no field named `{}`",
3555 kind_name, actual, field.ident)
3559 // prevent all specified fields from being suggested
3560 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3561 if let Some(field_name) = Self::suggest_field_name(variant,
3562 &field.ident.as_str(),
3563 skip_fields.collect()) {
3564 err.span_label(field.ident.span,
3565 format!("field does not exist - did you mean `{}`?", field_name));
3568 ty::Adt(adt, ..) => {
3570 err.span_label(field.ident.span,
3571 format!("`{}::{}` does not have this field",
3572 ty, variant.ident));
3574 err.span_label(field.ident.span,
3575 format!("`{}` does not have this field", ty));
3577 let available_field_names = self.available_field_names(variant);
3578 if !available_field_names.is_empty() {
3579 err.note(&format!("available fields are: {}",
3580 self.name_series_display(available_field_names)));
3583 _ => bug!("non-ADT passed to report_unknown_field")
3589 fn check_expr_struct_fields(&self,
3591 expected: Expectation<'tcx>,
3592 expr_id: ast::NodeId,
3594 variant: &'tcx ty::VariantDef,
3595 ast_fields: &'gcx [hir::Field],
3596 check_completeness: bool) -> bool {
3600 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3601 .get(0).cloned().unwrap_or(adt_ty);
3602 // re-link the regions that EIfEO can erase.
3603 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3605 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3606 &ty::Adt(adt, substs) => {
3607 (substs, adt.adt_kind(), adt.variant_descr())
3609 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3612 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3613 (field.ident.modern(), (i, field))
3614 ).collect::<FxHashMap<_, _>>();
3616 let mut seen_fields = FxHashMap::default();
3618 let mut error_happened = false;
3620 // Type-check each field.
3621 for field in ast_fields {
3622 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3623 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3624 seen_fields.insert(ident, field.span);
3625 self.write_field_index(field.id, i);
3627 // We don't look at stability attributes on
3628 // struct-like enums (yet...), but it's definitely not
3629 // a bug to have constructed one.
3630 if adt_kind != AdtKind::Enum {
3631 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3634 self.field_ty(field.span, v_field, substs)
3636 error_happened = true;
3637 if let Some(prev_span) = seen_fields.get(&ident) {
3638 let mut err = struct_span_err!(self.tcx.sess,
3641 "field `{}` specified more than once",
3644 err.span_label(field.ident.span, "used more than once");
3645 err.span_label(*prev_span, format!("first use of `{}`", ident));
3649 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3655 // Make sure to give a type to the field even if there's
3656 // an error, so we can continue type-checking.
3657 self.check_expr_coercable_to_type(&field.expr, field_type);
3660 // Make sure the programmer specified correct number of fields.
3661 if kind_name == "union" {
3662 if ast_fields.len() != 1 {
3663 tcx.sess.span_err(span, "union expressions should have exactly one field");
3665 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3666 let len = remaining_fields.len();
3668 let mut displayable_field_names = remaining_fields
3670 .map(|ident| ident.as_str())
3671 .collect::<Vec<_>>();
3673 displayable_field_names.sort();
3675 let truncated_fields_error = if len <= 3 {
3678 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3681 let remaining_fields_names = displayable_field_names.iter().take(3)
3682 .map(|n| format!("`{}`", n))
3683 .collect::<Vec<_>>()
3686 struct_span_err!(tcx.sess, span, E0063,
3687 "missing field{} {}{} in initializer of `{}`",
3688 if remaining_fields.len() == 1 { "" } else { "s" },
3689 remaining_fields_names,
3690 truncated_fields_error,
3692 .span_label(span, format!("missing {}{}",
3693 remaining_fields_names,
3694 truncated_fields_error))
3700 fn check_struct_fields_on_error(&self,
3701 fields: &'gcx [hir::Field],
3702 base_expr: &'gcx Option<P<hir::Expr>>) {
3703 for field in fields {
3704 self.check_expr(&field.expr);
3706 if let Some(ref base) = *base_expr {
3707 self.check_expr(&base);
3711 pub fn check_struct_path(&self,
3713 node_id: ast::NodeId)
3714 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3715 let path_span = match *qpath {
3716 QPath::Resolved(_, ref path) => path.span,
3717 QPath::TypeRelative(ref qself, _) => qself.span
3719 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3720 let variant = match def {
3722 self.set_tainted_by_errors();
3725 Def::Variant(..) => {
3727 ty::Adt(adt, substs) => {
3728 Some((adt.variant_of_def(def), adt.did, substs))
3730 _ => bug!("unexpected type: {:?}", ty.sty)
3733 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3734 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3736 ty::Adt(adt, substs) if !adt.is_enum() => {
3737 Some((adt.non_enum_variant(), adt.did, substs))
3742 _ => bug!("unexpected definition: {:?}", def)
3745 if let Some((variant, did, substs)) = variant {
3746 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3747 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
3748 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3750 // Check bounds on type arguments used in the path.
3751 let bounds = self.instantiate_bounds(path_span, did, substs);
3752 let cause = traits::ObligationCause::new(path_span, self.body_id,
3753 traits::ItemObligation(did));
3754 self.add_obligations_for_parameters(cause, &bounds);
3758 struct_span_err!(self.tcx.sess, path_span, E0071,
3759 "expected struct, variant or union type, found {}",
3760 ty.sort_string(self.tcx))
3761 .span_label(path_span, "not a struct")
3767 fn check_expr_struct(&self,
3769 expected: Expectation<'tcx>,
3771 fields: &'gcx [hir::Field],
3772 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3774 // Find the relevant variant
3775 let (variant, adt_ty) =
3776 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3779 self.check_struct_fields_on_error(fields, base_expr);
3780 return self.tcx.types.err;
3783 let path_span = match *qpath {
3784 QPath::Resolved(_, ref path) => path.span,
3785 QPath::TypeRelative(ref qself, _) => qself.span
3788 // Prohibit struct expressions when non-exhaustive flag is set.
3789 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3790 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3791 span_err!(self.tcx.sess, expr.span, E0639,
3792 "cannot create non-exhaustive {} using struct expression",
3793 adt.variant_descr());
3796 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3797 variant, fields, base_expr.is_none());
3798 if let &Some(ref base_expr) = base_expr {
3799 // If check_expr_struct_fields hit an error, do not attempt to populate
3800 // the fields with the base_expr. This could cause us to hit errors later
3801 // when certain fields are assumed to exist that in fact do not.
3802 if !error_happened {
3803 self.check_expr_has_type_or_error(base_expr, adt_ty);
3805 ty::Adt(adt, substs) if adt.is_struct() => {
3806 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3807 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3812 .fru_field_types_mut()
3813 .insert(expr.hir_id, fru_field_types);
3816 span_err!(self.tcx.sess, base_expr.span, E0436,
3817 "functional record update syntax requires a struct");
3822 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3828 /// If an expression has any sub-expressions that result in a type error,
3829 /// inspecting that expression's type with `ty.references_error()` will return
3830 /// true. Likewise, if an expression is known to diverge, inspecting its
3831 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3832 /// strict, _|_ can appear in the type of an expression that does not,
3833 /// itself, diverge: for example, fn() -> _|_.)
3834 /// Note that inspecting a type's structure *directly* may expose the fact
3835 /// that there are actually multiple representations for `Error`, so avoid
3836 /// that when err needs to be handled differently.
3837 fn check_expr_with_expectation_and_needs(&self,
3838 expr: &'gcx hir::Expr,
3839 expected: Expectation<'tcx>,
3840 needs: Needs) -> Ty<'tcx> {
3841 debug!(">> type-checking: expr={:?} expected={:?}",
3844 // Warn for expressions after diverging siblings.
3845 self.warn_if_unreachable(expr.id, expr.span, "expression");
3847 // Hide the outer diverging and has_errors flags.
3848 let old_diverges = self.diverges.get();
3849 let old_has_errors = self.has_errors.get();
3850 self.diverges.set(Diverges::Maybe);
3851 self.has_errors.set(false);
3853 let ty = self.check_expr_kind(expr, expected, needs);
3855 // Warn for non-block expressions with diverging children.
3857 ExprKind::Block(..) |
3858 ExprKind::Loop(..) | ExprKind::While(..) |
3859 ExprKind::If(..) | ExprKind::Match(..) => {}
3861 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3864 // Any expression that produces a value of type `!` must have diverged
3866 self.diverges.set(self.diverges.get() | Diverges::Always);
3869 // Record the type, which applies it effects.
3870 // We need to do this after the warning above, so that
3871 // we don't warn for the diverging expression itself.
3872 self.write_ty(expr.hir_id, ty);
3874 // Combine the diverging and has_error flags.
3875 self.diverges.set(self.diverges.get() | old_diverges);
3876 self.has_errors.set(self.has_errors.get() | old_has_errors);
3878 debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
3879 debug!("... {:?}, expected is {:?}", ty, expected);
3886 expr: &'gcx hir::Expr,
3887 expected: Expectation<'tcx>,
3891 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3900 ExprKind::Box(ref subexpr) => {
3901 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3903 ty::Adt(def, _) if def.is_box()
3904 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3908 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3909 tcx.mk_box(referent_ty)
3912 ExprKind::Lit(ref lit) => {
3913 self.check_lit(&lit, expected)
3915 ExprKind::Binary(op, ref lhs, ref rhs) => {
3916 self.check_binop(expr, op, lhs, rhs)
3918 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3919 self.check_binop_assign(expr, op, lhs, rhs)
3921 ExprKind::Unary(unop, ref oprnd) => {
3922 let expected_inner = match unop {
3923 hir::UnNot | hir::UnNeg => {
3930 let needs = match unop {
3931 hir::UnDeref => needs,
3934 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3938 if !oprnd_t.references_error() {
3939 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3942 if let Some(mt) = oprnd_t.builtin_deref(true) {
3944 } else if let Some(ok) = self.try_overloaded_deref(
3945 expr.span, oprnd_t, needs) {
3946 let method = self.register_infer_ok_obligations(ok);
3947 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3948 let mutbl = match mutbl {
3949 hir::MutImmutable => AutoBorrowMutability::Immutable,
3950 hir::MutMutable => AutoBorrowMutability::Mutable {
3951 // (It shouldn't actually matter for unary ops whether
3952 // we enable two-phase borrows or not, since a unary
3953 // op has no additional operands.)
3954 allow_two_phase_borrow: AllowTwoPhase::No,
3957 self.apply_adjustments(oprnd, vec![Adjustment {
3958 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3959 target: method.sig.inputs()[0]
3962 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3963 self.write_method_call(expr.hir_id, method);
3965 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3966 "type `{}` cannot be dereferenced",
3968 oprnd_t = tcx.types.err;
3972 let result = self.check_user_unop(expr, oprnd_t, unop);
3973 // If it's builtin, we can reuse the type, this helps inference.
3974 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3979 let result = self.check_user_unop(expr, oprnd_t, unop);
3980 // If it's builtin, we can reuse the type, this helps inference.
3981 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3989 ExprKind::AddrOf(mutbl, ref oprnd) => {
3990 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3992 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3993 if oprnd.is_place_expr() {
3994 // Places may legitimately have unsized types.
3995 // For example, dereferences of a fat pointer and
3996 // the last field of a struct can be unsized.
3999 Expectation::rvalue_hint(self, ty)
4005 let needs = Needs::maybe_mut_place(mutbl);
4006 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4008 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4009 if tm.ty.references_error() {
4012 // Note: at this point, we cannot say what the best lifetime
4013 // is to use for resulting pointer. We want to use the
4014 // shortest lifetime possible so as to avoid spurious borrowck
4015 // errors. Moreover, the longest lifetime will depend on the
4016 // precise details of the value whose address is being taken
4017 // (and how long it is valid), which we don't know yet until type
4018 // inference is complete.
4020 // Therefore, here we simply generate a region variable. The
4021 // region inferencer will then select the ultimate value.
4022 // Finally, borrowck is charged with guaranteeing that the
4023 // value whose address was taken can actually be made to live
4024 // as long as it needs to live.
4025 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4026 tcx.mk_ref(region, tm)
4029 ExprKind::Path(ref qpath) => {
4030 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
4031 let ty = match def {
4033 self.set_tainted_by_errors();
4036 Def::VariantCtor(_, CtorKind::Fictive) => {
4037 report_unexpected_variant_def(tcx, &def, expr.span, qpath);
4040 _ => self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0,
4043 if let ty::FnDef(..) = ty.sty {
4044 let fn_sig = ty.fn_sig(tcx);
4045 if !tcx.features().unsized_locals {
4046 // We want to remove some Sized bounds from std functions,
4047 // but don't want to expose the removal to stable Rust.
4048 // i.e., we don't want to allow
4054 // to work in stable even if the Sized bound on `drop` is relaxed.
4055 for i in 0..fn_sig.inputs().skip_binder().len() {
4056 // We just want to check sizedness, so instead of introducing
4057 // placeholder lifetimes with probing, we just replace higher lifetimes
4059 let input = self.replace_bound_vars_with_fresh_vars(
4061 infer::LateBoundRegionConversionTime::FnCall,
4062 &fn_sig.input(i)).0;
4063 self.require_type_is_sized_deferred(input, expr.span,
4064 traits::SizedArgumentType);
4067 // Here we want to prevent struct constructors from returning unsized types.
4068 // There were two cases this happened: fn pointer coercion in stable
4069 // and usual function call in presense of unsized_locals.
4070 // Also, as we just want to check sizedness, instead of introducing
4071 // placeholder lifetimes with probing, we just replace higher lifetimes
4073 let output = self.replace_bound_vars_with_fresh_vars(
4075 infer::LateBoundRegionConversionTime::FnCall,
4076 &fn_sig.output()).0;
4077 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4080 // We always require that the type provided as the value for
4081 // a type parameter outlives the moment of instantiation.
4082 let substs = self.tables.borrow().node_substs(expr.hir_id);
4083 self.add_wf_bounds(substs, expr);
4087 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4088 for expr in outputs.iter().chain(inputs.iter()) {
4089 self.check_expr(expr);
4093 ExprKind::Break(destination, ref expr_opt) => {
4094 if let Ok(target_id) = destination.target_id {
4096 if let Some(ref e) = *expr_opt {
4097 // If this is a break with a value, we need to type-check
4098 // the expression. Get an expected type from the loop context.
4099 let opt_coerce_to = {
4100 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4101 enclosing_breakables.find_breakable(target_id)
4104 .map(|coerce| coerce.expected_ty())
4107 // If the loop context is not a `loop { }`, then break with
4108 // a value is illegal, and `opt_coerce_to` will be `None`.
4109 // Just set expectation to error in that case.
4110 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4112 // Recurse without `enclosing_breakables` borrowed.
4113 e_ty = self.check_expr_with_hint(e, coerce_to);
4114 cause = self.misc(e.span);
4116 // Otherwise, this is a break *without* a value. That's
4117 // always legal, and is equivalent to `break ()`.
4118 e_ty = tcx.mk_unit();
4119 cause = self.misc(expr.span);
4122 // Now that we have type-checked `expr_opt`, borrow
4123 // the `enclosing_loops` field and let's coerce the
4124 // type of `expr_opt` into what is expected.
4125 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4126 let ctxt = enclosing_breakables.find_breakable(target_id);
4127 if let Some(ref mut coerce) = ctxt.coerce {
4128 if let Some(ref e) = *expr_opt {
4129 coerce.coerce(self, &cause, e, e_ty);
4131 assert!(e_ty.is_unit());
4132 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4135 // If `ctxt.coerce` is `None`, we can just ignore
4136 // the type of the expresison. This is because
4137 // either this was a break *without* a value, in
4138 // which case it is always a legal type (`()`), or
4139 // else an error would have been flagged by the
4140 // `loops` pass for using break with an expression
4141 // where you are not supposed to.
4142 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4145 ctxt.may_break = true;
4147 // the type of a `break` is always `!`, since it diverges
4150 // Otherwise, we failed to find the enclosing loop;
4151 // this can only happen if the `break` was not
4152 // inside a loop at all, which is caught by the
4153 // loop-checking pass.
4154 if self.tcx.sess.err_count() == 0 {
4155 self.tcx.sess.delay_span_bug(expr.span,
4156 "break was outside loop, but no error was emitted");
4159 // We still need to assign a type to the inner expression to
4160 // prevent the ICE in #43162.
4161 if let Some(ref e) = *expr_opt {
4162 self.check_expr_with_hint(e, tcx.types.err);
4164 // ... except when we try to 'break rust;'.
4165 // ICE this expression in particular (see #43162).
4166 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4167 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4168 fatally_break_rust(self.tcx.sess);
4172 // There was an error; make type-check fail.
4177 ExprKind::Continue(destination) => {
4178 if destination.target_id.is_ok() {
4181 // There was an error; make type-check fail.
4185 ExprKind::Ret(ref expr_opt) => {
4186 if self.ret_coercion.is_none() {
4187 struct_span_err!(self.tcx.sess, expr.span, E0572,
4188 "return statement outside of function body").emit();
4189 } else if let Some(ref e) = *expr_opt {
4190 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4191 self.check_return_expr(e);
4193 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4194 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4195 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4196 if let Some((fn_decl, _)) = self.get_fn_decl(expr.id) {
4197 coercion.coerce_forced_unit(
4202 fn_decl.output.span(),
4204 "expected `{}` because of this return type",
4212 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4217 ExprKind::Assign(ref lhs, ref rhs) => {
4218 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4220 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4223 ExpectIfCondition => {
4224 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4225 expected error elsehwere");
4228 // Only check this if not in an `if` condition, as the
4229 // mistyped comparison help is more appropriate.
4230 if !lhs.is_place_expr() {
4231 struct_span_err!(self.tcx.sess, expr.span, E0070,
4232 "invalid left-hand side expression")
4233 .span_label(expr.span, "left-hand of expression not valid")
4239 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4241 if lhs_ty.references_error() || rhs_ty.references_error() {
4247 ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4248 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4249 expr.span, expected)
4251 ExprKind::While(ref cond, ref body, _) => {
4252 let ctxt = BreakableCtxt {
4253 // cannot use break with a value from a while loop
4255 may_break: false, // Will get updated if/when we find a `break`.
4258 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4259 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4260 let cond_diverging = self.diverges.get();
4261 self.check_block_no_value(&body);
4263 // We may never reach the body so it diverging means nothing.
4264 self.diverges.set(cond_diverging);
4268 // No way to know whether it's diverging because
4269 // of a `break` or an outer `break` or `return`.
4270 self.diverges.set(Diverges::Maybe);
4275 ExprKind::Loop(ref body, _, source) => {
4276 let coerce = match source {
4277 // you can only use break with a value from a normal `loop { }`
4278 hir::LoopSource::Loop => {
4279 let coerce_to = expected.coercion_target_type(self, body.span);
4280 Some(CoerceMany::new(coerce_to))
4283 hir::LoopSource::WhileLet |
4284 hir::LoopSource::ForLoop => {
4289 let ctxt = BreakableCtxt {
4291 may_break: false, // Will get updated if/when we find a `break`.
4294 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4295 self.check_block_no_value(&body);
4299 // No way to know whether it's diverging because
4300 // of a `break` or an outer `break` or `return`.
4301 self.diverges.set(Diverges::Maybe);
4304 // If we permit break with a value, then result type is
4305 // the LUB of the breaks (possibly ! if none); else, it
4306 // is nil. This makes sense because infinite loops
4307 // (which would have type !) are only possible iff we
4308 // permit break with a value [1].
4309 if ctxt.coerce.is_none() && !ctxt.may_break {
4311 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4313 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4315 ExprKind::Match(ref discrim, ref arms, match_src) => {
4316 self.check_match(expr, &discrim, arms, expected, match_src)
4318 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4319 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4321 ExprKind::Block(ref body, _) => {
4322 self.check_block_with_expected(&body, expected)
4324 ExprKind::Call(ref callee, ref args) => {
4325 self.check_call(expr, &callee, args, expected)
4327 ExprKind::MethodCall(ref segment, span, ref args) => {
4328 self.check_method_call(expr, segment, span, args, expected, needs)
4330 ExprKind::Cast(ref e, ref t) => {
4331 // Find the type of `e`. Supply hints based on the type we are casting to,
4333 let t_cast = self.to_ty_saving_user_provided_ty(t);
4334 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4335 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4336 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4338 // Eagerly check for some obvious errors.
4339 if t_expr.references_error() || t_cast.references_error() {
4342 // Defer other checks until we're done type checking.
4343 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4344 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4346 deferred_cast_checks.push(cast_check);
4349 Err(ErrorReported) => {
4355 ExprKind::Type(ref e, ref t) => {
4356 let ty = self.to_ty_saving_user_provided_ty(&t);
4357 self.check_expr_eq_type(&e, ty);
4360 ExprKind::Array(ref args) => {
4361 let uty = expected.to_option(self).and_then(|uty| {
4363 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4368 let element_ty = if !args.is_empty() {
4369 let coerce_to = uty.unwrap_or_else(
4370 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4371 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4372 assert_eq!(self.diverges.get(), Diverges::Maybe);
4374 let e_ty = self.check_expr_with_hint(e, coerce_to);
4375 let cause = self.misc(e.span);
4376 coerce.coerce(self, &cause, e, e_ty);
4378 coerce.complete(self)
4380 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4382 tcx.mk_array(element_ty, args.len() as u64)
4384 ExprKind::Repeat(ref element, ref count) => {
4385 let count_def_id = tcx.hir().local_def_id(count.id);
4386 let param_env = ty::ParamEnv::empty();
4387 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4388 let instance = ty::Instance::resolve(
4394 let global_id = GlobalId {
4398 let count = tcx.const_eval(param_env.and(global_id));
4400 let uty = match expected {
4401 ExpectHasType(uty) => {
4403 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4410 let (element_ty, t) = match uty {
4412 self.check_expr_coercable_to_type(&element, uty);
4416 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4417 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4422 if let Ok(count) = count {
4423 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4425 // For [foo, ..n] where n > 1, `foo` must have
4427 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4428 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4432 if element_ty.references_error() {
4434 } else if let Ok(count) = count {
4435 tcx.mk_ty(ty::Array(t, count))
4440 ExprKind::Tup(ref elts) => {
4441 let flds = expected.only_has_type(self).and_then(|ty| {
4442 let ty = self.resolve_type_vars_with_obligations(ty);
4444 ty::Tuple(ref flds) => Some(&flds[..]),
4449 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4450 let t = match flds {
4451 Some(ref fs) if i < fs.len() => {
4453 self.check_expr_coercable_to_type(&e, ety);
4457 self.check_expr_with_expectation(&e, NoExpectation)
4462 let tuple = tcx.mk_tup(elt_ts_iter);
4463 if tuple.references_error() {
4466 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4470 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4471 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4473 ExprKind::Field(ref base, field) => {
4474 self.check_field(expr, needs, &base, field)
4476 ExprKind::Index(ref base, ref idx) => {
4477 let base_t = self.check_expr_with_needs(&base, needs);
4478 let idx_t = self.check_expr(&idx);
4480 if base_t.references_error() {
4482 } else if idx_t.references_error() {
4485 let base_t = self.structurally_resolved_type(base.span, base_t);
4486 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4487 Some((index_ty, element_ty)) => {
4488 // two-phase not needed because index_ty is never mutable
4489 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4494 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4495 "cannot index into a value of type `{}`",
4497 // Try to give some advice about indexing tuples.
4498 if let ty::Tuple(..) = base_t.sty {
4499 let mut needs_note = true;
4500 // If the index is an integer, we can show the actual
4501 // fixed expression:
4502 if let ExprKind::Lit(ref lit) = idx.node {
4503 if let ast::LitKind::Int(i,
4504 ast::LitIntType::Unsuffixed) = lit.node {
4505 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4506 if let Ok(snip) = snip {
4507 err.span_suggestion_with_applicability(
4509 "to access tuple elements, use",
4510 format!("{}.{}", snip, i),
4511 Applicability::MachineApplicable);
4517 err.help("to access tuple elements, use tuple indexing \
4518 syntax (e.g., `tuple.0`)");
4527 ExprKind::Yield(ref value) => {
4528 match self.yield_ty {
4530 self.check_expr_coercable_to_type(&value, ty);
4533 struct_span_err!(self.tcx.sess, expr.span, E0627,
4534 "yield statement outside of generator literal").emit();
4539 hir::ExprKind::Err => {
4545 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4546 // The newly resolved definition is written into `type_dependent_defs`.
4547 fn finish_resolving_struct_path(&self,
4550 node_id: ast::NodeId)
4554 QPath::Resolved(ref maybe_qself, ref path) => {
4555 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4556 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4559 QPath::TypeRelative(ref qself, ref segment) => {
4560 let ty = self.to_ty(qself);
4562 let def = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4567 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4570 // Write back the new resolution.
4571 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4572 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4579 // Resolve associated value path into a base type and associated constant or method definition.
4580 // The newly resolved definition is written into `type_dependent_defs`.
4581 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4583 node_id: ast::NodeId,
4585 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4587 let (ty, qself, item_segment) = match *qpath {
4588 QPath::Resolved(ref opt_qself, ref path) => {
4590 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4591 &path.segments[..]);
4593 QPath::TypeRelative(ref qself, ref segment) => {
4594 (self.to_ty(qself), qself, segment)
4597 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4598 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4599 // Return directly on cache hit. This is useful to avoid doubly reporting
4600 // errors with default match binding modes. See #44614.
4601 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4603 let item_name = item_segment.ident;
4604 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4607 let def = match error {
4608 method::MethodError::PrivateMatch(def, _) => def,
4611 if item_name.name != keywords::Invalid.name() {
4612 self.report_method_error(span,
4615 SelfSource::QPath(qself),
4623 // Write back the new resolution.
4624 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4625 (def, Some(ty), slice::from_ref(&**item_segment))
4628 pub fn check_decl_initializer(&self,
4629 local: &'gcx hir::Local,
4630 init: &'gcx hir::Expr) -> Ty<'tcx>
4632 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4633 // for #42640 (default match binding modes).
4636 let ref_bindings = local.pat.contains_explicit_ref_binding();
4638 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4639 if let Some(m) = ref_bindings {
4640 // Somewhat subtle: if we have a `ref` binding in the pattern,
4641 // we want to avoid introducing coercions for the RHS. This is
4642 // both because it helps preserve sanity and, in the case of
4643 // ref mut, for soundness (issue #23116). In particular, in
4644 // the latter case, we need to be clear that the type of the
4645 // referent for the reference that results is *equal to* the
4646 // type of the place it is referencing, and not some
4647 // supertype thereof.
4648 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4649 self.demand_eqtype(init.span, local_ty, init_ty);
4652 self.check_expr_coercable_to_type(init, local_ty)
4656 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4657 let t = self.local_ty(local.span, local.id).decl_ty;
4658 self.write_ty(local.hir_id, t);
4660 if let Some(ref init) = local.init {
4661 let init_ty = self.check_decl_initializer(local, &init);
4662 if init_ty.references_error() {
4663 self.write_ty(local.hir_id, init_ty);
4667 self.check_pat_walk(&local.pat, t,
4668 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4670 let pat_ty = self.node_ty(local.pat.hir_id);
4671 if pat_ty.references_error() {
4672 self.write_ty(local.hir_id, pat_ty);
4676 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4677 // Don't do all the complex logic below for `DeclItem`.
4679 hir::StmtKind::Decl(ref decl, _) => {
4680 if let hir::DeclKind::Item(_) = decl.node {
4684 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4687 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4689 // Hide the outer diverging and `has_errors` flags.
4690 let old_diverges = self.diverges.get();
4691 let old_has_errors = self.has_errors.get();
4692 self.diverges.set(Diverges::Maybe);
4693 self.has_errors.set(false);
4696 hir::StmtKind::Decl(ref decl, _) => {
4698 hir::DeclKind::Local(ref l) => {
4699 self.check_decl_local(&l);
4702 hir::DeclKind::Item(_) => ()
4705 hir::StmtKind::Expr(ref expr, _) => {
4706 // Check with expected type of `()`.
4707 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4709 hir::StmtKind::Semi(ref expr, _) => {
4710 self.check_expr(&expr);
4714 // Combine the diverging and `has_error` flags.
4715 self.diverges.set(self.diverges.get() | old_diverges);
4716 self.has_errors.set(self.has_errors.get() | old_has_errors);
4719 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4720 let unit = self.tcx.mk_unit();
4721 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4723 // if the block produces a `!` value, that can always be
4724 // (effectively) coerced to unit.
4726 self.demand_suptype(blk.span, unit, ty);
4730 fn check_block_with_expected(&self,
4731 blk: &'gcx hir::Block,
4732 expected: Expectation<'tcx>) -> Ty<'tcx> {
4734 let mut fcx_ps = self.ps.borrow_mut();
4735 let unsafety_state = fcx_ps.recurse(blk);
4736 replace(&mut *fcx_ps, unsafety_state)
4739 // In some cases, blocks have just one exit, but other blocks
4740 // can be targeted by multiple breaks. This can happen both
4741 // with labeled blocks as well as when we desugar
4742 // a `try { ... }` expression.
4746 // 'a: { if true { break 'a Err(()); } Ok(()) }
4748 // Here we would wind up with two coercions, one from
4749 // `Err(())` and the other from the tail expression
4750 // `Ok(())`. If the tail expression is omitted, that's a
4751 // "forced unit" -- unless the block diverges, in which
4752 // case we can ignore the tail expression (e.g., `'a: {
4753 // break 'a 22; }` would not force the type of the block
4755 let tail_expr = blk.expr.as_ref();
4756 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4757 let coerce = if blk.targeted_by_break {
4758 CoerceMany::new(coerce_to_ty)
4760 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4761 Some(e) => slice::from_ref(e),
4764 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4767 let prev_diverges = self.diverges.get();
4768 let ctxt = BreakableCtxt {
4769 coerce: Some(coerce),
4773 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4774 for s in &blk.stmts {
4778 // check the tail expression **without** holding the
4779 // `enclosing_breakables` lock below.
4780 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4782 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4783 let ctxt = enclosing_breakables.find_breakable(blk.id);
4784 let coerce = ctxt.coerce.as_mut().unwrap();
4785 if let Some(tail_expr_ty) = tail_expr_ty {
4786 let tail_expr = tail_expr.unwrap();
4787 let cause = self.cause(tail_expr.span,
4788 ObligationCauseCode::BlockTailExpression(blk.id));
4794 // Subtle: if there is no explicit tail expression,
4795 // that is typically equivalent to a tail expression
4796 // of `()` -- except if the block diverges. In that
4797 // case, there is no value supplied from the tail
4798 // expression (assuming there are no other breaks,
4799 // this implies that the type of the block will be
4802 // #41425 -- label the implicit `()` as being the
4803 // "found type" here, rather than the "expected type".
4804 if !self.diverges.get().always() {
4805 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4806 if let Some(expected_ty) = expected.only_has_type(self) {
4807 self.consider_hint_about_removing_semicolon(blk,
4817 // If we can break from the block, then the block's exit is always reachable
4818 // (... as long as the entry is reachable) - regardless of the tail of the block.
4819 self.diverges.set(prev_diverges);
4822 let mut ty = ctxt.coerce.unwrap().complete(self);
4824 if self.has_errors.get() || ty.references_error() {
4825 ty = self.tcx.types.err
4828 self.write_ty(blk.hir_id, ty);
4830 *self.ps.borrow_mut() = prev;
4834 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4835 /// suggestion can be made, `None` otherwise.
4836 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4837 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4838 // `while` before reaching it, as block tail returns are not available in them.
4839 if let Some(fn_id) = self.tcx.hir().get_return_block(blk_id) {
4840 let parent = self.tcx.hir().get(fn_id);
4842 if let Node::Item(&hir::Item {
4843 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4845 decl.clone().and_then(|decl| {
4846 // This is less than ideal, it will not suggest a return type span on any
4847 // method called `main`, regardless of whether it is actually the entry point,
4848 // but it will still present it as the reason for the expected type.
4849 Some((decl, ident.name != Symbol::intern("main")))
4851 } else if let Node::TraitItem(&hir::TraitItem {
4852 node: hir::TraitItemKind::Method(hir::MethodSig {
4856 decl.clone().and_then(|decl| {
4859 } else if let Node::ImplItem(&hir::ImplItem {
4860 node: hir::ImplItemKind::Method(hir::MethodSig {
4864 decl.clone().and_then(|decl| {
4875 /// On implicit return expressions with mismatched types, provide the following suggestions:
4877 /// - Point out the method's return type as the reason for the expected type
4878 /// - Possible missing semicolon
4879 /// - Possible missing return type if the return type is the default, and not `fn main()`
4880 pub fn suggest_mismatched_types_on_tail(&self,
4881 err: &mut DiagnosticBuilder<'tcx>,
4882 expression: &'gcx hir::Expr,
4886 blk_id: ast::NodeId) {
4887 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4888 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4889 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4891 self.suggest_ref_or_into(err, expression, expected, found);
4894 pub fn suggest_ref_or_into(
4896 err: &mut DiagnosticBuilder<'tcx>,
4901 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4902 err.span_suggestion_with_applicability(
4906 Applicability::MachineApplicable,
4908 } else if !self.check_for_cast(err, expr, found, expected) {
4909 let methods = self.get_conversion_methods(expr.span, expected, found);
4910 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4911 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4912 .filter_map(|(receiver, method)| {
4913 let method_call = format!(".{}()", method.ident);
4914 if receiver.ends_with(&method_call) {
4915 None // do not suggest code that is already there (#53348)
4917 let method_call_list = [".to_vec()", ".to_string()"];
4918 if receiver.ends_with(".clone()")
4919 && method_call_list.contains(&method_call.as_str()) {
4920 let max_len = receiver.rfind(".").unwrap();
4921 Some(format!("{}{}", &receiver[..max_len], method_call))
4924 Some(format!("{}{}", receiver, method_call))
4928 if suggestions.peek().is_some() {
4929 err.span_suggestions_with_applicability(
4931 "try using a conversion method",
4933 Applicability::MaybeIncorrect,
4940 /// A common error is to forget to add a semicolon at the end of a block:
4944 /// bar_that_returns_u32()
4948 /// This routine checks if the return expression in a block would make sense on its own as a
4949 /// statement and the return type has been left as default or has been specified as `()`. If so,
4950 /// it suggests adding a semicolon.
4951 fn suggest_missing_semicolon(&self,
4952 err: &mut DiagnosticBuilder<'tcx>,
4953 expression: &'gcx hir::Expr,
4956 if expected.is_unit() {
4957 // `BlockTailExpression` only relevant if the tail expr would be
4958 // useful on its own.
4959 match expression.node {
4960 ExprKind::Call(..) |
4961 ExprKind::MethodCall(..) |
4963 ExprKind::While(..) |
4964 ExprKind::Loop(..) |
4965 ExprKind::Match(..) |
4966 ExprKind::Block(..) => {
4967 let sp = self.tcx.sess.source_map().next_point(cause_span);
4968 err.span_suggestion_with_applicability(
4970 "try adding a semicolon",
4972 Applicability::MachineApplicable);
4979 /// A possible error is to forget to add a return type that is needed:
4983 /// bar_that_returns_u32()
4987 /// This routine checks if the return type is left as default, the method is not part of an
4988 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4990 fn suggest_missing_return_type(&self,
4991 err: &mut DiagnosticBuilder<'tcx>,
4992 fn_decl: &hir::FnDecl,
4995 can_suggest: bool) {
4996 // Only suggest changing the return type for methods that
4997 // haven't set a return type at all (and aren't `fn main()` or an impl).
4998 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4999 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5000 err.span_suggestion_with_applicability(
5002 "try adding a return type",
5003 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5004 Applicability::MachineApplicable);
5006 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5007 err.span_label(span, "possibly return type missing here?");
5009 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5010 // `fn main()` must return `()`, do not suggest changing return type
5011 err.span_label(span, "expected `()` because of default return type");
5013 // expectation was caused by something else, not the default return
5014 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
5015 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5016 // Only point to return type if the expected type is the return type, as if they
5017 // are not, the expectation must have been caused by something else.
5018 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5020 let ty = AstConv::ast_ty_to_ty(self, ty);
5021 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
5022 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
5023 if ty.sty == expected.sty {
5024 err.span_label(sp, format!("expected `{}` because of return type",
5032 /// A common error is to add an extra semicolon:
5035 /// fn foo() -> usize {
5040 /// This routine checks if the final statement in a block is an
5041 /// expression with an explicit semicolon whose type is compatible
5042 /// with `expected_ty`. If so, it suggests removing the semicolon.
5043 fn consider_hint_about_removing_semicolon(&self,
5044 blk: &'gcx hir::Block,
5045 expected_ty: Ty<'tcx>,
5046 err: &mut DiagnosticBuilder) {
5047 // Be helpful when the user wrote `{... expr;}` and
5048 // taking the `;` off is enough to fix the error.
5049 let last_stmt = match blk.stmts.last() {
5053 let last_expr = match last_stmt.node {
5054 hir::StmtKind::Semi(ref e, _) => e,
5057 let last_expr_ty = self.node_ty(last_expr.hir_id);
5058 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5061 let original_span = original_sp(last_stmt.span, blk.span);
5062 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
5063 err.span_suggestion_with_applicability(
5065 "consider removing this semicolon",
5067 Applicability::MachineApplicable);
5070 // Instantiates the given path, which must refer to an item with the given
5071 // number of type parameters and type.
5072 pub fn instantiate_value_path(&self,
5073 segments: &[hir::PathSegment],
5074 self_ty: Option<Ty<'tcx>>,
5077 node_id: ast::NodeId)
5078 -> (Ty<'tcx>, Def) {
5080 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5089 let path_segs = AstConv::def_ids_for_path_segments(self, segments, self_ty, def);
5091 let mut user_self_ty = None;
5092 let mut is_alias_variant_ctor = false;
5094 Def::VariantCtor(_, _) => {
5095 if let Some(self_ty) = self_ty {
5096 let adt_def = self_ty.ty_adt_def().unwrap();
5097 user_self_ty = Some(UserSelfTy {
5098 impl_def_id: adt_def.did,
5101 is_alias_variant_ctor = true;
5104 Def::Method(def_id) |
5105 Def::AssociatedConst(def_id) => {
5106 let container = tcx.associated_item(def_id).container;
5108 ty::TraitContainer(trait_did) => {
5109 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5111 ty::ImplContainer(impl_def_id) => {
5112 if segments.len() == 1 {
5113 // `<T>::assoc` will end up here, and so
5114 // can `T::assoc`. It this came from an
5115 // inherent impl, we need to record the
5116 // `T` for posterity (see `UserSelfTy` for
5118 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5119 user_self_ty = Some(UserSelfTy {
5130 // Now that we have categorized what space the parameters for each
5131 // segment belong to, let's sort out the parameters that the user
5132 // provided (if any) into their appropriate spaces. We'll also report
5133 // errors if type parameters are provided in an inappropriate place.
5135 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5136 let generics_has_err = AstConv::prohibit_generics(
5137 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5138 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5144 if generics_has_err {
5145 // Don't try to infer type parameters when prohibited generic arguments were given.
5146 user_self_ty = None;
5150 Def::Local(nid) | Def::Upvar(nid, ..) => {
5151 let ty = self.local_ty(span, nid).decl_ty;
5152 let ty = self.normalize_associated_types_in(span, &ty);
5153 self.write_ty(tcx.hir().node_to_hir_id(node_id), ty);
5159 // Now we have to compare the types that the user *actually*
5160 // provided against the types that were *expected*. If the user
5161 // did not provide any types, then we want to substitute inference
5162 // variables. If the user provided some types, we may still need
5163 // to add defaults. If the user provided *too many* types, that's
5166 let mut infer_args_for_err = FxHashSet::default();
5167 for &PathSeg(def_id, index) in &path_segs {
5168 let seg = &segments[index];
5169 let generics = tcx.generics_of(def_id);
5170 // Argument-position `impl Trait` is treated as a normal generic
5171 // parameter internally, but we don't allow users to specify the
5172 // parameter's value explicitly, so we have to do some error-
5174 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5179 false, // `is_method_call`
5181 if suppress_errors {
5182 infer_args_for_err.insert(index);
5183 self.set_tainted_by_errors(); // See issue #53251.
5187 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5188 tcx.generics_of(*def_id).has_self
5189 }).unwrap_or(false);
5191 let mut new_def = def;
5192 let (def_id, ty) = match def {
5193 Def::SelfCtor(impl_def_id) => {
5194 let ty = self.impl_self_ty(span, impl_def_id).ty;
5195 let adt_def = ty.ty_adt_def();
5198 Some(adt_def) if adt_def.has_ctor() => {
5199 let variant = adt_def.non_enum_variant();
5200 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5201 (variant.did, tcx.type_of(variant.did))
5204 let mut err = tcx.sess.struct_span_err(span,
5205 "the `Self` constructor can only be used with tuple or unit structs");
5206 if let Some(adt_def) = adt_def {
5207 match adt_def.adt_kind() {
5209 err.note("did you mean to use one of the enum's variants?");
5215 format!("did you mean `Self {{ /* fields */ }}`?"),
5222 (impl_def_id, tcx.types.err)
5227 let def_id = def.def_id();
5229 // The things we are substituting into the type should not contain
5230 // escaping late-bound regions, and nor should the base type scheme.
5231 let ty = tcx.type_of(def_id);
5236 let substs = AstConv::create_substs_for_generic_args(
5242 // Provide the generic args, and whether types should be inferred.
5244 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5247 // If we've encountered an `impl Trait`-related error, we're just
5248 // going to infer the arguments for better error messages.
5249 if !infer_args_for_err.contains(&index) {
5250 // Check whether the user has provided generic arguments.
5251 if let Some(ref data) = segments[index].args {
5252 return (Some(data), segments[index].infer_types);
5255 return (None, segments[index].infer_types);
5260 // Provide substitutions for parameters for which (valid) arguments have been provided.
5262 match (¶m.kind, arg) {
5263 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5264 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5266 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5267 self.to_ty(ty).into()
5269 _ => unreachable!(),
5272 // Provide substitutions for parameters for which arguments are inferred.
5273 |substs, param, infer_types| {
5275 GenericParamDefKind::Lifetime => {
5276 self.re_infer(span, Some(param)).unwrap().into()
5278 GenericParamDefKind::Type { has_default, .. } => {
5279 if !infer_types && has_default {
5280 // If we have a default, then we it doesn't matter that we're not
5281 // inferring the type arguments: we provide the default where any
5283 let default = tcx.type_of(param.def_id);
5286 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5289 // If no type arguments were provided, we have to infer them.
5290 // This case also occurs as a result of some malformed input, e.g.
5291 // a lifetime argument being given instead of a type parameter.
5292 // Using inference instead of `Error` gives better error messages.
5293 self.var_for_def(span, param)
5299 assert!(!substs.has_escaping_bound_vars());
5300 assert!(!ty.has_escaping_bound_vars());
5302 // First, store the "user substs" for later.
5303 let hir_id = tcx.hir().node_to_hir_id(node_id);
5304 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5306 // Add all the obligations that are required, substituting and
5307 // normalized appropriately.
5308 let bounds = self.instantiate_bounds(span, def_id, &substs);
5309 self.add_obligations_for_parameters(
5310 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5313 // Substitute the values for the type parameters into the type of
5314 // the referenced item.
5315 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5317 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5318 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5319 // is inherent, there is no `Self` parameter; instead, the impl needs
5320 // type parameters, which we can infer by unifying the provided `Self`
5321 // with the substituted impl type.
5322 // This also occurs for an enum variant on a type alias.
5323 let ty = tcx.type_of(impl_def_id);
5325 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5326 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5327 Ok(ok) => self.register_infer_ok_obligations(ok),
5330 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5337 self.check_rustc_args_require_const(def_id, node_id, span);
5339 debug!("instantiate_value_path: type of {:?} is {:?}",
5342 self.write_substs(hir_id, substs);
5344 (ty_substituted, new_def)
5347 fn check_rustc_args_require_const(&self,
5349 node_id: ast::NodeId,
5351 // We're only interested in functions tagged with
5352 // #[rustc_args_required_const], so ignore anything that's not.
5353 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5357 // If our calling expression is indeed the function itself, we're good!
5358 // If not, generate an error that this can only be called directly.
5359 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
5360 if let ExprKind::Call(ref callee, ..) = expr.node {
5361 if callee.id == node_id {
5367 self.tcx.sess.span_err(span, "this function can only be invoked \
5368 directly, not through a function pointer");
5371 // Resolves `typ` by a single level if `typ` is a type variable.
5372 // If no resolution is possible, then an error is reported.
5373 // Numeric inference variables may be left unresolved.
5374 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5375 let ty = self.resolve_type_vars_with_obligations(ty);
5376 if !ty.is_ty_var() {
5379 if !self.is_tainted_by_errors() {
5380 self.need_type_info_err((**self).body_id, sp, ty)
5381 .note("type must be known at this point")
5384 self.demand_suptype(sp, self.tcx.types.err, ty);
5389 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5390 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5391 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5394 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5395 index = enclosing_breakables.stack.len();
5396 enclosing_breakables.by_id.insert(id, index);
5397 enclosing_breakables.stack.push(ctxt);
5401 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5402 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5403 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5404 enclosing_breakables.stack.pop().expect("missing breakable context")
5409 /// Instantiate a QueryResponse in a probe context, without a
5410 /// good ObligationCause.
5411 fn probe_instantiate_query_response(
5414 original_values: &OriginalQueryValues<'tcx>,
5415 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5416 ) -> InferResult<'tcx, Ty<'tcx>>
5418 self.instantiate_query_response_and_region_obligations(
5419 &traits::ObligationCause::misc(span, self.body_id),
5426 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5427 generics: &ty::Generics,
5429 let own_counts = generics.own_counts();
5430 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5432 if own_counts.types == 0 {
5435 // Make a vector of booleans initially false, set to true when used.
5436 let mut types_used = vec![false; own_counts.types];
5438 for leaf_ty in ty.walk() {
5439 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5440 debug!("Found use of ty param num {}", idx);
5441 types_used[idx as usize - own_counts.lifetimes] = true;
5442 } else if let ty::Error = leaf_ty.sty {
5443 // If there is already another error, do not emit
5444 // an error for not using a type Parameter.
5445 assert!(tcx.sess.err_count() > 0);
5450 let types = generics.params.iter().filter(|param| match param.kind {
5451 ty::GenericParamDefKind::Type { .. } => true,
5454 for (&used, param) in types_used.iter().zip(types) {
5456 let id = tcx.hir().as_local_node_id(param.def_id).unwrap();
5457 let span = tcx.hir().span(id);
5458 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5459 .span_label(span, "unused type parameter")
5465 fn fatally_break_rust(sess: &Session) {
5466 let handler = sess.diagnostic();
5467 handler.span_bug_no_panic(
5469 "It looks like you're trying to break rust; would you like some ICE?",
5471 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5472 handler.note_without_error(
5473 "we would appreciate a joke overview: \
5474 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5476 handler.note_without_error(&format!("rustc {} running on {}",
5477 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5478 ::session::config::host_triple(),
5482 fn potentially_plural_count(count: usize, word: &str) -> String {
5483 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })