1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are unknown.
19 By far the most complex case is checking the body of a function. This
20 can be broken down into several distinct phases:
22 - gather: creates type variables to represent the type of each local
23 variable and pattern binding.
25 - main: the main pass does the lion's share of the work: it
26 determines the types of all expressions, resolves
27 methods, checks for most invalid conditions, and so forth. In
28 some cases, where a type is unknown, it may create a type or region
29 variable and use that as the type of an expression.
31 In the process of checking, various constraints will be placed on
32 these type variables through the subtyping relationships requested
33 through the `demand` module. The `infer` module is in charge
34 of resolving those constraints.
36 - regionck: after main is complete, the regionck pass goes over all
37 types looking for regions and making sure that they did not escape
38 into places they are not in scope. This may also influence the
39 final assignments of the various region variables if there is some
42 - vtable: find and records the impls to use for each trait bound that
43 appears on a type parameter.
45 - writeback: writes the final types within a function body, replacing
46 type variables with their final inferred types. These final types
47 are written into the `tcx.node_types` table, which should *never* contain
48 any reference to a type variable.
52 While type checking a function, the intermediate types for the
53 expressions, blocks, and so forth contained within the function are
54 stored in `fcx.node_types` and `fcx.node_substs`. These types
55 may contain unresolved type variables. After type checking is
56 complete, the functions in the writeback module are used to take the
57 types from this table, resolve them, and then write them into their
58 permanent home in the type context `tcx`.
60 This means that during inferencing you should use `fcx.write_ty()`
61 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
62 nodes within the function.
64 The types of top-level items, which never contain unbound type
65 variables, are stored directly into the `tcx` tables.
67 N.B., a type variable is not the same thing as a type parameter. A
68 type variable is rather an "instance" of a type parameter: that is,
69 given a generic function `fn foo<T>(t: T)`: while checking the
70 function `foo`, the type `ty_param(0)` refers to the type `T`, which
71 is treated in abstract. When `foo()` is called, however, `T` will be
72 substituted for a fresh type variable `N`. This variable will
73 eventually be resolved to some concrete type (which might itself be
92 mod generator_interior;
97 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
98 use rustc::hir::{self, GenericArg, ItemKind, Node, PatKind};
99 use rustc::hir::def::Def;
100 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
101 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
102 use rustc::hir::itemlikevisit::ItemLikeVisitor;
103 use middle::lang_items;
104 use namespace::Namespace;
105 use rustc::infer::{self, InferCtxt, InferOk, InferResult, RegionVariableOrigin};
106 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
107 use rustc_data_structures::indexed_vec::Idx;
108 use rustc_data_structures::sync::Lrc;
109 use rustc_target::spec::abi::Abi;
110 use rustc::infer::opaque_types::OpaqueTypeDecl;
111 use rustc::infer::type_variable::{TypeVariableOrigin};
112 use rustc::middle::region;
113 use rustc::mir::interpret::{ConstValue, GlobalId};
114 use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
115 UserSelfTy, UserSubsts};
116 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
117 use rustc::ty::{self, AdtKind, Ty, TyCtxt, GenericParamDefKind, RegionKind, Visibility,
118 ToPolyTraitRef, ToPredicate};
119 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
120 use rustc::ty::fold::TypeFoldable;
121 use rustc::ty::query::Providers;
122 use rustc::ty::util::{Representability, IntTypeExt, Discr};
123 use rustc::ty::layout::VariantIdx;
124 use syntax_pos::{self, BytePos, Span, MultiSpan};
127 use syntax::feature_gate::{GateIssue, emit_feature_err};
129 use syntax::source_map::{DUMMY_SP, original_sp};
130 use syntax::symbol::{Symbol, LocalInternedString, keywords};
131 use syntax::util::lev_distance::find_best_match_for_name;
133 use std::cell::{Cell, RefCell, Ref, RefMut};
134 use std::collections::hash_map::Entry;
136 use std::fmt::Display;
138 use std::mem::replace;
139 use std::ops::{self, Deref};
142 use require_c_abi_if_variadic;
143 use session::{CompileIncomplete, config, Session};
146 use util::captures::Captures;
147 use util::common::{ErrorReported, indenter};
148 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
150 pub use self::Expectation::*;
151 use self::autoderef::Autoderef;
152 use self::callee::DeferredCallResolution;
153 use self::coercion::{CoerceMany, DynamicCoerceMany};
154 pub use self::compare_method::{compare_impl_method, compare_const_impl};
155 use self::method::MethodCallee;
156 use self::TupleArgumentsFlag::*;
158 /// The type of a local binding, including the revealed type for anon types.
159 #[derive(Copy, Clone)]
160 pub struct LocalTy<'tcx> {
162 revealed_ty: Ty<'tcx>
165 /// A wrapper for InferCtxt's `in_progress_tables` field.
166 #[derive(Copy, Clone)]
167 struct MaybeInProgressTables<'a, 'tcx: 'a> {
168 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
171 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
172 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
173 match self.maybe_tables {
174 Some(tables) => tables.borrow(),
176 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
181 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
182 match self.maybe_tables {
183 Some(tables) => tables.borrow_mut(),
185 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
191 /// closures defined within the function. For example:
194 /// bar(move|| { ... })
197 /// Here, the function `foo()` and the closure passed to
198 /// `bar()` will each have their own `FnCtxt`, but they will
199 /// share the inherited fields.
200 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
201 infcx: InferCtxt<'a, 'gcx, 'tcx>,
203 tables: MaybeInProgressTables<'a, 'tcx>,
205 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
207 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
209 // Some additional `Sized` obligations badly affect type inference.
210 // These obligations are added in a later stage of typeck.
211 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
213 // When we process a call like `c()` where `c` is a closure type,
214 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
215 // `FnOnce` closure. In that case, we defer full resolution of the
216 // call until upvar inference can kick in and make the
217 // decision. We keep these deferred resolutions grouped by the
218 // def-id of the closure, so that once we decide, we can easily go
219 // back and process them.
220 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
222 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
224 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
226 // Opaque types found in explicit return types and their
227 // associated fresh inference variable. Writeback resolves these
228 // variables to get the concrete type, which can be used to
229 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
230 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
232 /// Each type parameter has an implicit region bound that
233 /// indicates it must outlive at least the function body (the user
234 /// may specify stronger requirements). This field indicates the
235 /// region of the callee. If it is `None`, then the parameter
236 /// environment is for an item or something where the "callee" is
238 implicit_region_bound: Option<ty::Region<'tcx>>,
240 body_id: Option<hir::BodyId>,
243 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
244 type Target = InferCtxt<'a, 'gcx, 'tcx>;
245 fn deref(&self) -> &Self::Target {
250 /// When type-checking an expression, we propagate downward
251 /// whatever type hint we are able in the form of an `Expectation`.
252 #[derive(Copy, Clone, Debug)]
253 pub enum Expectation<'tcx> {
254 /// We know nothing about what type this expression should have.
257 /// This expression is an `if` condition, it must resolve to `bool`.
260 /// This expression should have the type given (or some subtype)
261 ExpectHasType(Ty<'tcx>),
263 /// This expression will be cast to the `Ty`
264 ExpectCastableToType(Ty<'tcx>),
266 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
267 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
268 ExpectRvalueLikeUnsized(Ty<'tcx>),
271 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
272 // Disregard "castable to" expectations because they
273 // can lead us astray. Consider for example `if cond
274 // {22} else {c} as u8` -- if we propagate the
275 // "castable to u8" constraint to 22, it will pick the
276 // type 22u8, which is overly constrained (c might not
277 // be a u8). In effect, the problem is that the
278 // "castable to" expectation is not the tightest thing
279 // we can say, so we want to drop it in this case.
280 // The tightest thing we can say is "must unify with
281 // else branch". Note that in the case of a "has type"
282 // constraint, this limitation does not hold.
284 // If the expected type is just a type variable, then don't use
285 // an expected type. Otherwise, we might write parts of the type
286 // when checking the 'then' block which are incompatible with the
288 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
290 ExpectHasType(ety) => {
291 let ety = fcx.shallow_resolve(ety);
292 if !ety.is_ty_var() {
298 ExpectRvalueLikeUnsized(ety) => {
299 ExpectRvalueLikeUnsized(ety)
305 /// Provide an expectation for an rvalue expression given an *optional*
306 /// hint, which is not required for type safety (the resulting type might
307 /// be checked higher up, as is the case with `&expr` and `box expr`), but
308 /// is useful in determining the concrete type.
310 /// The primary use case is where the expected type is a fat pointer,
311 /// like `&[isize]`. For example, consider the following statement:
313 /// let x: &[isize] = &[1, 2, 3];
315 /// In this case, the expected type for the `&[1, 2, 3]` expression is
316 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
317 /// expectation `ExpectHasType([isize])`, that would be too strong --
318 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
319 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
320 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
321 /// which still is useful, because it informs integer literals and the like.
322 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
323 /// for examples of where this comes up,.
324 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
325 match fcx.tcx.struct_tail(ty).sty {
326 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
327 ExpectRvalueLikeUnsized(ty)
329 _ => ExpectHasType(ty)
333 // Resolves `expected` by a single level if it is a variable. If
334 // there is no expected type or resolution is not possible (e.g.,
335 // no constraints yet present), just returns `None`.
336 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
338 NoExpectation => NoExpectation,
339 ExpectIfCondition => ExpectIfCondition,
340 ExpectCastableToType(t) => {
341 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
343 ExpectHasType(t) => {
344 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
346 ExpectRvalueLikeUnsized(t) => {
347 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
352 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
353 match self.resolve(fcx) {
354 NoExpectation => None,
355 ExpectIfCondition => Some(fcx.tcx.types.bool),
356 ExpectCastableToType(ty) |
358 ExpectRvalueLikeUnsized(ty) => Some(ty),
362 /// It sometimes happens that we want to turn an expectation into
363 /// a **hard constraint** (i.e., something that must be satisfied
364 /// for the program to type-check). `only_has_type` will return
365 /// such a constraint, if it exists.
366 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
367 match self.resolve(fcx) {
368 ExpectHasType(ty) => Some(ty),
369 ExpectIfCondition => Some(fcx.tcx.types.bool),
370 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
374 /// Like `only_has_type`, but instead of returning `None` if no
375 /// hard constraint exists, creates a fresh type variable.
376 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
377 self.only_has_type(fcx)
378 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
382 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
389 fn maybe_mut_place(m: hir::Mutability) -> Self {
391 hir::MutMutable => Needs::MutPlace,
392 hir::MutImmutable => Needs::None,
397 #[derive(Copy, Clone)]
398 pub struct UnsafetyState {
399 pub def: ast::NodeId,
400 pub unsafety: hir::Unsafety,
401 pub unsafe_push_count: u32,
406 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
407 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
410 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
411 match self.unsafety {
412 // If this unsafe, then if the outer function was already marked as
413 // unsafe we shouldn't attribute the unsafe'ness to the block. This
414 // way the block can be warned about instead of ignoring this
415 // extraneous block (functions are never warned about).
416 hir::Unsafety::Unsafe if self.from_fn => *self,
419 let (unsafety, def, count) = match blk.rules {
420 hir::PushUnsafeBlock(..) =>
421 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
422 hir::PopUnsafeBlock(..) =>
423 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
424 hir::UnsafeBlock(..) =>
425 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
427 (unsafety, self.def, self.unsafe_push_count),
431 unsafe_push_count: count,
438 #[derive(Debug, Copy, Clone)]
444 /// Tracks whether executing a node may exit normally (versus
445 /// return/break/panic, which "diverge", leaving dead code in their
446 /// wake). Tracked semi-automatically (through type variables marked
447 /// as diverging), with some manual adjustments for control-flow
448 /// primitives (approximating a CFG).
449 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
451 /// Potentially unknown, some cases converge,
452 /// others require a CFG to determine them.
455 /// Definitely known to diverge and therefore
456 /// not reach the next sibling or its parent.
459 /// Same as `Always` but with a reachability
460 /// warning already emitted
464 // Convenience impls for combinig `Diverges`.
466 impl ops::BitAnd for Diverges {
468 fn bitand(self, other: Self) -> Self {
469 cmp::min(self, other)
473 impl ops::BitOr for Diverges {
475 fn bitor(self, other: Self) -> Self {
476 cmp::max(self, other)
480 impl ops::BitAndAssign for Diverges {
481 fn bitand_assign(&mut self, other: Self) {
482 *self = *self & other;
486 impl ops::BitOrAssign for Diverges {
487 fn bitor_assign(&mut self, other: Self) {
488 *self = *self | other;
493 fn always(self) -> bool {
494 self >= Diverges::Always
498 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
501 // this is `null` for loops where break with a value is illegal,
502 // such as `while`, `for`, and `while let`
503 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
506 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
507 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
508 by_id: NodeMap<usize>,
511 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
512 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
513 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
514 bug!("could not find enclosing breakable with id {}", target_id);
521 struct PathSeg(DefId, usize);
523 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
524 body_id: ast::NodeId,
526 /// The parameter environment used for proving trait obligations
527 /// in this function. This can change when we descend into
528 /// closures (as they bring new things into scope), hence it is
529 /// not part of `Inherited` (as of the time of this writing,
530 /// closures do not yet change the environment, but they will
532 param_env: ty::ParamEnv<'tcx>,
534 // Number of errors that had been reported when we started
535 // checking this function. On exit, if we find that *more* errors
536 // have been reported, we will skip regionck and other work that
537 // expects the types within the function to be consistent.
538 err_count_on_creation: usize,
540 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
541 ret_coercion_span: RefCell<Option<Span>>,
543 yield_ty: Option<Ty<'tcx>>,
545 ps: RefCell<UnsafetyState>,
547 /// Whether the last checked node generates a divergence (e.g.,
548 /// `return` will set this to Always). In general, when entering
549 /// an expression or other node in the tree, the initial value
550 /// indicates whether prior parts of the containing expression may
551 /// have diverged. It is then typically set to `Maybe` (and the
552 /// old value remembered) for processing the subparts of the
553 /// current expression. As each subpart is processed, they may set
554 /// the flag to `Always` etc. Finally, at the end, we take the
555 /// result and "union" it with the original value, so that when we
556 /// return the flag indicates if any subpart of the parent
557 /// expression (up to and including this part) has diverged. So,
558 /// if you read it after evaluating a subexpression `X`, the value
559 /// you get indicates whether any subexpression that was
560 /// evaluating up to and including `X` diverged.
562 /// We currently use this flag only for diagnostic purposes:
564 /// - To warn about unreachable code: if, after processing a
565 /// sub-expression but before we have applied the effects of the
566 /// current node, we see that the flag is set to `Always`, we
567 /// can issue a warning. This corresponds to something like
568 /// `foo(return)`; we warn on the `foo()` expression. (We then
569 /// update the flag to `WarnedAlways` to suppress duplicate
570 /// reports.) Similarly, if we traverse to a fresh statement (or
571 /// tail expression) from a `Always` setting, we will issue a
572 /// warning. This corresponds to something like `{return;
573 /// foo();}` or `{return; 22}`, where we would warn on the
576 /// An expression represents dead-code if, after checking it,
577 /// the diverges flag is set to something other than `Maybe`.
578 diverges: Cell<Diverges>,
580 /// Whether any child nodes have any type errors.
581 has_errors: Cell<bool>,
583 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
585 inh: &'a Inherited<'a, 'gcx, 'tcx>,
588 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
589 type Target = Inherited<'a, 'gcx, 'tcx>;
590 fn deref(&self) -> &Self::Target {
595 /// Helper type of a temporary returned by Inherited::build(...).
596 /// Necessary because we can't write the following bound:
597 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
598 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
599 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
603 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
604 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
605 -> InheritedBuilder<'a, 'gcx, 'tcx> {
606 let hir_id_root = if def_id.is_local() {
607 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
608 let hir_id = tcx.hir().definitions().node_to_hir_id(node_id);
609 DefId::local(hir_id.owner)
615 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
621 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
622 fn enter<F, R>(&'tcx mut self, f: F) -> R
623 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
625 let def_id = self.def_id;
626 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
630 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
631 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
633 let item_id = tcx.hir().as_local_node_id(def_id);
634 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
635 let implicit_region_bound = body_id.map(|body_id| {
636 let body = tcx.hir().body(body_id);
637 tcx.mk_region(ty::ReScope(region::Scope {
638 id: body.value.hir_id.local_id,
639 data: region::ScopeData::CallSite
644 tables: MaybeInProgressTables {
645 maybe_tables: infcx.in_progress_tables,
648 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
649 locals: RefCell::new(Default::default()),
650 deferred_sized_obligations: RefCell::new(Vec::new()),
651 deferred_call_resolutions: RefCell::new(Default::default()),
652 deferred_cast_checks: RefCell::new(Vec::new()),
653 deferred_generator_interiors: RefCell::new(Vec::new()),
654 opaque_types: RefCell::new(Default::default()),
655 implicit_region_bound,
660 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
661 debug!("register_predicate({:?})", obligation);
662 if obligation.has_escaping_bound_vars() {
663 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
668 .register_predicate_obligation(self, obligation);
671 fn register_predicates<I>(&self, obligations: I)
672 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
674 for obligation in obligations {
675 self.register_predicate(obligation);
679 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
680 self.register_predicates(infer_ok.obligations);
684 fn normalize_associated_types_in<T>(&self,
686 body_id: ast::NodeId,
687 param_env: ty::ParamEnv<'tcx>,
689 where T : TypeFoldable<'tcx>
691 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
692 self.register_infer_ok_obligations(ok)
696 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
698 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
699 fn visit_item(&mut self, i: &'tcx hir::Item) {
700 check_item_type(self.tcx, i);
702 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
703 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
706 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
707 tcx.sess.track_errors(|| {
708 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
709 tcx.hir().krate().visit_all_item_likes(&mut visit.as_deep_visitor());
713 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
714 tcx.sess.track_errors(|| {
715 tcx.hir().krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
719 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
720 tcx.typeck_item_bodies(LOCAL_CRATE)
723 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
724 -> Result<(), CompileIncomplete>
726 debug_assert!(crate_num == LOCAL_CRATE);
727 Ok(tcx.sess.track_errors(|| {
728 tcx.par_body_owners(|body_owner_def_id| {
729 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
734 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
735 wfcheck::check_item_well_formed(tcx, def_id);
738 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
739 wfcheck::check_trait_item(tcx, def_id);
742 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
743 wfcheck::check_impl_item(tcx, def_id);
746 pub fn provide(providers: &mut Providers) {
747 method::provide(providers);
748 *providers = Providers {
754 check_item_well_formed,
755 check_trait_item_well_formed,
756 check_impl_item_well_formed,
761 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
763 -> Option<ty::Destructor> {
764 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
767 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
768 /// with information about it's body-id and fn-decl (if any). Otherwise,
771 /// If this function returns "some", then `typeck_tables(def_id)` will
772 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
773 /// may not succeed. In some cases where this function returns `None`
774 /// (notably closures), `typeck_tables(def_id)` would wind up
775 /// redirecting to the owning function.
776 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
778 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
780 match tcx.hir().get(id) {
781 Node::Item(item) => {
783 hir::ItemKind::Const(_, body) |
784 hir::ItemKind::Static(_, _, body) =>
786 hir::ItemKind::Fn(ref decl, .., body) =>
787 Some((body, Some(decl))),
792 Node::TraitItem(item) => {
794 hir::TraitItemKind::Const(_, Some(body)) =>
796 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
797 Some((body, Some(&sig.decl))),
802 Node::ImplItem(item) => {
804 hir::ImplItemKind::Const(_, body) =>
806 hir::ImplItemKind::Method(ref sig, body) =>
807 Some((body, Some(&sig.decl))),
812 Node::AnonConst(constant) => Some((constant.body, None)),
817 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
820 // Closures' tables come from their outermost function,
821 // as they are part of the same "inference environment".
822 let outer_def_id = tcx.closure_base_def_id(def_id);
823 if outer_def_id != def_id {
824 return tcx.has_typeck_tables(outer_def_id);
827 let id = tcx.hir().as_local_node_id(def_id).unwrap();
828 primary_body_of(tcx, id).is_some()
831 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
834 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
837 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
839 -> &'tcx ty::TypeckTables<'tcx> {
840 // Closures' tables come from their outermost function,
841 // as they are part of the same "inference environment".
842 let outer_def_id = tcx.closure_base_def_id(def_id);
843 if outer_def_id != def_id {
844 return tcx.typeck_tables_of(outer_def_id);
847 let id = tcx.hir().as_local_node_id(def_id).unwrap();
848 let span = tcx.hir().span(id);
850 // Figure out what primary body this item has.
851 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
852 span_bug!(span, "can't type-check body of {:?}", def_id);
854 let body = tcx.hir().body(body_id);
856 let tables = Inherited::build(tcx, def_id).enter(|inh| {
857 let param_env = tcx.param_env(def_id);
858 let fcx = if let Some(decl) = fn_decl {
859 let fn_sig = tcx.fn_sig(def_id);
861 check_abi(tcx, span, fn_sig.abi());
863 // Compute the fty from point of view of inside the fn.
865 tcx.liberate_late_bound_regions(def_id, &fn_sig);
867 inh.normalize_associated_types_in(body.value.span,
872 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
875 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
876 let expected_type = tcx.type_of(def_id);
877 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
878 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
880 let revealed_ty = if tcx.features().impl_trait_in_bindings {
881 fcx.instantiate_opaque_types_from_value(
889 // Gather locals in statics (because of block expressions).
890 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
892 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
897 // All type checking constraints were added, try to fallback unsolved variables.
898 fcx.select_obligations_where_possible(false);
899 let mut fallback_has_occurred = false;
900 for ty in &fcx.unsolved_variables() {
901 fallback_has_occurred |= fcx.fallback_if_possible(ty);
903 fcx.select_obligations_where_possible(fallback_has_occurred);
905 // Even though coercion casts provide type hints, we check casts after fallback for
906 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
909 // Closure and generator analysis may run after fallback
910 // because they don't constrain other type variables.
911 fcx.closure_analyze(body);
912 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
913 fcx.resolve_generator_interiors(def_id);
915 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
916 let ty = fcx.normalize_ty(span, ty);
917 fcx.require_type_is_sized(ty, span, code);
919 fcx.select_all_obligations_or_error();
921 if fn_decl.is_some() {
922 fcx.regionck_fn(id, body);
924 fcx.regionck_expr(body);
927 fcx.resolve_type_vars_in_body(body)
930 // Consistency check our TypeckTables instance can hold all ItemLocalIds
931 // it will need to hold.
932 assert_eq!(tables.local_id_root,
933 Some(DefId::local(tcx.hir().definitions().node_to_hir_id(id).owner)));
937 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
938 if !tcx.sess.target.target.is_abi_supported(abi) {
939 struct_span_err!(tcx.sess, span, E0570,
940 "The ABI `{}` is not supported for the current target", abi).emit()
944 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
945 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
946 parent_id: ast::NodeId,
949 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
950 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
953 // infer the variable's type
954 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
955 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
962 // take type that the user specified
963 self.fcx.locals.borrow_mut().insert(nid, typ);
970 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
971 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
972 NestedVisitorMap::None
975 // Add explicitly-declared locals.
976 fn visit_local(&mut self, local: &'gcx hir::Local) {
977 let local_ty = match local.ty {
979 let o_ty = self.fcx.to_ty(&ty);
981 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
982 self.fcx.instantiate_opaque_types_from_value(
990 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(&revealed_ty);
991 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
992 ty.hir_id, o_ty, revealed_ty, c_ty);
993 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
995 Some(LocalTy { decl_ty: o_ty, revealed_ty })
999 self.assign(local.span, local.id, local_ty);
1001 debug!("Local variable {:?} is assigned type {}",
1003 self.fcx.ty_to_string(
1004 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
1005 intravisit::walk_local(self, local);
1008 // Add pattern bindings.
1009 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1010 if let PatKind::Binding(_, _, ident, _) = p.node {
1011 let var_ty = self.assign(p.span, p.id, None);
1013 if !self.fcx.tcx.features().unsized_locals {
1014 self.fcx.require_type_is_sized(var_ty, p.span,
1015 traits::VariableType(p.id));
1018 debug!("Pattern binding {} is assigned to {} with type {:?}",
1020 self.fcx.ty_to_string(
1021 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1024 intravisit::walk_pat(self, p);
1027 // Don't descend into the bodies of nested closures
1028 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1029 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1032 /// When `check_fn` is invoked on a generator (i.e., a body that
1033 /// includes yield), it returns back some information about the yield
1035 struct GeneratorTypes<'tcx> {
1036 /// Type of value that is yielded.
1037 yield_ty: ty::Ty<'tcx>,
1039 /// Types that are captured (see `GeneratorInterior` for more).
1040 interior: ty::Ty<'tcx>,
1042 /// Indicates if the generator is movable or static (immovable)
1043 movability: hir::GeneratorMovability,
1046 /// Helper used for fns and closures. Does the grungy work of checking a function
1047 /// body and returns the function context used for that purpose, since in the case of a fn item
1048 /// there is still a bit more to do.
1051 /// * inherited: other fields inherited from the enclosing fn (if any)
1052 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1053 param_env: ty::ParamEnv<'tcx>,
1054 fn_sig: ty::FnSig<'tcx>,
1055 decl: &'gcx hir::FnDecl,
1057 body: &'gcx hir::Body,
1058 can_be_generator: Option<hir::GeneratorMovability>)
1059 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1061 let mut fn_sig = fn_sig.clone();
1063 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1065 // Create the function context. This is either derived from scratch or,
1066 // in the case of closures, based on the outer context.
1067 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1068 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1070 let declared_ret_ty = fn_sig.output();
1071 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1072 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1073 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1074 fn_sig = fcx.tcx.mk_fn_sig(
1075 fn_sig.inputs().iter().cloned(),
1082 let span = body.value.span;
1084 if body.is_generator && can_be_generator.is_some() {
1085 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1086 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1087 fcx.yield_ty = Some(yield_ty);
1090 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1091 let outer_node_id = fcx.tcx.hir().as_local_node_id(outer_def_id).unwrap();
1092 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1094 // Add formal parameters.
1095 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1096 // Check the pattern.
1097 fcx.check_pat_walk(&arg.pat, arg_ty,
1098 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1100 // Check that argument is Sized.
1101 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1102 // for simple cases like `fn foo(x: Trait)`,
1103 // where we would error once on the parameter as a whole, and once on the binding `x`.
1104 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1105 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1108 fcx.write_ty(arg.hir_id, arg_ty);
1111 let fn_hir_id = fcx.tcx.hir().node_to_hir_id(fn_id);
1112 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1114 fcx.check_return_expr(&body.value);
1116 // We insert the deferred_generator_interiors entry after visiting the body.
1117 // This ensures that all nested generators appear before the entry of this generator.
1118 // resolve_generator_interiors relies on this property.
1119 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1120 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1121 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1122 Some(GeneratorTypes {
1123 yield_ty: fcx.yield_ty.unwrap(),
1125 movability: can_be_generator.unwrap(),
1131 // Finalize the return check by taking the LUB of the return types
1132 // we saw and assigning it to the expected return type. This isn't
1133 // really expected to fail, since the coercions would have failed
1134 // earlier when trying to find a LUB.
1136 // However, the behavior around `!` is sort of complex. In the
1137 // event that the `actual_return_ty` comes back as `!`, that
1138 // indicates that the fn either does not return or "returns" only
1139 // values of type `!`. In this case, if there is an expected
1140 // return type that is *not* `!`, that should be ok. But if the
1141 // return type is being inferred, we want to "fallback" to `!`:
1143 // let x = move || panic!();
1145 // To allow for that, I am creating a type variable with diverging
1146 // fallback. This was deemed ever so slightly better than unifying
1147 // the return value with `!` because it allows for the caller to
1148 // make more assumptions about the return type (e.g., they could do
1150 // let y: Option<u32> = Some(x());
1152 // which would then cause this return type to become `u32`, not
1154 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1155 let mut actual_return_ty = coercion.complete(&fcx);
1156 if actual_return_ty.is_never() {
1157 actual_return_ty = fcx.next_diverging_ty_var(
1158 TypeVariableOrigin::DivergingFn(span));
1160 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1162 // Check that the main return type implements the termination trait.
1163 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1164 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1166 if let config::EntryFnType::Main = entry_type {
1167 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1168 let trait_ref = ty::TraitRef::new(term_id, substs);
1169 let return_ty_span = decl.output.span();
1170 let cause = traits::ObligationCause::new(
1171 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1173 inherited.register_predicate(
1174 traits::Obligation::new(
1175 cause, param_env, trait_ref.to_predicate()));
1181 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1182 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1183 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1184 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1185 // at this point we don't care if there are duplicate handlers or if the handler has
1186 // the wrong signature as this value we'll be used when writing metadata and that
1187 // only happens if compilation succeeded
1188 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1190 if declared_ret_ty.sty != ty::Never {
1191 fcx.tcx.sess.span_err(
1193 "return type should be `!`",
1197 let inputs = fn_sig.inputs();
1198 let span = fcx.tcx.hir().span(fn_id);
1199 if inputs.len() == 1 {
1200 let arg_is_panic_info = match inputs[0].sty {
1201 ty::Ref(region, ty, mutbl) => match ty.sty {
1202 ty::Adt(ref adt, _) => {
1203 adt.did == panic_info_did &&
1204 mutbl == hir::Mutability::MutImmutable &&
1205 *region != RegionKind::ReStatic
1212 if !arg_is_panic_info {
1213 fcx.tcx.sess.span_err(
1214 decl.inputs[0].span,
1215 "argument should be `&PanicInfo`",
1219 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1220 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1221 if !generics.params.is_empty() {
1222 fcx.tcx.sess.span_err(
1224 "should have no type parameters",
1230 let span = fcx.tcx.sess.source_map().def_span(span);
1231 fcx.tcx.sess.span_err(span, "function should have one argument");
1234 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1239 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1240 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1241 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1242 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1243 if declared_ret_ty.sty != ty::Never {
1244 fcx.tcx.sess.span_err(
1246 "return type should be `!`",
1250 let inputs = fn_sig.inputs();
1251 let span = fcx.tcx.hir().span(fn_id);
1252 if inputs.len() == 1 {
1253 let arg_is_alloc_layout = match inputs[0].sty {
1254 ty::Adt(ref adt, _) => {
1255 adt.did == alloc_layout_did
1260 if !arg_is_alloc_layout {
1261 fcx.tcx.sess.span_err(
1262 decl.inputs[0].span,
1263 "argument should be `Layout`",
1267 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1268 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1269 if !generics.params.is_empty() {
1270 fcx.tcx.sess.span_err(
1272 "`#[alloc_error_handler]` function should have no type \
1279 let span = fcx.tcx.sess.source_map().def_span(span);
1280 fcx.tcx.sess.span_err(span, "function should have one argument");
1283 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1291 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1294 let def_id = tcx.hir().local_def_id(id);
1295 let def = tcx.adt_def(def_id);
1296 def.destructor(tcx); // force the destructor to be evaluated
1297 check_representable(tcx, span, def_id);
1299 if def.repr.simd() {
1300 check_simd(tcx, span, def_id);
1303 check_transparent(tcx, span, def_id);
1304 check_packed(tcx, span, def_id);
1307 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1310 let def_id = tcx.hir().local_def_id(id);
1311 let def = tcx.adt_def(def_id);
1312 def.destructor(tcx); // force the destructor to be evaluated
1313 check_representable(tcx, span, def_id);
1315 check_packed(tcx, span, def_id);
1318 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1320 "check_item_type(it.id={}, it.name={})",
1322 tcx.item_path_str(tcx.hir().local_def_id(it.id))
1324 let _indenter = indenter();
1326 // Consts can play a role in type-checking, so they are included here.
1327 hir::ItemKind::Static(..) => {
1328 let def_id = tcx.hir().local_def_id(it.id);
1329 tcx.typeck_tables_of(def_id);
1330 maybe_check_static_with_link_section(tcx, def_id, it.span);
1332 hir::ItemKind::Const(..) => {
1333 tcx.typeck_tables_of(tcx.hir().local_def_id(it.id));
1335 hir::ItemKind::Enum(ref enum_definition, _) => {
1336 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1338 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1339 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1340 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1341 let impl_def_id = tcx.hir().local_def_id(it.id);
1342 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1343 check_impl_items_against_trait(
1350 let trait_def_id = impl_trait_ref.def_id;
1351 check_on_unimplemented(tcx, trait_def_id, it);
1354 hir::ItemKind::Trait(..) => {
1355 let def_id = tcx.hir().local_def_id(it.id);
1356 check_on_unimplemented(tcx, def_id, it);
1358 hir::ItemKind::Struct(..) => {
1359 check_struct(tcx, it.id, it.span);
1361 hir::ItemKind::Union(..) => {
1362 check_union(tcx, it.id, it.span);
1364 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1365 let def_id = tcx.hir().local_def_id(it.id);
1366 let pty_ty = tcx.type_of(def_id);
1367 let generics = tcx.generics_of(def_id);
1368 check_bounds_are_used(tcx, &generics, pty_ty);
1370 hir::ItemKind::ForeignMod(ref m) => {
1371 check_abi(tcx, it.span, m.abi);
1373 if m.abi == Abi::RustIntrinsic {
1374 for item in &m.items {
1375 intrinsic::check_intrinsic_type(tcx, item);
1377 } else if m.abi == Abi::PlatformIntrinsic {
1378 for item in &m.items {
1379 intrinsic::check_platform_intrinsic_type(tcx, item);
1382 for item in &m.items {
1383 let generics = tcx.generics_of(tcx.hir().local_def_id(item.id));
1384 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1385 let mut err = struct_span_err!(
1389 "foreign items may not have type parameters"
1391 err.span_label(item.span, "can't have type parameters");
1392 // FIXME: once we start storing spans for type arguments, turn this into a
1395 "use specialization instead of type parameters by replacing them \
1396 with concrete types like `u32`",
1401 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1402 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1407 _ => { /* nothing to do */ }
1411 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1412 // Only restricted on wasm32 target for now
1413 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1417 // If `#[link_section]` is missing, then nothing to verify
1418 let attrs = tcx.codegen_fn_attrs(id);
1419 if attrs.link_section.is_none() {
1423 // For the wasm32 target statics with #[link_section] are placed into custom
1424 // sections of the final output file, but this isn't link custom sections of
1425 // other executable formats. Namely we can only embed a list of bytes,
1426 // nothing with pointers to anything else or relocations. If any relocation
1427 // show up, reject them here.
1428 let instance = ty::Instance::mono(tcx, id);
1429 let cid = GlobalId {
1433 let param_env = ty::ParamEnv::reveal_all();
1434 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1435 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1438 bug!("Matching on non-ByRef static")
1440 if alloc.relocations.len() != 0 {
1441 let msg = "statics with a custom `#[link_section]` must be a \
1442 simple list of bytes on the wasm target with no \
1443 extra levels of indirection such as references";
1444 tcx.sess.span_err(span, msg);
1449 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1450 trait_def_id: DefId,
1452 let item_def_id = tcx.hir().local_def_id(item.id);
1453 // an error would be reported if this fails.
1454 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1457 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1458 impl_item: &hir::ImplItem,
1461 let mut err = struct_span_err!(
1462 tcx.sess, impl_item.span, E0520,
1463 "`{}` specializes an item from a parent `impl`, but \
1464 that item is not marked `default`",
1466 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1469 match tcx.span_of_impl(parent_impl) {
1471 err.span_label(span, "parent `impl` is here");
1472 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1476 err.note(&format!("parent implementation is in crate `{}`", cname));
1483 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1484 trait_def: &ty::TraitDef,
1485 trait_item: &ty::AssociatedItem,
1487 impl_item: &hir::ImplItem)
1489 let ancestors = trait_def.ancestors(tcx, impl_id);
1491 let kind = match impl_item.node {
1492 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1493 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1494 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1495 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1498 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1499 .map(|node_item| node_item.map(|parent| parent.defaultness));
1501 if let Some(parent) = parent {
1502 if tcx.impl_item_is_final(&parent) {
1503 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1509 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1512 impl_trait_ref: ty::TraitRef<'tcx>,
1513 impl_item_refs: &[hir::ImplItemRef]) {
1514 let impl_span = tcx.sess.source_map().def_span(impl_span);
1516 // If the trait reference itself is erroneous (so the compilation is going
1517 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1518 // isn't populated for such impls.
1519 if impl_trait_ref.references_error() { return; }
1521 // Locate trait definition and items
1522 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1523 let mut overridden_associated_type = None;
1525 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1527 // Check existing impl methods to see if they are both present in trait
1528 // and compatible with trait signature
1529 for impl_item in impl_items() {
1530 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.id));
1531 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1532 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1533 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1535 // Not compatible, but needed for the error message
1536 tcx.associated_items(impl_trait_ref.def_id)
1537 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1540 // Check that impl definition matches trait definition
1541 if let Some(ty_trait_item) = ty_trait_item {
1542 match impl_item.node {
1543 hir::ImplItemKind::Const(..) => {
1544 // Find associated const definition.
1545 if ty_trait_item.kind == ty::AssociatedKind::Const {
1546 compare_const_impl(tcx,
1552 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1553 "item `{}` is an associated const, \
1554 which doesn't match its trait `{}`",
1557 err.span_label(impl_item.span, "does not match trait");
1558 // We can only get the spans from local trait definition
1559 // Same for E0324 and E0325
1560 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1561 err.span_label(trait_span, "item in trait");
1566 hir::ImplItemKind::Method(..) => {
1567 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1568 if ty_trait_item.kind == ty::AssociatedKind::Method {
1569 compare_impl_method(tcx,
1576 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1577 "item `{}` is an associated method, \
1578 which doesn't match its trait `{}`",
1581 err.span_label(impl_item.span, "does not match trait");
1582 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1583 err.span_label(trait_span, "item in trait");
1588 hir::ImplItemKind::Existential(..) |
1589 hir::ImplItemKind::Type(_) => {
1590 if ty_trait_item.kind == ty::AssociatedKind::Type {
1591 if ty_trait_item.defaultness.has_value() {
1592 overridden_associated_type = Some(impl_item);
1595 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1596 "item `{}` is an associated type, \
1597 which doesn't match its trait `{}`",
1600 err.span_label(impl_item.span, "does not match trait");
1601 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1602 err.span_label(trait_span, "item in trait");
1609 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1613 // Check for missing items from trait
1614 let mut missing_items = Vec::new();
1615 let mut invalidated_items = Vec::new();
1616 let associated_type_overridden = overridden_associated_type.is_some();
1617 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1618 let is_implemented = trait_def.ancestors(tcx, impl_id)
1619 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1621 .map(|node_item| !node_item.node.is_from_trait())
1624 if !is_implemented && !tcx.impl_is_default(impl_id) {
1625 if !trait_item.defaultness.has_value() {
1626 missing_items.push(trait_item);
1627 } else if associated_type_overridden {
1628 invalidated_items.push(trait_item.ident);
1633 if !missing_items.is_empty() {
1634 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1635 "not all trait items implemented, missing: `{}`",
1636 missing_items.iter()
1637 .map(|trait_item| trait_item.ident.to_string())
1638 .collect::<Vec<_>>().join("`, `"));
1639 err.span_label(impl_span, format!("missing `{}` in implementation",
1640 missing_items.iter()
1641 .map(|trait_item| trait_item.ident.to_string())
1642 .collect::<Vec<_>>().join("`, `")));
1643 for trait_item in missing_items {
1644 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1645 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1647 err.note_trait_signature(trait_item.ident.to_string(),
1648 trait_item.signature(&tcx));
1654 if !invalidated_items.is_empty() {
1655 let invalidator = overridden_associated_type.unwrap();
1656 span_err!(tcx.sess, invalidator.span, E0399,
1657 "the following trait items need to be reimplemented \
1658 as `{}` was overridden: `{}`",
1660 invalidated_items.iter()
1661 .map(|name| name.to_string())
1662 .collect::<Vec<_>>().join("`, `"))
1666 /// Checks whether a type can be represented in memory. In particular, it
1667 /// identifies types that contain themselves without indirection through a
1668 /// pointer, which would mean their size is unbounded.
1669 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1673 let rty = tcx.type_of(item_def_id);
1675 // Check that it is possible to represent this type. This call identifies
1676 // (1) types that contain themselves and (2) types that contain a different
1677 // recursive type. It is only necessary to throw an error on those that
1678 // contain themselves. For case 2, there must be an inner type that will be
1679 // caught by case 1.
1680 match rty.is_representable(tcx, sp) {
1681 Representability::SelfRecursive(spans) => {
1682 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1684 err.span_label(span, "recursive without indirection");
1689 Representability::Representable | Representability::ContainsRecursive => (),
1694 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1695 let t = tcx.type_of(def_id);
1696 if let ty::Adt(def, substs) = t.sty {
1697 if def.is_struct() {
1698 let fields = &def.non_enum_variant().fields;
1699 if fields.is_empty() {
1700 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1703 let e = fields[0].ty(tcx, substs);
1704 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1705 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1706 .span_label(sp, "SIMD elements must have the same type")
1711 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1712 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1714 span_err!(tcx.sess, sp, E0077,
1715 "SIMD vector element type should be machine type");
1723 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1724 let repr = tcx.adt_def(def_id).repr;
1726 for attr in tcx.get_attrs(def_id).iter() {
1727 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1728 if let attr::ReprPacked(pack) = r {
1729 if pack != repr.pack {
1730 struct_span_err!(tcx.sess, sp, E0634,
1731 "type has conflicting packed representation hints").emit();
1737 struct_span_err!(tcx.sess, sp, E0587,
1738 "type has conflicting packed and align representation hints").emit();
1740 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1741 struct_span_err!(tcx.sess, sp, E0588,
1742 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1747 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1749 stack: &mut Vec<DefId>) -> bool {
1750 let t = tcx.type_of(def_id);
1751 if stack.contains(&def_id) {
1752 debug!("check_packed_inner: {:?} is recursive", t);
1755 if let ty::Adt(def, substs) = t.sty {
1756 if def.is_struct() || def.is_union() {
1757 if tcx.adt_def(def.did).repr.align > 0 {
1760 // push struct def_id before checking fields
1762 for field in &def.non_enum_variant().fields {
1763 let f = field.ty(tcx, substs);
1764 if let ty::Adt(def, _) = f.sty {
1765 if check_packed_inner(tcx, def.did, stack) {
1770 // only need to pop if not early out
1777 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1778 let adt = tcx.adt_def(def_id);
1779 if !adt.repr.transparent() {
1783 // For each field, figure out if it's known to be a ZST and align(1)
1784 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1785 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1786 let param_env = tcx.param_env(field.did);
1787 let layout = tcx.layout_of(param_env.and(ty));
1788 // We are currently checking the type this field came from, so it must be local
1789 let span = tcx.hir().span_if_local(field.did).unwrap();
1790 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1791 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1795 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1796 let non_zst_count = non_zst_fields.clone().count();
1797 if non_zst_count != 1 {
1798 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1799 struct_span_err!(tcx.sess, sp, E0690,
1800 "transparent struct needs exactly one non-zero-sized field, but has {}",
1802 .span_note(field_spans, "non-zero-sized field")
1805 for (span, zst, align1) in field_infos {
1807 span_err!(tcx.sess, span, E0691,
1808 "zero-sized field in transparent struct has alignment larger than 1");
1813 #[allow(trivial_numeric_casts)]
1814 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1816 vs: &'tcx [hir::Variant],
1818 let def_id = tcx.hir().local_def_id(id);
1819 let def = tcx.adt_def(def_id);
1820 def.destructor(tcx); // force the destructor to be evaluated
1823 let attributes = tcx.get_attrs(def_id);
1824 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1826 tcx.sess, attr.span, E0084,
1827 "unsupported representation for zero-variant enum")
1828 .span_label(sp, "zero-variant enum")
1833 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1834 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1835 if !tcx.features().repr128 {
1836 emit_feature_err(&tcx.sess.parse_sess,
1839 GateIssue::Language,
1840 "repr with 128-bit type is unstable");
1845 if let Some(ref e) = v.node.disr_expr {
1846 tcx.typeck_tables_of(tcx.hir().local_def_id(e.id));
1850 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1851 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1852 // Check for duplicate discriminant values
1853 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1854 let variant_did = def.variants[VariantIdx::new(i)].did;
1855 let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap();
1856 let variant_i = tcx.hir().expect_variant(variant_i_node_id);
1857 let i_span = match variant_i.node.disr_expr {
1858 Some(ref expr) => tcx.hir().span(expr.id),
1859 None => tcx.hir().span(variant_i_node_id)
1861 let span = match v.node.disr_expr {
1862 Some(ref expr) => tcx.hir().span(expr.id),
1865 struct_span_err!(tcx.sess, span, E0081,
1866 "discriminant value `{}` already exists", disr_vals[i])
1867 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1868 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1871 disr_vals.push(discr);
1874 check_representable(tcx, sp, def_id);
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 // The NodeId and the ItemLocalId must identify the same item. We just pass
2115 // both of them for consistency checking.
2116 pub fn write_method_call(&self,
2118 method: MethodCallee<'tcx>) {
2119 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2122 .type_dependent_defs_mut()
2123 .insert(hir_id, Def::Method(method.def_id));
2125 self.write_substs(hir_id, method.substs);
2127 // When the method is confirmed, the `method.substs` includes
2128 // parameters from not just the method, but also the impl of
2129 // the method -- in particular, the `Self` type will be fully
2130 // resolved. However, those are not something that the "user
2131 // specified" -- i.e., those types come from the inferred type
2132 // of the receiver, not something the user wrote. So when we
2133 // create the user-substs, we want to replace those earlier
2134 // types with just the types that the user actually wrote --
2135 // that is, those that appear on the *method itself*.
2137 // As an example, if the user wrote something like
2138 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2139 // type of `foo` (possibly adjusted), but we don't want to
2140 // include that. We want just the `[_, u32]` part.
2141 if !method.substs.is_noop() {
2142 let method_generics = self.tcx.generics_of(method.def_id);
2143 if !method_generics.params.is_empty() {
2144 let user_substs = self.infcx.probe(|_| {
2145 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2146 let i = param.index as usize;
2147 if i < method_generics.parent_count {
2148 self.infcx.var_for_def(DUMMY_SP, param)
2153 self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2154 substs: just_method_substs,
2155 user_self_ty: None, // not relevant here
2159 debug!("write_method_call: user_substs = {:?}", user_substs);
2160 self.write_user_substs(hir_id, user_substs);
2165 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2166 if !substs.is_noop() {
2167 debug!("write_substs({:?}, {:?}) in fcx {}",
2172 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2176 /// Given the substs that we just converted from the HIR, try to
2177 /// canonicalize them and store them as user-given substitutions
2178 /// (i.e., substitutions that must be respected by the NLL check).
2180 /// This should be invoked **before any unifications have
2181 /// occurred**, so that annotations like `Vec<_>` are preserved
2183 pub fn write_user_substs_from_substs(
2186 substs: &'tcx Substs<'tcx>,
2187 user_self_ty: Option<UserSelfTy<'tcx>>,
2190 "write_user_substs_from_substs({:?}, {:?}) in fcx {}",
2196 if !substs.is_noop() {
2197 let user_substs = self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2201 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2202 self.write_user_substs(hir_id, user_substs);
2206 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalUserSubsts<'tcx>) {
2208 "write_user_substs({:?}, {:?}) in fcx {}",
2214 if !substs.is_identity() {
2215 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2217 debug!("write_user_substs: skipping identity substs");
2221 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2222 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2228 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2229 Entry::Vacant(entry) => { entry.insert(adj); },
2230 Entry::Occupied(mut entry) => {
2231 debug!(" - composing on top of {:?}", entry.get());
2232 match (&entry.get()[..], &adj[..]) {
2233 // Applying any adjustment on top of a NeverToAny
2234 // is a valid NeverToAny adjustment, because it can't
2236 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2238 Adjustment { kind: Adjust::Deref(_), .. },
2239 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2241 Adjustment { kind: Adjust::Deref(_), .. },
2242 .. // Any following adjustments are allowed.
2244 // A reborrow has no effect before a dereference.
2246 // FIXME: currently we never try to compose autoderefs
2247 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2249 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2250 expr, entry.get(), adj)
2252 *entry.get_mut() = adj;
2257 /// Basically whenever we are converting from a type scheme into
2258 /// the fn body space, we always want to normalize associated
2259 /// types as well. This function combines the two.
2260 fn instantiate_type_scheme<T>(&self,
2262 substs: &Substs<'tcx>,
2265 where T : TypeFoldable<'tcx>
2267 let value = value.subst(self.tcx, substs);
2268 let result = self.normalize_associated_types_in(span, &value);
2269 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2276 /// As `instantiate_type_scheme`, but for the bounds found in a
2277 /// generic type scheme.
2278 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2279 -> ty::InstantiatedPredicates<'tcx> {
2280 let bounds = self.tcx.predicates_of(def_id);
2281 let result = bounds.instantiate(self.tcx, substs);
2282 let result = self.normalize_associated_types_in(span, &result);
2283 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2290 /// Replace the opaque types from the given value with type variables,
2291 /// and records the `OpaqueTypeMap` for later use during writeback. See
2292 /// `InferCtxt::instantiate_opaque_types` for more details.
2293 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2295 parent_id: ast::NodeId,
2298 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2299 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2303 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2304 self.instantiate_opaque_types(
2312 let mut opaque_types = self.opaque_types.borrow_mut();
2313 for (ty, decl) in opaque_type_map {
2314 let old_value = opaque_types.insert(ty, decl);
2315 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2321 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2322 where T : TypeFoldable<'tcx>
2324 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2327 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2329 where T : TypeFoldable<'tcx>
2331 self.inh.partially_normalize_associated_types_in(span,
2337 pub fn require_type_meets(&self,
2340 code: traits::ObligationCauseCode<'tcx>,
2343 self.register_bound(
2346 traits::ObligationCause::new(span, self.body_id, code));
2349 pub fn require_type_is_sized(&self,
2352 code: traits::ObligationCauseCode<'tcx>)
2354 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2355 self.require_type_meets(ty, span, code, lang_item);
2358 pub fn require_type_is_sized_deferred(&self,
2361 code: traits::ObligationCauseCode<'tcx>)
2363 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2366 pub fn register_bound(&self,
2369 cause: traits::ObligationCause<'tcx>)
2371 self.fulfillment_cx.borrow_mut()
2372 .register_bound(self, self.param_env, ty, def_id, cause);
2375 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2376 let t = AstConv::ast_ty_to_ty(self, ast_t);
2377 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2381 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2382 let ty = self.to_ty(ast_ty);
2384 // If the type given by the user has free regions, save it for
2385 // later, since NLL would like to enforce those. Also pass in
2386 // types that involve projections, since those can resolve to
2387 // `'static` bounds (modulo #54940, which hopefully will be
2388 // fixed by the time you see this comment, dear reader,
2389 // although I have my doubts). Other sorts of things are
2390 // already sufficiently enforced with erased regions. =)
2391 if ty.has_free_regions() || ty.has_projections() {
2392 let c_ty = self.infcx.canonicalize_response(&ty);
2393 self.tables.borrow_mut().user_provided_tys_mut().insert(ast_ty.hir_id, c_ty);
2399 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2400 match self.tables.borrow().node_types().get(id) {
2402 None if self.is_tainted_by_errors() => self.tcx.types.err,
2404 let node_id = self.tcx.hir().hir_to_node_id(id);
2405 bug!("no type for node {}: {} in fcx {}",
2406 node_id, self.tcx.hir().node_to_string(node_id),
2412 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2413 /// outlive the region `r`.
2414 pub fn register_wf_obligation(&self,
2417 code: traits::ObligationCauseCode<'tcx>)
2419 // WF obligations never themselves fail, so no real need to give a detailed cause:
2420 let cause = traits::ObligationCause::new(span, self.body_id, code);
2421 self.register_predicate(traits::Obligation::new(cause,
2423 ty::Predicate::WellFormed(ty)));
2426 /// Registers obligations that all types appearing in `substs` are well-formed.
2427 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2428 for ty in substs.types() {
2429 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2433 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2434 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2435 /// trait/region obligations.
2437 /// For example, if there is a function:
2440 /// fn foo<'a,T:'a>(...)
2443 /// and a reference:
2449 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2450 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2451 pub fn add_obligations_for_parameters(&self,
2452 cause: traits::ObligationCause<'tcx>,
2453 predicates: &ty::InstantiatedPredicates<'tcx>)
2455 assert!(!predicates.has_escaping_bound_vars());
2457 debug!("add_obligations_for_parameters(predicates={:?})",
2460 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2461 self.register_predicate(obligation);
2465 // FIXME(arielb1): use this instead of field.ty everywhere
2466 // Only for fields! Returns <none> for methods>
2467 // Indifferent to privacy flags
2468 pub fn field_ty(&self,
2470 field: &'tcx ty::FieldDef,
2471 substs: &Substs<'tcx>)
2474 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2477 fn check_casts(&self) {
2478 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2479 for cast in deferred_cast_checks.drain(..) {
2484 fn resolve_generator_interiors(&self, def_id: DefId) {
2485 let mut generators = self.deferred_generator_interiors.borrow_mut();
2486 for (body_id, interior) in generators.drain(..) {
2487 self.select_obligations_where_possible(false);
2488 generator_interior::resolve_interior(self, def_id, body_id, interior);
2492 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2493 // Non-numerics get replaced with ! or () (depending on whether
2494 // feature(never_type) is enabled, unconstrained ints with i32,
2495 // unconstrained floats with f64.
2496 // Fallback becomes very dubious if we have encountered type-checking errors.
2497 // In that case, fallback to Error.
2498 // The return value indicates whether fallback has occurred.
2499 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2500 use rustc::ty::error::UnconstrainedNumeric::Neither;
2501 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2503 assert!(ty.is_ty_infer());
2504 let fallback = match self.type_is_unconstrained_numeric(ty) {
2505 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2506 UnconstrainedInt => self.tcx.types.i32,
2507 UnconstrainedFloat => self.tcx.types.f64,
2508 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2509 Neither => return false,
2511 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2512 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2516 fn select_all_obligations_or_error(&self) {
2517 debug!("select_all_obligations_or_error");
2518 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2519 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2523 /// Select as many obligations as we can at present.
2524 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2525 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2526 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2530 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2531 /// returns a type of `&T`, but the actual type we assign to the
2532 /// *expression* is `T`. So this function just peels off the return
2533 /// type by one layer to yield `T`.
2534 fn make_overloaded_place_return_type(&self,
2535 method: MethodCallee<'tcx>)
2536 -> ty::TypeAndMut<'tcx>
2538 // extract method return type, which will be &T;
2539 let ret_ty = method.sig.output();
2541 // method returns &T, but the type as visible to user is T, so deref
2542 ret_ty.builtin_deref(true).unwrap()
2545 fn lookup_indexing(&self,
2547 base_expr: &'gcx hir::Expr,
2551 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2553 // FIXME(#18741) -- this is almost but not quite the same as the
2554 // autoderef that normal method probing does. They could likely be
2557 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2558 let mut result = None;
2559 while result.is_none() && autoderef.next().is_some() {
2560 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2562 autoderef.finalize(self);
2566 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2567 /// (and otherwise adjust) `base_expr`, looking for a type which either
2568 /// supports builtin indexing or overloaded indexing.
2569 /// This loop implements one step in that search; the autoderef loop
2570 /// is implemented by `lookup_indexing`.
2571 fn try_index_step(&self,
2573 base_expr: &hir::Expr,
2574 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2577 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2579 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2580 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2587 for &unsize in &[false, true] {
2588 let mut self_ty = adjusted_ty;
2590 // We only unsize arrays here.
2591 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2592 self_ty = self.tcx.mk_slice(element_ty);
2598 // If some lookup succeeds, write callee into table and extract index/element
2599 // type from the method signature.
2600 // If some lookup succeeded, install method in table
2601 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2602 let method = self.try_overloaded_place_op(
2603 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2605 let result = method.map(|ok| {
2606 debug!("try_index_step: success, using overloaded indexing");
2607 let method = self.register_infer_ok_obligations(ok);
2609 let mut adjustments = autoderef.adjust_steps(self, needs);
2610 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2611 let mutbl = match r_mutbl {
2612 hir::MutImmutable => AutoBorrowMutability::Immutable,
2613 hir::MutMutable => AutoBorrowMutability::Mutable {
2614 // Indexing can be desugared to a method call,
2615 // so maybe we could use two-phase here.
2616 // See the documentation of AllowTwoPhase for why that's
2617 // not the case today.
2618 allow_two_phase_borrow: AllowTwoPhase::No,
2621 adjustments.push(Adjustment {
2622 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2623 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2630 adjustments.push(Adjustment {
2631 kind: Adjust::Unsize,
2632 target: method.sig.inputs()[0]
2635 self.apply_adjustments(base_expr, adjustments);
2637 self.write_method_call(expr.hir_id, method);
2638 (input_ty, self.make_overloaded_place_return_type(method).ty)
2640 if result.is_some() {
2648 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2649 let (tr, name) = match (op, is_mut) {
2650 (PlaceOp::Deref, false) =>
2651 (self.tcx.lang_items().deref_trait(), "deref"),
2652 (PlaceOp::Deref, true) =>
2653 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2654 (PlaceOp::Index, false) =>
2655 (self.tcx.lang_items().index_trait(), "index"),
2656 (PlaceOp::Index, true) =>
2657 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2659 (tr, ast::Ident::from_str(name))
2662 fn try_overloaded_place_op(&self,
2665 arg_tys: &[Ty<'tcx>],
2668 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2670 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2676 // Try Mut first, if needed.
2677 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2678 let method = match (needs, mut_tr) {
2679 (Needs::MutPlace, Some(trait_did)) => {
2680 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2685 // Otherwise, fall back to the immutable version.
2686 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2687 let method = match (method, imm_tr) {
2688 (None, Some(trait_did)) => {
2689 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2691 (method, _) => method,
2697 fn check_method_argument_types(&self,
2700 method: Result<MethodCallee<'tcx>, ()>,
2701 args_no_rcvr: &'gcx [hir::Expr],
2702 tuple_arguments: TupleArgumentsFlag,
2703 expected: Expectation<'tcx>)
2705 let has_error = match method {
2707 method.substs.references_error() || method.sig.references_error()
2712 let err_inputs = self.err_args(args_no_rcvr.len());
2714 let err_inputs = match tuple_arguments {
2715 DontTupleArguments => err_inputs,
2716 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2719 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2720 false, tuple_arguments, None);
2721 return self.tcx.types.err;
2724 let method = method.unwrap();
2725 // HACK(eddyb) ignore self in the definition (see above).
2726 let expected_arg_tys = self.expected_inputs_for_expected_output(
2729 method.sig.output(),
2730 &method.sig.inputs()[1..]
2732 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2733 args_no_rcvr, method.sig.variadic, tuple_arguments,
2734 self.tcx.hir().span_if_local(method.def_id));
2738 fn self_type_matches_expected_vid(
2740 trait_ref: ty::PolyTraitRef<'tcx>,
2741 expected_vid: ty::TyVid,
2743 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2745 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2746 trait_ref, self_ty, expected_vid
2749 ty::Infer(ty::TyVar(found_vid)) => {
2750 // FIXME: consider using `sub_root_var` here so we
2751 // can see through subtyping.
2752 let found_vid = self.root_var(found_vid);
2753 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2754 expected_vid == found_vid
2760 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2761 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2762 + Captures<'gcx> + 'b
2764 // FIXME: consider using `sub_root_var` here so we
2765 // can see through subtyping.
2766 let ty_var_root = self.root_var(self_ty);
2767 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2768 self_ty, ty_var_root,
2769 self.fulfillment_cx.borrow().pending_obligations());
2773 .pending_obligations()
2775 .filter_map(move |obligation| match obligation.predicate {
2776 ty::Predicate::Projection(ref data) =>
2777 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2778 ty::Predicate::Trait(ref data) =>
2779 Some((data.to_poly_trait_ref(), obligation)),
2780 ty::Predicate::Subtype(..) => None,
2781 ty::Predicate::RegionOutlives(..) => None,
2782 ty::Predicate::TypeOutlives(..) => None,
2783 ty::Predicate::WellFormed(..) => None,
2784 ty::Predicate::ObjectSafe(..) => None,
2785 ty::Predicate::ConstEvaluatable(..) => None,
2786 // N.B., this predicate is created by breaking down a
2787 // `ClosureType: FnFoo()` predicate, where
2788 // `ClosureType` represents some `Closure`. It can't
2789 // possibly be referring to the current closure,
2790 // because we haven't produced the `Closure` for
2791 // this closure yet; this is exactly why the other
2792 // code is looking for a self type of a unresolved
2793 // inference variable.
2794 ty::Predicate::ClosureKind(..) => None,
2795 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2798 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2799 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2800 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2804 /// Generic function that factors out common logic from function calls,
2805 /// method calls and overloaded operators.
2806 fn check_argument_types(&self,
2809 fn_inputs: &[Ty<'tcx>],
2810 mut expected_arg_tys: &[Ty<'tcx>],
2811 args: &'gcx [hir::Expr],
2813 tuple_arguments: TupleArgumentsFlag,
2814 def_span: Option<Span>) {
2817 // Grab the argument types, supplying fresh type variables
2818 // if the wrong number of arguments were supplied
2819 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2825 // All the input types from the fn signature must outlive the call
2826 // so as to validate implied bounds.
2827 for &fn_input_ty in fn_inputs {
2828 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2831 let expected_arg_count = fn_inputs.len();
2833 let param_count_error = |expected_count: usize,
2838 let mut err = tcx.sess.struct_span_err_with_code(sp,
2839 &format!("this function takes {}{} but {} {} supplied",
2840 if variadic {"at least "} else {""},
2841 potentially_plural_count(expected_count, "parameter"),
2842 potentially_plural_count(arg_count, "parameter"),
2843 if arg_count == 1 {"was"} else {"were"}),
2844 DiagnosticId::Error(error_code.to_owned()));
2846 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2847 err.span_label(def_s, "defined here");
2850 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2851 // remove closing `)` from the span
2852 let sugg_span = sugg_span.shrink_to_lo();
2853 err.span_suggestion_with_applicability(
2855 "expected the unit value `()`; create it with empty parentheses",
2857 Applicability::MachineApplicable);
2859 err.span_label(sp, format!("expected {}{}",
2860 if variadic {"at least "} else {""},
2861 potentially_plural_count(expected_count, "parameter")));
2866 let formal_tys = if tuple_arguments == TupleArguments {
2867 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2868 match tuple_type.sty {
2869 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2870 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2871 expected_arg_tys = &[];
2872 self.err_args(args.len())
2874 ty::Tuple(arg_types) => {
2875 expected_arg_tys = match expected_arg_tys.get(0) {
2876 Some(&ty) => match ty.sty {
2877 ty::Tuple(ref tys) => &tys,
2885 span_err!(tcx.sess, sp, E0059,
2886 "cannot use call notation; the first type parameter \
2887 for the function trait is neither a tuple nor unit");
2888 expected_arg_tys = &[];
2889 self.err_args(args.len())
2892 } else if expected_arg_count == supplied_arg_count {
2894 } else if variadic {
2895 if supplied_arg_count >= expected_arg_count {
2898 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2899 expected_arg_tys = &[];
2900 self.err_args(supplied_arg_count)
2903 // is the missing argument of type `()`?
2904 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2905 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2906 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2907 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2911 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2913 expected_arg_tys = &[];
2914 self.err_args(supplied_arg_count)
2916 // If there is no expectation, expect formal_tys.
2917 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2923 debug!("check_argument_types: formal_tys={:?}",
2924 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2926 // Check the arguments.
2927 // We do this in a pretty awful way: first we type-check any arguments
2928 // that are not closures, then we type-check the closures. This is so
2929 // that we have more information about the types of arguments when we
2930 // type-check the functions. This isn't really the right way to do this.
2931 for &check_closures in &[false, true] {
2932 debug!("check_closures={}", check_closures);
2934 // More awful hacks: before we check argument types, try to do
2935 // an "opportunistic" vtable resolution of any trait bounds on
2936 // the call. This helps coercions.
2938 self.select_obligations_where_possible(false);
2941 // For variadic functions, we don't have a declared type for all of
2942 // the arguments hence we only do our usual type checking with
2943 // the arguments who's types we do know.
2944 let t = if variadic {
2946 } else if tuple_arguments == TupleArguments {
2951 for (i, arg) in args.iter().take(t).enumerate() {
2952 // Warn only for the first loop (the "no closures" one).
2953 // Closure arguments themselves can't be diverging, but
2954 // a previous argument can, e.g., `foo(panic!(), || {})`.
2955 if !check_closures {
2956 self.warn_if_unreachable(arg.id, arg.span, "expression");
2959 let is_closure = match arg.node {
2960 hir::ExprKind::Closure(..) => true,
2964 if is_closure != check_closures {
2968 debug!("checking the argument");
2969 let formal_ty = formal_tys[i];
2971 // The special-cased logic below has three functions:
2972 // 1. Provide as good of an expected type as possible.
2973 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2975 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2977 // 2. Coerce to the most detailed type that could be coerced
2978 // to, which is `expected_ty` if `rvalue_hint` returns an
2979 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2980 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2981 // We're processing function arguments so we definitely want to use
2982 // two-phase borrows.
2983 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2985 // 3. Relate the expected type and the formal one,
2986 // if the expected type was used for the coercion.
2987 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2991 // We also need to make sure we at least write the ty of the other
2992 // arguments which we skipped above.
2994 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2995 use structured_errors::{VariadicError, StructuredDiagnostic};
2996 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2999 for arg in args.iter().skip(expected_arg_count) {
3000 let arg_ty = self.check_expr(&arg);
3002 // There are a few types which get autopromoted when passed via varargs
3003 // in C but we just error out instead and require explicit casts.
3004 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3006 ty::Float(ast::FloatTy::F32) => {
3007 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3009 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3010 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3012 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3013 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3016 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3017 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3018 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3026 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3027 vec![self.tcx.types.err; len]
3030 // AST fragment checking
3033 expected: Expectation<'tcx>)
3039 ast::LitKind::Str(..) => tcx.mk_static_str(),
3040 ast::LitKind::ByteStr(ref v) => {
3041 tcx.mk_imm_ref(tcx.types.re_static,
3042 tcx.mk_array(tcx.types.u8, v.len() as u64))
3044 ast::LitKind::Byte(_) => tcx.types.u8,
3045 ast::LitKind::Char(_) => tcx.types.char,
3046 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3047 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3048 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3049 let opt_ty = expected.to_option(self).and_then(|ty| {
3051 ty::Int(_) | ty::Uint(_) => Some(ty),
3052 ty::Char => Some(tcx.types.u8),
3053 ty::RawPtr(..) => Some(tcx.types.usize),
3054 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3058 opt_ty.unwrap_or_else(
3059 || tcx.mk_int_var(self.next_int_var_id()))
3061 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3062 ast::LitKind::FloatUnsuffixed(_) => {
3063 let opt_ty = expected.to_option(self).and_then(|ty| {
3065 ty::Float(_) => Some(ty),
3069 opt_ty.unwrap_or_else(
3070 || tcx.mk_float_var(self.next_float_var_id()))
3072 ast::LitKind::Bool(_) => tcx.types.bool
3076 fn check_expr_eq_type(&self,
3077 expr: &'gcx hir::Expr,
3078 expected: Ty<'tcx>) {
3079 let ty = self.check_expr_with_hint(expr, expected);
3080 self.demand_eqtype(expr.span, expected, ty);
3083 pub fn check_expr_has_type_or_error(&self,
3084 expr: &'gcx hir::Expr,
3085 expected: Ty<'tcx>) -> Ty<'tcx> {
3086 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3089 fn check_expr_meets_expectation_or_error(&self,
3090 expr: &'gcx hir::Expr,
3091 expected: Expectation<'tcx>) -> Ty<'tcx> {
3092 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3093 let mut ty = self.check_expr_with_expectation(expr, expected);
3095 // While we don't allow *arbitrary* coercions here, we *do* allow
3096 // coercions from ! to `expected`.
3098 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3099 "expression with never type wound up being adjusted");
3100 let adj_ty = self.next_diverging_ty_var(
3101 TypeVariableOrigin::AdjustmentType(expr.span));
3102 self.apply_adjustments(expr, vec![Adjustment {
3103 kind: Adjust::NeverToAny,
3109 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3110 // Add help to type error if this is an `if` condition with an assignment
3111 if let (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs))
3112 = (expected, &expr.node)
3114 let msg = "try comparing for equality";
3115 if let (Ok(left), Ok(right)) = (
3116 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3117 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3119 err.span_suggestion_with_applicability(
3122 format!("{} == {}", left, right),
3123 Applicability::MaybeIncorrect);
3133 fn check_expr_coercable_to_type(&self,
3134 expr: &'gcx hir::Expr,
3135 expected: Ty<'tcx>) -> Ty<'tcx> {
3136 let ty = self.check_expr_with_hint(expr, expected);
3137 // checks don't need two phase
3138 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3141 fn check_expr_with_hint(&self,
3142 expr: &'gcx hir::Expr,
3143 expected: Ty<'tcx>) -> Ty<'tcx> {
3144 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3147 fn check_expr_with_expectation(&self,
3148 expr: &'gcx hir::Expr,
3149 expected: Expectation<'tcx>) -> Ty<'tcx> {
3150 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3153 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3154 self.check_expr_with_expectation(expr, NoExpectation)
3157 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3158 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3161 // Determine the `Self` type, using fresh variables for all variables
3162 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3163 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3165 pub fn impl_self_ty(&self,
3166 span: Span, // (potential) receiver for this impl
3168 -> TypeAndSubsts<'tcx> {
3169 let ity = self.tcx.type_of(did);
3170 debug!("impl_self_ty: ity={:?}", ity);
3172 let substs = self.fresh_substs_for_item(span, did);
3173 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3175 TypeAndSubsts { substs: substs, ty: substd_ty }
3178 /// Unifies the output type with the expected type early, for more coercions
3179 /// and forward type information on the input expressions.
3180 fn expected_inputs_for_expected_output(&self,
3182 expected_ret: Expectation<'tcx>,
3183 formal_ret: Ty<'tcx>,
3184 formal_args: &[Ty<'tcx>])
3186 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3187 let ret_ty = match expected_ret.only_has_type(self) {
3189 None => return Vec::new()
3191 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3192 // Attempt to apply a subtyping relationship between the formal
3193 // return type (likely containing type variables if the function
3194 // is polymorphic) and the expected return type.
3195 // No argument expectations are produced if unification fails.
3196 let origin = self.misc(call_span);
3197 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3199 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3200 // to identity so the resulting type is not constrained.
3203 // Process any obligations locally as much as
3204 // we can. We don't care if some things turn
3205 // out unconstrained or ambiguous, as we're
3206 // just trying to get hints here.
3207 self.save_and_restore_in_snapshot_flag(|_| {
3208 let mut fulfill = TraitEngine::new(self.tcx);
3209 for obligation in ok.obligations {
3210 fulfill.register_predicate_obligation(self, obligation);
3212 fulfill.select_where_possible(self)
3213 }).map_err(|_| ())?;
3215 Err(_) => return Err(()),
3218 // Record all the argument types, with the substitutions
3219 // produced from the above subtyping unification.
3220 Ok(formal_args.iter().map(|ty| {
3221 self.resolve_type_vars_if_possible(ty)
3223 }).unwrap_or_default();
3224 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3225 formal_args, formal_ret,
3226 expect_args, expected_ret);
3230 // Checks a method call.
3231 fn check_method_call(&self,
3232 expr: &'gcx hir::Expr,
3233 segment: &hir::PathSegment,
3235 args: &'gcx [hir::Expr],
3236 expected: Expectation<'tcx>,
3237 needs: Needs) -> Ty<'tcx> {
3238 let rcvr = &args[0];
3239 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3240 // no need to check for bot/err -- callee does that
3241 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3243 let method = match self.lookup_method(rcvr_t,
3249 self.write_method_call(expr.hir_id, method);
3253 if segment.ident.name != keywords::Invalid.name() {
3254 self.report_method_error(span,
3265 // Call the generic checker.
3266 self.check_method_argument_types(span,
3274 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3278 .unwrap_or_else(|| span_bug!(return_expr.span,
3279 "check_return_expr called outside fn body"));
3281 let ret_ty = ret_coercion.borrow().expected_ty();
3282 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3283 ret_coercion.borrow_mut()
3285 &self.cause(return_expr.span,
3286 ObligationCauseCode::ReturnType(return_expr.id)),
3291 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3292 // or 'if-else' expression.
3293 fn check_then_else(&self,
3294 cond_expr: &'gcx hir::Expr,
3295 then_expr: &'gcx hir::Expr,
3296 opt_else_expr: Option<&'gcx hir::Expr>,
3298 expected: Expectation<'tcx>) -> Ty<'tcx> {
3299 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3300 let cond_diverges = self.diverges.get();
3301 self.diverges.set(Diverges::Maybe);
3303 let expected = expected.adjust_for_branches(self);
3304 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3305 let then_diverges = self.diverges.get();
3306 self.diverges.set(Diverges::Maybe);
3308 // We've already taken the expected type's preferences
3309 // into account when typing the `then` branch. To figure
3310 // out the initial shot at a LUB, we thus only consider
3311 // `expected` if it represents a *hard* constraint
3312 // (`only_has_type`); otherwise, we just go with a
3313 // fresh type variable.
3314 let coerce_to_ty = expected.coercion_target_type(self, sp);
3315 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3317 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3318 coerce.coerce(self, &if_cause, then_expr, then_ty);
3320 if let Some(else_expr) = opt_else_expr {
3321 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3322 let else_diverges = self.diverges.get();
3324 coerce.coerce(self, &if_cause, else_expr, else_ty);
3326 // We won't diverge unless both branches do (or the condition does).
3327 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3329 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3330 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3332 // If the condition is false we can't diverge.
3333 self.diverges.set(cond_diverges);
3336 let result_ty = coerce.complete(self);
3337 if cond_ty.references_error() {
3344 // Check field access expressions
3345 fn check_field(&self,
3346 expr: &'gcx hir::Expr,
3348 base: &'gcx hir::Expr,
3349 field: ast::Ident) -> Ty<'tcx> {
3350 let expr_t = self.check_expr_with_needs(base, needs);
3351 let expr_t = self.structurally_resolved_type(base.span,
3353 let mut private_candidate = None;
3354 let mut autoderef = self.autoderef(expr.span, expr_t);
3355 while let Some((base_t, _)) = autoderef.next() {
3357 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3358 debug!("struct named {:?}", base_t);
3359 let (ident, def_scope) =
3360 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3361 let fields = &base_def.non_enum_variant().fields;
3362 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3363 let field = &fields[index];
3364 let field_ty = self.field_ty(expr.span, field, substs);
3365 // Save the index of all fields regardless of their visibility in case
3366 // of error recovery.
3367 self.write_field_index(expr.id, index);
3368 if field.vis.is_accessible_from(def_scope, self.tcx) {
3369 let adjustments = autoderef.adjust_steps(self, needs);
3370 self.apply_adjustments(base, adjustments);
3371 autoderef.finalize(self);
3373 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3376 private_candidate = Some((base_def.did, field_ty));
3379 ty::Tuple(ref tys) => {
3380 let fstr = field.as_str();
3381 if let Ok(index) = fstr.parse::<usize>() {
3382 if fstr == index.to_string() {
3383 if let Some(field_ty) = tys.get(index) {
3384 let adjustments = autoderef.adjust_steps(self, needs);
3385 self.apply_adjustments(base, adjustments);
3386 autoderef.finalize(self);
3388 self.write_field_index(expr.id, index);
3397 autoderef.unambiguous_final_ty(self);
3399 if let Some((did, field_ty)) = private_candidate {
3400 let struct_path = self.tcx().item_path_str(did);
3401 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3402 "field `{}` of struct `{}` is private",
3403 field, struct_path);
3404 // Also check if an accessible method exists, which is often what is meant.
3405 if self.method_exists(field, expr_t, expr.id, false) {
3406 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3410 } else if field.name == keywords::Invalid.name() {
3411 self.tcx().types.err
3412 } else if self.method_exists(field, expr_t, expr.id, true) {
3413 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3414 "attempted to take value of method `{}` on type `{}`",
3416 .help("maybe a `()` to call it is missing?")
3418 self.tcx().types.err
3420 if !expr_t.is_primitive_ty() {
3421 let mut err = self.no_such_field_err(field.span, field, expr_t);
3424 ty::Adt(def, _) if !def.is_enum() => {
3425 if let Some(suggested_field_name) =
3426 Self::suggest_field_name(def.non_enum_variant(),
3427 &field.as_str(), vec![]) {
3428 err.span_label(field.span,
3429 format!("did you mean `{}`?", suggested_field_name));
3431 err.span_label(field.span, "unknown field");
3432 let struct_variant_def = def.non_enum_variant();
3433 let field_names = self.available_field_names(struct_variant_def);
3434 if !field_names.is_empty() {
3435 err.note(&format!("available fields are: {}",
3436 self.name_series_display(field_names)));
3440 ty::Array(_, len) => {
3441 if let (Some(len), Ok(user_index)) = (
3442 len.assert_usize(self.tcx),
3443 field.as_str().parse::<u64>()
3445 let base = self.tcx.sess.source_map()
3446 .span_to_snippet(base.span)
3447 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3448 let help = "instead of using tuple indexing, use array indexing";
3449 let suggestion = format!("{}[{}]", base, field);
3450 let applicability = if len < user_index {
3451 Applicability::MachineApplicable
3453 Applicability::MaybeIncorrect
3455 err.span_suggestion_with_applicability(
3456 expr.span, help, suggestion, applicability
3461 let base = self.tcx.sess.source_map()
3462 .span_to_snippet(base.span)
3463 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3464 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3465 let suggestion = format!("(*{}).{}", base, field);
3466 err.span_suggestion_with_applicability(
3470 Applicability::MaybeIncorrect,
3477 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3478 "`{}` is a primitive type and therefore doesn't have fields",
3481 self.tcx().types.err
3485 // Return an hint about the closest match in field names
3486 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3488 skip: Vec<LocalInternedString>)
3490 let names = variant.fields.iter().filter_map(|field| {
3491 // ignore already set fields and private fields from non-local crates
3492 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3493 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3496 Some(&field.ident.name)
3500 find_best_match_for_name(names, field, None)
3503 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3504 variant.fields.iter().filter(|field| {
3505 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3506 field.vis.is_accessible_from(def_scope, self.tcx)
3508 .map(|field| field.ident.name)
3512 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3513 // dynamic limit, to never omit just one field
3514 let limit = if names.len() == 6 { 6 } else { 5 };
3515 let mut display = names.iter().take(limit)
3516 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3517 if names.len() > limit {
3518 display = format!("{} ... and {} others", display, names.len() - limit);
3523 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3524 -> DiagnosticBuilder {
3525 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3526 "no field `{}` on type `{}`",
3530 fn report_unknown_field(&self,
3532 variant: &'tcx ty::VariantDef,
3534 skip_fields: &[hir::Field],
3536 let mut err = self.type_error_struct_with_diag(
3538 |actual| match ty.sty {
3539 ty::Adt(adt, ..) if adt.is_enum() => {
3540 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3541 "{} `{}::{}` has no field named `{}`",
3542 kind_name, actual, variant.name, field.ident)
3545 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3546 "{} `{}` has no field named `{}`",
3547 kind_name, actual, field.ident)
3551 // prevent all specified fields from being suggested
3552 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3553 if let Some(field_name) = Self::suggest_field_name(variant,
3554 &field.ident.as_str(),
3555 skip_fields.collect()) {
3556 err.span_label(field.ident.span,
3557 format!("field does not exist - did you mean `{}`?", field_name));
3560 ty::Adt(adt, ..) => {
3562 err.span_label(field.ident.span,
3563 format!("`{}::{}` does not have this field",
3566 err.span_label(field.ident.span,
3567 format!("`{}` does not have this field", ty));
3569 let available_field_names = self.available_field_names(variant);
3570 if !available_field_names.is_empty() {
3571 err.note(&format!("available fields are: {}",
3572 self.name_series_display(available_field_names)));
3575 _ => bug!("non-ADT passed to report_unknown_field")
3581 fn check_expr_struct_fields(&self,
3583 expected: Expectation<'tcx>,
3584 expr_id: ast::NodeId,
3586 variant: &'tcx ty::VariantDef,
3587 ast_fields: &'gcx [hir::Field],
3588 check_completeness: bool) -> bool {
3592 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3593 .get(0).cloned().unwrap_or(adt_ty);
3594 // re-link the regions that EIfEO can erase.
3595 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3597 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3598 &ty::Adt(adt, substs) => {
3599 (substs, adt.adt_kind(), adt.variant_descr())
3601 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3604 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3605 (field.ident.modern(), (i, field))
3606 ).collect::<FxHashMap<_, _>>();
3608 let mut seen_fields = FxHashMap::default();
3610 let mut error_happened = false;
3612 // Type-check each field.
3613 for field in ast_fields {
3614 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3615 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3616 seen_fields.insert(ident, field.span);
3617 self.write_field_index(field.id, i);
3619 // We don't look at stability attributes on
3620 // struct-like enums (yet...), but it's definitely not
3621 // a bug to have constructed one.
3622 if adt_kind != AdtKind::Enum {
3623 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3626 self.field_ty(field.span, v_field, substs)
3628 error_happened = true;
3629 if let Some(prev_span) = seen_fields.get(&ident) {
3630 let mut err = struct_span_err!(self.tcx.sess,
3633 "field `{}` specified more than once",
3636 err.span_label(field.ident.span, "used more than once");
3637 err.span_label(*prev_span, format!("first use of `{}`", ident));
3641 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3647 // Make sure to give a type to the field even if there's
3648 // an error, so we can continue type-checking.
3649 self.check_expr_coercable_to_type(&field.expr, field_type);
3652 // Make sure the programmer specified correct number of fields.
3653 if kind_name == "union" {
3654 if ast_fields.len() != 1 {
3655 tcx.sess.span_err(span, "union expressions should have exactly one field");
3657 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3658 let len = remaining_fields.len();
3660 let mut displayable_field_names = remaining_fields
3662 .map(|ident| ident.as_str())
3663 .collect::<Vec<_>>();
3665 displayable_field_names.sort();
3667 let truncated_fields_error = if len <= 3 {
3670 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3673 let remaining_fields_names = displayable_field_names.iter().take(3)
3674 .map(|n| format!("`{}`", n))
3675 .collect::<Vec<_>>()
3678 struct_span_err!(tcx.sess, span, E0063,
3679 "missing field{} {}{} in initializer of `{}`",
3680 if remaining_fields.len() == 1 { "" } else { "s" },
3681 remaining_fields_names,
3682 truncated_fields_error,
3684 .span_label(span, format!("missing {}{}",
3685 remaining_fields_names,
3686 truncated_fields_error))
3692 fn check_struct_fields_on_error(&self,
3693 fields: &'gcx [hir::Field],
3694 base_expr: &'gcx Option<P<hir::Expr>>) {
3695 for field in fields {
3696 self.check_expr(&field.expr);
3698 if let Some(ref base) = *base_expr {
3699 self.check_expr(&base);
3703 pub fn check_struct_path(&self,
3705 node_id: ast::NodeId)
3706 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3707 let path_span = match *qpath {
3708 hir::QPath::Resolved(_, ref path) => path.span,
3709 hir::QPath::TypeRelative(ref qself, _) => qself.span
3711 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3712 let variant = match def {
3714 self.set_tainted_by_errors();
3717 Def::Variant(..) => {
3719 ty::Adt(adt, substs) => {
3720 Some((adt.variant_of_def(def), adt.did, substs))
3722 _ => bug!("unexpected type: {:?}", ty.sty)
3725 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3726 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3728 ty::Adt(adt, substs) if !adt.is_enum() => {
3729 Some((adt.non_enum_variant(), adt.did, substs))
3734 _ => bug!("unexpected definition: {:?}", def)
3737 if let Some((variant, did, substs)) = variant {
3738 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3739 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
3740 self.write_user_substs_from_substs(hir_id, substs, None);
3742 // Check bounds on type arguments used in the path.
3743 let bounds = self.instantiate_bounds(path_span, did, substs);
3744 let cause = traits::ObligationCause::new(path_span, self.body_id,
3745 traits::ItemObligation(did));
3746 self.add_obligations_for_parameters(cause, &bounds);
3750 struct_span_err!(self.tcx.sess, path_span, E0071,
3751 "expected struct, variant or union type, found {}",
3752 ty.sort_string(self.tcx))
3753 .span_label(path_span, "not a struct")
3759 fn check_expr_struct(&self,
3761 expected: Expectation<'tcx>,
3763 fields: &'gcx [hir::Field],
3764 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3766 // Find the relevant variant
3767 let (variant, adt_ty) =
3768 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3771 self.check_struct_fields_on_error(fields, base_expr);
3772 return self.tcx.types.err;
3775 let path_span = match *qpath {
3776 hir::QPath::Resolved(_, ref path) => path.span,
3777 hir::QPath::TypeRelative(ref qself, _) => qself.span
3780 // Prohibit struct expressions when non-exhaustive flag is set.
3781 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3782 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3783 span_err!(self.tcx.sess, expr.span, E0639,
3784 "cannot create non-exhaustive {} using struct expression",
3785 adt.variant_descr());
3788 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3789 variant, fields, base_expr.is_none());
3790 if let &Some(ref base_expr) = base_expr {
3791 // If check_expr_struct_fields hit an error, do not attempt to populate
3792 // the fields with the base_expr. This could cause us to hit errors later
3793 // when certain fields are assumed to exist that in fact do not.
3794 if !error_happened {
3795 self.check_expr_has_type_or_error(base_expr, adt_ty);
3797 ty::Adt(adt, substs) if adt.is_struct() => {
3798 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3799 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3804 .fru_field_types_mut()
3805 .insert(expr.hir_id, fru_field_types);
3808 span_err!(self.tcx.sess, base_expr.span, E0436,
3809 "functional record update syntax requires a struct");
3814 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3820 /// If an expression has any sub-expressions that result in a type error,
3821 /// inspecting that expression's type with `ty.references_error()` will return
3822 /// true. Likewise, if an expression is known to diverge, inspecting its
3823 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3824 /// strict, _|_ can appear in the type of an expression that does not,
3825 /// itself, diverge: for example, fn() -> _|_.)
3826 /// Note that inspecting a type's structure *directly* may expose the fact
3827 /// that there are actually multiple representations for `Error`, so avoid
3828 /// that when err needs to be handled differently.
3829 fn check_expr_with_expectation_and_needs(&self,
3830 expr: &'gcx hir::Expr,
3831 expected: Expectation<'tcx>,
3832 needs: Needs) -> Ty<'tcx> {
3833 debug!(">> type-checking: expr={:?} expected={:?}",
3836 // Warn for expressions after diverging siblings.
3837 self.warn_if_unreachable(expr.id, expr.span, "expression");
3839 // Hide the outer diverging and has_errors flags.
3840 let old_diverges = self.diverges.get();
3841 let old_has_errors = self.has_errors.get();
3842 self.diverges.set(Diverges::Maybe);
3843 self.has_errors.set(false);
3845 let ty = self.check_expr_kind(expr, expected, needs);
3847 // Warn for non-block expressions with diverging children.
3849 hir::ExprKind::Block(..) |
3850 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3851 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3853 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3856 // Any expression that produces a value of type `!` must have diverged
3858 self.diverges.set(self.diverges.get() | Diverges::Always);
3861 // Record the type, which applies it effects.
3862 // We need to do this after the warning above, so that
3863 // we don't warn for the diverging expression itself.
3864 self.write_ty(expr.hir_id, ty);
3866 // Combine the diverging and has_error flags.
3867 self.diverges.set(self.diverges.get() | old_diverges);
3868 self.has_errors.set(self.has_errors.get() | old_has_errors);
3870 debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
3871 debug!("... {:?}, expected is {:?}", ty, expected);
3878 expr: &'gcx hir::Expr,
3879 expected: Expectation<'tcx>,
3883 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3892 hir::ExprKind::Box(ref subexpr) => {
3893 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3895 ty::Adt(def, _) if def.is_box()
3896 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3900 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3901 tcx.mk_box(referent_ty)
3904 hir::ExprKind::Lit(ref lit) => {
3905 self.check_lit(&lit, expected)
3907 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3908 self.check_binop(expr, op, lhs, rhs)
3910 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3911 self.check_binop_assign(expr, op, lhs, rhs)
3913 hir::ExprKind::Unary(unop, ref oprnd) => {
3914 let expected_inner = match unop {
3915 hir::UnNot | hir::UnNeg => {
3922 let needs = match unop {
3923 hir::UnDeref => needs,
3926 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3930 if !oprnd_t.references_error() {
3931 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3934 if let Some(mt) = oprnd_t.builtin_deref(true) {
3936 } else if let Some(ok) = self.try_overloaded_deref(
3937 expr.span, oprnd_t, needs) {
3938 let method = self.register_infer_ok_obligations(ok);
3939 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3940 let mutbl = match mutbl {
3941 hir::MutImmutable => AutoBorrowMutability::Immutable,
3942 hir::MutMutable => AutoBorrowMutability::Mutable {
3943 // (It shouldn't actually matter for unary ops whether
3944 // we enable two-phase borrows or not, since a unary
3945 // op has no additional operands.)
3946 allow_two_phase_borrow: AllowTwoPhase::No,
3949 self.apply_adjustments(oprnd, vec![Adjustment {
3950 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3951 target: method.sig.inputs()[0]
3954 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3955 self.write_method_call(expr.hir_id, method);
3957 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3958 "type `{}` cannot be dereferenced",
3960 oprnd_t = tcx.types.err;
3964 let result = self.check_user_unop(expr, oprnd_t, unop);
3965 // If it's builtin, we can reuse the type, this helps inference.
3966 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3971 let result = self.check_user_unop(expr, oprnd_t, unop);
3972 // If it's builtin, we can reuse the type, this helps inference.
3973 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3981 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3982 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3984 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3985 if oprnd.is_place_expr() {
3986 // Places may legitimately have unsized types.
3987 // For example, dereferences of a fat pointer and
3988 // the last field of a struct can be unsized.
3991 Expectation::rvalue_hint(self, ty)
3997 let needs = Needs::maybe_mut_place(mutbl);
3998 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4000 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4001 if tm.ty.references_error() {
4004 // Note: at this point, we cannot say what the best lifetime
4005 // is to use for resulting pointer. We want to use the
4006 // shortest lifetime possible so as to avoid spurious borrowck
4007 // errors. Moreover, the longest lifetime will depend on the
4008 // precise details of the value whose address is being taken
4009 // (and how long it is valid), which we don't know yet until type
4010 // inference is complete.
4012 // Therefore, here we simply generate a region variable. The
4013 // region inferencer will then select the ultimate value.
4014 // Finally, borrowck is charged with guaranteeing that the
4015 // value whose address was taken can actually be made to live
4016 // as long as it needs to live.
4017 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4018 tcx.mk_ref(region, tm)
4021 hir::ExprKind::Path(ref qpath) => {
4022 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
4023 let ty = if def != Def::Err {
4024 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
4026 self.set_tainted_by_errors();
4030 if let ty::FnDef(..) = ty.sty {
4031 let fn_sig = ty.fn_sig(tcx);
4032 if !tcx.features().unsized_locals {
4033 // We want to remove some Sized bounds from std functions,
4034 // but don't want to expose the removal to stable Rust.
4035 // i.e., we don't want to allow
4041 // to work in stable even if the Sized bound on `drop` is relaxed.
4042 for i in 0..fn_sig.inputs().skip_binder().len() {
4043 // We just want to check sizedness, so instead of introducing
4044 // placeholder lifetimes with probing, we just replace higher lifetimes
4046 let input = self.replace_bound_vars_with_fresh_vars(
4048 infer::LateBoundRegionConversionTime::FnCall,
4049 &fn_sig.input(i)).0;
4050 self.require_type_is_sized_deferred(input, expr.span,
4051 traits::SizedArgumentType);
4054 // Here we want to prevent struct constructors from returning unsized types.
4055 // There were two cases this happened: fn pointer coercion in stable
4056 // and usual function call in presense of unsized_locals.
4057 // Also, as we just want to check sizedness, instead of introducing
4058 // placeholder lifetimes with probing, we just replace higher lifetimes
4060 let output = self.replace_bound_vars_with_fresh_vars(
4062 infer::LateBoundRegionConversionTime::FnCall,
4063 &fn_sig.output()).0;
4064 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4067 // We always require that the type provided as the value for
4068 // a type parameter outlives the moment of instantiation.
4069 let substs = self.tables.borrow().node_substs(expr.hir_id);
4070 self.add_wf_bounds(substs, expr);
4074 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4075 for expr in outputs.iter().chain(inputs.iter()) {
4076 self.check_expr(expr);
4080 hir::ExprKind::Break(destination, ref expr_opt) => {
4081 if let Ok(target_id) = destination.target_id {
4083 if let Some(ref e) = *expr_opt {
4084 // If this is a break with a value, we need to type-check
4085 // the expression. Get an expected type from the loop context.
4086 let opt_coerce_to = {
4087 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4088 enclosing_breakables.find_breakable(target_id)
4091 .map(|coerce| coerce.expected_ty())
4094 // If the loop context is not a `loop { }`, then break with
4095 // a value is illegal, and `opt_coerce_to` will be `None`.
4096 // Just set expectation to error in that case.
4097 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4099 // Recurse without `enclosing_breakables` borrowed.
4100 e_ty = self.check_expr_with_hint(e, coerce_to);
4101 cause = self.misc(e.span);
4103 // Otherwise, this is a break *without* a value. That's
4104 // always legal, and is equivalent to `break ()`.
4105 e_ty = tcx.mk_unit();
4106 cause = self.misc(expr.span);
4109 // Now that we have type-checked `expr_opt`, borrow
4110 // the `enclosing_loops` field and let's coerce the
4111 // type of `expr_opt` into what is expected.
4112 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4113 let ctxt = enclosing_breakables.find_breakable(target_id);
4114 if let Some(ref mut coerce) = ctxt.coerce {
4115 if let Some(ref e) = *expr_opt {
4116 coerce.coerce(self, &cause, e, e_ty);
4118 assert!(e_ty.is_unit());
4119 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4122 // If `ctxt.coerce` is `None`, we can just ignore
4123 // the type of the expresison. This is because
4124 // either this was a break *without* a value, in
4125 // which case it is always a legal type (`()`), or
4126 // else an error would have been flagged by the
4127 // `loops` pass for using break with an expression
4128 // where you are not supposed to.
4129 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4132 ctxt.may_break = true;
4134 // the type of a `break` is always `!`, since it diverges
4137 // Otherwise, we failed to find the enclosing loop;
4138 // this can only happen if the `break` was not
4139 // inside a loop at all, which is caught by the
4140 // loop-checking pass.
4141 if self.tcx.sess.err_count() == 0 {
4142 self.tcx.sess.delay_span_bug(expr.span,
4143 "break was outside loop, but no error was emitted");
4146 // We still need to assign a type to the inner expression to
4147 // prevent the ICE in #43162.
4148 if let Some(ref e) = *expr_opt {
4149 self.check_expr_with_hint(e, tcx.types.err);
4151 // ... except when we try to 'break rust;'.
4152 // ICE this expression in particular (see #43162).
4153 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
4154 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4155 fatally_break_rust(self.tcx.sess);
4159 // There was an error; make type-check fail.
4164 hir::ExprKind::Continue(destination) => {
4165 if destination.target_id.is_ok() {
4168 // There was an error; make type-check fail.
4172 hir::ExprKind::Ret(ref expr_opt) => {
4173 if self.ret_coercion.is_none() {
4174 struct_span_err!(self.tcx.sess, expr.span, E0572,
4175 "return statement outside of function body").emit();
4176 } else if let Some(ref e) = *expr_opt {
4177 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4178 self.check_return_expr(e);
4180 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4181 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4182 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4183 if let Some((fn_decl, _)) = self.get_fn_decl(expr.id) {
4184 coercion.coerce_forced_unit(
4189 fn_decl.output.span(),
4191 "expected `{}` because of this return type",
4199 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4204 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4205 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4207 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4210 ExpectIfCondition => {
4211 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4212 expected error elsehwere");
4215 // Only check this if not in an `if` condition, as the
4216 // mistyped comparison help is more appropriate.
4217 if !lhs.is_place_expr() {
4218 struct_span_err!(self.tcx.sess, expr.span, E0070,
4219 "invalid left-hand side expression")
4220 .span_label(expr.span, "left-hand of expression not valid")
4226 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4228 if lhs_ty.references_error() || rhs_ty.references_error() {
4234 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4235 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4236 expr.span, expected)
4238 hir::ExprKind::While(ref cond, ref body, _) => {
4239 let ctxt = BreakableCtxt {
4240 // cannot use break with a value from a while loop
4242 may_break: false, // Will get updated if/when we find a `break`.
4245 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4246 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4247 let cond_diverging = self.diverges.get();
4248 self.check_block_no_value(&body);
4250 // We may never reach the body so it diverging means nothing.
4251 self.diverges.set(cond_diverging);
4255 // No way to know whether it's diverging because
4256 // of a `break` or an outer `break` or `return`.
4257 self.diverges.set(Diverges::Maybe);
4262 hir::ExprKind::Loop(ref body, _, source) => {
4263 let coerce = match source {
4264 // you can only use break with a value from a normal `loop { }`
4265 hir::LoopSource::Loop => {
4266 let coerce_to = expected.coercion_target_type(self, body.span);
4267 Some(CoerceMany::new(coerce_to))
4270 hir::LoopSource::WhileLet |
4271 hir::LoopSource::ForLoop => {
4276 let ctxt = BreakableCtxt {
4278 may_break: false, // Will get updated if/when we find a `break`.
4281 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4282 self.check_block_no_value(&body);
4286 // No way to know whether it's diverging because
4287 // of a `break` or an outer `break` or `return`.
4288 self.diverges.set(Diverges::Maybe);
4291 // If we permit break with a value, then result type is
4292 // the LUB of the breaks (possibly ! if none); else, it
4293 // is nil. This makes sense because infinite loops
4294 // (which would have type !) are only possible iff we
4295 // permit break with a value [1].
4296 if ctxt.coerce.is_none() && !ctxt.may_break {
4298 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4300 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4302 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4303 self.check_match(expr, &discrim, arms, expected, match_src)
4305 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4306 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4308 hir::ExprKind::Block(ref body, _) => {
4309 self.check_block_with_expected(&body, expected)
4311 hir::ExprKind::Call(ref callee, ref args) => {
4312 self.check_call(expr, &callee, args, expected)
4314 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4315 self.check_method_call(expr, segment, span, args, expected, needs)
4317 hir::ExprKind::Cast(ref e, ref t) => {
4318 // Find the type of `e`. Supply hints based on the type we are casting to,
4320 let t_cast = self.to_ty_saving_user_provided_ty(t);
4321 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4322 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4323 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4325 // Eagerly check for some obvious errors.
4326 if t_expr.references_error() || t_cast.references_error() {
4329 // Defer other checks until we're done type checking.
4330 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4331 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4333 deferred_cast_checks.push(cast_check);
4336 Err(ErrorReported) => {
4342 hir::ExprKind::Type(ref e, ref t) => {
4343 let ty = self.to_ty_saving_user_provided_ty(&t);
4344 self.check_expr_eq_type(&e, ty);
4347 hir::ExprKind::Array(ref args) => {
4348 let uty = expected.to_option(self).and_then(|uty| {
4350 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4355 let element_ty = if !args.is_empty() {
4356 let coerce_to = uty.unwrap_or_else(
4357 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4358 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4359 assert_eq!(self.diverges.get(), Diverges::Maybe);
4361 let e_ty = self.check_expr_with_hint(e, coerce_to);
4362 let cause = self.misc(e.span);
4363 coerce.coerce(self, &cause, e, e_ty);
4365 coerce.complete(self)
4367 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4369 tcx.mk_array(element_ty, args.len() as u64)
4371 hir::ExprKind::Repeat(ref element, ref count) => {
4372 let count_def_id = tcx.hir().local_def_id(count.id);
4373 let param_env = ty::ParamEnv::empty();
4374 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4375 let instance = ty::Instance::resolve(
4381 let global_id = GlobalId {
4385 let count = tcx.const_eval(param_env.and(global_id));
4387 let uty = match expected {
4388 ExpectHasType(uty) => {
4390 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4397 let (element_ty, t) = match uty {
4399 self.check_expr_coercable_to_type(&element, uty);
4403 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4404 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4409 if let Ok(count) = count {
4410 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4412 // For [foo, ..n] where n > 1, `foo` must have
4414 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4415 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4419 if element_ty.references_error() {
4421 } else if let Ok(count) = count {
4422 tcx.mk_ty(ty::Array(t, count))
4427 hir::ExprKind::Tup(ref elts) => {
4428 let flds = expected.only_has_type(self).and_then(|ty| {
4429 let ty = self.resolve_type_vars_with_obligations(ty);
4431 ty::Tuple(ref flds) => Some(&flds[..]),
4436 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4437 let t = match flds {
4438 Some(ref fs) if i < fs.len() => {
4440 self.check_expr_coercable_to_type(&e, ety);
4444 self.check_expr_with_expectation(&e, NoExpectation)
4449 let tuple = tcx.mk_tup(elt_ts_iter);
4450 if tuple.references_error() {
4453 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4457 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4458 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4460 hir::ExprKind::Field(ref base, field) => {
4461 self.check_field(expr, needs, &base, field)
4463 hir::ExprKind::Index(ref base, ref idx) => {
4464 let base_t = self.check_expr_with_needs(&base, needs);
4465 let idx_t = self.check_expr(&idx);
4467 if base_t.references_error() {
4469 } else if idx_t.references_error() {
4472 let base_t = self.structurally_resolved_type(base.span, base_t);
4473 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4474 Some((index_ty, element_ty)) => {
4475 // two-phase not needed because index_ty is never mutable
4476 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4481 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4482 "cannot index into a value of type `{}`",
4484 // Try to give some advice about indexing tuples.
4485 if let ty::Tuple(..) = base_t.sty {
4486 let mut needs_note = true;
4487 // If the index is an integer, we can show the actual
4488 // fixed expression:
4489 if let hir::ExprKind::Lit(ref lit) = idx.node {
4490 if let ast::LitKind::Int(i,
4491 ast::LitIntType::Unsuffixed) = lit.node {
4492 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4493 if let Ok(snip) = snip {
4494 err.span_suggestion_with_applicability(
4496 "to access tuple elements, use",
4497 format!("{}.{}", snip, i),
4498 Applicability::MachineApplicable);
4504 err.help("to access tuple elements, use tuple indexing \
4505 syntax (e.g., `tuple.0`)");
4514 hir::ExprKind::Yield(ref value) => {
4515 match self.yield_ty {
4517 self.check_expr_coercable_to_type(&value, ty);
4520 struct_span_err!(self.tcx.sess, expr.span, E0627,
4521 "yield statement outside of generator literal").emit();
4529 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4530 // The newly resolved definition is written into `type_dependent_defs`.
4531 fn finish_resolving_struct_path(&self,
4534 node_id: ast::NodeId)
4538 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4539 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4540 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4543 hir::QPath::TypeRelative(ref qself, ref segment) => {
4544 let ty = self.to_ty(qself);
4546 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4551 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4554 // Write back the new resolution.
4555 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4556 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4563 // Resolve associated value path into a base type and associated constant or method definition.
4564 // The newly resolved definition is written into `type_dependent_defs`.
4565 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4566 qpath: &'b hir::QPath,
4567 node_id: ast::NodeId,
4569 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4571 let (ty, item_segment) = match *qpath {
4572 hir::QPath::Resolved(ref opt_qself, ref path) => {
4574 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4575 &path.segments[..]);
4577 hir::QPath::TypeRelative(ref qself, ref segment) => {
4578 (self.to_ty(qself), segment)
4581 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4582 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4583 // Return directly on cache hit. This is useful to avoid doubly reporting
4584 // errors with default match binding modes. See #44614.
4585 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4587 let item_name = item_segment.ident;
4588 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4591 let def = match error {
4592 method::MethodError::PrivateMatch(def, _) => def,
4595 if item_name.name != keywords::Invalid.name() {
4596 self.report_method_error(span, ty, item_name, None, error, None);
4602 // Write back the new resolution.
4603 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4604 (def, Some(ty), slice::from_ref(&**item_segment))
4607 pub fn check_decl_initializer(&self,
4608 local: &'gcx hir::Local,
4609 init: &'gcx hir::Expr) -> Ty<'tcx>
4611 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4612 // for #42640 (default match binding modes).
4615 let ref_bindings = local.pat.contains_explicit_ref_binding();
4617 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4618 if let Some(m) = ref_bindings {
4619 // Somewhat subtle: if we have a `ref` binding in the pattern,
4620 // we want to avoid introducing coercions for the RHS. This is
4621 // both because it helps preserve sanity and, in the case of
4622 // ref mut, for soundness (issue #23116). In particular, in
4623 // the latter case, we need to be clear that the type of the
4624 // referent for the reference that results is *equal to* the
4625 // type of the place it is referencing, and not some
4626 // supertype thereof.
4627 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4628 self.demand_eqtype(init.span, local_ty, init_ty);
4631 self.check_expr_coercable_to_type(init, local_ty)
4635 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4636 let t = self.local_ty(local.span, local.id).decl_ty;
4637 self.write_ty(local.hir_id, t);
4639 if let Some(ref init) = local.init {
4640 let init_ty = self.check_decl_initializer(local, &init);
4641 if init_ty.references_error() {
4642 self.write_ty(local.hir_id, init_ty);
4646 self.check_pat_walk(&local.pat, t,
4647 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4649 let pat_ty = self.node_ty(local.pat.hir_id);
4650 if pat_ty.references_error() {
4651 self.write_ty(local.hir_id, pat_ty);
4655 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4656 // Don't do all the complex logic below for DeclItem.
4658 hir::StmtKind::Decl(ref decl, _) => {
4659 if let hir::DeclKind::Item(_) = decl.node {
4663 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4666 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4668 // Hide the outer diverging and has_errors flags.
4669 let old_diverges = self.diverges.get();
4670 let old_has_errors = self.has_errors.get();
4671 self.diverges.set(Diverges::Maybe);
4672 self.has_errors.set(false);
4675 hir::StmtKind::Decl(ref decl, _) => {
4677 hir::DeclKind::Local(ref l) => {
4678 self.check_decl_local(&l);
4680 hir::DeclKind::Item(_) => {/* ignore for now */}
4683 hir::StmtKind::Expr(ref expr, _) => {
4684 // Check with expected type of ()
4685 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4687 hir::StmtKind::Semi(ref expr, _) => {
4688 self.check_expr(&expr);
4692 // Combine the diverging and has_error flags.
4693 self.diverges.set(self.diverges.get() | old_diverges);
4694 self.has_errors.set(self.has_errors.get() | old_has_errors);
4697 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4698 let unit = self.tcx.mk_unit();
4699 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4701 // if the block produces a `!` value, that can always be
4702 // (effectively) coerced to unit.
4704 self.demand_suptype(blk.span, unit, ty);
4708 fn check_block_with_expected(&self,
4709 blk: &'gcx hir::Block,
4710 expected: Expectation<'tcx>) -> Ty<'tcx> {
4712 let mut fcx_ps = self.ps.borrow_mut();
4713 let unsafety_state = fcx_ps.recurse(blk);
4714 replace(&mut *fcx_ps, unsafety_state)
4717 // In some cases, blocks have just one exit, but other blocks
4718 // can be targeted by multiple breaks. This can happen both
4719 // with labeled blocks as well as when we desugar
4720 // a `try { ... }` expression.
4724 // 'a: { if true { break 'a Err(()); } Ok(()) }
4726 // Here we would wind up with two coercions, one from
4727 // `Err(())` and the other from the tail expression
4728 // `Ok(())`. If the tail expression is omitted, that's a
4729 // "forced unit" -- unless the block diverges, in which
4730 // case we can ignore the tail expression (e.g., `'a: {
4731 // break 'a 22; }` would not force the type of the block
4733 let tail_expr = blk.expr.as_ref();
4734 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4735 let coerce = if blk.targeted_by_break {
4736 CoerceMany::new(coerce_to_ty)
4738 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4739 Some(e) => slice::from_ref(e),
4742 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4745 let prev_diverges = self.diverges.get();
4746 let ctxt = BreakableCtxt {
4747 coerce: Some(coerce),
4751 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4752 for s in &blk.stmts {
4756 // check the tail expression **without** holding the
4757 // `enclosing_breakables` lock below.
4758 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4760 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4761 let ctxt = enclosing_breakables.find_breakable(blk.id);
4762 let coerce = ctxt.coerce.as_mut().unwrap();
4763 if let Some(tail_expr_ty) = tail_expr_ty {
4764 let tail_expr = tail_expr.unwrap();
4765 let cause = self.cause(tail_expr.span,
4766 ObligationCauseCode::BlockTailExpression(blk.id));
4772 // Subtle: if there is no explicit tail expression,
4773 // that is typically equivalent to a tail expression
4774 // of `()` -- except if the block diverges. In that
4775 // case, there is no value supplied from the tail
4776 // expression (assuming there are no other breaks,
4777 // this implies that the type of the block will be
4780 // #41425 -- label the implicit `()` as being the
4781 // "found type" here, rather than the "expected type".
4783 // #44579 -- if the block was recovered during parsing,
4784 // the type would be nonsensical and it is not worth it
4785 // to perform the type check, so we avoid generating the
4786 // diagnostic output.
4787 if !self.diverges.get().always() && !blk.recovered {
4788 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4789 if let Some(expected_ty) = expected.only_has_type(self) {
4790 self.consider_hint_about_removing_semicolon(blk,
4800 // If we can break from the block, then the block's exit is always reachable
4801 // (... as long as the entry is reachable) - regardless of the tail of the block.
4802 self.diverges.set(prev_diverges);
4805 let mut ty = ctxt.coerce.unwrap().complete(self);
4807 if self.has_errors.get() || ty.references_error() {
4808 ty = self.tcx.types.err
4811 self.write_ty(blk.hir_id, ty);
4813 *self.ps.borrow_mut() = prev;
4817 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4818 /// suggestion can be made, `None` otherwise.
4819 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4820 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4821 // `while` before reaching it, as block tail returns are not available in them.
4822 if let Some(fn_id) = self.tcx.hir().get_return_block(blk_id) {
4823 let parent = self.tcx.hir().get(fn_id);
4825 if let Node::Item(&hir::Item {
4826 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4828 decl.clone().and_then(|decl| {
4829 // This is less than ideal, it will not suggest a return type span on any
4830 // method called `main`, regardless of whether it is actually the entry point,
4831 // but it will still present it as the reason for the expected type.
4832 Some((decl, name != Symbol::intern("main")))
4834 } else if let Node::TraitItem(&hir::TraitItem {
4835 node: hir::TraitItemKind::Method(hir::MethodSig {
4839 decl.clone().and_then(|decl| {
4842 } else if let Node::ImplItem(&hir::ImplItem {
4843 node: hir::ImplItemKind::Method(hir::MethodSig {
4847 decl.clone().and_then(|decl| {
4858 /// On implicit return expressions with mismatched types, provide the following suggestions:
4860 /// - Point out the method's return type as the reason for the expected type
4861 /// - Possible missing semicolon
4862 /// - Possible missing return type if the return type is the default, and not `fn main()`
4863 pub fn suggest_mismatched_types_on_tail(&self,
4864 err: &mut DiagnosticBuilder<'tcx>,
4865 expression: &'gcx hir::Expr,
4869 blk_id: ast::NodeId) {
4870 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4871 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4872 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4874 self.suggest_ref_or_into(err, expression, expected, found);
4877 pub fn suggest_ref_or_into(
4879 err: &mut DiagnosticBuilder<'tcx>,
4884 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4885 err.span_suggestion_with_applicability(
4889 Applicability::MachineApplicable,
4891 } else if !self.check_for_cast(err, expr, found, expected) {
4892 let methods = self.get_conversion_methods(expr.span, expected, found);
4893 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4894 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4895 .filter_map(|(receiver, method)| {
4896 let method_call = format!(".{}()", method.ident);
4897 if receiver.ends_with(&method_call) {
4898 None // do not suggest code that is already there (#53348)
4900 let method_call_list = [".to_vec()", ".to_string()"];
4901 if receiver.ends_with(".clone()")
4902 && method_call_list.contains(&method_call.as_str()) {
4903 let max_len = receiver.rfind(".").unwrap();
4904 Some(format!("{}{}", &receiver[..max_len], method_call))
4907 Some(format!("{}{}", receiver, method_call))
4911 if suggestions.peek().is_some() {
4912 err.span_suggestions_with_applicability(
4914 "try using a conversion method",
4916 Applicability::MaybeIncorrect,
4923 /// A common error is to forget to add a semicolon at the end of a block:
4927 /// bar_that_returns_u32()
4931 /// This routine checks if the return expression in a block would make sense on its own as a
4932 /// statement and the return type has been left as default or has been specified as `()`. If so,
4933 /// it suggests adding a semicolon.
4934 fn suggest_missing_semicolon(&self,
4935 err: &mut DiagnosticBuilder<'tcx>,
4936 expression: &'gcx hir::Expr,
4939 if expected.is_unit() {
4940 // `BlockTailExpression` only relevant if the tail expr would be
4941 // useful on its own.
4942 match expression.node {
4943 hir::ExprKind::Call(..) |
4944 hir::ExprKind::MethodCall(..) |
4945 hir::ExprKind::If(..) |
4946 hir::ExprKind::While(..) |
4947 hir::ExprKind::Loop(..) |
4948 hir::ExprKind::Match(..) |
4949 hir::ExprKind::Block(..) => {
4950 let sp = self.tcx.sess.source_map().next_point(cause_span);
4951 err.span_suggestion_with_applicability(
4953 "try adding a semicolon",
4955 Applicability::MachineApplicable);
4962 /// A possible error is to forget to add a return type that is needed:
4966 /// bar_that_returns_u32()
4970 /// This routine checks if the return type is left as default, the method is not part of an
4971 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4973 fn suggest_missing_return_type(&self,
4974 err: &mut DiagnosticBuilder<'tcx>,
4975 fn_decl: &hir::FnDecl,
4978 can_suggest: bool) {
4979 // Only suggest changing the return type for methods that
4980 // haven't set a return type at all (and aren't `fn main()` or an impl).
4981 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4982 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4983 err.span_suggestion_with_applicability(
4985 "try adding a return type",
4986 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4987 Applicability::MachineApplicable);
4989 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4990 err.span_label(span, "possibly return type missing here?");
4992 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4993 // `fn main()` must return `()`, do not suggest changing return type
4994 err.span_label(span, "expected `()` because of default return type");
4996 // expectation was caused by something else, not the default return
4997 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4998 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4999 // Only point to return type if the expected type is the return type, as if they
5000 // are not, the expectation must have been caused by something else.
5001 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5003 let ty = AstConv::ast_ty_to_ty(self, ty);
5004 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
5005 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
5006 if ty.sty == expected.sty {
5007 err.span_label(sp, format!("expected `{}` because of return type",
5015 /// A common error is to add an extra semicolon:
5018 /// fn foo() -> usize {
5023 /// This routine checks if the final statement in a block is an
5024 /// expression with an explicit semicolon whose type is compatible
5025 /// with `expected_ty`. If so, it suggests removing the semicolon.
5026 fn consider_hint_about_removing_semicolon(&self,
5027 blk: &'gcx hir::Block,
5028 expected_ty: Ty<'tcx>,
5029 err: &mut DiagnosticBuilder) {
5030 // Be helpful when the user wrote `{... expr;}` and
5031 // taking the `;` off is enough to fix the error.
5032 let last_stmt = match blk.stmts.last() {
5036 let last_expr = match last_stmt.node {
5037 hir::StmtKind::Semi(ref e, _) => e,
5040 let last_expr_ty = self.node_ty(last_expr.hir_id);
5041 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5044 let original_span = original_sp(last_stmt.span, blk.span);
5045 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
5046 err.span_suggestion_with_applicability(
5048 "consider removing this semicolon",
5050 Applicability::MachineApplicable);
5053 fn def_ids_for_path_segments(&self,
5054 segments: &[hir::PathSegment],
5057 // We need to extract the type parameters supplied by the user in
5058 // the path `path`. Due to the current setup, this is a bit of a
5059 // tricky-process; the problem is that resolve only tells us the
5060 // end-point of the path resolution, and not the intermediate steps.
5061 // Luckily, we can (at least for now) deduce the intermediate steps
5062 // just from the end-point.
5064 // There are basically four cases to consider:
5066 // 1. Reference to a constructor of enum variant or struct:
5068 // struct Foo<T>(...)
5069 // enum E<T> { Foo(...) }
5071 // In these cases, the parameters are declared in the type
5074 // 2. Reference to a fn item or a free constant:
5078 // In this case, the path will again always have the form
5079 // `a::b::foo::<T>` where only the final segment should have
5080 // type parameters. However, in this case, those parameters are
5081 // declared on a value, and hence are in the `FnSpace`.
5083 // 3. Reference to a method or an associated constant:
5085 // impl<A> SomeStruct<A> {
5089 // Here we can have a path like
5090 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
5091 // may appear in two places. The penultimate segment,
5092 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
5093 // final segment, `foo::<B>` contains parameters in fn space.
5095 // 4. Reference to a local variable
5097 // Local variables can't have any type parameters.
5099 // The first step then is to categorize the segments appropriately.
5101 assert!(!segments.is_empty());
5102 let last = segments.len() - 1;
5104 let mut path_segs = vec![];
5107 // Case 1. Reference to a struct/variant constructor.
5108 Def::StructCtor(def_id, ..) |
5109 Def::VariantCtor(def_id, ..) |
5110 Def::SelfCtor(.., def_id) => {
5111 // Everything but the final segment should have no
5112 // parameters at all.
5113 let generics = self.tcx.generics_of(def_id);
5114 // Variant and struct constructors use the
5115 // generics of their parent type definition.
5116 let generics_def_id = generics.parent.unwrap_or(def_id);
5117 path_segs.push(PathSeg(generics_def_id, last));
5120 // Case 2. Reference to a top-level value.
5122 Def::Const(def_id) |
5123 Def::Static(def_id, _) => {
5124 path_segs.push(PathSeg(def_id, last));
5127 // Case 3. Reference to a method or associated const.
5128 Def::Method(def_id) |
5129 Def::AssociatedConst(def_id) => {
5130 if segments.len() >= 2 {
5131 let generics = self.tcx.generics_of(def_id);
5132 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
5134 path_segs.push(PathSeg(def_id, last));
5137 // Case 4. Local variable, no generics.
5138 Def::Local(..) | Def::Upvar(..) => {}
5140 _ => bug!("unexpected definition: {:?}", def),
5143 debug!("path_segs = {:?}", path_segs);
5148 // Instantiates the given path, which must refer to an item with the given
5149 // number of type parameters and type.
5150 pub fn instantiate_value_path(&self,
5151 segments: &[hir::PathSegment],
5152 self_ty: Option<Ty<'tcx>>,
5155 node_id: ast::NodeId)
5156 -> (Ty<'tcx>, Def) {
5158 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5165 let path_segs = self.def_ids_for_path_segments(segments, def);
5167 let mut user_self_ty = None;
5169 Def::Method(def_id) |
5170 Def::AssociatedConst(def_id) => {
5171 let container = self.tcx.associated_item(def_id).container;
5173 ty::TraitContainer(trait_did) => {
5174 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5176 ty::ImplContainer(impl_def_id) => {
5177 if segments.len() == 1 {
5178 // `<T>::assoc` will end up here, and so
5179 // can `T::assoc`. It this came from an
5180 // inherent impl, we need to record the
5181 // `T` for posterity (see `UserSelfTy` for
5183 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5184 user_self_ty = Some(UserSelfTy {
5195 // Now that we have categorized what space the parameters for each
5196 // segment belong to, let's sort out the parameters that the user
5197 // provided (if any) into their appropriate spaces. We'll also report
5198 // errors if type parameters are provided in an inappropriate place.
5200 let generic_segs = path_segs.iter().map(|PathSeg(_, index)| index)
5201 .collect::<FxHashSet<_>>();
5202 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5203 if !generic_segs.contains(&index) {
5211 Def::Local(nid) | Def::Upvar(nid, ..) => {
5212 let ty = self.local_ty(span, nid).decl_ty;
5213 let ty = self.normalize_associated_types_in(span, &ty);
5214 self.write_ty(self.tcx.hir().node_to_hir_id(node_id), ty);
5220 // Now we have to compare the types that the user *actually*
5221 // provided against the types that were *expected*. If the user
5222 // did not provide any types, then we want to substitute inference
5223 // variables. If the user provided some types, we may still need
5224 // to add defaults. If the user provided *too many* types, that's
5227 let mut infer_args_for_err = FxHashSet::default();
5228 for &PathSeg(def_id, index) in &path_segs {
5229 let seg = &segments[index];
5230 let generics = self.tcx.generics_of(def_id);
5231 // Argument-position `impl Trait` is treated as a normal generic
5232 // parameter internally, but we don't allow users to specify the
5233 // parameter's value explicitly, so we have to do some error-
5235 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5240 false, // `is_method_call`
5242 if suppress_errors {
5243 infer_args_for_err.insert(index);
5244 self.set_tainted_by_errors(); // See issue #53251.
5248 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5249 self.tcx.generics_of(*def_id).has_self
5250 }).unwrap_or(false);
5252 let mut new_def = def;
5253 let (def_id, ty) = match def {
5254 Def::SelfCtor(impl_def_id) => {
5255 let ty = self.impl_self_ty(span, impl_def_id).ty;
5256 let adt_def = ty.ty_adt_def();
5259 Some(adt_def) if adt_def.has_ctor() => {
5260 let variant = adt_def.non_enum_variant();
5261 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5262 (variant.did, self.tcx.type_of(variant.did))
5265 let mut err = self.tcx.sess.struct_span_err(span,
5266 "the `Self` constructor can only be used with tuple or unit structs");
5267 if let Some(adt_def) = adt_def {
5268 match adt_def.adt_kind() {
5270 err.note("did you mean to use one of the enum's variants?");
5276 format!("did you mean `Self {{ /* fields */ }}`?"),
5283 (impl_def_id, self.tcx.types.err)
5288 let def_id = def.def_id();
5290 // The things we are substituting into the type should not contain
5291 // escaping late-bound regions, and nor should the base type scheme.
5292 let ty = self.tcx.type_of(def_id);
5297 let substs = AstConv::create_substs_for_generic_args(
5303 // Provide the generic args, and whether types should be inferred.
5305 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5308 // If we've encountered an `impl Trait`-related error, we're just
5309 // going to infer the arguments for better error messages.
5310 if !infer_args_for_err.contains(&index) {
5311 // Check whether the user has provided generic arguments.
5312 if let Some(ref data) = segments[index].args {
5313 return (Some(data), segments[index].infer_types);
5316 return (None, segments[index].infer_types);
5321 // Provide substitutions for parameters for which (valid) arguments have been provided.
5323 match (¶m.kind, arg) {
5324 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5325 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5327 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5328 self.to_ty(ty).into()
5330 _ => unreachable!(),
5333 // Provide substitutions for parameters for which arguments are inferred.
5334 |substs, param, infer_types| {
5336 GenericParamDefKind::Lifetime => {
5337 self.re_infer(span, Some(param)).unwrap().into()
5339 GenericParamDefKind::Type { has_default, .. } => {
5340 if !infer_types && has_default {
5341 // If we have a default, then we it doesn't matter that we're not
5342 // inferring the type arguments: we provide the default where any
5344 let default = self.tcx.type_of(param.def_id);
5347 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5350 // If no type arguments were provided, we have to infer them.
5351 // This case also occurs as a result of some malformed input, e.g.
5352 // a lifetime argument being given instead of a type parameter.
5353 // Using inference instead of `Error` gives better error messages.
5354 self.var_for_def(span, param)
5360 assert!(!substs.has_escaping_bound_vars());
5361 assert!(!ty.has_escaping_bound_vars());
5363 // First, store the "user substs" for later.
5364 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
5365 self.write_user_substs_from_substs(hir_id, substs, user_self_ty);
5367 // Add all the obligations that are required, substituting and
5368 // normalized appropriately.
5369 let bounds = self.instantiate_bounds(span, def_id, &substs);
5370 self.add_obligations_for_parameters(
5371 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5374 // Substitute the values for the type parameters into the type of
5375 // the referenced item.
5376 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5378 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5379 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5380 // is inherent, there is no `Self` parameter, instead, the impl needs
5381 // type parameters, which we can infer by unifying the provided `Self`
5382 // with the substituted impl type.
5383 let ty = self.tcx.type_of(impl_def_id);
5385 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5386 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5387 Ok(ok) => self.register_infer_ok_obligations(ok),
5390 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5397 self.check_rustc_args_require_const(def_id, node_id, span);
5399 debug!("instantiate_value_path: type of {:?} is {:?}",
5402 self.write_substs(hir_id, substs);
5404 (ty_substituted, new_def)
5407 fn check_rustc_args_require_const(&self,
5409 node_id: ast::NodeId,
5411 // We're only interested in functions tagged with
5412 // #[rustc_args_required_const], so ignore anything that's not.
5413 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5417 // If our calling expression is indeed the function itself, we're good!
5418 // If not, generate an error that this can only be called directly.
5419 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
5420 if let hir::ExprKind::Call(ref callee, ..) = expr.node {
5421 if callee.id == node_id {
5427 self.tcx.sess.span_err(span, "this function can only be invoked \
5428 directly, not through a function pointer");
5431 // Resolves `typ` by a single level if `typ` is a type variable.
5432 // If no resolution is possible, then an error is reported.
5433 // Numeric inference variables may be left unresolved.
5434 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5435 let ty = self.resolve_type_vars_with_obligations(ty);
5436 if !ty.is_ty_var() {
5439 if !self.is_tainted_by_errors() {
5440 self.need_type_info_err((**self).body_id, sp, ty)
5441 .note("type must be known at this point")
5444 self.demand_suptype(sp, self.tcx.types.err, ty);
5449 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5450 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5451 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5454 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5455 index = enclosing_breakables.stack.len();
5456 enclosing_breakables.by_id.insert(id, index);
5457 enclosing_breakables.stack.push(ctxt);
5461 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5462 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5463 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5464 enclosing_breakables.stack.pop().expect("missing breakable context")
5469 /// Instantiate a QueryResponse in a probe context, without a
5470 /// good ObligationCause.
5471 fn probe_instantiate_query_response(
5474 original_values: &OriginalQueryValues<'tcx>,
5475 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5476 ) -> InferResult<'tcx, Ty<'tcx>>
5478 self.instantiate_query_response_and_region_obligations(
5479 &traits::ObligationCause::misc(span, self.body_id),
5486 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5487 generics: &ty::Generics,
5489 let own_counts = generics.own_counts();
5490 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5492 if own_counts.types == 0 {
5495 // Make a vector of booleans initially false, set to true when used.
5496 let mut types_used = vec![false; own_counts.types];
5498 for leaf_ty in ty.walk() {
5499 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5500 debug!("Found use of ty param num {}", idx);
5501 types_used[idx as usize - own_counts.lifetimes] = true;
5502 } else if let ty::Error = leaf_ty.sty {
5503 // If there is already another error, do not emit
5504 // an error for not using a type Parameter.
5505 assert!(tcx.sess.err_count() > 0);
5510 let types = generics.params.iter().filter(|param| match param.kind {
5511 ty::GenericParamDefKind::Type { .. } => true,
5514 for (&used, param) in types_used.iter().zip(types) {
5516 let id = tcx.hir().as_local_node_id(param.def_id).unwrap();
5517 let span = tcx.hir().span(id);
5518 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5519 .span_label(span, "unused type parameter")
5525 fn fatally_break_rust(sess: &Session) {
5526 let handler = sess.diagnostic();
5527 handler.span_bug_no_panic(
5529 "It looks like you're trying to break rust; would you like some ICE?",
5531 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5532 handler.note_without_error(
5533 "we would appreciate a joke overview: \
5534 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5536 handler.note_without_error(&format!("rustc {} running on {}",
5537 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5538 ::session::config::host_triple(),
5542 fn potentially_plural_count(count: usize, word: &str) -> String {
5543 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })