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_data_structures::indexed_vec::Idx;
106 use rustc_data_structures::sync::Lrc;
107 use rustc_target::spec::abi::Abi;
108 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
109 use rustc::infer::opaque_types::OpaqueTypeDecl;
110 use rustc::infer::type_variable::{TypeVariableOrigin};
111 use rustc::middle::region;
112 use rustc::mir::interpret::{ConstValue, GlobalId};
113 use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
114 UserSelfTy, UserSubsts};
115 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
116 use rustc::ty::{self, AdtKind, Ty, TyCtxt, GenericParamDefKind, RegionKind, Visibility,
117 ToPolyTraitRef, ToPredicate};
118 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
119 use rustc::ty::fold::TypeFoldable;
120 use rustc::ty::query::Providers;
121 use rustc::ty::util::{Representability, IntTypeExt, Discr};
122 use rustc::ty::layout::VariantIdx;
123 use syntax_pos::{self, BytePos, Span, MultiSpan};
126 use syntax::feature_gate::{GateIssue, emit_feature_err};
128 use syntax::source_map::{DUMMY_SP, original_sp};
129 use syntax::symbol::{Symbol, LocalInternedString, keywords};
130 use syntax::util::lev_distance::find_best_match_for_name;
132 use std::cell::{Cell, RefCell, Ref, RefMut};
133 use std::collections::hash_map::Entry;
135 use std::fmt::Display;
137 use std::mem::replace;
138 use std::ops::{self, Deref};
141 use require_c_abi_if_variadic;
142 use session::{CompileIncomplete, config, Session};
145 use util::captures::Captures;
146 use util::common::{ErrorReported, indenter};
147 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
149 pub use self::Expectation::*;
150 use self::autoderef::Autoderef;
151 use self::callee::DeferredCallResolution;
152 use self::coercion::{CoerceMany, DynamicCoerceMany};
153 pub use self::compare_method::{compare_impl_method, compare_const_impl};
154 use self::method::MethodCallee;
155 use self::TupleArgumentsFlag::*;
157 /// The type of a local binding, including the revealed type for anon types.
158 #[derive(Copy, Clone)]
159 pub struct LocalTy<'tcx> {
161 revealed_ty: Ty<'tcx>
164 /// A wrapper for InferCtxt's `in_progress_tables` field.
165 #[derive(Copy, Clone)]
166 struct MaybeInProgressTables<'a, 'tcx: 'a> {
167 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
170 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
171 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
172 match self.maybe_tables {
173 Some(tables) => tables.borrow(),
175 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
180 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
181 match self.maybe_tables {
182 Some(tables) => tables.borrow_mut(),
184 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
190 /// closures defined within the function. For example:
193 /// bar(move|| { ... })
196 /// Here, the function `foo()` and the closure passed to
197 /// `bar()` will each have their own `FnCtxt`, but they will
198 /// share the inherited fields.
199 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
200 infcx: InferCtxt<'a, 'gcx, 'tcx>,
202 tables: MaybeInProgressTables<'a, 'tcx>,
204 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
206 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
208 // Some additional `Sized` obligations badly affect type inference.
209 // These obligations are added in a later stage of typeck.
210 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
212 // When we process a call like `c()` where `c` is a closure type,
213 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
214 // `FnOnce` closure. In that case, we defer full resolution of the
215 // call until upvar inference can kick in and make the
216 // decision. We keep these deferred resolutions grouped by the
217 // def-id of the closure, so that once we decide, we can easily go
218 // back and process them.
219 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
221 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
223 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
225 // Opaque types found in explicit return types and their
226 // associated fresh inference variable. Writeback resolves these
227 // variables to get the concrete type, which can be used to
228 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
229 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
231 /// Each type parameter has an implicit region bound that
232 /// indicates it must outlive at least the function body (the user
233 /// may specify stronger requirements). This field indicates the
234 /// region of the callee. If it is `None`, then the parameter
235 /// environment is for an item or something where the "callee" is
237 implicit_region_bound: Option<ty::Region<'tcx>>,
239 body_id: Option<hir::BodyId>,
242 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
243 type Target = InferCtxt<'a, 'gcx, 'tcx>;
244 fn deref(&self) -> &Self::Target {
249 /// When type-checking an expression, we propagate downward
250 /// whatever type hint we are able in the form of an `Expectation`.
251 #[derive(Copy, Clone, Debug)]
252 pub enum Expectation<'tcx> {
253 /// We know nothing about what type this expression should have.
256 /// This expression is an `if` condition, it must resolve to `bool`.
259 /// This expression should have the type given (or some subtype)
260 ExpectHasType(Ty<'tcx>),
262 /// This expression will be cast to the `Ty`
263 ExpectCastableToType(Ty<'tcx>),
265 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
266 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
267 ExpectRvalueLikeUnsized(Ty<'tcx>),
270 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
271 // Disregard "castable to" expectations because they
272 // can lead us astray. Consider for example `if cond
273 // {22} else {c} as u8` -- if we propagate the
274 // "castable to u8" constraint to 22, it will pick the
275 // type 22u8, which is overly constrained (c might not
276 // be a u8). In effect, the problem is that the
277 // "castable to" expectation is not the tightest thing
278 // we can say, so we want to drop it in this case.
279 // The tightest thing we can say is "must unify with
280 // else branch". Note that in the case of a "has type"
281 // constraint, this limitation does not hold.
283 // If the expected type is just a type variable, then don't use
284 // an expected type. Otherwise, we might write parts of the type
285 // when checking the 'then' block which are incompatible with the
287 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
289 ExpectHasType(ety) => {
290 let ety = fcx.shallow_resolve(ety);
291 if !ety.is_ty_var() {
297 ExpectRvalueLikeUnsized(ety) => {
298 ExpectRvalueLikeUnsized(ety)
304 /// Provide an expectation for an rvalue expression given an *optional*
305 /// hint, which is not required for type safety (the resulting type might
306 /// be checked higher up, as is the case with `&expr` and `box expr`), but
307 /// is useful in determining the concrete type.
309 /// The primary use case is where the expected type is a fat pointer,
310 /// like `&[isize]`. For example, consider the following statement:
312 /// let x: &[isize] = &[1, 2, 3];
314 /// In this case, the expected type for the `&[1, 2, 3]` expression is
315 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
316 /// expectation `ExpectHasType([isize])`, that would be too strong --
317 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
318 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
319 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
320 /// which still is useful, because it informs integer literals and the like.
321 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
322 /// for examples of where this comes up,.
323 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
324 match fcx.tcx.struct_tail(ty).sty {
325 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
326 ExpectRvalueLikeUnsized(ty)
328 _ => ExpectHasType(ty)
332 // Resolves `expected` by a single level if it is a variable. If
333 // there is no expected type or resolution is not possible (e.g.,
334 // no constraints yet present), just returns `None`.
335 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
337 NoExpectation => NoExpectation,
338 ExpectIfCondition => ExpectIfCondition,
339 ExpectCastableToType(t) => {
340 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
342 ExpectHasType(t) => {
343 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
345 ExpectRvalueLikeUnsized(t) => {
346 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
351 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
352 match self.resolve(fcx) {
353 NoExpectation => None,
354 ExpectIfCondition => Some(fcx.tcx.types.bool),
355 ExpectCastableToType(ty) |
357 ExpectRvalueLikeUnsized(ty) => Some(ty),
361 /// It sometimes happens that we want to turn an expectation into
362 /// a **hard constraint** (i.e., something that must be satisfied
363 /// for the program to type-check). `only_has_type` will return
364 /// such a constraint, if it exists.
365 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
366 match self.resolve(fcx) {
367 ExpectHasType(ty) => Some(ty),
368 ExpectIfCondition => Some(fcx.tcx.types.bool),
369 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
373 /// Like `only_has_type`, but instead of returning `None` if no
374 /// hard constraint exists, creates a fresh type variable.
375 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
376 self.only_has_type(fcx)
377 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
381 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
388 fn maybe_mut_place(m: hir::Mutability) -> Self {
390 hir::MutMutable => Needs::MutPlace,
391 hir::MutImmutable => Needs::None,
396 #[derive(Copy, Clone)]
397 pub struct UnsafetyState {
398 pub def: ast::NodeId,
399 pub unsafety: hir::Unsafety,
400 pub unsafe_push_count: u32,
405 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
406 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
409 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
410 match self.unsafety {
411 // If this unsafe, then if the outer function was already marked as
412 // unsafe we shouldn't attribute the unsafe'ness to the block. This
413 // way the block can be warned about instead of ignoring this
414 // extraneous block (functions are never warned about).
415 hir::Unsafety::Unsafe if self.from_fn => *self,
418 let (unsafety, def, count) = match blk.rules {
419 hir::PushUnsafeBlock(..) =>
420 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
421 hir::PopUnsafeBlock(..) =>
422 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
423 hir::UnsafeBlock(..) =>
424 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
426 (unsafety, self.def, self.unsafe_push_count),
430 unsafe_push_count: count,
437 #[derive(Debug, Copy, Clone)]
443 /// Tracks whether executing a node may exit normally (versus
444 /// return/break/panic, which "diverge", leaving dead code in their
445 /// wake). Tracked semi-automatically (through type variables marked
446 /// as diverging), with some manual adjustments for control-flow
447 /// primitives (approximating a CFG).
448 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
450 /// Potentially unknown, some cases converge,
451 /// others require a CFG to determine them.
454 /// Definitely known to diverge and therefore
455 /// not reach the next sibling or its parent.
458 /// Same as `Always` but with a reachability
459 /// warning already emitted
463 // Convenience impls for combinig `Diverges`.
465 impl ops::BitAnd for Diverges {
467 fn bitand(self, other: Self) -> Self {
468 cmp::min(self, other)
472 impl ops::BitOr for Diverges {
474 fn bitor(self, other: Self) -> Self {
475 cmp::max(self, other)
479 impl ops::BitAndAssign for Diverges {
480 fn bitand_assign(&mut self, other: Self) {
481 *self = *self & other;
485 impl ops::BitOrAssign for Diverges {
486 fn bitor_assign(&mut self, other: Self) {
487 *self = *self | other;
492 fn always(self) -> bool {
493 self >= Diverges::Always
497 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
500 // this is `null` for loops where break with a value is illegal,
501 // such as `while`, `for`, and `while let`
502 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
505 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
506 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
507 by_id: NodeMap<usize>,
510 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
511 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
512 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
513 bug!("could not find enclosing breakable with id {}", target_id);
520 struct PathSeg(DefId, usize);
522 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
523 body_id: ast::NodeId,
525 /// The parameter environment used for proving trait obligations
526 /// in this function. This can change when we descend into
527 /// closures (as they bring new things into scope), hence it is
528 /// not part of `Inherited` (as of the time of this writing,
529 /// closures do not yet change the environment, but they will
531 param_env: ty::ParamEnv<'tcx>,
533 // Number of errors that had been reported when we started
534 // checking this function. On exit, if we find that *more* errors
535 // have been reported, we will skip regionck and other work that
536 // expects the types within the function to be consistent.
537 err_count_on_creation: usize,
539 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
541 yield_ty: Option<Ty<'tcx>>,
543 ps: RefCell<UnsafetyState>,
545 /// Whether the last checked node generates a divergence (e.g.,
546 /// `return` will set this to Always). In general, when entering
547 /// an expression or other node in the tree, the initial value
548 /// indicates whether prior parts of the containing expression may
549 /// have diverged. It is then typically set to `Maybe` (and the
550 /// old value remembered) for processing the subparts of the
551 /// current expression. As each subpart is processed, they may set
552 /// the flag to `Always` etc. Finally, at the end, we take the
553 /// result and "union" it with the original value, so that when we
554 /// return the flag indicates if any subpart of the parent
555 /// expression (up to and including this part) has diverged. So,
556 /// if you read it after evaluating a subexpression `X`, the value
557 /// you get indicates whether any subexpression that was
558 /// evaluating up to and including `X` diverged.
560 /// We currently use this flag only for diagnostic purposes:
562 /// - To warn about unreachable code: if, after processing a
563 /// sub-expression but before we have applied the effects of the
564 /// current node, we see that the flag is set to `Always`, we
565 /// can issue a warning. This corresponds to something like
566 /// `foo(return)`; we warn on the `foo()` expression. (We then
567 /// update the flag to `WarnedAlways` to suppress duplicate
568 /// reports.) Similarly, if we traverse to a fresh statement (or
569 /// tail expression) from a `Always` setting, we will issue a
570 /// warning. This corresponds to something like `{return;
571 /// foo();}` or `{return; 22}`, where we would warn on the
574 /// An expression represents dead-code if, after checking it,
575 /// the diverges flag is set to something other than `Maybe`.
576 diverges: Cell<Diverges>,
578 /// Whether any child nodes have any type errors.
579 has_errors: Cell<bool>,
581 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
583 inh: &'a Inherited<'a, 'gcx, 'tcx>,
586 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
587 type Target = Inherited<'a, 'gcx, 'tcx>;
588 fn deref(&self) -> &Self::Target {
593 /// Helper type of a temporary returned by Inherited::build(...).
594 /// Necessary because we can't write the following bound:
595 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
596 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
597 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
601 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
602 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
603 -> InheritedBuilder<'a, 'gcx, 'tcx> {
604 let hir_id_root = if def_id.is_local() {
605 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
606 let hir_id = tcx.hir().definitions().node_to_hir_id(node_id);
607 DefId::local(hir_id.owner)
613 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
619 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
620 fn enter<F, R>(&'tcx mut self, f: F) -> R
621 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
623 let def_id = self.def_id;
624 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
628 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
629 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
631 let item_id = tcx.hir().as_local_node_id(def_id);
632 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
633 let implicit_region_bound = body_id.map(|body_id| {
634 let body = tcx.hir().body(body_id);
635 tcx.mk_region(ty::ReScope(region::Scope {
636 id: body.value.hir_id.local_id,
637 data: region::ScopeData::CallSite
642 tables: MaybeInProgressTables {
643 maybe_tables: infcx.in_progress_tables,
646 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
647 locals: RefCell::new(Default::default()),
648 deferred_sized_obligations: RefCell::new(Vec::new()),
649 deferred_call_resolutions: RefCell::new(Default::default()),
650 deferred_cast_checks: RefCell::new(Vec::new()),
651 deferred_generator_interiors: RefCell::new(Vec::new()),
652 opaque_types: RefCell::new(Default::default()),
653 implicit_region_bound,
658 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
659 debug!("register_predicate({:?})", obligation);
660 if obligation.has_escaping_bound_vars() {
661 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
666 .register_predicate_obligation(self, obligation);
669 fn register_predicates<I>(&self, obligations: I)
670 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
672 for obligation in obligations {
673 self.register_predicate(obligation);
677 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
678 self.register_predicates(infer_ok.obligations);
682 fn normalize_associated_types_in<T>(&self,
684 body_id: ast::NodeId,
685 param_env: ty::ParamEnv<'tcx>,
687 where T : TypeFoldable<'tcx>
689 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
690 self.register_infer_ok_obligations(ok)
694 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
696 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
697 fn visit_item(&mut self, i: &'tcx hir::Item) {
698 check_item_type(self.tcx, i);
700 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
701 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
704 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
705 tcx.sess.track_errors(|| {
706 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
707 tcx.hir().krate().visit_all_item_likes(&mut visit.as_deep_visitor());
711 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
712 tcx.sess.track_errors(|| {
713 tcx.hir().krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
717 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
718 tcx.typeck_item_bodies(LOCAL_CRATE)
721 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
722 -> Result<(), CompileIncomplete>
724 debug_assert!(crate_num == LOCAL_CRATE);
725 Ok(tcx.sess.track_errors(|| {
726 tcx.par_body_owners(|body_owner_def_id| {
727 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
732 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
733 wfcheck::check_item_well_formed(tcx, def_id);
736 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
737 wfcheck::check_trait_item(tcx, def_id);
740 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
741 wfcheck::check_impl_item(tcx, def_id);
744 pub fn provide(providers: &mut Providers) {
745 method::provide(providers);
746 *providers = Providers {
752 check_item_well_formed,
753 check_trait_item_well_formed,
754 check_impl_item_well_formed,
759 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
761 -> Option<ty::Destructor> {
762 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
765 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
766 /// with information about it's body-id and fn-decl (if any). Otherwise,
769 /// If this function returns "some", then `typeck_tables(def_id)` will
770 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
771 /// may not succeed. In some cases where this function returns `None`
772 /// (notably closures), `typeck_tables(def_id)` would wind up
773 /// redirecting to the owning function.
774 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
776 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
778 match tcx.hir().get(id) {
779 Node::Item(item) => {
781 hir::ItemKind::Const(_, body) |
782 hir::ItemKind::Static(_, _, body) =>
784 hir::ItemKind::Fn(ref decl, .., body) =>
785 Some((body, Some(decl))),
790 Node::TraitItem(item) => {
792 hir::TraitItemKind::Const(_, Some(body)) =>
794 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
795 Some((body, Some(&sig.decl))),
800 Node::ImplItem(item) => {
802 hir::ImplItemKind::Const(_, body) =>
804 hir::ImplItemKind::Method(ref sig, body) =>
805 Some((body, Some(&sig.decl))),
810 Node::AnonConst(constant) => Some((constant.body, None)),
815 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
818 // Closures' tables come from their outermost function,
819 // as they are part of the same "inference environment".
820 let outer_def_id = tcx.closure_base_def_id(def_id);
821 if outer_def_id != def_id {
822 return tcx.has_typeck_tables(outer_def_id);
825 let id = tcx.hir().as_local_node_id(def_id).unwrap();
826 primary_body_of(tcx, id).is_some()
829 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
832 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
835 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
837 -> &'tcx ty::TypeckTables<'tcx> {
838 // Closures' tables come from their outermost function,
839 // as they are part of the same "inference environment".
840 let outer_def_id = tcx.closure_base_def_id(def_id);
841 if outer_def_id != def_id {
842 return tcx.typeck_tables_of(outer_def_id);
845 let id = tcx.hir().as_local_node_id(def_id).unwrap();
846 let span = tcx.hir().span(id);
848 // Figure out what primary body this item has.
849 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
850 span_bug!(span, "can't type-check body of {:?}", def_id);
852 let body = tcx.hir().body(body_id);
854 let tables = Inherited::build(tcx, def_id).enter(|inh| {
855 let param_env = tcx.param_env(def_id);
856 let fcx = if let Some(decl) = fn_decl {
857 let fn_sig = tcx.fn_sig(def_id);
859 check_abi(tcx, span, fn_sig.abi());
861 // Compute the fty from point of view of inside the fn.
863 tcx.liberate_late_bound_regions(def_id, &fn_sig);
865 inh.normalize_associated_types_in(body.value.span,
870 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
873 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
874 let expected_type = tcx.type_of(def_id);
875 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
876 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
878 let revealed_ty = if tcx.features().impl_trait_in_bindings {
879 fcx.instantiate_opaque_types_from_value(
887 // Gather locals in statics (because of block expressions).
888 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
890 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
895 // All type checking constraints were added, try to fallback unsolved variables.
896 fcx.select_obligations_where_possible(false);
897 let mut fallback_has_occurred = false;
898 for ty in &fcx.unsolved_variables() {
899 fallback_has_occurred |= fcx.fallback_if_possible(ty);
901 fcx.select_obligations_where_possible(fallback_has_occurred);
903 // Even though coercion casts provide type hints, we check casts after fallback for
904 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
907 // Closure and generator analysis may run after fallback
908 // because they don't constrain other type variables.
909 fcx.closure_analyze(body);
910 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
911 fcx.resolve_generator_interiors(def_id);
913 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
914 let ty = fcx.normalize_ty(span, ty);
915 fcx.require_type_is_sized(ty, span, code);
917 fcx.select_all_obligations_or_error();
919 if fn_decl.is_some() {
920 fcx.regionck_fn(id, body);
922 fcx.regionck_expr(body);
925 fcx.resolve_type_vars_in_body(body)
928 // Consistency check our TypeckTables instance can hold all ItemLocalIds
929 // it will need to hold.
930 assert_eq!(tables.local_id_root,
931 Some(DefId::local(tcx.hir().definitions().node_to_hir_id(id).owner)));
935 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
936 if !tcx.sess.target.target.is_abi_supported(abi) {
937 struct_span_err!(tcx.sess, span, E0570,
938 "The ABI `{}` is not supported for the current target", abi).emit()
942 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
943 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
944 parent_id: ast::NodeId,
947 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
948 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
951 // infer the variable's type
952 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
953 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
960 // take type that the user specified
961 self.fcx.locals.borrow_mut().insert(nid, typ);
968 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
969 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
970 NestedVisitorMap::None
973 // Add explicitly-declared locals.
974 fn visit_local(&mut self, local: &'gcx hir::Local) {
975 let local_ty = match local.ty {
977 let o_ty = self.fcx.to_ty(&ty);
979 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
980 self.fcx.instantiate_opaque_types_from_value(
988 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(&revealed_ty);
989 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
990 ty.hir_id, o_ty, revealed_ty, c_ty);
991 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
993 Some(LocalTy { decl_ty: o_ty, revealed_ty })
997 self.assign(local.span, local.id, local_ty);
999 debug!("Local variable {:?} is assigned type {}",
1001 self.fcx.ty_to_string(
1002 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
1003 intravisit::walk_local(self, local);
1006 // Add pattern bindings.
1007 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1008 if let PatKind::Binding(_, _, ident, _) = p.node {
1009 let var_ty = self.assign(p.span, p.id, None);
1011 if !self.fcx.tcx.features().unsized_locals {
1012 self.fcx.require_type_is_sized(var_ty, p.span,
1013 traits::VariableType(p.id));
1016 debug!("Pattern binding {} is assigned to {} with type {:?}",
1018 self.fcx.ty_to_string(
1019 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1022 intravisit::walk_pat(self, p);
1025 // Don't descend into the bodies of nested closures
1026 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1027 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1030 /// When `check_fn` is invoked on a generator (i.e., a body that
1031 /// includes yield), it returns back some information about the yield
1033 struct GeneratorTypes<'tcx> {
1034 /// Type of value that is yielded.
1035 yield_ty: ty::Ty<'tcx>,
1037 /// Types that are captured (see `GeneratorInterior` for more).
1038 interior: ty::Ty<'tcx>,
1040 /// Indicates if the generator is movable or static (immovable)
1041 movability: hir::GeneratorMovability,
1044 /// Helper used for fns and closures. Does the grungy work of checking a function
1045 /// body and returns the function context used for that purpose, since in the case of a fn item
1046 /// there is still a bit more to do.
1049 /// * inherited: other fields inherited from the enclosing fn (if any)
1050 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1051 param_env: ty::ParamEnv<'tcx>,
1052 fn_sig: ty::FnSig<'tcx>,
1053 decl: &'gcx hir::FnDecl,
1055 body: &'gcx hir::Body,
1056 can_be_generator: Option<hir::GeneratorMovability>)
1057 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1059 let mut fn_sig = fn_sig.clone();
1061 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1063 // Create the function context. This is either derived from scratch or,
1064 // in the case of closures, based on the outer context.
1065 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1066 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1068 let declared_ret_ty = fn_sig.output();
1069 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1070 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1071 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1072 fn_sig = fcx.tcx.mk_fn_sig(
1073 fn_sig.inputs().iter().cloned(),
1080 let span = body.value.span;
1082 if body.is_generator && can_be_generator.is_some() {
1083 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1084 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1085 fcx.yield_ty = Some(yield_ty);
1088 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1089 let outer_node_id = fcx.tcx.hir().as_local_node_id(outer_def_id).unwrap();
1090 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1092 // Add formal parameters.
1093 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1094 // Check the pattern.
1095 fcx.check_pat_walk(&arg.pat, arg_ty,
1096 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1098 // Check that argument is Sized.
1099 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1100 // for simple cases like `fn foo(x: Trait)`,
1101 // where we would error once on the parameter as a whole, and once on the binding `x`.
1102 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1103 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1106 fcx.write_ty(arg.hir_id, arg_ty);
1109 let fn_hir_id = fcx.tcx.hir().node_to_hir_id(fn_id);
1110 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1112 fcx.check_return_expr(&body.value);
1114 // We insert the deferred_generator_interiors entry after visiting the body.
1115 // This ensures that all nested generators appear before the entry of this generator.
1116 // resolve_generator_interiors relies on this property.
1117 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1118 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1119 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1120 Some(GeneratorTypes {
1121 yield_ty: fcx.yield_ty.unwrap(),
1123 movability: can_be_generator.unwrap(),
1129 // Finalize the return check by taking the LUB of the return types
1130 // we saw and assigning it to the expected return type. This isn't
1131 // really expected to fail, since the coercions would have failed
1132 // earlier when trying to find a LUB.
1134 // However, the behavior around `!` is sort of complex. In the
1135 // event that the `actual_return_ty` comes back as `!`, that
1136 // indicates that the fn either does not return or "returns" only
1137 // values of type `!`. In this case, if there is an expected
1138 // return type that is *not* `!`, that should be ok. But if the
1139 // return type is being inferred, we want to "fallback" to `!`:
1141 // let x = move || panic!();
1143 // To allow for that, I am creating a type variable with diverging
1144 // fallback. This was deemed ever so slightly better than unifying
1145 // the return value with `!` because it allows for the caller to
1146 // make more assumptions about the return type (e.g., they could do
1148 // let y: Option<u32> = Some(x());
1150 // which would then cause this return type to become `u32`, not
1152 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1153 let mut actual_return_ty = coercion.complete(&fcx);
1154 if actual_return_ty.is_never() {
1155 actual_return_ty = fcx.next_diverging_ty_var(
1156 TypeVariableOrigin::DivergingFn(span));
1158 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1160 // Check that the main return type implements the termination trait.
1161 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1162 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1164 if let config::EntryFnType::Main = entry_type {
1165 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1166 let trait_ref = ty::TraitRef::new(term_id, substs);
1167 let return_ty_span = decl.output.span();
1168 let cause = traits::ObligationCause::new(
1169 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1171 inherited.register_predicate(
1172 traits::Obligation::new(
1173 cause, param_env, trait_ref.to_predicate()));
1179 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1180 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1181 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1182 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1183 // at this point we don't care if there are duplicate handlers or if the handler has
1184 // the wrong signature as this value we'll be used when writing metadata and that
1185 // only happens if compilation succeeded
1186 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1188 if declared_ret_ty.sty != ty::Never {
1189 fcx.tcx.sess.span_err(
1191 "return type should be `!`",
1195 let inputs = fn_sig.inputs();
1196 let span = fcx.tcx.hir().span(fn_id);
1197 if inputs.len() == 1 {
1198 let arg_is_panic_info = match inputs[0].sty {
1199 ty::Ref(region, ty, mutbl) => match ty.sty {
1200 ty::Adt(ref adt, _) => {
1201 adt.did == panic_info_did &&
1202 mutbl == hir::Mutability::MutImmutable &&
1203 *region != RegionKind::ReStatic
1210 if !arg_is_panic_info {
1211 fcx.tcx.sess.span_err(
1212 decl.inputs[0].span,
1213 "argument should be `&PanicInfo`",
1217 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1218 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1219 if !generics.params.is_empty() {
1220 fcx.tcx.sess.span_err(
1222 "should have no type parameters",
1228 let span = fcx.tcx.sess.source_map().def_span(span);
1229 fcx.tcx.sess.span_err(span, "function should have one argument");
1232 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1237 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1238 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1239 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1240 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1241 if declared_ret_ty.sty != ty::Never {
1242 fcx.tcx.sess.span_err(
1244 "return type should be `!`",
1248 let inputs = fn_sig.inputs();
1249 let span = fcx.tcx.hir().span(fn_id);
1250 if inputs.len() == 1 {
1251 let arg_is_alloc_layout = match inputs[0].sty {
1252 ty::Adt(ref adt, _) => {
1253 adt.did == alloc_layout_did
1258 if !arg_is_alloc_layout {
1259 fcx.tcx.sess.span_err(
1260 decl.inputs[0].span,
1261 "argument should be `Layout`",
1265 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1266 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1267 if !generics.params.is_empty() {
1268 fcx.tcx.sess.span_err(
1270 "`#[alloc_error_handler]` function should have no type \
1277 let span = fcx.tcx.sess.source_map().def_span(span);
1278 fcx.tcx.sess.span_err(span, "function should have one argument");
1281 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1289 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1292 let def_id = tcx.hir().local_def_id(id);
1293 let def = tcx.adt_def(def_id);
1294 def.destructor(tcx); // force the destructor to be evaluated
1295 check_representable(tcx, span, def_id);
1297 if def.repr.simd() {
1298 check_simd(tcx, span, def_id);
1301 check_transparent(tcx, span, def_id);
1302 check_packed(tcx, span, def_id);
1305 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1308 let def_id = tcx.hir().local_def_id(id);
1309 let def = tcx.adt_def(def_id);
1310 def.destructor(tcx); // force the destructor to be evaluated
1311 check_representable(tcx, span, def_id);
1313 check_packed(tcx, span, def_id);
1316 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1318 "check_item_type(it.id={}, it.name={})",
1320 tcx.item_path_str(tcx.hir().local_def_id(it.id))
1322 let _indenter = indenter();
1324 // Consts can play a role in type-checking, so they are included here.
1325 hir::ItemKind::Static(..) => {
1326 let def_id = tcx.hir().local_def_id(it.id);
1327 tcx.typeck_tables_of(def_id);
1328 maybe_check_static_with_link_section(tcx, def_id, it.span);
1330 hir::ItemKind::Const(..) => {
1331 tcx.typeck_tables_of(tcx.hir().local_def_id(it.id));
1333 hir::ItemKind::Enum(ref enum_definition, _) => {
1334 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1336 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1337 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1338 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1339 let impl_def_id = tcx.hir().local_def_id(it.id);
1340 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1341 check_impl_items_against_trait(
1348 let trait_def_id = impl_trait_ref.def_id;
1349 check_on_unimplemented(tcx, trait_def_id, it);
1352 hir::ItemKind::Trait(..) => {
1353 let def_id = tcx.hir().local_def_id(it.id);
1354 check_on_unimplemented(tcx, def_id, it);
1356 hir::ItemKind::Struct(..) => {
1357 check_struct(tcx, it.id, it.span);
1359 hir::ItemKind::Union(..) => {
1360 check_union(tcx, it.id, it.span);
1362 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1363 let def_id = tcx.hir().local_def_id(it.id);
1364 let pty_ty = tcx.type_of(def_id);
1365 let generics = tcx.generics_of(def_id);
1366 check_bounds_are_used(tcx, &generics, pty_ty);
1368 hir::ItemKind::ForeignMod(ref m) => {
1369 check_abi(tcx, it.span, m.abi);
1371 if m.abi == Abi::RustIntrinsic {
1372 for item in &m.items {
1373 intrinsic::check_intrinsic_type(tcx, item);
1375 } else if m.abi == Abi::PlatformIntrinsic {
1376 for item in &m.items {
1377 intrinsic::check_platform_intrinsic_type(tcx, item);
1380 for item in &m.items {
1381 let generics = tcx.generics_of(tcx.hir().local_def_id(item.id));
1382 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1383 let mut err = struct_span_err!(
1387 "foreign items may not have type parameters"
1389 err.span_label(item.span, "can't have type parameters");
1390 // FIXME: once we start storing spans for type arguments, turn this into a
1393 "use specialization instead of type parameters by replacing them \
1394 with concrete types like `u32`",
1399 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1400 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1405 _ => { /* nothing to do */ }
1409 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1410 // Only restricted on wasm32 target for now
1411 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1415 // If `#[link_section]` is missing, then nothing to verify
1416 let attrs = tcx.codegen_fn_attrs(id);
1417 if attrs.link_section.is_none() {
1421 // For the wasm32 target statics with #[link_section] are placed into custom
1422 // sections of the final output file, but this isn't link custom sections of
1423 // other executable formats. Namely we can only embed a list of bytes,
1424 // nothing with pointers to anything else or relocations. If any relocation
1425 // show up, reject them here.
1426 let instance = ty::Instance::mono(tcx, id);
1427 let cid = GlobalId {
1431 let param_env = ty::ParamEnv::reveal_all();
1432 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1433 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1436 bug!("Matching on non-ByRef static")
1438 if alloc.relocations.len() != 0 {
1439 let msg = "statics with a custom `#[link_section]` must be a \
1440 simple list of bytes on the wasm target with no \
1441 extra levels of indirection such as references";
1442 tcx.sess.span_err(span, msg);
1447 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1448 trait_def_id: DefId,
1450 let item_def_id = tcx.hir().local_def_id(item.id);
1451 // an error would be reported if this fails.
1452 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1455 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1456 impl_item: &hir::ImplItem,
1459 let mut err = struct_span_err!(
1460 tcx.sess, impl_item.span, E0520,
1461 "`{}` specializes an item from a parent `impl`, but \
1462 that item is not marked `default`",
1464 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1467 match tcx.span_of_impl(parent_impl) {
1469 err.span_label(span, "parent `impl` is here");
1470 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1474 err.note(&format!("parent implementation is in crate `{}`", cname));
1481 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1482 trait_def: &ty::TraitDef,
1483 trait_item: &ty::AssociatedItem,
1485 impl_item: &hir::ImplItem)
1487 let ancestors = trait_def.ancestors(tcx, impl_id);
1489 let kind = match impl_item.node {
1490 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1491 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1492 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1493 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1496 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1497 .map(|node_item| node_item.map(|parent| parent.defaultness));
1499 if let Some(parent) = parent {
1500 if tcx.impl_item_is_final(&parent) {
1501 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1507 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1510 impl_trait_ref: ty::TraitRef<'tcx>,
1511 impl_item_refs: &[hir::ImplItemRef]) {
1512 let impl_span = tcx.sess.source_map().def_span(impl_span);
1514 // If the trait reference itself is erroneous (so the compilation is going
1515 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1516 // isn't populated for such impls.
1517 if impl_trait_ref.references_error() { return; }
1519 // Locate trait definition and items
1520 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1521 let mut overridden_associated_type = None;
1523 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1525 // Check existing impl methods to see if they are both present in trait
1526 // and compatible with trait signature
1527 for impl_item in impl_items() {
1528 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.id));
1529 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1530 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1531 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1533 // Not compatible, but needed for the error message
1534 tcx.associated_items(impl_trait_ref.def_id)
1535 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1538 // Check that impl definition matches trait definition
1539 if let Some(ty_trait_item) = ty_trait_item {
1540 match impl_item.node {
1541 hir::ImplItemKind::Const(..) => {
1542 // Find associated const definition.
1543 if ty_trait_item.kind == ty::AssociatedKind::Const {
1544 compare_const_impl(tcx,
1550 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1551 "item `{}` is an associated const, \
1552 which doesn't match its trait `{}`",
1555 err.span_label(impl_item.span, "does not match trait");
1556 // We can only get the spans from local trait definition
1557 // Same for E0324 and E0325
1558 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1559 err.span_label(trait_span, "item in trait");
1564 hir::ImplItemKind::Method(..) => {
1565 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1566 if ty_trait_item.kind == ty::AssociatedKind::Method {
1567 compare_impl_method(tcx,
1574 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1575 "item `{}` is an associated method, \
1576 which doesn't match its trait `{}`",
1579 err.span_label(impl_item.span, "does not match trait");
1580 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1581 err.span_label(trait_span, "item in trait");
1586 hir::ImplItemKind::Existential(..) |
1587 hir::ImplItemKind::Type(_) => {
1588 if ty_trait_item.kind == ty::AssociatedKind::Type {
1589 if ty_trait_item.defaultness.has_value() {
1590 overridden_associated_type = Some(impl_item);
1593 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1594 "item `{}` is an associated type, \
1595 which doesn't match its trait `{}`",
1598 err.span_label(impl_item.span, "does not match trait");
1599 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1600 err.span_label(trait_span, "item in trait");
1607 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1611 // Check for missing items from trait
1612 let mut missing_items = Vec::new();
1613 let mut invalidated_items = Vec::new();
1614 let associated_type_overridden = overridden_associated_type.is_some();
1615 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1616 let is_implemented = trait_def.ancestors(tcx, impl_id)
1617 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1619 .map(|node_item| !node_item.node.is_from_trait())
1622 if !is_implemented && !tcx.impl_is_default(impl_id) {
1623 if !trait_item.defaultness.has_value() {
1624 missing_items.push(trait_item);
1625 } else if associated_type_overridden {
1626 invalidated_items.push(trait_item.ident);
1631 if !missing_items.is_empty() {
1632 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1633 "not all trait items implemented, missing: `{}`",
1634 missing_items.iter()
1635 .map(|trait_item| trait_item.ident.to_string())
1636 .collect::<Vec<_>>().join("`, `"));
1637 err.span_label(impl_span, format!("missing `{}` in implementation",
1638 missing_items.iter()
1639 .map(|trait_item| trait_item.ident.to_string())
1640 .collect::<Vec<_>>().join("`, `")));
1641 for trait_item in missing_items {
1642 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1643 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1645 err.note_trait_signature(trait_item.ident.to_string(),
1646 trait_item.signature(&tcx));
1652 if !invalidated_items.is_empty() {
1653 let invalidator = overridden_associated_type.unwrap();
1654 span_err!(tcx.sess, invalidator.span, E0399,
1655 "the following trait items need to be reimplemented \
1656 as `{}` was overridden: `{}`",
1658 invalidated_items.iter()
1659 .map(|name| name.to_string())
1660 .collect::<Vec<_>>().join("`, `"))
1664 /// Checks whether a type can be represented in memory. In particular, it
1665 /// identifies types that contain themselves without indirection through a
1666 /// pointer, which would mean their size is unbounded.
1667 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1671 let rty = tcx.type_of(item_def_id);
1673 // Check that it is possible to represent this type. This call identifies
1674 // (1) types that contain themselves and (2) types that contain a different
1675 // recursive type. It is only necessary to throw an error on those that
1676 // contain themselves. For case 2, there must be an inner type that will be
1677 // caught by case 1.
1678 match rty.is_representable(tcx, sp) {
1679 Representability::SelfRecursive(spans) => {
1680 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1682 err.span_label(span, "recursive without indirection");
1687 Representability::Representable | Representability::ContainsRecursive => (),
1692 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1693 let t = tcx.type_of(def_id);
1694 if let ty::Adt(def, substs) = t.sty {
1695 if def.is_struct() {
1696 let fields = &def.non_enum_variant().fields;
1697 if fields.is_empty() {
1698 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1701 let e = fields[0].ty(tcx, substs);
1702 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1703 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1704 .span_label(sp, "SIMD elements must have the same type")
1709 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1710 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1712 span_err!(tcx.sess, sp, E0077,
1713 "SIMD vector element type should be machine type");
1721 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1722 let repr = tcx.adt_def(def_id).repr;
1724 for attr in tcx.get_attrs(def_id).iter() {
1725 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1726 if let attr::ReprPacked(pack) = r {
1727 if pack != repr.pack {
1728 struct_span_err!(tcx.sess, sp, E0634,
1729 "type has conflicting packed representation hints").emit();
1735 struct_span_err!(tcx.sess, sp, E0587,
1736 "type has conflicting packed and align representation hints").emit();
1738 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1739 struct_span_err!(tcx.sess, sp, E0588,
1740 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1745 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1747 stack: &mut Vec<DefId>) -> bool {
1748 let t = tcx.type_of(def_id);
1749 if stack.contains(&def_id) {
1750 debug!("check_packed_inner: {:?} is recursive", t);
1753 if let ty::Adt(def, substs) = t.sty {
1754 if def.is_struct() || def.is_union() {
1755 if tcx.adt_def(def.did).repr.align > 0 {
1758 // push struct def_id before checking fields
1760 for field in &def.non_enum_variant().fields {
1761 let f = field.ty(tcx, substs);
1762 if let ty::Adt(def, _) = f.sty {
1763 if check_packed_inner(tcx, def.did, stack) {
1768 // only need to pop if not early out
1775 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1776 let adt = tcx.adt_def(def_id);
1777 if !adt.repr.transparent() {
1781 // For each field, figure out if it's known to be a ZST and align(1)
1782 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1783 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1784 let param_env = tcx.param_env(field.did);
1785 let layout = tcx.layout_of(param_env.and(ty));
1786 // We are currently checking the type this field came from, so it must be local
1787 let span = tcx.hir().span_if_local(field.did).unwrap();
1788 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1789 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1793 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1794 let non_zst_count = non_zst_fields.clone().count();
1795 if non_zst_count != 1 {
1796 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1797 struct_span_err!(tcx.sess, sp, E0690,
1798 "transparent struct needs exactly one non-zero-sized field, but has {}",
1800 .span_note(field_spans, "non-zero-sized field")
1803 for (span, zst, align1) in field_infos {
1805 span_err!(tcx.sess, span, E0691,
1806 "zero-sized field in transparent struct has alignment larger than 1");
1811 #[allow(trivial_numeric_casts)]
1812 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1814 vs: &'tcx [hir::Variant],
1816 let def_id = tcx.hir().local_def_id(id);
1817 let def = tcx.adt_def(def_id);
1818 def.destructor(tcx); // force the destructor to be evaluated
1821 let attributes = tcx.get_attrs(def_id);
1822 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1824 tcx.sess, attr.span, E0084,
1825 "unsupported representation for zero-variant enum")
1826 .span_label(sp, "zero-variant enum")
1831 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1832 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1833 if !tcx.features().repr128 {
1834 emit_feature_err(&tcx.sess.parse_sess,
1837 GateIssue::Language,
1838 "repr with 128-bit type is unstable");
1843 if let Some(ref e) = v.node.disr_expr {
1844 tcx.typeck_tables_of(tcx.hir().local_def_id(e.id));
1848 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1849 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1850 // Check for duplicate discriminant values
1851 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1852 let variant_did = def.variants[VariantIdx::new(i)].did;
1853 let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap();
1854 let variant_i = tcx.hir().expect_variant(variant_i_node_id);
1855 let i_span = match variant_i.node.disr_expr {
1856 Some(ref expr) => tcx.hir().span(expr.id),
1857 None => tcx.hir().span(variant_i_node_id)
1859 let span = match v.node.disr_expr {
1860 Some(ref expr) => tcx.hir().span(expr.id),
1863 struct_span_err!(tcx.sess, span, E0081,
1864 "discriminant value `{}` already exists", disr_vals[i])
1865 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1866 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1869 disr_vals.push(discr);
1872 check_representable(tcx, sp, def_id);
1875 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1876 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1878 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1879 -> Lrc<ty::GenericPredicates<'tcx>>
1882 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
1883 let item_id = tcx.hir().ty_param_owner(node_id);
1884 let item_def_id = tcx.hir().local_def_id(item_id);
1885 let generics = tcx.generics_of(item_def_id);
1886 let index = generics.param_def_id_to_index[&def_id];
1887 Lrc::new(ty::GenericPredicates {
1889 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1891 ty::Predicate::Trait(ref data)
1892 if data.skip_binder().self_ty().is_param(index) => {
1893 // HACK(eddyb) should get the original `Span`.
1894 let span = tcx.def_span(def_id);
1895 Some((predicate, span))
1903 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1904 -> Option<ty::Region<'tcx>> {
1906 Some(def) => infer::EarlyBoundRegion(span, def.name),
1907 None => infer::MiscVariable(span)
1909 Some(self.next_region_var(v))
1912 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1913 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1916 fn ty_infer_for_def(&self,
1917 ty_param_def: &ty::GenericParamDef,
1918 span: Span) -> Ty<'tcx> {
1919 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1925 fn projected_ty_from_poly_trait_ref(&self,
1928 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1931 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1933 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1937 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1940 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1941 if ty.has_escaping_bound_vars() {
1942 ty // FIXME: normalization and escaping regions
1944 self.normalize_associated_types_in(span, &ty)
1948 fn set_tainted_by_errors(&self) {
1949 self.infcx.set_tainted_by_errors()
1952 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1953 self.write_ty(hir_id, ty)
1957 /// Controls whether the arguments are tupled. This is used for the call
1960 /// Tupling means that all call-side arguments are packed into a tuple and
1961 /// passed as a single parameter. For example, if tupling is enabled, this
1964 /// fn f(x: (isize, isize))
1966 /// Can be called as:
1973 #[derive(Clone, Eq, PartialEq)]
1974 enum TupleArgumentsFlag {
1979 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1980 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1981 param_env: ty::ParamEnv<'tcx>,
1982 body_id: ast::NodeId)
1983 -> FnCtxt<'a, 'gcx, 'tcx> {
1987 err_count_on_creation: inh.tcx.sess.err_count(),
1990 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1991 ast::CRATE_NODE_ID)),
1992 diverges: Cell::new(Diverges::Maybe),
1993 has_errors: Cell::new(false),
1994 enclosing_breakables: RefCell::new(EnclosingBreakables {
1996 by_id: Default::default(),
2002 pub fn sess(&self) -> &Session {
2006 pub fn err_count_since_creation(&self) -> usize {
2007 self.tcx.sess.err_count() - self.err_count_on_creation
2010 /// Produce warning on the given node, if the current point in the
2011 /// function is unreachable, and there hasn't been another warning.
2012 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2013 if self.diverges.get() == Diverges::Always {
2014 self.diverges.set(Diverges::WarnedAlways);
2016 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2018 self.tcx().lint_node(
2019 lint::builtin::UNREACHABLE_CODE,
2021 &format!("unreachable {}", kind));
2027 code: ObligationCauseCode<'tcx>)
2028 -> ObligationCause<'tcx> {
2029 ObligationCause::new(span, self.body_id, code)
2032 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2033 self.cause(span, ObligationCauseCode::MiscObligation)
2036 /// Resolves type variables in `ty` if possible. Unlike the infcx
2037 /// version (resolve_type_vars_if_possible), this version will
2038 /// also select obligations if it seems useful, in an effort
2039 /// to get more type information.
2040 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2041 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2043 // No Infer()? Nothing needs doing.
2044 if !ty.has_infer_types() {
2045 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2049 // If `ty` is a type variable, see whether we already know what it is.
2050 ty = self.resolve_type_vars_if_possible(&ty);
2051 if !ty.has_infer_types() {
2052 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2056 // If not, try resolving pending obligations as much as
2057 // possible. This can help substantially when there are
2058 // indirect dependencies that don't seem worth tracking
2060 self.select_obligations_where_possible(false);
2061 ty = self.resolve_type_vars_if_possible(&ty);
2063 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2067 fn record_deferred_call_resolution(&self,
2068 closure_def_id: DefId,
2069 r: DeferredCallResolution<'gcx, 'tcx>) {
2070 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2071 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2074 fn remove_deferred_call_resolutions(&self,
2075 closure_def_id: DefId)
2076 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2078 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2079 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2082 pub fn tag(&self) -> String {
2083 let self_ptr: *const FnCtxt = self;
2084 format!("{:?}", self_ptr)
2087 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2088 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2089 span_bug!(span, "no type for local variable {}",
2090 self.tcx.hir().node_to_string(nid))
2095 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2096 debug!("write_ty({:?}, {:?}) in fcx {}",
2097 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2098 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2100 if ty.references_error() {
2101 self.has_errors.set(true);
2102 self.set_tainted_by_errors();
2106 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2107 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
2108 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2111 // The NodeId and the ItemLocalId must identify the same item. We just pass
2112 // both of them for consistency checking.
2113 pub fn write_method_call(&self,
2115 method: MethodCallee<'tcx>) {
2116 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2119 .type_dependent_defs_mut()
2120 .insert(hir_id, Def::Method(method.def_id));
2122 self.write_substs(hir_id, method.substs);
2124 // When the method is confirmed, the `method.substs` includes
2125 // parameters from not just the method, but also the impl of
2126 // the method -- in particular, the `Self` type will be fully
2127 // resolved. However, those are not something that the "user
2128 // specified" -- i.e., those types come from the inferred type
2129 // of the receiver, not something the user wrote. So when we
2130 // create the user-substs, we want to replace those earlier
2131 // types with just the types that the user actually wrote --
2132 // that is, those that appear on the *method itself*.
2134 // As an example, if the user wrote something like
2135 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2136 // type of `foo` (possibly adjusted), but we don't want to
2137 // include that. We want just the `[_, u32]` part.
2138 if !method.substs.is_noop() {
2139 let method_generics = self.tcx.generics_of(method.def_id);
2140 if !method_generics.params.is_empty() {
2141 let user_substs = self.infcx.probe(|_| {
2142 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2143 let i = param.index as usize;
2144 if i < method_generics.parent_count {
2145 self.infcx.var_for_def(DUMMY_SP, param)
2150 self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2151 substs: just_method_substs,
2152 user_self_ty: None, // not relevant here
2156 debug!("write_method_call: user_substs = {:?}", user_substs);
2157 self.write_user_substs(hir_id, user_substs);
2162 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2163 if !substs.is_noop() {
2164 debug!("write_substs({:?}, {:?}) in fcx {}",
2169 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2173 /// Given the substs that we just converted from the HIR, try to
2174 /// canonicalize them and store them as user-given substitutions
2175 /// (i.e., substitutions that must be respected by the NLL check).
2177 /// This should be invoked **before any unifications have
2178 /// occurred**, so that annotations like `Vec<_>` are preserved
2180 pub fn write_user_substs_from_substs(
2183 substs: &'tcx Substs<'tcx>,
2184 user_self_ty: Option<UserSelfTy<'tcx>>,
2187 "write_user_substs_from_substs({:?}, {:?}) in fcx {}",
2193 if !substs.is_noop() {
2194 let user_substs = self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2198 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2199 self.write_user_substs(hir_id, user_substs);
2203 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalUserSubsts<'tcx>) {
2205 "write_user_substs({:?}, {:?}) in fcx {}",
2211 if !substs.is_identity() {
2212 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2214 debug!("write_user_substs: skipping identity substs");
2218 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2219 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2225 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2226 Entry::Vacant(entry) => { entry.insert(adj); },
2227 Entry::Occupied(mut entry) => {
2228 debug!(" - composing on top of {:?}", entry.get());
2229 match (&entry.get()[..], &adj[..]) {
2230 // Applying any adjustment on top of a NeverToAny
2231 // is a valid NeverToAny adjustment, because it can't
2233 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2235 Adjustment { kind: Adjust::Deref(_), .. },
2236 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2238 Adjustment { kind: Adjust::Deref(_), .. },
2239 .. // Any following adjustments are allowed.
2241 // A reborrow has no effect before a dereference.
2243 // FIXME: currently we never try to compose autoderefs
2244 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2246 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2247 expr, entry.get(), adj)
2249 *entry.get_mut() = adj;
2254 /// Basically whenever we are converting from a type scheme into
2255 /// the fn body space, we always want to normalize associated
2256 /// types as well. This function combines the two.
2257 fn instantiate_type_scheme<T>(&self,
2259 substs: &Substs<'tcx>,
2262 where T : TypeFoldable<'tcx>
2264 let value = value.subst(self.tcx, substs);
2265 let result = self.normalize_associated_types_in(span, &value);
2266 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2273 /// As `instantiate_type_scheme`, but for the bounds found in a
2274 /// generic type scheme.
2275 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2276 -> ty::InstantiatedPredicates<'tcx> {
2277 let bounds = self.tcx.predicates_of(def_id);
2278 let result = bounds.instantiate(self.tcx, substs);
2279 let result = self.normalize_associated_types_in(span, &result);
2280 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2287 /// Replace the opaque types from the given value with type variables,
2288 /// and records the `OpaqueTypeMap` for later use during writeback. See
2289 /// `InferCtxt::instantiate_opaque_types` for more details.
2290 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2292 parent_id: ast::NodeId,
2295 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2296 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2300 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2301 self.instantiate_opaque_types(
2309 let mut opaque_types = self.opaque_types.borrow_mut();
2310 for (ty, decl) in opaque_type_map {
2311 let old_value = opaque_types.insert(ty, decl);
2312 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2318 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2319 where T : TypeFoldable<'tcx>
2321 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2324 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2326 where T : TypeFoldable<'tcx>
2328 self.inh.partially_normalize_associated_types_in(span,
2334 pub fn require_type_meets(&self,
2337 code: traits::ObligationCauseCode<'tcx>,
2340 self.register_bound(
2343 traits::ObligationCause::new(span, self.body_id, code));
2346 pub fn require_type_is_sized(&self,
2349 code: traits::ObligationCauseCode<'tcx>)
2351 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2352 self.require_type_meets(ty, span, code, lang_item);
2355 pub fn require_type_is_sized_deferred(&self,
2358 code: traits::ObligationCauseCode<'tcx>)
2360 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2363 pub fn register_bound(&self,
2366 cause: traits::ObligationCause<'tcx>)
2368 self.fulfillment_cx.borrow_mut()
2369 .register_bound(self, self.param_env, ty, def_id, cause);
2372 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2373 let t = AstConv::ast_ty_to_ty(self, ast_t);
2374 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2378 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2379 let ty = self.to_ty(ast_ty);
2381 // If the type given by the user has free regions, save it for
2382 // later, since NLL would like to enforce those. Also pass in
2383 // types that involve projections, since those can resolve to
2384 // `'static` bounds (modulo #54940, which hopefully will be
2385 // fixed by the time you see this comment, dear reader,
2386 // although I have my doubts). Other sorts of things are
2387 // already sufficiently enforced with erased regions. =)
2388 if ty.has_free_regions() || ty.has_projections() {
2389 let c_ty = self.infcx.canonicalize_response(&ty);
2390 self.tables.borrow_mut().user_provided_tys_mut().insert(ast_ty.hir_id, c_ty);
2396 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2397 match self.tables.borrow().node_types().get(id) {
2399 None if self.is_tainted_by_errors() => self.tcx.types.err,
2401 let node_id = self.tcx.hir().hir_to_node_id(id);
2402 bug!("no type for node {}: {} in fcx {}",
2403 node_id, self.tcx.hir().node_to_string(node_id),
2409 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2410 /// outlive the region `r`.
2411 pub fn register_wf_obligation(&self,
2414 code: traits::ObligationCauseCode<'tcx>)
2416 // WF obligations never themselves fail, so no real need to give a detailed cause:
2417 let cause = traits::ObligationCause::new(span, self.body_id, code);
2418 self.register_predicate(traits::Obligation::new(cause,
2420 ty::Predicate::WellFormed(ty)));
2423 /// Registers obligations that all types appearing in `substs` are well-formed.
2424 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2425 for ty in substs.types() {
2426 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2430 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2431 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2432 /// trait/region obligations.
2434 /// For example, if there is a function:
2437 /// fn foo<'a,T:'a>(...)
2440 /// and a reference:
2446 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2447 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2448 pub fn add_obligations_for_parameters(&self,
2449 cause: traits::ObligationCause<'tcx>,
2450 predicates: &ty::InstantiatedPredicates<'tcx>)
2452 assert!(!predicates.has_escaping_bound_vars());
2454 debug!("add_obligations_for_parameters(predicates={:?})",
2457 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2458 self.register_predicate(obligation);
2462 // FIXME(arielb1): use this instead of field.ty everywhere
2463 // Only for fields! Returns <none> for methods>
2464 // Indifferent to privacy flags
2465 pub fn field_ty(&self,
2467 field: &'tcx ty::FieldDef,
2468 substs: &Substs<'tcx>)
2471 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2474 fn check_casts(&self) {
2475 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2476 for cast in deferred_cast_checks.drain(..) {
2481 fn resolve_generator_interiors(&self, def_id: DefId) {
2482 let mut generators = self.deferred_generator_interiors.borrow_mut();
2483 for (body_id, interior) in generators.drain(..) {
2484 self.select_obligations_where_possible(false);
2485 generator_interior::resolve_interior(self, def_id, body_id, interior);
2489 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2490 // Non-numerics get replaced with ! or () (depending on whether
2491 // feature(never_type) is enabled, unconstrained ints with i32,
2492 // unconstrained floats with f64.
2493 // Fallback becomes very dubious if we have encountered type-checking errors.
2494 // In that case, fallback to Error.
2495 // The return value indicates whether fallback has occurred.
2496 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2497 use rustc::ty::error::UnconstrainedNumeric::Neither;
2498 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2500 assert!(ty.is_ty_infer());
2501 let fallback = match self.type_is_unconstrained_numeric(ty) {
2502 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2503 UnconstrainedInt => self.tcx.types.i32,
2504 UnconstrainedFloat => self.tcx.types.f64,
2505 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2506 Neither => return false,
2508 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2509 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2513 fn select_all_obligations_or_error(&self) {
2514 debug!("select_all_obligations_or_error");
2515 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2516 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2520 /// Select as many obligations as we can at present.
2521 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2522 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2523 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2527 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2528 /// returns a type of `&T`, but the actual type we assign to the
2529 /// *expression* is `T`. So this function just peels off the return
2530 /// type by one layer to yield `T`.
2531 fn make_overloaded_place_return_type(&self,
2532 method: MethodCallee<'tcx>)
2533 -> ty::TypeAndMut<'tcx>
2535 // extract method return type, which will be &T;
2536 let ret_ty = method.sig.output();
2538 // method returns &T, but the type as visible to user is T, so deref
2539 ret_ty.builtin_deref(true).unwrap()
2542 fn lookup_indexing(&self,
2544 base_expr: &'gcx hir::Expr,
2548 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2550 // FIXME(#18741) -- this is almost but not quite the same as the
2551 // autoderef that normal method probing does. They could likely be
2554 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2555 let mut result = None;
2556 while result.is_none() && autoderef.next().is_some() {
2557 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2559 autoderef.finalize();
2563 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2564 /// (and otherwise adjust) `base_expr`, looking for a type which either
2565 /// supports builtin indexing or overloaded indexing.
2566 /// This loop implements one step in that search; the autoderef loop
2567 /// is implemented by `lookup_indexing`.
2568 fn try_index_step(&self,
2570 base_expr: &hir::Expr,
2571 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2574 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2576 let adjusted_ty = autoderef.unambiguous_final_ty();
2577 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2584 for &unsize in &[false, true] {
2585 let mut self_ty = adjusted_ty;
2587 // We only unsize arrays here.
2588 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2589 self_ty = self.tcx.mk_slice(element_ty);
2595 // If some lookup succeeds, write callee into table and extract index/element
2596 // type from the method signature.
2597 // If some lookup succeeded, install method in table
2598 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2599 let method = self.try_overloaded_place_op(
2600 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2602 let result = method.map(|ok| {
2603 debug!("try_index_step: success, using overloaded indexing");
2604 let method = self.register_infer_ok_obligations(ok);
2606 let mut adjustments = autoderef.adjust_steps(needs);
2607 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2608 let mutbl = match r_mutbl {
2609 hir::MutImmutable => AutoBorrowMutability::Immutable,
2610 hir::MutMutable => AutoBorrowMutability::Mutable {
2611 // Indexing can be desugared to a method call,
2612 // so maybe we could use two-phase here.
2613 // See the documentation of AllowTwoPhase for why that's
2614 // not the case today.
2615 allow_two_phase_borrow: AllowTwoPhase::No,
2618 adjustments.push(Adjustment {
2619 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2620 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2627 adjustments.push(Adjustment {
2628 kind: Adjust::Unsize,
2629 target: method.sig.inputs()[0]
2632 self.apply_adjustments(base_expr, adjustments);
2634 self.write_method_call(expr.hir_id, method);
2635 (input_ty, self.make_overloaded_place_return_type(method).ty)
2637 if result.is_some() {
2645 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2646 let (tr, name) = match (op, is_mut) {
2647 (PlaceOp::Deref, false) =>
2648 (self.tcx.lang_items().deref_trait(), "deref"),
2649 (PlaceOp::Deref, true) =>
2650 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2651 (PlaceOp::Index, false) =>
2652 (self.tcx.lang_items().index_trait(), "index"),
2653 (PlaceOp::Index, true) =>
2654 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2656 (tr, ast::Ident::from_str(name))
2659 fn try_overloaded_place_op(&self,
2662 arg_tys: &[Ty<'tcx>],
2665 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2667 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2673 // Try Mut first, if needed.
2674 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2675 let method = match (needs, mut_tr) {
2676 (Needs::MutPlace, Some(trait_did)) => {
2677 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2682 // Otherwise, fall back to the immutable version.
2683 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2684 let method = match (method, imm_tr) {
2685 (None, Some(trait_did)) => {
2686 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2688 (method, _) => method,
2694 fn check_method_argument_types(&self,
2697 method: Result<MethodCallee<'tcx>, ()>,
2698 args_no_rcvr: &'gcx [hir::Expr],
2699 tuple_arguments: TupleArgumentsFlag,
2700 expected: Expectation<'tcx>)
2702 let has_error = match method {
2704 method.substs.references_error() || method.sig.references_error()
2709 let err_inputs = self.err_args(args_no_rcvr.len());
2711 let err_inputs = match tuple_arguments {
2712 DontTupleArguments => err_inputs,
2713 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2716 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2717 false, tuple_arguments, None);
2718 return self.tcx.types.err;
2721 let method = method.unwrap();
2722 // HACK(eddyb) ignore self in the definition (see above).
2723 let expected_arg_tys = self.expected_inputs_for_expected_output(
2726 method.sig.output(),
2727 &method.sig.inputs()[1..]
2729 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2730 args_no_rcvr, method.sig.variadic, tuple_arguments,
2731 self.tcx.hir().span_if_local(method.def_id));
2735 fn self_type_matches_expected_vid(
2737 trait_ref: ty::PolyTraitRef<'tcx>,
2738 expected_vid: ty::TyVid,
2740 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2742 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2743 trait_ref, self_ty, expected_vid
2746 ty::Infer(ty::TyVar(found_vid)) => {
2747 let found_vid = self.root_var(found_vid);
2748 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2749 expected_vid == found_vid
2755 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2756 -> impl Iterator<Item=ty::PolyTraitRef<'tcx>> + Captures<'gcx> + 'b
2758 let ty_var_root = self.root_var(self_ty);
2759 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2760 self_ty, ty_var_root,
2761 self.fulfillment_cx.borrow().pending_obligations());
2765 .pending_obligations()
2767 .filter_map(move |obligation| match obligation.predicate {
2768 ty::Predicate::Projection(ref data) => Some(data.to_poly_trait_ref(self.tcx)),
2769 ty::Predicate::Trait(ref data) => Some(data.to_poly_trait_ref()),
2770 ty::Predicate::Subtype(..) => None,
2771 ty::Predicate::RegionOutlives(..) => None,
2772 ty::Predicate::TypeOutlives(..) => None,
2773 ty::Predicate::WellFormed(..) => None,
2774 ty::Predicate::ObjectSafe(..) => None,
2775 ty::Predicate::ConstEvaluatable(..) => None,
2776 // N.B., this predicate is created by breaking down a
2777 // `ClosureType: FnFoo()` predicate, where
2778 // `ClosureType` represents some `Closure`. It can't
2779 // possibly be referring to the current closure,
2780 // because we haven't produced the `Closure` for
2781 // this closure yet; this is exactly why the other
2782 // code is looking for a self type of a unresolved
2783 // inference variable.
2784 ty::Predicate::ClosureKind(..) => None,
2785 }).filter(move |tr| self.self_type_matches_expected_vid(*tr, ty_var_root))
2788 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2789 self.obligations_for_self_ty(self_ty).any(|tr| {
2790 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2794 /// Generic function that factors out common logic from function calls,
2795 /// method calls and overloaded operators.
2796 fn check_argument_types(&self,
2799 fn_inputs: &[Ty<'tcx>],
2800 mut expected_arg_tys: &[Ty<'tcx>],
2801 args: &'gcx [hir::Expr],
2803 tuple_arguments: TupleArgumentsFlag,
2804 def_span: Option<Span>) {
2807 // Grab the argument types, supplying fresh type variables
2808 // if the wrong number of arguments were supplied
2809 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2815 // All the input types from the fn signature must outlive the call
2816 // so as to validate implied bounds.
2817 for &fn_input_ty in fn_inputs {
2818 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2821 let expected_arg_count = fn_inputs.len();
2823 let param_count_error = |expected_count: usize,
2828 let mut err = tcx.sess.struct_span_err_with_code(sp,
2829 &format!("this function takes {}{} but {} {} supplied",
2830 if variadic {"at least "} else {""},
2831 potentially_plural_count(expected_count, "parameter"),
2832 potentially_plural_count(arg_count, "parameter"),
2833 if arg_count == 1 {"was"} else {"were"}),
2834 DiagnosticId::Error(error_code.to_owned()));
2836 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2837 err.span_label(def_s, "defined here");
2840 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2841 // remove closing `)` from the span
2842 let sugg_span = sugg_span.shrink_to_lo();
2843 err.span_suggestion_with_applicability(
2845 "expected the unit value `()`; create it with empty parentheses",
2847 Applicability::MachineApplicable);
2849 err.span_label(sp, format!("expected {}{}",
2850 if variadic {"at least "} else {""},
2851 potentially_plural_count(expected_count, "parameter")));
2856 let formal_tys = if tuple_arguments == TupleArguments {
2857 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2858 match tuple_type.sty {
2859 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2860 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2861 expected_arg_tys = &[];
2862 self.err_args(args.len())
2864 ty::Tuple(arg_types) => {
2865 expected_arg_tys = match expected_arg_tys.get(0) {
2866 Some(&ty) => match ty.sty {
2867 ty::Tuple(ref tys) => &tys,
2875 span_err!(tcx.sess, sp, E0059,
2876 "cannot use call notation; the first type parameter \
2877 for the function trait is neither a tuple nor unit");
2878 expected_arg_tys = &[];
2879 self.err_args(args.len())
2882 } else if expected_arg_count == supplied_arg_count {
2884 } else if variadic {
2885 if supplied_arg_count >= expected_arg_count {
2888 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2889 expected_arg_tys = &[];
2890 self.err_args(supplied_arg_count)
2893 // is the missing argument of type `()`?
2894 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2895 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2896 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2897 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2901 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2903 expected_arg_tys = &[];
2904 self.err_args(supplied_arg_count)
2906 // If there is no expectation, expect formal_tys.
2907 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2913 debug!("check_argument_types: formal_tys={:?}",
2914 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2916 // Check the arguments.
2917 // We do this in a pretty awful way: first we type-check any arguments
2918 // that are not closures, then we type-check the closures. This is so
2919 // that we have more information about the types of arguments when we
2920 // type-check the functions. This isn't really the right way to do this.
2921 for &check_closures in &[false, true] {
2922 debug!("check_closures={}", check_closures);
2924 // More awful hacks: before we check argument types, try to do
2925 // an "opportunistic" vtable resolution of any trait bounds on
2926 // the call. This helps coercions.
2928 self.select_obligations_where_possible(false);
2931 // For variadic functions, we don't have a declared type for all of
2932 // the arguments hence we only do our usual type checking with
2933 // the arguments who's types we do know.
2934 let t = if variadic {
2936 } else if tuple_arguments == TupleArguments {
2941 for (i, arg) in args.iter().take(t).enumerate() {
2942 // Warn only for the first loop (the "no closures" one).
2943 // Closure arguments themselves can't be diverging, but
2944 // a previous argument can, e.g., `foo(panic!(), || {})`.
2945 if !check_closures {
2946 self.warn_if_unreachable(arg.id, arg.span, "expression");
2949 let is_closure = match arg.node {
2950 hir::ExprKind::Closure(..) => true,
2954 if is_closure != check_closures {
2958 debug!("checking the argument");
2959 let formal_ty = formal_tys[i];
2961 // The special-cased logic below has three functions:
2962 // 1. Provide as good of an expected type as possible.
2963 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2965 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2967 // 2. Coerce to the most detailed type that could be coerced
2968 // to, which is `expected_ty` if `rvalue_hint` returns an
2969 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2970 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2971 // We're processing function arguments so we definitely want to use
2972 // two-phase borrows.
2973 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2975 // 3. Relate the expected type and the formal one,
2976 // if the expected type was used for the coercion.
2977 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2981 // We also need to make sure we at least write the ty of the other
2982 // arguments which we skipped above.
2984 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2985 use structured_errors::{VariadicError, StructuredDiagnostic};
2986 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2989 for arg in args.iter().skip(expected_arg_count) {
2990 let arg_ty = self.check_expr(&arg);
2992 // There are a few types which get autopromoted when passed via varargs
2993 // in C but we just error out instead and require explicit casts.
2994 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2996 ty::Float(ast::FloatTy::F32) => {
2997 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2999 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3000 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3002 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3003 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3006 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3007 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3008 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3016 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3017 vec![self.tcx.types.err; len]
3020 // AST fragment checking
3023 expected: Expectation<'tcx>)
3029 ast::LitKind::Str(..) => tcx.mk_static_str(),
3030 ast::LitKind::ByteStr(ref v) => {
3031 tcx.mk_imm_ref(tcx.types.re_static,
3032 tcx.mk_array(tcx.types.u8, v.len() as u64))
3034 ast::LitKind::Byte(_) => tcx.types.u8,
3035 ast::LitKind::Char(_) => tcx.types.char,
3036 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3037 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3038 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3039 let opt_ty = expected.to_option(self).and_then(|ty| {
3041 ty::Int(_) | ty::Uint(_) => Some(ty),
3042 ty::Char => Some(tcx.types.u8),
3043 ty::RawPtr(..) => Some(tcx.types.usize),
3044 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3048 opt_ty.unwrap_or_else(
3049 || tcx.mk_int_var(self.next_int_var_id()))
3051 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3052 ast::LitKind::FloatUnsuffixed(_) => {
3053 let opt_ty = expected.to_option(self).and_then(|ty| {
3055 ty::Float(_) => Some(ty),
3059 opt_ty.unwrap_or_else(
3060 || tcx.mk_float_var(self.next_float_var_id()))
3062 ast::LitKind::Bool(_) => tcx.types.bool
3066 fn check_expr_eq_type(&self,
3067 expr: &'gcx hir::Expr,
3068 expected: Ty<'tcx>) {
3069 let ty = self.check_expr_with_hint(expr, expected);
3070 self.demand_eqtype(expr.span, expected, ty);
3073 pub fn check_expr_has_type_or_error(&self,
3074 expr: &'gcx hir::Expr,
3075 expected: Ty<'tcx>) -> Ty<'tcx> {
3076 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3079 fn check_expr_meets_expectation_or_error(&self,
3080 expr: &'gcx hir::Expr,
3081 expected: Expectation<'tcx>) -> Ty<'tcx> {
3082 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3083 let mut ty = self.check_expr_with_expectation(expr, expected);
3085 // While we don't allow *arbitrary* coercions here, we *do* allow
3086 // coercions from ! to `expected`.
3088 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3089 "expression with never type wound up being adjusted");
3090 let adj_ty = self.next_diverging_ty_var(
3091 TypeVariableOrigin::AdjustmentType(expr.span));
3092 self.apply_adjustments(expr, vec![Adjustment {
3093 kind: Adjust::NeverToAny,
3099 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3100 // Add help to type error if this is an `if` condition with an assignment
3101 if let (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs))
3102 = (expected, &expr.node)
3104 let msg = "try comparing for equality";
3105 if let (Ok(left), Ok(right)) = (
3106 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3107 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3109 err.span_suggestion_with_applicability(
3112 format!("{} == {}", left, right),
3113 Applicability::MaybeIncorrect);
3123 fn check_expr_coercable_to_type(&self,
3124 expr: &'gcx hir::Expr,
3125 expected: Ty<'tcx>) -> Ty<'tcx> {
3126 let ty = self.check_expr_with_hint(expr, expected);
3127 // checks don't need two phase
3128 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3131 fn check_expr_with_hint(&self,
3132 expr: &'gcx hir::Expr,
3133 expected: Ty<'tcx>) -> Ty<'tcx> {
3134 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3137 fn check_expr_with_expectation(&self,
3138 expr: &'gcx hir::Expr,
3139 expected: Expectation<'tcx>) -> Ty<'tcx> {
3140 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3143 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3144 self.check_expr_with_expectation(expr, NoExpectation)
3147 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3148 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3151 // Determine the `Self` type, using fresh variables for all variables
3152 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3153 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3155 pub fn impl_self_ty(&self,
3156 span: Span, // (potential) receiver for this impl
3158 -> TypeAndSubsts<'tcx> {
3159 let ity = self.tcx.type_of(did);
3160 debug!("impl_self_ty: ity={:?}", ity);
3162 let substs = self.fresh_substs_for_item(span, did);
3163 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3165 TypeAndSubsts { substs: substs, ty: substd_ty }
3168 /// Unifies the output type with the expected type early, for more coercions
3169 /// and forward type information on the input expressions.
3170 fn expected_inputs_for_expected_output(&self,
3172 expected_ret: Expectation<'tcx>,
3173 formal_ret: Ty<'tcx>,
3174 formal_args: &[Ty<'tcx>])
3176 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3177 let ret_ty = match expected_ret.only_has_type(self) {
3179 None => return Vec::new()
3181 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3182 // Attempt to apply a subtyping relationship between the formal
3183 // return type (likely containing type variables if the function
3184 // is polymorphic) and the expected return type.
3185 // No argument expectations are produced if unification fails.
3186 let origin = self.misc(call_span);
3187 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3189 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3190 // to identity so the resulting type is not constrained.
3193 // Process any obligations locally as much as
3194 // we can. We don't care if some things turn
3195 // out unconstrained or ambiguous, as we're
3196 // just trying to get hints here.
3197 self.save_and_restore_in_snapshot_flag(|_| {
3198 let mut fulfill = TraitEngine::new(self.tcx);
3199 for obligation in ok.obligations {
3200 fulfill.register_predicate_obligation(self, obligation);
3202 fulfill.select_where_possible(self)
3203 }).map_err(|_| ())?;
3205 Err(_) => return Err(()),
3208 // Record all the argument types, with the substitutions
3209 // produced from the above subtyping unification.
3210 Ok(formal_args.iter().map(|ty| {
3211 self.resolve_type_vars_if_possible(ty)
3213 }).unwrap_or_default();
3214 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3215 formal_args, formal_ret,
3216 expect_args, expected_ret);
3220 // Checks a method call.
3221 fn check_method_call(&self,
3222 expr: &'gcx hir::Expr,
3223 segment: &hir::PathSegment,
3225 args: &'gcx [hir::Expr],
3226 expected: Expectation<'tcx>,
3227 needs: Needs) -> Ty<'tcx> {
3228 let rcvr = &args[0];
3229 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3230 // no need to check for bot/err -- callee does that
3231 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3233 let method = match self.lookup_method(rcvr_t,
3239 self.write_method_call(expr.hir_id, method);
3243 if segment.ident.name != keywords::Invalid.name() {
3244 self.report_method_error(span,
3255 // Call the generic checker.
3256 self.check_method_argument_types(span,
3264 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3268 .unwrap_or_else(|| span_bug!(return_expr.span,
3269 "check_return_expr called outside fn body"));
3271 let ret_ty = ret_coercion.borrow().expected_ty();
3272 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3273 ret_coercion.borrow_mut()
3275 &self.cause(return_expr.span,
3276 ObligationCauseCode::ReturnType(return_expr.id)),
3281 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3282 // or 'if-else' expression.
3283 fn check_then_else(&self,
3284 cond_expr: &'gcx hir::Expr,
3285 then_expr: &'gcx hir::Expr,
3286 opt_else_expr: Option<&'gcx hir::Expr>,
3288 expected: Expectation<'tcx>) -> Ty<'tcx> {
3289 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3290 let cond_diverges = self.diverges.get();
3291 self.diverges.set(Diverges::Maybe);
3293 let expected = expected.adjust_for_branches(self);
3294 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3295 let then_diverges = self.diverges.get();
3296 self.diverges.set(Diverges::Maybe);
3298 // We've already taken the expected type's preferences
3299 // into account when typing the `then` branch. To figure
3300 // out the initial shot at a LUB, we thus only consider
3301 // `expected` if it represents a *hard* constraint
3302 // (`only_has_type`); otherwise, we just go with a
3303 // fresh type variable.
3304 let coerce_to_ty = expected.coercion_target_type(self, sp);
3305 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3307 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3308 coerce.coerce(self, &if_cause, then_expr, then_ty);
3310 if let Some(else_expr) = opt_else_expr {
3311 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3312 let else_diverges = self.diverges.get();
3314 coerce.coerce(self, &if_cause, else_expr, else_ty);
3316 // We won't diverge unless both branches do (or the condition does).
3317 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3319 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3320 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3322 // If the condition is false we can't diverge.
3323 self.diverges.set(cond_diverges);
3326 let result_ty = coerce.complete(self);
3327 if cond_ty.references_error() {
3334 // Check field access expressions
3335 fn check_field(&self,
3336 expr: &'gcx hir::Expr,
3338 base: &'gcx hir::Expr,
3339 field: ast::Ident) -> Ty<'tcx> {
3340 let expr_t = self.check_expr_with_needs(base, needs);
3341 let expr_t = self.structurally_resolved_type(base.span,
3343 let mut private_candidate = None;
3344 let mut autoderef = self.autoderef(expr.span, expr_t);
3345 while let Some((base_t, _)) = autoderef.next() {
3347 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3348 debug!("struct named {:?}", base_t);
3349 let (ident, def_scope) =
3350 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3351 let fields = &base_def.non_enum_variant().fields;
3352 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3353 let field = &fields[index];
3354 let field_ty = self.field_ty(expr.span, field, substs);
3355 // Save the index of all fields regardless of their visibility in case
3356 // of error recovery.
3357 self.write_field_index(expr.id, index);
3358 if field.vis.is_accessible_from(def_scope, self.tcx) {
3359 let adjustments = autoderef.adjust_steps(needs);
3360 self.apply_adjustments(base, adjustments);
3361 autoderef.finalize();
3363 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3366 private_candidate = Some((base_def.did, field_ty));
3369 ty::Tuple(ref tys) => {
3370 let fstr = field.as_str();
3371 if let Ok(index) = fstr.parse::<usize>() {
3372 if fstr == index.to_string() {
3373 if let Some(field_ty) = tys.get(index) {
3374 let adjustments = autoderef.adjust_steps(needs);
3375 self.apply_adjustments(base, adjustments);
3376 autoderef.finalize();
3378 self.write_field_index(expr.id, index);
3387 autoderef.unambiguous_final_ty();
3389 if let Some((did, field_ty)) = private_candidate {
3390 let struct_path = self.tcx().item_path_str(did);
3391 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3392 "field `{}` of struct `{}` is private",
3393 field, struct_path);
3394 // Also check if an accessible method exists, which is often what is meant.
3395 if self.method_exists(field, expr_t, expr.id, false) {
3396 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3400 } else if field.name == keywords::Invalid.name() {
3401 self.tcx().types.err
3402 } else if self.method_exists(field, expr_t, expr.id, true) {
3403 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3404 "attempted to take value of method `{}` on type `{}`",
3406 .help("maybe a `()` to call it is missing?")
3408 self.tcx().types.err
3410 if !expr_t.is_primitive_ty() {
3411 let mut err = self.no_such_field_err(field.span, field, expr_t);
3414 ty::Adt(def, _) if !def.is_enum() => {
3415 if let Some(suggested_field_name) =
3416 Self::suggest_field_name(def.non_enum_variant(),
3417 &field.as_str(), vec![]) {
3418 err.span_label(field.span,
3419 format!("did you mean `{}`?", suggested_field_name));
3421 err.span_label(field.span, "unknown field");
3422 let struct_variant_def = def.non_enum_variant();
3423 let field_names = self.available_field_names(struct_variant_def);
3424 if !field_names.is_empty() {
3425 err.note(&format!("available fields are: {}",
3426 self.name_series_display(field_names)));
3430 ty::Array(_, len) => {
3431 if let (Some(len), Ok(user_index)) = (
3432 len.assert_usize(self.tcx),
3433 field.as_str().parse::<u64>()
3435 let base = self.tcx.hir().node_to_pretty_string(base.id);
3436 let help = "instead of using tuple indexing, use array indexing";
3437 let suggestion = format!("{}[{}]", base, field);
3438 let applicability = if len < user_index {
3439 Applicability::MachineApplicable
3441 Applicability::MaybeIncorrect
3443 err.span_suggestion_with_applicability(
3444 expr.span, help, suggestion, applicability
3449 let base = self.tcx.hir().node_to_pretty_string(base.id);
3450 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3451 let suggestion = format!("(*{}).{}", base, field);
3452 err.span_suggestion_with_applicability(
3456 Applicability::MaybeIncorrect,
3463 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3464 "`{}` is a primitive type and therefore doesn't have fields",
3467 self.tcx().types.err
3471 // Return an hint about the closest match in field names
3472 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3474 skip: Vec<LocalInternedString>)
3476 let names = variant.fields.iter().filter_map(|field| {
3477 // ignore already set fields and private fields from non-local crates
3478 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3479 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3482 Some(&field.ident.name)
3486 find_best_match_for_name(names, field, None)
3489 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3490 variant.fields.iter().filter(|field| {
3491 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3492 field.vis.is_accessible_from(def_scope, self.tcx)
3494 .map(|field| field.ident.name)
3498 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3499 // dynamic limit, to never omit just one field
3500 let limit = if names.len() == 6 { 6 } else { 5 };
3501 let mut display = names.iter().take(limit)
3502 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3503 if names.len() > limit {
3504 display = format!("{} ... and {} others", display, names.len() - limit);
3509 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3510 -> DiagnosticBuilder {
3511 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3512 "no field `{}` on type `{}`",
3516 fn report_unknown_field(&self,
3518 variant: &'tcx ty::VariantDef,
3520 skip_fields: &[hir::Field],
3522 let mut err = self.type_error_struct_with_diag(
3524 |actual| match ty.sty {
3525 ty::Adt(adt, ..) if adt.is_enum() => {
3526 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3527 "{} `{}::{}` has no field named `{}`",
3528 kind_name, actual, variant.name, field.ident)
3531 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3532 "{} `{}` has no field named `{}`",
3533 kind_name, actual, field.ident)
3537 // prevent all specified fields from being suggested
3538 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3539 if let Some(field_name) = Self::suggest_field_name(variant,
3540 &field.ident.as_str(),
3541 skip_fields.collect()) {
3542 err.span_label(field.ident.span,
3543 format!("field does not exist - did you mean `{}`?", field_name));
3546 ty::Adt(adt, ..) => {
3548 err.span_label(field.ident.span,
3549 format!("`{}::{}` does not have this field",
3552 err.span_label(field.ident.span,
3553 format!("`{}` does not have this field", ty));
3555 let available_field_names = self.available_field_names(variant);
3556 if !available_field_names.is_empty() {
3557 err.note(&format!("available fields are: {}",
3558 self.name_series_display(available_field_names)));
3561 _ => bug!("non-ADT passed to report_unknown_field")
3567 fn check_expr_struct_fields(&self,
3569 expected: Expectation<'tcx>,
3570 expr_id: ast::NodeId,
3572 variant: &'tcx ty::VariantDef,
3573 ast_fields: &'gcx [hir::Field],
3574 check_completeness: bool) -> bool {
3578 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3579 .get(0).cloned().unwrap_or(adt_ty);
3580 // re-link the regions that EIfEO can erase.
3581 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3583 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3584 &ty::Adt(adt, substs) => {
3585 (substs, adt.adt_kind(), adt.variant_descr())
3587 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3590 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3591 (field.ident.modern(), (i, field))
3592 ).collect::<FxHashMap<_, _>>();
3594 let mut seen_fields = FxHashMap::default();
3596 let mut error_happened = false;
3598 // Type-check each field.
3599 for field in ast_fields {
3600 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3601 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3602 seen_fields.insert(ident, field.span);
3603 self.write_field_index(field.id, i);
3605 // We don't look at stability attributes on
3606 // struct-like enums (yet...), but it's definitely not
3607 // a bug to have constructed one.
3608 if adt_kind != AdtKind::Enum {
3609 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3612 self.field_ty(field.span, v_field, substs)
3614 error_happened = true;
3615 if let Some(prev_span) = seen_fields.get(&ident) {
3616 let mut err = struct_span_err!(self.tcx.sess,
3619 "field `{}` specified more than once",
3622 err.span_label(field.ident.span, "used more than once");
3623 err.span_label(*prev_span, format!("first use of `{}`", ident));
3627 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3633 // Make sure to give a type to the field even if there's
3634 // an error, so we can continue type-checking.
3635 self.check_expr_coercable_to_type(&field.expr, field_type);
3638 // Make sure the programmer specified correct number of fields.
3639 if kind_name == "union" {
3640 if ast_fields.len() != 1 {
3641 tcx.sess.span_err(span, "union expressions should have exactly one field");
3643 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3644 let len = remaining_fields.len();
3646 let mut displayable_field_names = remaining_fields
3648 .map(|ident| ident.as_str())
3649 .collect::<Vec<_>>();
3651 displayable_field_names.sort();
3653 let truncated_fields_error = if len <= 3 {
3656 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3659 let remaining_fields_names = displayable_field_names.iter().take(3)
3660 .map(|n| format!("`{}`", n))
3661 .collect::<Vec<_>>()
3664 struct_span_err!(tcx.sess, span, E0063,
3665 "missing field{} {}{} in initializer of `{}`",
3666 if remaining_fields.len() == 1 { "" } else { "s" },
3667 remaining_fields_names,
3668 truncated_fields_error,
3670 .span_label(span, format!("missing {}{}",
3671 remaining_fields_names,
3672 truncated_fields_error))
3678 fn check_struct_fields_on_error(&self,
3679 fields: &'gcx [hir::Field],
3680 base_expr: &'gcx Option<P<hir::Expr>>) {
3681 for field in fields {
3682 self.check_expr(&field.expr);
3684 if let Some(ref base) = *base_expr {
3685 self.check_expr(&base);
3689 pub fn check_struct_path(&self,
3691 node_id: ast::NodeId)
3692 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3693 let path_span = match *qpath {
3694 hir::QPath::Resolved(_, ref path) => path.span,
3695 hir::QPath::TypeRelative(ref qself, _) => qself.span
3697 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3698 let variant = match def {
3700 self.set_tainted_by_errors();
3703 Def::Variant(..) => {
3705 ty::Adt(adt, substs) => {
3706 Some((adt.variant_of_def(def), adt.did, substs))
3708 _ => bug!("unexpected type: {:?}", ty.sty)
3711 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3712 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3714 ty::Adt(adt, substs) if !adt.is_enum() => {
3715 Some((adt.non_enum_variant(), adt.did, substs))
3720 _ => bug!("unexpected definition: {:?}", def)
3723 if let Some((variant, did, substs)) = variant {
3724 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3725 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
3726 self.write_user_substs_from_substs(hir_id, substs, None);
3728 // Check bounds on type arguments used in the path.
3729 let bounds = self.instantiate_bounds(path_span, did, substs);
3730 let cause = traits::ObligationCause::new(path_span, self.body_id,
3731 traits::ItemObligation(did));
3732 self.add_obligations_for_parameters(cause, &bounds);
3736 struct_span_err!(self.tcx.sess, path_span, E0071,
3737 "expected struct, variant or union type, found {}",
3738 ty.sort_string(self.tcx))
3739 .span_label(path_span, "not a struct")
3745 fn check_expr_struct(&self,
3747 expected: Expectation<'tcx>,
3749 fields: &'gcx [hir::Field],
3750 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3752 // Find the relevant variant
3753 let (variant, adt_ty) =
3754 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3757 self.check_struct_fields_on_error(fields, base_expr);
3758 return self.tcx.types.err;
3761 let path_span = match *qpath {
3762 hir::QPath::Resolved(_, ref path) => path.span,
3763 hir::QPath::TypeRelative(ref qself, _) => qself.span
3766 // Prohibit struct expressions when non-exhaustive flag is set.
3767 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3768 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3769 span_err!(self.tcx.sess, expr.span, E0639,
3770 "cannot create non-exhaustive {} using struct expression",
3771 adt.variant_descr());
3774 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3775 variant, fields, base_expr.is_none());
3776 if let &Some(ref base_expr) = base_expr {
3777 // If check_expr_struct_fields hit an error, do not attempt to populate
3778 // the fields with the base_expr. This could cause us to hit errors later
3779 // when certain fields are assumed to exist that in fact do not.
3780 if !error_happened {
3781 self.check_expr_has_type_or_error(base_expr, adt_ty);
3783 ty::Adt(adt, substs) if adt.is_struct() => {
3784 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3785 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3790 .fru_field_types_mut()
3791 .insert(expr.hir_id, fru_field_types);
3794 span_err!(self.tcx.sess, base_expr.span, E0436,
3795 "functional record update syntax requires a struct");
3800 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3806 /// If an expression has any sub-expressions that result in a type error,
3807 /// inspecting that expression's type with `ty.references_error()` will return
3808 /// true. Likewise, if an expression is known to diverge, inspecting its
3809 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3810 /// strict, _|_ can appear in the type of an expression that does not,
3811 /// itself, diverge: for example, fn() -> _|_.)
3812 /// Note that inspecting a type's structure *directly* may expose the fact
3813 /// that there are actually multiple representations for `Error`, so avoid
3814 /// that when err needs to be handled differently.
3815 fn check_expr_with_expectation_and_needs(&self,
3816 expr: &'gcx hir::Expr,
3817 expected: Expectation<'tcx>,
3818 needs: Needs) -> Ty<'tcx> {
3819 debug!(">> type-checking: expr={:?} expected={:?}",
3822 // Warn for expressions after diverging siblings.
3823 self.warn_if_unreachable(expr.id, expr.span, "expression");
3825 // Hide the outer diverging and has_errors flags.
3826 let old_diverges = self.diverges.get();
3827 let old_has_errors = self.has_errors.get();
3828 self.diverges.set(Diverges::Maybe);
3829 self.has_errors.set(false);
3831 let ty = self.check_expr_kind(expr, expected, needs);
3833 // Warn for non-block expressions with diverging children.
3835 hir::ExprKind::Block(..) |
3836 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3837 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3839 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3842 // Any expression that produces a value of type `!` must have diverged
3844 self.diverges.set(self.diverges.get() | Diverges::Always);
3847 // Record the type, which applies it effects.
3848 // We need to do this after the warning above, so that
3849 // we don't warn for the diverging expression itself.
3850 self.write_ty(expr.hir_id, ty);
3852 // Combine the diverging and has_error flags.
3853 self.diverges.set(self.diverges.get() | old_diverges);
3854 self.has_errors.set(self.has_errors.get() | old_has_errors);
3856 debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
3857 debug!("... {:?}, expected is {:?}", ty, expected);
3864 expr: &'gcx hir::Expr,
3865 expected: Expectation<'tcx>,
3869 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3878 hir::ExprKind::Box(ref subexpr) => {
3879 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3881 ty::Adt(def, _) if def.is_box()
3882 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3886 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3887 tcx.mk_box(referent_ty)
3890 hir::ExprKind::Lit(ref lit) => {
3891 self.check_lit(&lit, expected)
3893 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3894 self.check_binop(expr, op, lhs, rhs)
3896 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3897 self.check_binop_assign(expr, op, lhs, rhs)
3899 hir::ExprKind::Unary(unop, ref oprnd) => {
3900 let expected_inner = match unop {
3901 hir::UnNot | hir::UnNeg => {
3908 let needs = match unop {
3909 hir::UnDeref => needs,
3912 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3916 if !oprnd_t.references_error() {
3917 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3920 if let Some(mt) = oprnd_t.builtin_deref(true) {
3922 } else if let Some(ok) = self.try_overloaded_deref(
3923 expr.span, oprnd_t, needs) {
3924 let method = self.register_infer_ok_obligations(ok);
3925 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3926 let mutbl = match mutbl {
3927 hir::MutImmutable => AutoBorrowMutability::Immutable,
3928 hir::MutMutable => AutoBorrowMutability::Mutable {
3929 // (It shouldn't actually matter for unary ops whether
3930 // we enable two-phase borrows or not, since a unary
3931 // op has no additional operands.)
3932 allow_two_phase_borrow: AllowTwoPhase::No,
3935 self.apply_adjustments(oprnd, vec![Adjustment {
3936 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3937 target: method.sig.inputs()[0]
3940 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3941 self.write_method_call(expr.hir_id, method);
3943 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3944 "type `{}` cannot be dereferenced",
3946 oprnd_t = tcx.types.err;
3950 let result = self.check_user_unop(expr, oprnd_t, unop);
3951 // If it's builtin, we can reuse the type, this helps inference.
3952 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3957 let result = self.check_user_unop(expr, oprnd_t, unop);
3958 // If it's builtin, we can reuse the type, this helps inference.
3959 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3967 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3968 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3970 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3971 if oprnd.is_place_expr() {
3972 // Places may legitimately have unsized types.
3973 // For example, dereferences of a fat pointer and
3974 // the last field of a struct can be unsized.
3977 Expectation::rvalue_hint(self, ty)
3983 let needs = Needs::maybe_mut_place(mutbl);
3984 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3986 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3987 if tm.ty.references_error() {
3990 // Note: at this point, we cannot say what the best lifetime
3991 // is to use for resulting pointer. We want to use the
3992 // shortest lifetime possible so as to avoid spurious borrowck
3993 // errors. Moreover, the longest lifetime will depend on the
3994 // precise details of the value whose address is being taken
3995 // (and how long it is valid), which we don't know yet until type
3996 // inference is complete.
3998 // Therefore, here we simply generate a region variable. The
3999 // region inferencer will then select the ultimate value.
4000 // Finally, borrowck is charged with guaranteeing that the
4001 // value whose address was taken can actually be made to live
4002 // as long as it needs to live.
4003 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4004 tcx.mk_ref(region, tm)
4007 hir::ExprKind::Path(ref qpath) => {
4008 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
4009 let ty = if def != Def::Err {
4010 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
4012 self.set_tainted_by_errors();
4016 if let ty::FnDef(..) = ty.sty {
4017 let fn_sig = ty.fn_sig(tcx);
4018 if !tcx.features().unsized_locals {
4019 // We want to remove some Sized bounds from std functions,
4020 // but don't want to expose the removal to stable Rust.
4021 // i.e., we don't want to allow
4027 // to work in stable even if the Sized bound on `drop` is relaxed.
4028 for i in 0..fn_sig.inputs().skip_binder().len() {
4029 // We just want to check sizedness, so instead of introducing
4030 // placeholder lifetimes with probing, we just replace higher lifetimes
4032 let input = self.replace_bound_vars_with_fresh_vars(
4034 infer::LateBoundRegionConversionTime::FnCall,
4035 &fn_sig.input(i)).0;
4036 self.require_type_is_sized_deferred(input, expr.span,
4037 traits::SizedArgumentType);
4040 // Here we want to prevent struct constructors from returning unsized types.
4041 // There were two cases this happened: fn pointer coercion in stable
4042 // and usual function call in presense of unsized_locals.
4043 // Also, as we just want to check sizedness, instead of introducing
4044 // placeholder lifetimes with probing, we just replace higher lifetimes
4046 let output = self.replace_bound_vars_with_fresh_vars(
4048 infer::LateBoundRegionConversionTime::FnCall,
4049 &fn_sig.output()).0;
4050 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4053 // We always require that the type provided as the value for
4054 // a type parameter outlives the moment of instantiation.
4055 let substs = self.tables.borrow().node_substs(expr.hir_id);
4056 self.add_wf_bounds(substs, expr);
4060 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4061 for expr in outputs.iter().chain(inputs.iter()) {
4062 self.check_expr(expr);
4066 hir::ExprKind::Break(destination, ref expr_opt) => {
4067 if let Ok(target_id) = destination.target_id {
4069 if let Some(ref e) = *expr_opt {
4070 // If this is a break with a value, we need to type-check
4071 // the expression. Get an expected type from the loop context.
4072 let opt_coerce_to = {
4073 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4074 enclosing_breakables.find_breakable(target_id)
4077 .map(|coerce| coerce.expected_ty())
4080 // If the loop context is not a `loop { }`, then break with
4081 // a value is illegal, and `opt_coerce_to` will be `None`.
4082 // Just set expectation to error in that case.
4083 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4085 // Recurse without `enclosing_breakables` borrowed.
4086 e_ty = self.check_expr_with_hint(e, coerce_to);
4087 cause = self.misc(e.span);
4089 // Otherwise, this is a break *without* a value. That's
4090 // always legal, and is equivalent to `break ()`.
4091 e_ty = tcx.mk_unit();
4092 cause = self.misc(expr.span);
4095 // Now that we have type-checked `expr_opt`, borrow
4096 // the `enclosing_loops` field and let's coerce the
4097 // type of `expr_opt` into what is expected.
4098 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4099 let ctxt = enclosing_breakables.find_breakable(target_id);
4100 if let Some(ref mut coerce) = ctxt.coerce {
4101 if let Some(ref e) = *expr_opt {
4102 coerce.coerce(self, &cause, e, e_ty);
4104 assert!(e_ty.is_unit());
4105 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4108 // If `ctxt.coerce` is `None`, we can just ignore
4109 // the type of the expresison. This is because
4110 // either this was a break *without* a value, in
4111 // which case it is always a legal type (`()`), or
4112 // else an error would have been flagged by the
4113 // `loops` pass for using break with an expression
4114 // where you are not supposed to.
4115 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4118 ctxt.may_break = true;
4120 // the type of a `break` is always `!`, since it diverges
4123 // Otherwise, we failed to find the enclosing loop;
4124 // this can only happen if the `break` was not
4125 // inside a loop at all, which is caught by the
4126 // loop-checking pass.
4127 if self.tcx.sess.err_count() == 0 {
4128 self.tcx.sess.delay_span_bug(expr.span,
4129 "break was outside loop, but no error was emitted");
4132 // We still need to assign a type to the inner expression to
4133 // prevent the ICE in #43162.
4134 if let Some(ref e) = *expr_opt {
4135 self.check_expr_with_hint(e, tcx.types.err);
4137 // ... except when we try to 'break rust;'.
4138 // ICE this expression in particular (see #43162).
4139 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
4140 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4141 fatally_break_rust(self.tcx.sess);
4145 // There was an error; make type-check fail.
4150 hir::ExprKind::Continue(destination) => {
4151 if destination.target_id.is_ok() {
4154 // There was an error; make type-check fail.
4158 hir::ExprKind::Ret(ref expr_opt) => {
4159 if self.ret_coercion.is_none() {
4160 struct_span_err!(self.tcx.sess, expr.span, E0572,
4161 "return statement outside of function body").emit();
4162 } else if let Some(ref e) = *expr_opt {
4163 self.check_return_expr(e);
4165 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4166 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4167 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4171 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4172 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4174 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4177 ExpectIfCondition => {
4178 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4179 expected error elsehwere");
4182 // Only check this if not in an `if` condition, as the
4183 // mistyped comparison help is more appropriate.
4184 if !lhs.is_place_expr() {
4185 struct_span_err!(self.tcx.sess, expr.span, E0070,
4186 "invalid left-hand side expression")
4187 .span_label(expr.span, "left-hand of expression not valid")
4193 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4195 if lhs_ty.references_error() || rhs_ty.references_error() {
4201 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4202 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4203 expr.span, expected)
4205 hir::ExprKind::While(ref cond, ref body, _) => {
4206 let ctxt = BreakableCtxt {
4207 // cannot use break with a value from a while loop
4209 may_break: false, // Will get updated if/when we find a `break`.
4212 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4213 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4214 let cond_diverging = self.diverges.get();
4215 self.check_block_no_value(&body);
4217 // We may never reach the body so it diverging means nothing.
4218 self.diverges.set(cond_diverging);
4222 // No way to know whether it's diverging because
4223 // of a `break` or an outer `break` or `return`.
4224 self.diverges.set(Diverges::Maybe);
4229 hir::ExprKind::Loop(ref body, _, source) => {
4230 let coerce = match source {
4231 // you can only use break with a value from a normal `loop { }`
4232 hir::LoopSource::Loop => {
4233 let coerce_to = expected.coercion_target_type(self, body.span);
4234 Some(CoerceMany::new(coerce_to))
4237 hir::LoopSource::WhileLet |
4238 hir::LoopSource::ForLoop => {
4243 let ctxt = BreakableCtxt {
4245 may_break: false, // Will get updated if/when we find a `break`.
4248 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4249 self.check_block_no_value(&body);
4253 // No way to know whether it's diverging because
4254 // of a `break` or an outer `break` or `return`.
4255 self.diverges.set(Diverges::Maybe);
4258 // If we permit break with a value, then result type is
4259 // the LUB of the breaks (possibly ! if none); else, it
4260 // is nil. This makes sense because infinite loops
4261 // (which would have type !) are only possible iff we
4262 // permit break with a value [1].
4263 if ctxt.coerce.is_none() && !ctxt.may_break {
4265 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4267 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4269 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4270 self.check_match(expr, &discrim, arms, expected, match_src)
4272 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4273 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4275 hir::ExprKind::Block(ref body, _) => {
4276 self.check_block_with_expected(&body, expected)
4278 hir::ExprKind::Call(ref callee, ref args) => {
4279 self.check_call(expr, &callee, args, expected)
4281 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4282 self.check_method_call(expr, segment, span, args, expected, needs)
4284 hir::ExprKind::Cast(ref e, ref t) => {
4285 // Find the type of `e`. Supply hints based on the type we are casting to,
4287 let t_cast = self.to_ty_saving_user_provided_ty(t);
4288 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4289 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4290 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4292 // Eagerly check for some obvious errors.
4293 if t_expr.references_error() || t_cast.references_error() {
4296 // Defer other checks until we're done type checking.
4297 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4298 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4300 deferred_cast_checks.push(cast_check);
4303 Err(ErrorReported) => {
4309 hir::ExprKind::Type(ref e, ref t) => {
4310 let ty = self.to_ty_saving_user_provided_ty(&t);
4311 self.check_expr_eq_type(&e, ty);
4314 hir::ExprKind::Array(ref args) => {
4315 let uty = expected.to_option(self).and_then(|uty| {
4317 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4322 let element_ty = if !args.is_empty() {
4323 let coerce_to = uty.unwrap_or_else(
4324 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4325 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4326 assert_eq!(self.diverges.get(), Diverges::Maybe);
4328 let e_ty = self.check_expr_with_hint(e, coerce_to);
4329 let cause = self.misc(e.span);
4330 coerce.coerce(self, &cause, e, e_ty);
4332 coerce.complete(self)
4334 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4336 tcx.mk_array(element_ty, args.len() as u64)
4338 hir::ExprKind::Repeat(ref element, ref count) => {
4339 let count_def_id = tcx.hir().local_def_id(count.id);
4340 let param_env = ty::ParamEnv::empty();
4341 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4342 let instance = ty::Instance::resolve(
4348 let global_id = GlobalId {
4352 let count = tcx.const_eval(param_env.and(global_id));
4354 let uty = match expected {
4355 ExpectHasType(uty) => {
4357 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4364 let (element_ty, t) = match uty {
4366 self.check_expr_coercable_to_type(&element, uty);
4370 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4371 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4376 if let Ok(count) = count {
4377 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4379 // For [foo, ..n] where n > 1, `foo` must have
4381 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4382 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4386 if element_ty.references_error() {
4388 } else if let Ok(count) = count {
4389 tcx.mk_ty(ty::Array(t, count))
4394 hir::ExprKind::Tup(ref elts) => {
4395 let flds = expected.only_has_type(self).and_then(|ty| {
4396 let ty = self.resolve_type_vars_with_obligations(ty);
4398 ty::Tuple(ref flds) => Some(&flds[..]),
4403 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4404 let t = match flds {
4405 Some(ref fs) if i < fs.len() => {
4407 self.check_expr_coercable_to_type(&e, ety);
4411 self.check_expr_with_expectation(&e, NoExpectation)
4416 let tuple = tcx.mk_tup(elt_ts_iter);
4417 if tuple.references_error() {
4420 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4424 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4425 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4427 hir::ExprKind::Field(ref base, field) => {
4428 self.check_field(expr, needs, &base, field)
4430 hir::ExprKind::Index(ref base, ref idx) => {
4431 let base_t = self.check_expr_with_needs(&base, needs);
4432 let idx_t = self.check_expr(&idx);
4434 if base_t.references_error() {
4436 } else if idx_t.references_error() {
4439 let base_t = self.structurally_resolved_type(base.span, base_t);
4440 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4441 Some((index_ty, element_ty)) => {
4442 // two-phase not needed because index_ty is never mutable
4443 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4448 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4449 "cannot index into a value of type `{}`",
4451 // Try to give some advice about indexing tuples.
4452 if let ty::Tuple(..) = base_t.sty {
4453 let mut needs_note = true;
4454 // If the index is an integer, we can show the actual
4455 // fixed expression:
4456 if let hir::ExprKind::Lit(ref lit) = idx.node {
4457 if let ast::LitKind::Int(i,
4458 ast::LitIntType::Unsuffixed) = lit.node {
4459 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4460 if let Ok(snip) = snip {
4461 err.span_suggestion_with_applicability(
4463 "to access tuple elements, use",
4464 format!("{}.{}", snip, i),
4465 Applicability::MachineApplicable);
4471 err.help("to access tuple elements, use tuple indexing \
4472 syntax (e.g., `tuple.0`)");
4481 hir::ExprKind::Yield(ref value) => {
4482 match self.yield_ty {
4484 self.check_expr_coercable_to_type(&value, ty);
4487 struct_span_err!(self.tcx.sess, expr.span, E0627,
4488 "yield statement outside of generator literal").emit();
4496 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4497 // The newly resolved definition is written into `type_dependent_defs`.
4498 fn finish_resolving_struct_path(&self,
4501 node_id: ast::NodeId)
4505 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4506 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4507 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4510 hir::QPath::TypeRelative(ref qself, ref segment) => {
4511 let ty = self.to_ty(qself);
4513 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4518 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4521 // Write back the new resolution.
4522 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4523 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4530 // Resolve associated value path into a base type and associated constant or method definition.
4531 // The newly resolved definition is written into `type_dependent_defs`.
4532 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4533 qpath: &'b hir::QPath,
4534 node_id: ast::NodeId,
4536 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4538 let (ty, item_segment) = match *qpath {
4539 hir::QPath::Resolved(ref opt_qself, ref path) => {
4541 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4542 &path.segments[..]);
4544 hir::QPath::TypeRelative(ref qself, ref segment) => {
4545 (self.to_ty(qself), segment)
4548 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4549 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4550 // Return directly on cache hit. This is useful to avoid doubly reporting
4551 // errors with default match binding modes. See #44614.
4552 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4554 let item_name = item_segment.ident;
4555 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4558 let def = match error {
4559 method::MethodError::PrivateMatch(def, _) => def,
4562 if item_name.name != keywords::Invalid.name() {
4563 self.report_method_error(span, ty, item_name, None, error, None);
4569 // Write back the new resolution.
4570 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4571 (def, Some(ty), slice::from_ref(&**item_segment))
4574 pub fn check_decl_initializer(&self,
4575 local: &'gcx hir::Local,
4576 init: &'gcx hir::Expr) -> Ty<'tcx>
4578 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4579 // for #42640 (default match binding modes).
4582 let ref_bindings = local.pat.contains_explicit_ref_binding();
4584 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4585 if let Some(m) = ref_bindings {
4586 // Somewhat subtle: if we have a `ref` binding in the pattern,
4587 // we want to avoid introducing coercions for the RHS. This is
4588 // both because it helps preserve sanity and, in the case of
4589 // ref mut, for soundness (issue #23116). In particular, in
4590 // the latter case, we need to be clear that the type of the
4591 // referent for the reference that results is *equal to* the
4592 // type of the place it is referencing, and not some
4593 // supertype thereof.
4594 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4595 self.demand_eqtype(init.span, local_ty, init_ty);
4598 self.check_expr_coercable_to_type(init, local_ty)
4602 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4603 let t = self.local_ty(local.span, local.id).decl_ty;
4604 self.write_ty(local.hir_id, t);
4606 if let Some(ref init) = local.init {
4607 let init_ty = self.check_decl_initializer(local, &init);
4608 if init_ty.references_error() {
4609 self.write_ty(local.hir_id, init_ty);
4613 self.check_pat_walk(&local.pat, t,
4614 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4616 let pat_ty = self.node_ty(local.pat.hir_id);
4617 if pat_ty.references_error() {
4618 self.write_ty(local.hir_id, pat_ty);
4622 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4623 // Don't do all the complex logic below for DeclItem.
4625 hir::StmtKind::Decl(ref decl, _) => {
4626 if let hir::DeclKind::Item(_) = decl.node {
4630 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4633 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4635 // Hide the outer diverging and has_errors flags.
4636 let old_diverges = self.diverges.get();
4637 let old_has_errors = self.has_errors.get();
4638 self.diverges.set(Diverges::Maybe);
4639 self.has_errors.set(false);
4642 hir::StmtKind::Decl(ref decl, _) => {
4644 hir::DeclKind::Local(ref l) => {
4645 self.check_decl_local(&l);
4647 hir::DeclKind::Item(_) => {/* ignore for now */}
4650 hir::StmtKind::Expr(ref expr, _) => {
4651 // Check with expected type of ()
4652 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4654 hir::StmtKind::Semi(ref expr, _) => {
4655 self.check_expr(&expr);
4659 // Combine the diverging and has_error flags.
4660 self.diverges.set(self.diverges.get() | old_diverges);
4661 self.has_errors.set(self.has_errors.get() | old_has_errors);
4664 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4665 let unit = self.tcx.mk_unit();
4666 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4668 // if the block produces a `!` value, that can always be
4669 // (effectively) coerced to unit.
4671 self.demand_suptype(blk.span, unit, ty);
4675 fn check_block_with_expected(&self,
4676 blk: &'gcx hir::Block,
4677 expected: Expectation<'tcx>) -> Ty<'tcx> {
4679 let mut fcx_ps = self.ps.borrow_mut();
4680 let unsafety_state = fcx_ps.recurse(blk);
4681 replace(&mut *fcx_ps, unsafety_state)
4684 // In some cases, blocks have just one exit, but other blocks
4685 // can be targeted by multiple breaks. This can happen both
4686 // with labeled blocks as well as when we desugar
4687 // a `try { ... }` expression.
4691 // 'a: { if true { break 'a Err(()); } Ok(()) }
4693 // Here we would wind up with two coercions, one from
4694 // `Err(())` and the other from the tail expression
4695 // `Ok(())`. If the tail expression is omitted, that's a
4696 // "forced unit" -- unless the block diverges, in which
4697 // case we can ignore the tail expression (e.g., `'a: {
4698 // break 'a 22; }` would not force the type of the block
4700 let tail_expr = blk.expr.as_ref();
4701 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4702 let coerce = if blk.targeted_by_break {
4703 CoerceMany::new(coerce_to_ty)
4705 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4706 Some(e) => slice::from_ref(e),
4709 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4712 let prev_diverges = self.diverges.get();
4713 let ctxt = BreakableCtxt {
4714 coerce: Some(coerce),
4718 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4719 for s in &blk.stmts {
4723 // check the tail expression **without** holding the
4724 // `enclosing_breakables` lock below.
4725 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4727 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4728 let ctxt = enclosing_breakables.find_breakable(blk.id);
4729 let coerce = ctxt.coerce.as_mut().unwrap();
4730 if let Some(tail_expr_ty) = tail_expr_ty {
4731 let tail_expr = tail_expr.unwrap();
4732 let cause = self.cause(tail_expr.span,
4733 ObligationCauseCode::BlockTailExpression(blk.id));
4739 // Subtle: if there is no explicit tail expression,
4740 // that is typically equivalent to a tail expression
4741 // of `()` -- except if the block diverges. In that
4742 // case, there is no value supplied from the tail
4743 // expression (assuming there are no other breaks,
4744 // this implies that the type of the block will be
4747 // #41425 -- label the implicit `()` as being the
4748 // "found type" here, rather than the "expected type".
4750 // #44579 -- if the block was recovered during parsing,
4751 // the type would be nonsensical and it is not worth it
4752 // to perform the type check, so we avoid generating the
4753 // diagnostic output.
4754 if !self.diverges.get().always() && !blk.recovered {
4755 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4756 if let Some(expected_ty) = expected.only_has_type(self) {
4757 self.consider_hint_about_removing_semicolon(blk,
4767 // If we can break from the block, then the block's exit is always reachable
4768 // (... as long as the entry is reachable) - regardless of the tail of the block.
4769 self.diverges.set(prev_diverges);
4772 let mut ty = ctxt.coerce.unwrap().complete(self);
4774 if self.has_errors.get() || ty.references_error() {
4775 ty = self.tcx.types.err
4778 self.write_ty(blk.hir_id, ty);
4780 *self.ps.borrow_mut() = prev;
4784 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4785 /// suggestion can be made, `None` otherwise.
4786 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4787 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4788 // `while` before reaching it, as block tail returns are not available in them.
4789 if let Some(fn_id) = self.tcx.hir().get_return_block(blk_id) {
4790 let parent = self.tcx.hir().get(fn_id);
4792 if let Node::Item(&hir::Item {
4793 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4795 decl.clone().and_then(|decl| {
4796 // This is less than ideal, it will not suggest a return type span on any
4797 // method called `main`, regardless of whether it is actually the entry point,
4798 // but it will still present it as the reason for the expected type.
4799 Some((decl, name != Symbol::intern("main")))
4801 } else if let Node::TraitItem(&hir::TraitItem {
4802 node: hir::TraitItemKind::Method(hir::MethodSig {
4806 decl.clone().and_then(|decl| {
4809 } else if let Node::ImplItem(&hir::ImplItem {
4810 node: hir::ImplItemKind::Method(hir::MethodSig {
4814 decl.clone().and_then(|decl| {
4825 /// On implicit return expressions with mismatched types, provide the following suggestions:
4827 /// - Point out the method's return type as the reason for the expected type
4828 /// - Possible missing semicolon
4829 /// - Possible missing return type if the return type is the default, and not `fn main()`
4830 pub fn suggest_mismatched_types_on_tail(&self,
4831 err: &mut DiagnosticBuilder<'tcx>,
4832 expression: &'gcx hir::Expr,
4836 blk_id: ast::NodeId) {
4837 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4838 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4839 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4841 self.suggest_ref_or_into(err, expression, expected, found);
4844 pub fn suggest_ref_or_into(
4846 err: &mut DiagnosticBuilder<'tcx>,
4851 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4852 err.span_suggestion_with_applicability(
4856 Applicability::MachineApplicable,
4858 } else if !self.check_for_cast(err, expr, found, expected) {
4859 let methods = self.get_conversion_methods(expr.span, expected, found);
4860 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4861 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4862 .filter_map(|(receiver, method)| {
4863 let method_call = format!(".{}()", method.ident);
4864 if receiver.ends_with(&method_call) {
4865 None // do not suggest code that is already there (#53348)
4867 let method_call_list = [".to_vec()", ".to_string()"];
4868 if receiver.ends_with(".clone()")
4869 && method_call_list.contains(&method_call.as_str()) {
4870 let max_len = receiver.rfind(".").unwrap();
4871 Some(format!("{}{}", &receiver[..max_len], method_call))
4874 Some(format!("{}{}", receiver, method_call))
4878 if suggestions.peek().is_some() {
4879 err.span_suggestions_with_applicability(
4881 "try using a conversion method",
4883 Applicability::MaybeIncorrect,
4890 /// A common error is to forget to add a semicolon at the end of a block:
4894 /// bar_that_returns_u32()
4898 /// This routine checks if the return expression in a block would make sense on its own as a
4899 /// statement and the return type has been left as default or has been specified as `()`. If so,
4900 /// it suggests adding a semicolon.
4901 fn suggest_missing_semicolon(&self,
4902 err: &mut DiagnosticBuilder<'tcx>,
4903 expression: &'gcx hir::Expr,
4906 if expected.is_unit() {
4907 // `BlockTailExpression` only relevant if the tail expr would be
4908 // useful on its own.
4909 match expression.node {
4910 hir::ExprKind::Call(..) |
4911 hir::ExprKind::MethodCall(..) |
4912 hir::ExprKind::If(..) |
4913 hir::ExprKind::While(..) |
4914 hir::ExprKind::Loop(..) |
4915 hir::ExprKind::Match(..) |
4916 hir::ExprKind::Block(..) => {
4917 let sp = self.tcx.sess.source_map().next_point(cause_span);
4918 err.span_suggestion_with_applicability(
4920 "try adding a semicolon",
4922 Applicability::MachineApplicable);
4929 /// A possible error is to forget to add a return type that is needed:
4933 /// bar_that_returns_u32()
4937 /// This routine checks if the return type is left as default, the method is not part of an
4938 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4940 fn suggest_missing_return_type(&self,
4941 err: &mut DiagnosticBuilder<'tcx>,
4942 fn_decl: &hir::FnDecl,
4945 can_suggest: bool) {
4946 // Only suggest changing the return type for methods that
4947 // haven't set a return type at all (and aren't `fn main()` or an impl).
4948 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4949 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4950 err.span_suggestion_with_applicability(
4952 "try adding a return type",
4953 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4954 Applicability::MachineApplicable);
4956 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4957 err.span_label(span, "possibly return type missing here?");
4959 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4960 // `fn main()` must return `()`, do not suggest changing return type
4961 err.span_label(span, "expected `()` because of default return type");
4963 // expectation was caused by something else, not the default return
4964 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4965 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4966 // Only point to return type if the expected type is the return type, as if they
4967 // are not, the expectation must have been caused by something else.
4968 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4970 let ty = AstConv::ast_ty_to_ty(self, ty);
4971 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4972 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4973 if ty.sty == expected.sty {
4974 err.span_label(sp, format!("expected `{}` because of return type",
4982 /// A common error is to add an extra semicolon:
4985 /// fn foo() -> usize {
4990 /// This routine checks if the final statement in a block is an
4991 /// expression with an explicit semicolon whose type is compatible
4992 /// with `expected_ty`. If so, it suggests removing the semicolon.
4993 fn consider_hint_about_removing_semicolon(&self,
4994 blk: &'gcx hir::Block,
4995 expected_ty: Ty<'tcx>,
4996 err: &mut DiagnosticBuilder) {
4997 // Be helpful when the user wrote `{... expr;}` and
4998 // taking the `;` off is enough to fix the error.
4999 let last_stmt = match blk.stmts.last() {
5003 let last_expr = match last_stmt.node {
5004 hir::StmtKind::Semi(ref e, _) => e,
5007 let last_expr_ty = self.node_ty(last_expr.hir_id);
5008 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5011 let original_span = original_sp(last_stmt.span, blk.span);
5012 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
5013 err.span_suggestion_with_applicability(
5015 "consider removing this semicolon",
5017 Applicability::MachineApplicable);
5020 fn def_ids_for_path_segments(&self,
5021 segments: &[hir::PathSegment],
5024 // We need to extract the type parameters supplied by the user in
5025 // the path `path`. Due to the current setup, this is a bit of a
5026 // tricky-process; the problem is that resolve only tells us the
5027 // end-point of the path resolution, and not the intermediate steps.
5028 // Luckily, we can (at least for now) deduce the intermediate steps
5029 // just from the end-point.
5031 // There are basically four cases to consider:
5033 // 1. Reference to a constructor of enum variant or struct:
5035 // struct Foo<T>(...)
5036 // enum E<T> { Foo(...) }
5038 // In these cases, the parameters are declared in the type
5041 // 2. Reference to a fn item or a free constant:
5045 // In this case, the path will again always have the form
5046 // `a::b::foo::<T>` where only the final segment should have
5047 // type parameters. However, in this case, those parameters are
5048 // declared on a value, and hence are in the `FnSpace`.
5050 // 3. Reference to a method or an associated constant:
5052 // impl<A> SomeStruct<A> {
5056 // Here we can have a path like
5057 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
5058 // may appear in two places. The penultimate segment,
5059 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
5060 // final segment, `foo::<B>` contains parameters in fn space.
5062 // 4. Reference to a local variable
5064 // Local variables can't have any type parameters.
5066 // The first step then is to categorize the segments appropriately.
5068 assert!(!segments.is_empty());
5069 let last = segments.len() - 1;
5071 let mut path_segs = vec![];
5074 // Case 1. Reference to a struct/variant constructor.
5075 Def::StructCtor(def_id, ..) |
5076 Def::VariantCtor(def_id, ..) |
5077 Def::SelfCtor(.., def_id) => {
5078 // Everything but the final segment should have no
5079 // parameters at all.
5080 let generics = self.tcx.generics_of(def_id);
5081 // Variant and struct constructors use the
5082 // generics of their parent type definition.
5083 let generics_def_id = generics.parent.unwrap_or(def_id);
5084 path_segs.push(PathSeg(generics_def_id, last));
5087 // Case 2. Reference to a top-level value.
5089 Def::Const(def_id) |
5090 Def::Static(def_id, _) => {
5091 path_segs.push(PathSeg(def_id, last));
5094 // Case 3. Reference to a method or associated const.
5095 Def::Method(def_id) |
5096 Def::AssociatedConst(def_id) => {
5097 if segments.len() >= 2 {
5098 let generics = self.tcx.generics_of(def_id);
5099 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
5101 path_segs.push(PathSeg(def_id, last));
5104 // Case 4. Local variable, no generics.
5105 Def::Local(..) | Def::Upvar(..) => {}
5107 _ => bug!("unexpected definition: {:?}", def),
5110 debug!("path_segs = {:?}", path_segs);
5115 // Instantiates the given path, which must refer to an item with the given
5116 // number of type parameters and type.
5117 pub fn instantiate_value_path(&self,
5118 segments: &[hir::PathSegment],
5119 self_ty: Option<Ty<'tcx>>,
5122 node_id: ast::NodeId)
5123 -> (Ty<'tcx>, Def) {
5125 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5132 let path_segs = self.def_ids_for_path_segments(segments, def);
5134 let mut user_self_ty = None;
5136 Def::Method(def_id) |
5137 Def::AssociatedConst(def_id) => {
5138 let container = self.tcx.associated_item(def_id).container;
5140 ty::TraitContainer(trait_did) => {
5141 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5143 ty::ImplContainer(impl_def_id) => {
5144 if segments.len() == 1 {
5145 // `<T>::assoc` will end up here, and so
5146 // can `T::assoc`. It this came from an
5147 // inherent impl, we need to record the
5148 // `T` for posterity (see `UserSelfTy` for
5150 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5151 user_self_ty = Some(UserSelfTy {
5162 // Now that we have categorized what space the parameters for each
5163 // segment belong to, let's sort out the parameters that the user
5164 // provided (if any) into their appropriate spaces. We'll also report
5165 // errors if type parameters are provided in an inappropriate place.
5167 let generic_segs = path_segs.iter().map(|PathSeg(_, index)| index)
5168 .collect::<FxHashSet<_>>();
5169 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5170 if !generic_segs.contains(&index) {
5178 Def::Local(nid) | Def::Upvar(nid, ..) => {
5179 let ty = self.local_ty(span, nid).decl_ty;
5180 let ty = self.normalize_associated_types_in(span, &ty);
5181 self.write_ty(self.tcx.hir().node_to_hir_id(node_id), ty);
5187 // Now we have to compare the types that the user *actually*
5188 // provided against the types that were *expected*. If the user
5189 // did not provide any types, then we want to substitute inference
5190 // variables. If the user provided some types, we may still need
5191 // to add defaults. If the user provided *too many* types, that's
5194 let mut infer_args_for_err = FxHashSet::default();
5195 for &PathSeg(def_id, index) in &path_segs {
5196 let seg = &segments[index];
5197 let generics = self.tcx.generics_of(def_id);
5198 // Argument-position `impl Trait` is treated as a normal generic
5199 // parameter internally, but we don't allow users to specify the
5200 // parameter's value explicitly, so we have to do some error-
5202 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5207 false, // `is_method_call`
5209 if suppress_errors {
5210 infer_args_for_err.insert(index);
5211 self.set_tainted_by_errors(); // See issue #53251.
5215 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5216 self.tcx.generics_of(*def_id).has_self
5217 }).unwrap_or(false);
5219 let mut new_def = def;
5220 let (def_id, ty) = match def {
5221 Def::SelfCtor(impl_def_id) => {
5222 let ty = self.impl_self_ty(span, impl_def_id).ty;
5223 let adt_def = ty.ty_adt_def();
5226 Some(adt_def) if adt_def.has_ctor() => {
5227 let variant = adt_def.non_enum_variant();
5228 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5229 (variant.did, self.tcx.type_of(variant.did))
5232 let mut err = self.tcx.sess.struct_span_err(span,
5233 "the `Self` constructor can only be used with tuple or unit structs");
5234 if let Some(adt_def) = adt_def {
5235 match adt_def.adt_kind() {
5237 err.note("did you mean to use one of the enum's variants?");
5243 format!("did you mean `Self {{ /* fields */ }}`?"),
5250 (impl_def_id, self.tcx.types.err)
5255 let def_id = def.def_id();
5257 // The things we are substituting into the type should not contain
5258 // escaping late-bound regions, and nor should the base type scheme.
5259 let ty = self.tcx.type_of(def_id);
5264 let substs = AstConv::create_substs_for_generic_args(
5270 // Provide the generic args, and whether types should be inferred.
5272 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5275 // If we've encountered an `impl Trait`-related error, we're just
5276 // going to infer the arguments for better error messages.
5277 if !infer_args_for_err.contains(&index) {
5278 // Check whether the user has provided generic arguments.
5279 if let Some(ref data) = segments[index].args {
5280 return (Some(data), segments[index].infer_types);
5283 return (None, segments[index].infer_types);
5288 // Provide substitutions for parameters for which (valid) arguments have been provided.
5290 match (¶m.kind, arg) {
5291 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5292 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5294 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5295 self.to_ty(ty).into()
5297 _ => unreachable!(),
5300 // Provide substitutions for parameters for which arguments are inferred.
5301 |substs, param, infer_types| {
5303 GenericParamDefKind::Lifetime => {
5304 self.re_infer(span, Some(param)).unwrap().into()
5306 GenericParamDefKind::Type { has_default, .. } => {
5307 if !infer_types && has_default {
5308 // If we have a default, then we it doesn't matter that we're not
5309 // inferring the type arguments: we provide the default where any
5311 let default = self.tcx.type_of(param.def_id);
5314 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5317 // If no type arguments were provided, we have to infer them.
5318 // This case also occurs as a result of some malformed input, e.g.
5319 // a lifetime argument being given instead of a type parameter.
5320 // Using inference instead of `Error` gives better error messages.
5321 self.var_for_def(span, param)
5327 assert!(!substs.has_escaping_bound_vars());
5328 assert!(!ty.has_escaping_bound_vars());
5330 // First, store the "user substs" for later.
5331 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
5332 self.write_user_substs_from_substs(hir_id, substs, user_self_ty);
5334 // Add all the obligations that are required, substituting and
5335 // normalized appropriately.
5336 let bounds = self.instantiate_bounds(span, def_id, &substs);
5337 self.add_obligations_for_parameters(
5338 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5341 // Substitute the values for the type parameters into the type of
5342 // the referenced item.
5343 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5345 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5346 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5347 // is inherent, there is no `Self` parameter, instead, the impl needs
5348 // type parameters, which we can infer by unifying the provided `Self`
5349 // with the substituted impl type.
5350 let ty = self.tcx.type_of(impl_def_id);
5352 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5353 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5354 Ok(ok) => self.register_infer_ok_obligations(ok),
5357 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5364 self.check_rustc_args_require_const(def_id, node_id, span);
5366 debug!("instantiate_value_path: type of {:?} is {:?}",
5369 self.write_substs(hir_id, substs);
5371 (ty_substituted, new_def)
5374 fn check_rustc_args_require_const(&self,
5376 node_id: ast::NodeId,
5378 // We're only interested in functions tagged with
5379 // #[rustc_args_required_const], so ignore anything that's not.
5380 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5384 // If our calling expression is indeed the function itself, we're good!
5385 // If not, generate an error that this can only be called directly.
5386 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
5387 if let hir::ExprKind::Call(ref callee, ..) = expr.node {
5388 if callee.id == node_id {
5394 self.tcx.sess.span_err(span, "this function can only be invoked \
5395 directly, not through a function pointer");
5398 // Resolves `typ` by a single level if `typ` is a type variable.
5399 // If no resolution is possible, then an error is reported.
5400 // Numeric inference variables may be left unresolved.
5401 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5402 let ty = self.resolve_type_vars_with_obligations(ty);
5403 if !ty.is_ty_var() {
5406 if !self.is_tainted_by_errors() {
5407 self.need_type_info_err((**self).body_id, sp, ty)
5408 .note("type must be known at this point")
5411 self.demand_suptype(sp, self.tcx.types.err, ty);
5416 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5417 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5418 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5421 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5422 index = enclosing_breakables.stack.len();
5423 enclosing_breakables.by_id.insert(id, index);
5424 enclosing_breakables.stack.push(ctxt);
5428 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5429 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5430 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5431 enclosing_breakables.stack.pop().expect("missing breakable context")
5437 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5438 generics: &ty::Generics,
5440 let own_counts = generics.own_counts();
5441 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5443 if own_counts.types == 0 {
5446 // Make a vector of booleans initially false, set to true when used.
5447 let mut types_used = vec![false; own_counts.types];
5449 for leaf_ty in ty.walk() {
5450 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5451 debug!("Found use of ty param num {}", idx);
5452 types_used[idx as usize - own_counts.lifetimes] = true;
5453 } else if let ty::Error = leaf_ty.sty {
5454 // If there is already another error, do not emit
5455 // an error for not using a type Parameter.
5456 assert!(tcx.sess.err_count() > 0);
5461 let types = generics.params.iter().filter(|param| match param.kind {
5462 ty::GenericParamDefKind::Type { .. } => true,
5465 for (&used, param) in types_used.iter().zip(types) {
5467 let id = tcx.hir().as_local_node_id(param.def_id).unwrap();
5468 let span = tcx.hir().span(id);
5469 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5470 .span_label(span, "unused type parameter")
5476 fn fatally_break_rust(sess: &Session) {
5477 let handler = sess.diagnostic();
5478 handler.span_bug_no_panic(
5480 "It looks like you're trying to break rust; would you like some ICE?",
5482 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5483 handler.note_without_error(
5484 "we would appreciate a joke overview: \
5485 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5487 handler.note_without_error(&format!("rustc {} running on {}",
5488 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5489 ::session::config::host_triple(),
5493 fn potentially_plural_count(count: usize, word: &str) -> String {
5494 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })