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
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 N.B.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
92 use namespace::Namespace;
93 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
94 use rustc::infer::opaque_types::OpaqueTypeDecl;
95 use rustc::infer::type_variable::{TypeVariableOrigin};
96 use rustc::middle::region;
97 use rustc::mir::interpret::{ConstValue, GlobalId};
98 use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
99 UserSelfTy, UserSubsts};
100 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
101 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
102 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
103 use rustc::ty::fold::TypeFoldable;
104 use rustc::ty::query::Providers;
105 use rustc::ty::util::{Representability, IntTypeExt, Discr};
106 use rustc::ty::layout::VariantIdx;
107 use rustc_data_structures::indexed_vec::Idx;
108 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
110 use require_c_abi_if_variadic;
111 use session::{CompileIncomplete, config, Session};
114 use util::common::{ErrorReported, indenter};
115 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
117 use std::cell::{Cell, RefCell, Ref, RefMut};
118 use rustc_data_structures::sync::Lrc;
119 use std::collections::hash_map::Entry;
121 use std::fmt::Display;
123 use std::mem::replace;
124 use std::ops::{self, Deref};
125 use rustc_target::spec::abi::Abi;
128 use syntax::source_map::DUMMY_SP;
129 use syntax::source_map::original_sp;
130 use syntax::feature_gate::{GateIssue, emit_feature_err};
132 use syntax::symbol::{Symbol, LocalInternedString, keywords};
133 use syntax::util::lev_distance::find_best_match_for_name;
134 use syntax_pos::{self, BytePos, Span, MultiSpan};
136 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
137 use rustc::hir::itemlikevisit::ItemLikeVisitor;
138 use rustc::hir::Node;
139 use rustc::hir::{self, PatKind, ItemKind};
140 use rustc::middle::lang_items;
156 mod generator_interior;
160 /// The type of a local binding, including the revealed type for anon types.
161 #[derive(Copy, Clone)]
162 pub struct LocalTy<'tcx> {
164 revealed_ty: Ty<'tcx>
167 /// A wrapper for InferCtxt's `in_progress_tables` field.
168 #[derive(Copy, Clone)]
169 struct MaybeInProgressTables<'a, 'tcx: 'a> {
170 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
173 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
174 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
175 match self.maybe_tables {
176 Some(tables) => tables.borrow(),
178 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
183 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
184 match self.maybe_tables {
185 Some(tables) => tables.borrow_mut(),
187 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
193 /// closures defined within the function. For example:
196 /// bar(move|| { ... })
199 /// Here, the function `foo()` and the closure passed to
200 /// `bar()` will each have their own `FnCtxt`, but they will
201 /// share the inherited fields.
202 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
203 infcx: InferCtxt<'a, 'gcx, 'tcx>,
205 tables: MaybeInProgressTables<'a, 'tcx>,
207 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
209 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
211 // Some additional `Sized` obligations badly affect type inference.
212 // These obligations are added in a later stage of typeck.
213 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
215 // When we process a call like `c()` where `c` is a closure type,
216 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
217 // `FnOnce` closure. In that case, we defer full resolution of the
218 // call until upvar inference can kick in and make the
219 // decision. We keep these deferred resolutions grouped by the
220 // def-id of the closure, so that once we decide, we can easily go
221 // back and process them.
222 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
224 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
226 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
228 // Opaque types found in explicit return types and their
229 // associated fresh inference variable. Writeback resolves these
230 // variables to get the concrete type, which can be used to
231 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
232 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
234 /// Each type parameter has an implicit region bound that
235 /// indicates it must outlive at least the function body (the user
236 /// may specify stronger requirements). This field indicates the
237 /// region of the callee. If it is `None`, then the parameter
238 /// environment is for an item or something where the "callee" is
240 implicit_region_bound: Option<ty::Region<'tcx>>,
242 body_id: Option<hir::BodyId>,
245 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
246 type Target = InferCtxt<'a, 'gcx, 'tcx>;
247 fn deref(&self) -> &Self::Target {
252 /// When type-checking an expression, we propagate downward
253 /// whatever type hint we are able in the form of an `Expectation`.
254 #[derive(Copy, Clone, Debug)]
255 pub enum Expectation<'tcx> {
256 /// We know nothing about what type this expression should have.
259 /// This expression is an `if` condition, it must resolve to `bool`.
262 /// This expression should have the type given (or some subtype)
263 ExpectHasType(Ty<'tcx>),
265 /// This expression will be cast to the `Ty`
266 ExpectCastableToType(Ty<'tcx>),
268 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
269 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
270 ExpectRvalueLikeUnsized(Ty<'tcx>),
273 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
274 // Disregard "castable to" expectations because they
275 // can lead us astray. Consider for example `if cond
276 // {22} else {c} as u8` -- if we propagate the
277 // "castable to u8" constraint to 22, it will pick the
278 // type 22u8, which is overly constrained (c might not
279 // be a u8). In effect, the problem is that the
280 // "castable to" expectation is not the tightest thing
281 // we can say, so we want to drop it in this case.
282 // The tightest thing we can say is "must unify with
283 // else branch". Note that in the case of a "has type"
284 // constraint, this limitation does not hold.
286 // If the expected type is just a type variable, then don't use
287 // an expected type. Otherwise, we might write parts of the type
288 // when checking the 'then' block which are incompatible with the
290 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
292 ExpectHasType(ety) => {
293 let ety = fcx.shallow_resolve(ety);
294 if !ety.is_ty_var() {
300 ExpectRvalueLikeUnsized(ety) => {
301 ExpectRvalueLikeUnsized(ety)
307 /// Provide an expectation for an rvalue expression given an *optional*
308 /// hint, which is not required for type safety (the resulting type might
309 /// be checked higher up, as is the case with `&expr` and `box expr`), but
310 /// is useful in determining the concrete type.
312 /// The primary use case is where the expected type is a fat pointer,
313 /// like `&[isize]`. For example, consider the following statement:
315 /// let x: &[isize] = &[1, 2, 3];
317 /// In this case, the expected type for the `&[1, 2, 3]` expression is
318 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
319 /// expectation `ExpectHasType([isize])`, that would be too strong --
320 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
321 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
322 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
323 /// which still is useful, because it informs integer literals and the like.
324 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
325 /// for examples of where this comes up,.
326 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
327 match fcx.tcx.struct_tail(ty).sty {
328 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
329 ExpectRvalueLikeUnsized(ty)
331 _ => ExpectHasType(ty)
335 // Resolves `expected` by a single level if it is a variable. If
336 // there is no expected type or resolution is not possible (e.g.,
337 // no constraints yet present), just returns `None`.
338 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
340 NoExpectation => NoExpectation,
341 ExpectIfCondition => ExpectIfCondition,
342 ExpectCastableToType(t) => {
343 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
345 ExpectHasType(t) => {
346 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
348 ExpectRvalueLikeUnsized(t) => {
349 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
354 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
355 match self.resolve(fcx) {
356 NoExpectation => None,
357 ExpectIfCondition => Some(fcx.tcx.types.bool),
358 ExpectCastableToType(ty) |
360 ExpectRvalueLikeUnsized(ty) => Some(ty),
364 /// It sometimes happens that we want to turn an expectation into
365 /// a **hard constraint** (i.e., something that must be satisfied
366 /// for the program to type-check). `only_has_type` will return
367 /// such a constraint, if it exists.
368 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
369 match self.resolve(fcx) {
370 ExpectHasType(ty) => Some(ty),
371 ExpectIfCondition => Some(fcx.tcx.types.bool),
372 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
376 /// Like `only_has_type`, but instead of returning `None` if no
377 /// hard constraint exists, creates a fresh type variable.
378 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
379 self.only_has_type(fcx)
380 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
384 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
391 fn maybe_mut_place(m: hir::Mutability) -> Self {
393 hir::MutMutable => Needs::MutPlace,
394 hir::MutImmutable => Needs::None,
399 #[derive(Copy, Clone)]
400 pub struct UnsafetyState {
401 pub def: ast::NodeId,
402 pub unsafety: hir::Unsafety,
403 pub unsafe_push_count: u32,
408 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
409 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
412 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
413 match self.unsafety {
414 // If this unsafe, then if the outer function was already marked as
415 // unsafe we shouldn't attribute the unsafe'ness to the block. This
416 // way the block can be warned about instead of ignoring this
417 // extraneous block (functions are never warned about).
418 hir::Unsafety::Unsafe if self.from_fn => *self,
421 let (unsafety, def, count) = match blk.rules {
422 hir::PushUnsafeBlock(..) =>
423 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
424 hir::PopUnsafeBlock(..) =>
425 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
426 hir::UnsafeBlock(..) =>
427 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
429 (unsafety, self.def, self.unsafe_push_count),
433 unsafe_push_count: count,
440 #[derive(Debug, Copy, Clone)]
446 /// Tracks whether executing a node may exit normally (versus
447 /// return/break/panic, which "diverge", leaving dead code in their
448 /// wake). Tracked semi-automatically (through type variables marked
449 /// as diverging), with some manual adjustments for control-flow
450 /// primitives (approximating a CFG).
451 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
453 /// Potentially unknown, some cases converge,
454 /// others require a CFG to determine them.
457 /// Definitely known to diverge and therefore
458 /// not reach the next sibling or its parent.
461 /// Same as `Always` but with a reachability
462 /// warning already emitted
466 // Convenience impls for combinig `Diverges`.
468 impl ops::BitAnd for Diverges {
470 fn bitand(self, other: Self) -> Self {
471 cmp::min(self, other)
475 impl ops::BitOr for Diverges {
477 fn bitor(self, other: Self) -> Self {
478 cmp::max(self, other)
482 impl ops::BitAndAssign for Diverges {
483 fn bitand_assign(&mut self, other: Self) {
484 *self = *self & other;
488 impl ops::BitOrAssign for Diverges {
489 fn bitor_assign(&mut self, other: Self) {
490 *self = *self | other;
495 fn always(self) -> bool {
496 self >= Diverges::Always
500 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
503 // this is `null` for loops where break with a value is illegal,
504 // such as `while`, `for`, and `while let`
505 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
508 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
509 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
510 by_id: NodeMap<usize>,
513 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
514 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
515 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
516 bug!("could not find enclosing breakable with id {}", target_id);
523 struct PathSeg(DefId, usize);
525 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
526 body_id: ast::NodeId,
528 /// The parameter environment used for proving trait obligations
529 /// in this function. This can change when we descend into
530 /// closures (as they bring new things into scope), hence it is
531 /// not part of `Inherited` (as of the time of this writing,
532 /// closures do not yet change the environment, but they will
534 param_env: ty::ParamEnv<'tcx>,
536 // Number of errors that had been reported when we started
537 // checking this function. On exit, if we find that *more* errors
538 // have been reported, we will skip regionck and other work that
539 // expects the types within the function to be consistent.
540 err_count_on_creation: usize,
542 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
544 yield_ty: Option<Ty<'tcx>>,
546 ps: RefCell<UnsafetyState>,
548 /// Whether the last checked node generates a divergence (e.g.,
549 /// `return` will set this to Always). In general, when entering
550 /// an expression or other node in the tree, the initial value
551 /// indicates whether prior parts of the containing expression may
552 /// have diverged. It is then typically set to `Maybe` (and the
553 /// old value remembered) for processing the subparts of the
554 /// current expression. As each subpart is processed, they may set
555 /// the flag to `Always` etc. Finally, at the end, we take the
556 /// result and "union" it with the original value, so that when we
557 /// return the flag indicates if any subpart of the parent
558 /// expression (up to and including this part) has diverged. So,
559 /// if you read it after evaluating a subexpression `X`, the value
560 /// you get indicates whether any subexpression that was
561 /// evaluating up to and including `X` diverged.
563 /// We currently use this flag only for diagnostic purposes:
565 /// - To warn about unreachable code: if, after processing a
566 /// sub-expression but before we have applied the effects of the
567 /// current node, we see that the flag is set to `Always`, we
568 /// can issue a warning. This corresponds to something like
569 /// `foo(return)`; we warn on the `foo()` expression. (We then
570 /// update the flag to `WarnedAlways` to suppress duplicate
571 /// reports.) Similarly, if we traverse to a fresh statement (or
572 /// tail expression) from a `Always` setting, we will issue a
573 /// warning. This corresponds to something like `{return;
574 /// foo();}` or `{return; 22}`, where we would warn on the
577 /// An expression represents dead-code if, after checking it,
578 /// the diverges flag is set to something other than `Maybe`.
579 diverges: Cell<Diverges>,
581 /// Whether any child nodes have any type errors.
582 has_errors: Cell<bool>,
584 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
586 inh: &'a Inherited<'a, 'gcx, 'tcx>,
589 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
590 type Target = Inherited<'a, 'gcx, 'tcx>;
591 fn deref(&self) -> &Self::Target {
596 /// Helper type of a temporary returned by Inherited::build(...).
597 /// Necessary because we can't write the following bound:
598 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
599 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
600 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
604 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
605 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
606 -> InheritedBuilder<'a, 'gcx, 'tcx> {
607 let hir_id_root = if def_id.is_local() {
608 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
609 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
610 DefId::local(hir_id.owner)
616 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
622 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
623 fn enter<F, R>(&'tcx mut self, f: F) -> R
624 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
626 let def_id = self.def_id;
627 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
631 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
632 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
634 let item_id = tcx.hir.as_local_node_id(def_id);
635 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
636 let implicit_region_bound = body_id.map(|body_id| {
637 let body = tcx.hir.body(body_id);
638 tcx.mk_region(ty::ReScope(region::Scope {
639 id: body.value.hir_id.local_id,
640 data: region::ScopeData::CallSite
645 tables: MaybeInProgressTables {
646 maybe_tables: infcx.in_progress_tables,
649 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
650 locals: RefCell::new(Default::default()),
651 deferred_sized_obligations: RefCell::new(Vec::new()),
652 deferred_call_resolutions: RefCell::new(Default::default()),
653 deferred_cast_checks: RefCell::new(Vec::new()),
654 deferred_generator_interiors: RefCell::new(Vec::new()),
655 opaque_types: RefCell::new(Default::default()),
656 implicit_region_bound,
661 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
662 debug!("register_predicate({:?})", obligation);
663 if obligation.has_escaping_bound_vars() {
664 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
669 .register_predicate_obligation(self, obligation);
672 fn register_predicates<I>(&self, obligations: I)
673 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
675 for obligation in obligations {
676 self.register_predicate(obligation);
680 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
681 self.register_predicates(infer_ok.obligations);
685 fn normalize_associated_types_in<T>(&self,
687 body_id: ast::NodeId,
688 param_env: ty::ParamEnv<'tcx>,
690 where T : TypeFoldable<'tcx>
692 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
693 self.register_infer_ok_obligations(ok)
697 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
699 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
700 fn visit_item(&mut self, i: &'tcx hir::Item) {
701 check_item_type(self.tcx, i);
703 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
704 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
707 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
708 tcx.sess.track_errors(|| {
709 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
710 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
714 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
715 tcx.sess.track_errors(|| {
716 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
720 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
721 tcx.typeck_item_bodies(LOCAL_CRATE)
724 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
725 -> Result<(), CompileIncomplete>
727 debug_assert!(crate_num == LOCAL_CRATE);
728 Ok(tcx.sess.track_errors(|| {
729 tcx.par_body_owners(|body_owner_def_id| {
730 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
735 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
736 wfcheck::check_item_well_formed(tcx, def_id);
739 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
740 wfcheck::check_trait_item(tcx, def_id);
743 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
744 wfcheck::check_impl_item(tcx, def_id);
747 pub fn provide(providers: &mut Providers) {
748 method::provide(providers);
749 *providers = Providers {
755 check_item_well_formed,
756 check_trait_item_well_formed,
757 check_impl_item_well_formed,
762 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
764 -> Option<ty::Destructor> {
765 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
768 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
769 /// with information about it's body-id and fn-decl (if any). Otherwise,
772 /// If this function returns "some", then `typeck_tables(def_id)` will
773 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
774 /// may not succeed. In some cases where this function returns `None`
775 /// (notably closures), `typeck_tables(def_id)` would wind up
776 /// redirecting to the owning function.
777 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
779 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
781 match tcx.hir.get(id) {
782 Node::Item(item) => {
784 hir::ItemKind::Const(_, body) |
785 hir::ItemKind::Static(_, _, body) =>
787 hir::ItemKind::Fn(ref decl, .., body) =>
788 Some((body, Some(decl))),
793 Node::TraitItem(item) => {
795 hir::TraitItemKind::Const(_, Some(body)) =>
797 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
798 Some((body, Some(&sig.decl))),
803 Node::ImplItem(item) => {
805 hir::ImplItemKind::Const(_, body) =>
807 hir::ImplItemKind::Method(ref sig, body) =>
808 Some((body, Some(&sig.decl))),
813 Node::AnonConst(constant) => Some((constant.body, None)),
818 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
821 // Closures' tables come from their outermost function,
822 // as they are part of the same "inference environment".
823 let outer_def_id = tcx.closure_base_def_id(def_id);
824 if outer_def_id != def_id {
825 return tcx.has_typeck_tables(outer_def_id);
828 let id = tcx.hir.as_local_node_id(def_id).unwrap();
829 primary_body_of(tcx, id).is_some()
832 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
835 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
838 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
840 -> &'tcx ty::TypeckTables<'tcx> {
841 // Closures' tables come from their outermost function,
842 // as they are part of the same "inference environment".
843 let outer_def_id = tcx.closure_base_def_id(def_id);
844 if outer_def_id != def_id {
845 return tcx.typeck_tables_of(outer_def_id);
848 let id = tcx.hir.as_local_node_id(def_id).unwrap();
849 let span = tcx.hir.span(id);
851 // Figure out what primary body this item has.
852 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
853 span_bug!(span, "can't type-check body of {:?}", def_id);
855 let body = tcx.hir.body(body_id);
857 let tables = Inherited::build(tcx, def_id).enter(|inh| {
858 let param_env = tcx.param_env(def_id);
859 let fcx = if let Some(decl) = fn_decl {
860 let fn_sig = tcx.fn_sig(def_id);
862 check_abi(tcx, span, fn_sig.abi());
864 // Compute the fty from point of view of inside the fn.
866 tcx.liberate_late_bound_regions(def_id, &fn_sig);
868 inh.normalize_associated_types_in(body.value.span,
873 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
876 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
877 let expected_type = tcx.type_of(def_id);
878 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
879 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
881 let revealed_ty = if tcx.features().impl_trait_in_bindings {
882 fcx.instantiate_opaque_types_from_value(
890 // Gather locals in statics (because of block expressions).
891 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
893 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
898 // All type checking constraints were added, try to fallback unsolved variables.
899 fcx.select_obligations_where_possible(false);
900 let mut fallback_has_occurred = false;
901 for ty in &fcx.unsolved_variables() {
902 fallback_has_occurred |= fcx.fallback_if_possible(ty);
904 fcx.select_obligations_where_possible(fallback_has_occurred);
906 // Even though coercion casts provide type hints, we check casts after fallback for
907 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
910 // Closure and generator analysis may run after fallback
911 // because they don't constrain other type variables.
912 fcx.closure_analyze(body);
913 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
914 fcx.resolve_generator_interiors(def_id);
916 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
917 fcx.require_type_is_sized(ty, span, code);
919 fcx.select_all_obligations_or_error();
921 if fn_decl.is_some() {
922 fcx.regionck_fn(id, body);
924 fcx.regionck_expr(body);
927 fcx.resolve_type_vars_in_body(body)
930 // Consistency check our TypeckTables instance can hold all ItemLocalIds
931 // it will need to hold.
932 assert_eq!(tables.local_id_root,
933 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
937 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
938 if !tcx.sess.target.target.is_abi_supported(abi) {
939 struct_span_err!(tcx.sess, span, E0570,
940 "The ABI `{}` is not supported for the current target", abi).emit()
944 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
945 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
946 parent_id: ast::NodeId,
949 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
950 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
953 // infer the variable's type
954 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
955 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
962 // take type that the user specified
963 self.fcx.locals.borrow_mut().insert(nid, typ);
970 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
971 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
972 NestedVisitorMap::None
975 // Add explicitly-declared locals.
976 fn visit_local(&mut self, local: &'gcx hir::Local) {
977 let local_ty = match local.ty {
979 let o_ty = self.fcx.to_ty(&ty);
981 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
982 self.fcx.instantiate_opaque_types_from_value(
990 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(&revealed_ty);
991 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
992 ty.hir_id, o_ty, revealed_ty, c_ty);
993 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
995 Some(LocalTy { decl_ty: o_ty, revealed_ty })
999 self.assign(local.span, local.id, local_ty);
1001 debug!("Local variable {:?} is assigned type {}",
1003 self.fcx.ty_to_string(
1004 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
1005 intravisit::walk_local(self, local);
1008 // Add pattern bindings.
1009 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1010 if let PatKind::Binding(_, _, ident, _) = p.node {
1011 let var_ty = self.assign(p.span, p.id, None);
1013 if !self.fcx.tcx.features().unsized_locals {
1014 self.fcx.require_type_is_sized(var_ty, p.span,
1015 traits::VariableType(p.id));
1018 debug!("Pattern binding {} is assigned to {} with type {:?}",
1020 self.fcx.ty_to_string(
1021 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1024 intravisit::walk_pat(self, p);
1027 // Don't descend into the bodies of nested closures
1028 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1029 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1032 /// When `check_fn` is invoked on a generator (i.e., a body that
1033 /// includes yield), it returns back some information about the yield
1035 struct GeneratorTypes<'tcx> {
1036 /// Type of value that is yielded.
1037 yield_ty: ty::Ty<'tcx>,
1039 /// Types that are captured (see `GeneratorInterior` for more).
1040 interior: ty::Ty<'tcx>,
1042 /// Indicates if the generator is movable or static (immovable)
1043 movability: hir::GeneratorMovability,
1046 /// Helper used for fns and closures. Does the grungy work of checking a function
1047 /// body and returns the function context used for that purpose, since in the case of a fn item
1048 /// there is still a bit more to do.
1051 /// * inherited: other fields inherited from the enclosing fn (if any)
1052 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1053 param_env: ty::ParamEnv<'tcx>,
1054 fn_sig: ty::FnSig<'tcx>,
1055 decl: &'gcx hir::FnDecl,
1057 body: &'gcx hir::Body,
1058 can_be_generator: Option<hir::GeneratorMovability>)
1059 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1061 let mut fn_sig = fn_sig.clone();
1063 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1065 // Create the function context. This is either derived from scratch or,
1066 // in the case of closures, based on the outer context.
1067 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1068 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1070 let declared_ret_ty = fn_sig.output();
1071 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1072 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1073 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1074 fn_sig = fcx.tcx.mk_fn_sig(
1075 fn_sig.inputs().iter().cloned(),
1082 let span = body.value.span;
1084 if body.is_generator && can_be_generator.is_some() {
1085 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1086 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1087 fcx.yield_ty = Some(yield_ty);
1090 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir.local_def_id(fn_id));
1091 let outer_node_id = fcx.tcx.hir.as_local_node_id(outer_def_id).unwrap();
1092 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1094 // Add formal parameters.
1095 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1096 // Check the pattern.
1097 fcx.check_pat_walk(&arg.pat, arg_ty,
1098 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1100 // Check that argument is Sized.
1101 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1102 // for simple cases like `fn foo(x: Trait)`,
1103 // where we would error once on the parameter as a whole, and once on the binding `x`.
1104 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1105 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1108 fcx.write_ty(arg.hir_id, arg_ty);
1111 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1112 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1114 fcx.check_return_expr(&body.value);
1116 // We insert the deferred_generator_interiors entry after visiting the body.
1117 // This ensures that all nested generators appear before the entry of this generator.
1118 // resolve_generator_interiors relies on this property.
1119 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1120 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1121 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1122 Some(GeneratorTypes {
1123 yield_ty: fcx.yield_ty.unwrap(),
1125 movability: can_be_generator.unwrap(),
1131 // Finalize the return check by taking the LUB of the return types
1132 // we saw and assigning it to the expected return type. This isn't
1133 // really expected to fail, since the coercions would have failed
1134 // earlier when trying to find a LUB.
1136 // However, the behavior around `!` is sort of complex. In the
1137 // event that the `actual_return_ty` comes back as `!`, that
1138 // indicates that the fn either does not return or "returns" only
1139 // values of type `!`. In this case, if there is an expected
1140 // return type that is *not* `!`, that should be ok. But if the
1141 // return type is being inferred, we want to "fallback" to `!`:
1143 // let x = move || panic!();
1145 // To allow for that, I am creating a type variable with diverging
1146 // fallback. This was deemed ever so slightly better than unifying
1147 // the return value with `!` because it allows for the caller to
1148 // make more assumptions about the return type (e.g., they could do
1150 // let y: Option<u32> = Some(x());
1152 // which would then cause this return type to become `u32`, not
1154 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1155 let mut actual_return_ty = coercion.complete(&fcx);
1156 if actual_return_ty.is_never() {
1157 actual_return_ty = fcx.next_diverging_ty_var(
1158 TypeVariableOrigin::DivergingFn(span));
1160 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1162 // Check that the main return type implements the termination trait.
1163 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1164 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1166 if let config::EntryFnType::Main = entry_type {
1167 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1168 let trait_ref = ty::TraitRef::new(term_id, substs);
1169 let return_ty_span = decl.output.span();
1170 let cause = traits::ObligationCause::new(
1171 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1173 inherited.register_predicate(
1174 traits::Obligation::new(
1175 cause, param_env, trait_ref.to_predicate()));
1181 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1182 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1183 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1184 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1185 // at this point we don't care if there are duplicate handlers or if the handler has
1186 // the wrong signature as this value we'll be used when writing metadata and that
1187 // only happens if compilation succeeded
1188 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1190 if declared_ret_ty.sty != ty::Never {
1191 fcx.tcx.sess.span_err(
1193 "return type should be `!`",
1197 let inputs = fn_sig.inputs();
1198 let span = fcx.tcx.hir.span(fn_id);
1199 if inputs.len() == 1 {
1200 let arg_is_panic_info = match inputs[0].sty {
1201 ty::Ref(region, ty, mutbl) => match ty.sty {
1202 ty::Adt(ref adt, _) => {
1203 adt.did == panic_info_did &&
1204 mutbl == hir::Mutability::MutImmutable &&
1205 *region != RegionKind::ReStatic
1212 if !arg_is_panic_info {
1213 fcx.tcx.sess.span_err(
1214 decl.inputs[0].span,
1215 "argument should be `&PanicInfo`",
1219 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1220 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1221 if !generics.params.is_empty() {
1222 fcx.tcx.sess.span_err(
1224 "should have no type parameters",
1230 let span = fcx.tcx.sess.source_map().def_span(span);
1231 fcx.tcx.sess.span_err(span, "function should have one argument");
1234 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1239 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1240 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1241 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1242 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1243 if declared_ret_ty.sty != ty::Never {
1244 fcx.tcx.sess.span_err(
1246 "return type should be `!`",
1250 let inputs = fn_sig.inputs();
1251 let span = fcx.tcx.hir.span(fn_id);
1252 if inputs.len() == 1 {
1253 let arg_is_alloc_layout = match inputs[0].sty {
1254 ty::Adt(ref adt, _) => {
1255 adt.did == alloc_layout_did
1260 if !arg_is_alloc_layout {
1261 fcx.tcx.sess.span_err(
1262 decl.inputs[0].span,
1263 "argument should be `Layout`",
1267 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1268 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1269 if !generics.params.is_empty() {
1270 fcx.tcx.sess.span_err(
1272 "`#[alloc_error_handler]` function should have no type \
1279 let span = fcx.tcx.sess.source_map().def_span(span);
1280 fcx.tcx.sess.span_err(span, "function should have one argument");
1283 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1291 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1294 let def_id = tcx.hir.local_def_id(id);
1295 let def = tcx.adt_def(def_id);
1296 def.destructor(tcx); // force the destructor to be evaluated
1297 check_representable(tcx, span, def_id);
1299 if def.repr.simd() {
1300 check_simd(tcx, span, def_id);
1303 check_transparent(tcx, span, def_id);
1304 check_packed(tcx, span, def_id);
1307 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1310 let def_id = tcx.hir.local_def_id(id);
1311 let def = tcx.adt_def(def_id);
1312 def.destructor(tcx); // force the destructor to be evaluated
1313 check_representable(tcx, span, def_id);
1315 check_packed(tcx, span, def_id);
1318 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1320 "check_item_type(it.id={}, it.name={})",
1322 tcx.item_path_str(tcx.hir.local_def_id(it.id))
1324 let _indenter = indenter();
1326 // Consts can play a role in type-checking, so they are included here.
1327 hir::ItemKind::Static(..) => {
1328 let def_id = tcx.hir.local_def_id(it.id);
1329 tcx.typeck_tables_of(def_id);
1330 maybe_check_static_with_link_section(tcx, def_id, it.span);
1332 hir::ItemKind::Const(..) => {
1333 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1335 hir::ItemKind::Enum(ref enum_definition, _) => {
1336 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1338 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1339 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1340 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1341 let impl_def_id = tcx.hir.local_def_id(it.id);
1342 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1343 check_impl_items_against_trait(
1350 let trait_def_id = impl_trait_ref.def_id;
1351 check_on_unimplemented(tcx, trait_def_id, it);
1354 hir::ItemKind::Trait(..) => {
1355 let def_id = tcx.hir.local_def_id(it.id);
1356 check_on_unimplemented(tcx, def_id, it);
1358 hir::ItemKind::Struct(..) => {
1359 check_struct(tcx, it.id, it.span);
1361 hir::ItemKind::Union(..) => {
1362 check_union(tcx, it.id, it.span);
1364 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1365 let def_id = tcx.hir.local_def_id(it.id);
1366 let pty_ty = tcx.type_of(def_id);
1367 let generics = tcx.generics_of(def_id);
1368 check_bounds_are_used(tcx, &generics, pty_ty);
1370 hir::ItemKind::ForeignMod(ref m) => {
1371 check_abi(tcx, it.span, m.abi);
1373 if m.abi == Abi::RustIntrinsic {
1374 for item in &m.items {
1375 intrinsic::check_intrinsic_type(tcx, item);
1377 } else if m.abi == Abi::PlatformIntrinsic {
1378 for item in &m.items {
1379 intrinsic::check_platform_intrinsic_type(tcx, item);
1382 for item in &m.items {
1383 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1384 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1385 let mut err = struct_span_err!(
1389 "foreign items may not have type parameters"
1391 err.span_label(item.span, "can't have type parameters");
1392 // FIXME: once we start storing spans for type arguments, turn this into a
1395 "use specialization instead of type parameters by replacing them \
1396 with concrete types like `u32`",
1401 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1402 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1407 _ => { /* nothing to do */ }
1411 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1412 // Only restricted on wasm32 target for now
1413 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1417 // If `#[link_section]` is missing, then nothing to verify
1418 let attrs = tcx.codegen_fn_attrs(id);
1419 if attrs.link_section.is_none() {
1423 // For the wasm32 target statics with #[link_section] are placed into custom
1424 // sections of the final output file, but this isn't link custom sections of
1425 // other executable formats. Namely we can only embed a list of bytes,
1426 // nothing with pointers to anything else or relocations. If any relocation
1427 // show up, reject them here.
1428 let instance = ty::Instance::mono(tcx, id);
1429 let cid = GlobalId {
1433 let param_env = ty::ParamEnv::reveal_all();
1434 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1435 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1438 bug!("Matching on non-ByRef static")
1440 if alloc.relocations.len() != 0 {
1441 let msg = "statics with a custom `#[link_section]` must be a \
1442 simple list of bytes on the wasm target with no \
1443 extra levels of indirection such as references";
1444 tcx.sess.span_err(span, msg);
1449 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1450 trait_def_id: DefId,
1452 let item_def_id = tcx.hir.local_def_id(item.id);
1453 // an error would be reported if this fails.
1454 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1457 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1458 impl_item: &hir::ImplItem,
1461 let mut err = struct_span_err!(
1462 tcx.sess, impl_item.span, E0520,
1463 "`{}` specializes an item from a parent `impl`, but \
1464 that item is not marked `default`",
1466 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1469 match tcx.span_of_impl(parent_impl) {
1471 err.span_label(span, "parent `impl` is here");
1472 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1476 err.note(&format!("parent implementation is in crate `{}`", cname));
1483 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1484 trait_def: &ty::TraitDef,
1485 trait_item: &ty::AssociatedItem,
1487 impl_item: &hir::ImplItem)
1489 let ancestors = trait_def.ancestors(tcx, impl_id);
1491 let kind = match impl_item.node {
1492 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1493 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1494 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1495 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1498 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1499 .map(|node_item| node_item.map(|parent| parent.defaultness));
1501 if let Some(parent) = parent {
1502 if tcx.impl_item_is_final(&parent) {
1503 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1509 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1512 impl_trait_ref: ty::TraitRef<'tcx>,
1513 impl_item_refs: &[hir::ImplItemRef]) {
1514 let impl_span = tcx.sess.source_map().def_span(impl_span);
1516 // If the trait reference itself is erroneous (so the compilation is going
1517 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1518 // isn't populated for such impls.
1519 if impl_trait_ref.references_error() { return; }
1521 // Locate trait definition and items
1522 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1523 let mut overridden_associated_type = None;
1525 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1527 // Check existing impl methods to see if they are both present in trait
1528 // and compatible with trait signature
1529 for impl_item in impl_items() {
1530 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1531 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1532 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1533 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1535 // Not compatible, but needed for the error message
1536 tcx.associated_items(impl_trait_ref.def_id)
1537 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1540 // Check that impl definition matches trait definition
1541 if let Some(ty_trait_item) = ty_trait_item {
1542 match impl_item.node {
1543 hir::ImplItemKind::Const(..) => {
1544 // Find associated const definition.
1545 if ty_trait_item.kind == ty::AssociatedKind::Const {
1546 compare_const_impl(tcx,
1552 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1553 "item `{}` is an associated const, \
1554 which doesn't match its trait `{}`",
1557 err.span_label(impl_item.span, "does not match trait");
1558 // We can only get the spans from local trait definition
1559 // Same for E0324 and E0325
1560 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1561 err.span_label(trait_span, "item in trait");
1566 hir::ImplItemKind::Method(..) => {
1567 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1568 if ty_trait_item.kind == ty::AssociatedKind::Method {
1569 compare_impl_method(tcx,
1576 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1577 "item `{}` is an associated method, \
1578 which doesn't match its trait `{}`",
1581 err.span_label(impl_item.span, "does not match trait");
1582 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1583 err.span_label(trait_span, "item in trait");
1588 hir::ImplItemKind::Existential(..) |
1589 hir::ImplItemKind::Type(_) => {
1590 if ty_trait_item.kind == ty::AssociatedKind::Type {
1591 if ty_trait_item.defaultness.has_value() {
1592 overridden_associated_type = Some(impl_item);
1595 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1596 "item `{}` is an associated type, \
1597 which doesn't match its trait `{}`",
1600 err.span_label(impl_item.span, "does not match trait");
1601 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1602 err.span_label(trait_span, "item in trait");
1609 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1613 // Check for missing items from trait
1614 let mut missing_items = Vec::new();
1615 let mut invalidated_items = Vec::new();
1616 let associated_type_overridden = overridden_associated_type.is_some();
1617 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1618 let is_implemented = trait_def.ancestors(tcx, impl_id)
1619 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1621 .map(|node_item| !node_item.node.is_from_trait())
1624 if !is_implemented && !tcx.impl_is_default(impl_id) {
1625 if !trait_item.defaultness.has_value() {
1626 missing_items.push(trait_item);
1627 } else if associated_type_overridden {
1628 invalidated_items.push(trait_item.ident);
1633 if !missing_items.is_empty() {
1634 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1635 "not all trait items implemented, missing: `{}`",
1636 missing_items.iter()
1637 .map(|trait_item| trait_item.ident.to_string())
1638 .collect::<Vec<_>>().join("`, `"));
1639 err.span_label(impl_span, format!("missing `{}` in implementation",
1640 missing_items.iter()
1641 .map(|trait_item| trait_item.ident.to_string())
1642 .collect::<Vec<_>>().join("`, `")));
1643 for trait_item in missing_items {
1644 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1645 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1647 err.note_trait_signature(trait_item.ident.to_string(),
1648 trait_item.signature(&tcx));
1654 if !invalidated_items.is_empty() {
1655 let invalidator = overridden_associated_type.unwrap();
1656 span_err!(tcx.sess, invalidator.span, E0399,
1657 "the following trait items need to be reimplemented \
1658 as `{}` was overridden: `{}`",
1660 invalidated_items.iter()
1661 .map(|name| name.to_string())
1662 .collect::<Vec<_>>().join("`, `"))
1666 /// Checks whether a type can be represented in memory. In particular, it
1667 /// identifies types that contain themselves without indirection through a
1668 /// pointer, which would mean their size is unbounded.
1669 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1673 let rty = tcx.type_of(item_def_id);
1675 // Check that it is possible to represent this type. This call identifies
1676 // (1) types that contain themselves and (2) types that contain a different
1677 // recursive type. It is only necessary to throw an error on those that
1678 // contain themselves. For case 2, there must be an inner type that will be
1679 // caught by case 1.
1680 match rty.is_representable(tcx, sp) {
1681 Representability::SelfRecursive(spans) => {
1682 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1684 err.span_label(span, "recursive without indirection");
1689 Representability::Representable | Representability::ContainsRecursive => (),
1694 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1695 let t = tcx.type_of(def_id);
1696 if let ty::Adt(def, substs) = t.sty {
1697 if def.is_struct() {
1698 let fields = &def.non_enum_variant().fields;
1699 if fields.is_empty() {
1700 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1703 let e = fields[0].ty(tcx, substs);
1704 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1705 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1706 .span_label(sp, "SIMD elements must have the same type")
1711 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1712 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1714 span_err!(tcx.sess, sp, E0077,
1715 "SIMD vector element type should be machine type");
1723 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1724 let repr = tcx.adt_def(def_id).repr;
1726 for attr in tcx.get_attrs(def_id).iter() {
1727 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1728 if let attr::ReprPacked(pack) = r {
1729 if pack != repr.pack {
1730 struct_span_err!(tcx.sess, sp, E0634,
1731 "type has conflicting packed representation hints").emit();
1737 struct_span_err!(tcx.sess, sp, E0587,
1738 "type has conflicting packed and align representation hints").emit();
1740 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1741 struct_span_err!(tcx.sess, sp, E0588,
1742 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1747 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1749 stack: &mut Vec<DefId>) -> bool {
1750 let t = tcx.type_of(def_id);
1751 if stack.contains(&def_id) {
1752 debug!("check_packed_inner: {:?} is recursive", t);
1755 if let ty::Adt(def, substs) = t.sty {
1756 if def.is_struct() || def.is_union() {
1757 if tcx.adt_def(def.did).repr.align > 0 {
1760 // push struct def_id before checking fields
1762 for field in &def.non_enum_variant().fields {
1763 let f = field.ty(tcx, substs);
1764 if let ty::Adt(def, _) = f.sty {
1765 if check_packed_inner(tcx, def.did, stack) {
1770 // only need to pop if not early out
1777 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1778 let adt = tcx.adt_def(def_id);
1779 if !adt.repr.transparent() {
1783 // For each field, figure out if it's known to be a ZST and align(1)
1784 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1785 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1786 let param_env = tcx.param_env(field.did);
1787 let layout = tcx.layout_of(param_env.and(ty));
1788 // We are currently checking the type this field came from, so it must be local
1789 let span = tcx.hir.span_if_local(field.did).unwrap();
1790 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1791 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1795 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1796 let non_zst_count = non_zst_fields.clone().count();
1797 if non_zst_count != 1 {
1798 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1799 struct_span_err!(tcx.sess, sp, E0690,
1800 "transparent struct needs exactly one non-zero-sized field, but has {}",
1802 .span_note(field_spans, "non-zero-sized field")
1805 for (span, zst, align1) in field_infos {
1807 span_err!(tcx.sess, span, E0691,
1808 "zero-sized field in transparent struct has alignment larger than 1");
1813 #[allow(trivial_numeric_casts)]
1814 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1816 vs: &'tcx [hir::Variant],
1818 let def_id = tcx.hir.local_def_id(id);
1819 let def = tcx.adt_def(def_id);
1820 def.destructor(tcx); // force the destructor to be evaluated
1823 let attributes = tcx.get_attrs(def_id);
1824 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1826 tcx.sess, attr.span, E0084,
1827 "unsupported representation for zero-variant enum")
1828 .span_label(sp, "zero-variant enum")
1833 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1834 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1835 if !tcx.features().repr128 {
1836 emit_feature_err(&tcx.sess.parse_sess,
1839 GateIssue::Language,
1840 "repr with 128-bit type is unstable");
1845 if let Some(ref e) = v.node.disr_expr {
1846 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1850 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1851 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1852 // Check for duplicate discriminant values
1853 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1854 let variant_did = def.variants[VariantIdx::new(i)].did;
1855 let variant_i_node_id = tcx.hir.as_local_node_id(variant_did).unwrap();
1856 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1857 let i_span = match variant_i.node.disr_expr {
1858 Some(ref expr) => tcx.hir.span(expr.id),
1859 None => tcx.hir.span(variant_i_node_id)
1861 let span = match v.node.disr_expr {
1862 Some(ref expr) => tcx.hir.span(expr.id),
1865 struct_span_err!(tcx.sess, span, E0081,
1866 "discriminant value `{}` already exists", disr_vals[i])
1867 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1868 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1871 disr_vals.push(discr);
1874 check_representable(tcx, sp, def_id);
1877 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1878 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1880 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1881 -> Lrc<ty::GenericPredicates<'tcx>>
1884 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1885 let item_id = tcx.hir.ty_param_owner(node_id);
1886 let item_def_id = tcx.hir.local_def_id(item_id);
1887 let generics = tcx.generics_of(item_def_id);
1888 let index = generics.param_def_id_to_index[&def_id];
1889 Lrc::new(ty::GenericPredicates {
1891 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1893 ty::Predicate::Trait(ref data)
1894 if data.skip_binder().self_ty().is_param(index) => {
1895 // HACK(eddyb) should get the original `Span`.
1896 let span = tcx.def_span(def_id);
1897 Some((predicate, span))
1905 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1906 -> Option<ty::Region<'tcx>> {
1908 Some(def) => infer::EarlyBoundRegion(span, def.name),
1909 None => infer::MiscVariable(span)
1911 Some(self.next_region_var(v))
1914 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1915 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1918 fn ty_infer_for_def(&self,
1919 ty_param_def: &ty::GenericParamDef,
1920 span: Span) -> Ty<'tcx> {
1921 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1927 fn projected_ty_from_poly_trait_ref(&self,
1930 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1933 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1935 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1939 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1942 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1943 if ty.has_escaping_bound_vars() {
1944 ty // FIXME: normalization and escaping regions
1946 self.normalize_associated_types_in(span, &ty)
1950 fn set_tainted_by_errors(&self) {
1951 self.infcx.set_tainted_by_errors()
1954 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1955 self.write_ty(hir_id, ty)
1959 /// Controls whether the arguments are tupled. This is used for the call
1962 /// Tupling means that all call-side arguments are packed into a tuple and
1963 /// passed as a single parameter. For example, if tupling is enabled, this
1966 /// fn f(x: (isize, isize))
1968 /// Can be called as:
1975 #[derive(Clone, Eq, PartialEq)]
1976 enum TupleArgumentsFlag {
1981 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1982 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1983 param_env: ty::ParamEnv<'tcx>,
1984 body_id: ast::NodeId)
1985 -> FnCtxt<'a, 'gcx, 'tcx> {
1989 err_count_on_creation: inh.tcx.sess.err_count(),
1992 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1993 ast::CRATE_NODE_ID)),
1994 diverges: Cell::new(Diverges::Maybe),
1995 has_errors: Cell::new(false),
1996 enclosing_breakables: RefCell::new(EnclosingBreakables {
1998 by_id: Default::default(),
2004 pub fn sess(&self) -> &Session {
2008 pub fn err_count_since_creation(&self) -> usize {
2009 self.tcx.sess.err_count() - self.err_count_on_creation
2012 /// Produce warning on the given node, if the current point in the
2013 /// function is unreachable, and there hasn't been another warning.
2014 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2015 if self.diverges.get() == Diverges::Always {
2016 self.diverges.set(Diverges::WarnedAlways);
2018 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2020 self.tcx().lint_node(
2021 lint::builtin::UNREACHABLE_CODE,
2023 &format!("unreachable {}", kind));
2029 code: ObligationCauseCode<'tcx>)
2030 -> ObligationCause<'tcx> {
2031 ObligationCause::new(span, self.body_id, code)
2034 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2035 self.cause(span, ObligationCauseCode::MiscObligation)
2038 /// Resolves type variables in `ty` if possible. Unlike the infcx
2039 /// version (resolve_type_vars_if_possible), this version will
2040 /// also select obligations if it seems useful, in an effort
2041 /// to get more type information.
2042 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2043 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2045 // No Infer()? Nothing needs doing.
2046 if !ty.has_infer_types() {
2047 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2051 // If `ty` is a type variable, see whether we already know what it is.
2052 ty = self.resolve_type_vars_if_possible(&ty);
2053 if !ty.has_infer_types() {
2054 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2058 // If not, try resolving pending obligations as much as
2059 // possible. This can help substantially when there are
2060 // indirect dependencies that don't seem worth tracking
2062 self.select_obligations_where_possible(false);
2063 ty = self.resolve_type_vars_if_possible(&ty);
2065 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2069 fn record_deferred_call_resolution(&self,
2070 closure_def_id: DefId,
2071 r: DeferredCallResolution<'gcx, 'tcx>) {
2072 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2073 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2076 fn remove_deferred_call_resolutions(&self,
2077 closure_def_id: DefId)
2078 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2080 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2081 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2084 pub fn tag(&self) -> String {
2085 let self_ptr: *const FnCtxt = self;
2086 format!("{:?}", self_ptr)
2089 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2090 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2091 span_bug!(span, "no type for local variable {}",
2092 self.tcx.hir.node_to_string(nid))
2097 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2098 debug!("write_ty({:?}, {:?}) in fcx {}",
2099 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2100 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2102 if ty.references_error() {
2103 self.has_errors.set(true);
2104 self.set_tainted_by_errors();
2108 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2109 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2110 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2113 // The NodeId and the ItemLocalId must identify the same item. We just pass
2114 // both of them for consistency checking.
2115 pub fn write_method_call(&self,
2117 method: MethodCallee<'tcx>) {
2118 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2121 .type_dependent_defs_mut()
2122 .insert(hir_id, Def::Method(method.def_id));
2124 self.write_substs(hir_id, method.substs);
2126 // When the method is confirmed, the `method.substs` includes
2127 // parameters from not just the method, but also the impl of
2128 // the method -- in particular, the `Self` type will be fully
2129 // resolved. However, those are not something that the "user
2130 // specified" -- i.e., those types come from the inferred type
2131 // of the receiver, not something the user wrote. So when we
2132 // create the user-substs, we want to replace those earlier
2133 // types with just the types that the user actually wrote --
2134 // that is, those that appear on the *method itself*.
2136 // As an example, if the user wrote something like
2137 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2138 // type of `foo` (possibly adjusted), but we don't want to
2139 // include that. We want just the `[_, u32]` part.
2140 if !method.substs.is_noop() {
2141 let method_generics = self.tcx.generics_of(method.def_id);
2142 if !method_generics.params.is_empty() {
2143 let user_substs = self.infcx.probe(|_| {
2144 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2145 let i = param.index as usize;
2146 if i < method_generics.parent_count {
2147 self.infcx.var_for_def(DUMMY_SP, param)
2152 self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2153 substs: just_method_substs,
2154 user_self_ty: None, // not relevant here
2158 debug!("write_method_call: user_substs = {:?}", user_substs);
2159 self.write_user_substs(hir_id, user_substs);
2164 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2165 if !substs.is_noop() {
2166 debug!("write_substs({:?}, {:?}) in fcx {}",
2171 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2175 /// Given the substs that we just converted from the HIR, try to
2176 /// canonicalize them and store them as user-given substitutions
2177 /// (i.e., substitutions that must be respected by the NLL check).
2179 /// This should be invoked **before any unifications have
2180 /// occurred**, so that annotations like `Vec<_>` are preserved
2182 pub fn write_user_substs_from_substs(
2185 substs: &'tcx Substs<'tcx>,
2186 user_self_ty: Option<UserSelfTy<'tcx>>,
2189 "write_user_substs_from_substs({:?}, {:?}) in fcx {}",
2195 if !substs.is_noop() {
2196 let user_substs = self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2200 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2201 self.write_user_substs(hir_id, user_substs);
2205 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalUserSubsts<'tcx>) {
2207 "write_user_substs({:?}, {:?}) in fcx {}",
2213 if !substs.is_identity() {
2214 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2216 debug!("write_user_substs: skipping identity substs");
2220 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2221 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2227 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2228 Entry::Vacant(entry) => { entry.insert(adj); },
2229 Entry::Occupied(mut entry) => {
2230 debug!(" - composing on top of {:?}", entry.get());
2231 match (&entry.get()[..], &adj[..]) {
2232 // Applying any adjustment on top of a NeverToAny
2233 // is a valid NeverToAny adjustment, because it can't
2235 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2237 Adjustment { kind: Adjust::Deref(_), .. },
2238 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2240 Adjustment { kind: Adjust::Deref(_), .. },
2241 .. // Any following adjustments are allowed.
2243 // A reborrow has no effect before a dereference.
2245 // FIXME: currently we never try to compose autoderefs
2246 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2248 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2249 expr, entry.get(), adj)
2251 *entry.get_mut() = adj;
2256 /// Basically whenever we are converting from a type scheme into
2257 /// the fn body space, we always want to normalize associated
2258 /// types as well. This function combines the two.
2259 fn instantiate_type_scheme<T>(&self,
2261 substs: &Substs<'tcx>,
2264 where T : TypeFoldable<'tcx>
2266 let value = value.subst(self.tcx, substs);
2267 let result = self.normalize_associated_types_in(span, &value);
2268 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2275 /// As `instantiate_type_scheme`, but for the bounds found in a
2276 /// generic type scheme.
2277 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2278 -> ty::InstantiatedPredicates<'tcx> {
2279 let bounds = self.tcx.predicates_of(def_id);
2280 let result = bounds.instantiate(self.tcx, substs);
2281 let result = self.normalize_associated_types_in(span, &result);
2282 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2289 /// Replace the opaque types from the given value with type variables,
2290 /// and records the `OpaqueTypeMap` for later use during writeback. See
2291 /// `InferCtxt::instantiate_opaque_types` for more details.
2292 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2294 parent_id: ast::NodeId,
2297 let parent_def_id = self.tcx.hir.local_def_id(parent_id);
2298 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2302 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2303 self.instantiate_opaque_types(
2311 let mut opaque_types = self.opaque_types.borrow_mut();
2312 for (ty, decl) in opaque_type_map {
2313 let old_value = opaque_types.insert(ty, decl);
2314 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2320 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2321 where T : TypeFoldable<'tcx>
2323 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2326 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2328 where T : TypeFoldable<'tcx>
2330 self.inh.partially_normalize_associated_types_in(span,
2336 pub fn require_type_meets(&self,
2339 code: traits::ObligationCauseCode<'tcx>,
2342 self.register_bound(
2345 traits::ObligationCause::new(span, self.body_id, code));
2348 pub fn require_type_is_sized(&self,
2351 code: traits::ObligationCauseCode<'tcx>)
2353 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2354 self.require_type_meets(ty, span, code, lang_item);
2357 pub fn require_type_is_sized_deferred(&self,
2360 code: traits::ObligationCauseCode<'tcx>)
2362 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2365 pub fn register_bound(&self,
2368 cause: traits::ObligationCause<'tcx>)
2370 self.fulfillment_cx.borrow_mut()
2371 .register_bound(self, self.param_env, ty, def_id, cause);
2374 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2375 let t = AstConv::ast_ty_to_ty(self, ast_t);
2376 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2380 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2381 let ty = self.to_ty(ast_ty);
2383 // If the type given by the user has free regions, save it for
2384 // later, since NLL would like to enforce those. Also pass in
2385 // types that involve projections, since those can resolve to
2386 // `'static` bounds (modulo #54940, which hopefully will be
2387 // fixed by the time you see this comment, dear reader,
2388 // although I have my doubts). Other sorts of things are
2389 // already sufficiently enforced with erased regions. =)
2390 if ty.has_free_regions() || ty.has_projections() {
2391 let c_ty = self.infcx.canonicalize_response(&ty);
2392 self.tables.borrow_mut().user_provided_tys_mut().insert(ast_ty.hir_id, c_ty);
2398 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2399 match self.tables.borrow().node_types().get(id) {
2401 None if self.is_tainted_by_errors() => self.tcx.types.err,
2403 let node_id = self.tcx.hir.hir_to_node_id(id);
2404 bug!("no type for node {}: {} in fcx {}",
2405 node_id, self.tcx.hir.node_to_string(node_id),
2411 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2412 /// outlive the region `r`.
2413 pub fn register_wf_obligation(&self,
2416 code: traits::ObligationCauseCode<'tcx>)
2418 // WF obligations never themselves fail, so no real need to give a detailed cause:
2419 let cause = traits::ObligationCause::new(span, self.body_id, code);
2420 self.register_predicate(traits::Obligation::new(cause,
2422 ty::Predicate::WellFormed(ty)));
2425 /// Registers obligations that all types appearing in `substs` are well-formed.
2426 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2427 for ty in substs.types() {
2428 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2432 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2433 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2434 /// trait/region obligations.
2436 /// For example, if there is a function:
2439 /// fn foo<'a,T:'a>(...)
2442 /// and a reference:
2448 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2449 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2450 pub fn add_obligations_for_parameters(&self,
2451 cause: traits::ObligationCause<'tcx>,
2452 predicates: &ty::InstantiatedPredicates<'tcx>)
2454 assert!(!predicates.has_escaping_bound_vars());
2456 debug!("add_obligations_for_parameters(predicates={:?})",
2459 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2460 self.register_predicate(obligation);
2464 // FIXME(arielb1): use this instead of field.ty everywhere
2465 // Only for fields! Returns <none> for methods>
2466 // Indifferent to privacy flags
2467 pub fn field_ty(&self,
2469 field: &'tcx ty::FieldDef,
2470 substs: &Substs<'tcx>)
2473 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2476 fn check_casts(&self) {
2477 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2478 for cast in deferred_cast_checks.drain(..) {
2483 fn resolve_generator_interiors(&self, def_id: DefId) {
2484 let mut generators = self.deferred_generator_interiors.borrow_mut();
2485 for (body_id, interior) in generators.drain(..) {
2486 self.select_obligations_where_possible(false);
2487 generator_interior::resolve_interior(self, def_id, body_id, interior);
2491 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2492 // Non-numerics get replaced with ! or () (depending on whether
2493 // feature(never_type) is enabled, unconstrained ints with i32,
2494 // unconstrained floats with f64.
2495 // Fallback becomes very dubious if we have encountered type-checking errors.
2496 // In that case, fallback to Error.
2497 // The return value indicates whether fallback has occurred.
2498 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2499 use rustc::ty::error::UnconstrainedNumeric::Neither;
2500 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2502 assert!(ty.is_ty_infer());
2503 let fallback = match self.type_is_unconstrained_numeric(ty) {
2504 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2505 UnconstrainedInt => self.tcx.types.i32,
2506 UnconstrainedFloat => self.tcx.types.f64,
2507 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2508 Neither => return false,
2510 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2511 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2515 fn select_all_obligations_or_error(&self) {
2516 debug!("select_all_obligations_or_error");
2517 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2518 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2522 /// Select as many obligations as we can at present.
2523 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2524 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2525 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2529 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2530 /// returns a type of `&T`, but the actual type we assign to the
2531 /// *expression* is `T`. So this function just peels off the return
2532 /// type by one layer to yield `T`.
2533 fn make_overloaded_place_return_type(&self,
2534 method: MethodCallee<'tcx>)
2535 -> ty::TypeAndMut<'tcx>
2537 // extract method return type, which will be &T;
2538 let ret_ty = method.sig.output();
2540 // method returns &T, but the type as visible to user is T, so deref
2541 ret_ty.builtin_deref(true).unwrap()
2544 fn lookup_indexing(&self,
2546 base_expr: &'gcx hir::Expr,
2550 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2552 // FIXME(#18741) -- this is almost but not quite the same as the
2553 // autoderef that normal method probing does. They could likely be
2556 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2557 let mut result = None;
2558 while result.is_none() && autoderef.next().is_some() {
2559 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2561 autoderef.finalize();
2565 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2566 /// (and otherwise adjust) `base_expr`, looking for a type which either
2567 /// supports builtin indexing or overloaded indexing.
2568 /// This loop implements one step in that search; the autoderef loop
2569 /// is implemented by `lookup_indexing`.
2570 fn try_index_step(&self,
2572 base_expr: &hir::Expr,
2573 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2576 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2578 let adjusted_ty = autoderef.unambiguous_final_ty();
2579 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2586 for &unsize in &[false, true] {
2587 let mut self_ty = adjusted_ty;
2589 // We only unsize arrays here.
2590 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2591 self_ty = self.tcx.mk_slice(element_ty);
2597 // If some lookup succeeds, write callee into table and extract index/element
2598 // type from the method signature.
2599 // If some lookup succeeded, install method in table
2600 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2601 let method = self.try_overloaded_place_op(
2602 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2604 let result = method.map(|ok| {
2605 debug!("try_index_step: success, using overloaded indexing");
2606 let method = self.register_infer_ok_obligations(ok);
2608 let mut adjustments = autoderef.adjust_steps(needs);
2609 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2610 let mutbl = match r_mutbl {
2611 hir::MutImmutable => AutoBorrowMutability::Immutable,
2612 hir::MutMutable => AutoBorrowMutability::Mutable {
2613 // Indexing can be desugared to a method call,
2614 // so maybe we could use two-phase here.
2615 // See the documentation of AllowTwoPhase for why that's
2616 // not the case today.
2617 allow_two_phase_borrow: AllowTwoPhase::No,
2620 adjustments.push(Adjustment {
2621 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2622 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2629 adjustments.push(Adjustment {
2630 kind: Adjust::Unsize,
2631 target: method.sig.inputs()[0]
2634 self.apply_adjustments(base_expr, adjustments);
2636 self.write_method_call(expr.hir_id, method);
2637 (input_ty, self.make_overloaded_place_return_type(method).ty)
2639 if result.is_some() {
2647 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2648 let (tr, name) = match (op, is_mut) {
2649 (PlaceOp::Deref, false) =>
2650 (self.tcx.lang_items().deref_trait(), "deref"),
2651 (PlaceOp::Deref, true) =>
2652 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2653 (PlaceOp::Index, false) =>
2654 (self.tcx.lang_items().index_trait(), "index"),
2655 (PlaceOp::Index, true) =>
2656 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2658 (tr, ast::Ident::from_str(name))
2661 fn try_overloaded_place_op(&self,
2664 arg_tys: &[Ty<'tcx>],
2667 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2669 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2675 // Try Mut first, if needed.
2676 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2677 let method = match (needs, mut_tr) {
2678 (Needs::MutPlace, Some(trait_did)) => {
2679 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2684 // Otherwise, fall back to the immutable version.
2685 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2686 let method = match (method, imm_tr) {
2687 (None, Some(trait_did)) => {
2688 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2690 (method, _) => method,
2696 fn check_method_argument_types(&self,
2699 method: Result<MethodCallee<'tcx>, ()>,
2700 args_no_rcvr: &'gcx [hir::Expr],
2701 tuple_arguments: TupleArgumentsFlag,
2702 expected: Expectation<'tcx>)
2704 let has_error = match method {
2706 method.substs.references_error() || method.sig.references_error()
2711 let err_inputs = self.err_args(args_no_rcvr.len());
2713 let err_inputs = match tuple_arguments {
2714 DontTupleArguments => err_inputs,
2715 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2718 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2719 false, tuple_arguments, None);
2720 return self.tcx.types.err;
2723 let method = method.unwrap();
2724 // HACK(eddyb) ignore self in the definition (see above).
2725 let expected_arg_tys = self.expected_inputs_for_expected_output(
2728 method.sig.output(),
2729 &method.sig.inputs()[1..]
2731 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2732 args_no_rcvr, method.sig.variadic, tuple_arguments,
2733 self.tcx.hir.span_if_local(method.def_id));
2737 /// Generic function that factors out common logic from function calls,
2738 /// method calls and overloaded operators.
2739 fn check_argument_types(&self,
2742 fn_inputs: &[Ty<'tcx>],
2743 mut expected_arg_tys: &[Ty<'tcx>],
2744 args: &'gcx [hir::Expr],
2746 tuple_arguments: TupleArgumentsFlag,
2747 def_span: Option<Span>) {
2750 // Grab the argument types, supplying fresh type variables
2751 // if the wrong number of arguments were supplied
2752 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2758 // All the input types from the fn signature must outlive the call
2759 // so as to validate implied bounds.
2760 for &fn_input_ty in fn_inputs {
2761 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2764 let expected_arg_count = fn_inputs.len();
2766 let param_count_error = |expected_count: usize,
2771 let mut err = tcx.sess.struct_span_err_with_code(sp,
2772 &format!("this function takes {}{} but {} {} supplied",
2773 if variadic {"at least "} else {""},
2774 potentially_plural_count(expected_count, "parameter"),
2775 potentially_plural_count(arg_count, "parameter"),
2776 if arg_count == 1 {"was"} else {"were"}),
2777 DiagnosticId::Error(error_code.to_owned()));
2779 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2780 err.span_label(def_s, "defined here");
2783 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2784 // remove closing `)` from the span
2785 let sugg_span = sugg_span.shrink_to_lo();
2786 err.span_suggestion_with_applicability(
2788 "expected the unit value `()`; create it with empty parentheses",
2790 Applicability::MachineApplicable);
2792 err.span_label(sp, format!("expected {}{}",
2793 if variadic {"at least "} else {""},
2794 potentially_plural_count(expected_count, "parameter")));
2799 let formal_tys = if tuple_arguments == TupleArguments {
2800 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2801 match tuple_type.sty {
2802 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2803 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2804 expected_arg_tys = &[];
2805 self.err_args(args.len())
2807 ty::Tuple(arg_types) => {
2808 expected_arg_tys = match expected_arg_tys.get(0) {
2809 Some(&ty) => match ty.sty {
2810 ty::Tuple(ref tys) => &tys,
2818 span_err!(tcx.sess, sp, E0059,
2819 "cannot use call notation; the first type parameter \
2820 for the function trait is neither a tuple nor unit");
2821 expected_arg_tys = &[];
2822 self.err_args(args.len())
2825 } else if expected_arg_count == supplied_arg_count {
2827 } else if variadic {
2828 if supplied_arg_count >= expected_arg_count {
2831 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2832 expected_arg_tys = &[];
2833 self.err_args(supplied_arg_count)
2836 // is the missing argument of type `()`?
2837 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2838 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2839 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2840 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2844 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2846 expected_arg_tys = &[];
2847 self.err_args(supplied_arg_count)
2849 // If there is no expectation, expect formal_tys.
2850 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2856 debug!("check_argument_types: formal_tys={:?}",
2857 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2859 // Check the arguments.
2860 // We do this in a pretty awful way: first we typecheck any arguments
2861 // that are not closures, then we typecheck the closures. This is so
2862 // that we have more information about the types of arguments when we
2863 // typecheck the functions. This isn't really the right way to do this.
2864 for &check_closures in &[false, true] {
2865 debug!("check_closures={}", check_closures);
2867 // More awful hacks: before we check argument types, try to do
2868 // an "opportunistic" vtable resolution of any trait bounds on
2869 // the call. This helps coercions.
2871 self.select_obligations_where_possible(false);
2874 // For variadic functions, we don't have a declared type for all of
2875 // the arguments hence we only do our usual type checking with
2876 // the arguments who's types we do know.
2877 let t = if variadic {
2879 } else if tuple_arguments == TupleArguments {
2884 for (i, arg) in args.iter().take(t).enumerate() {
2885 // Warn only for the first loop (the "no closures" one).
2886 // Closure arguments themselves can't be diverging, but
2887 // a previous argument can, e.g. `foo(panic!(), || {})`.
2888 if !check_closures {
2889 self.warn_if_unreachable(arg.id, arg.span, "expression");
2892 let is_closure = match arg.node {
2893 hir::ExprKind::Closure(..) => true,
2897 if is_closure != check_closures {
2901 debug!("checking the argument");
2902 let formal_ty = formal_tys[i];
2904 // The special-cased logic below has three functions:
2905 // 1. Provide as good of an expected type as possible.
2906 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2908 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2910 // 2. Coerce to the most detailed type that could be coerced
2911 // to, which is `expected_ty` if `rvalue_hint` returns an
2912 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2913 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2914 // We're processing function arguments so we definitely want to use
2915 // two-phase borrows.
2916 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2918 // 3. Relate the expected type and the formal one,
2919 // if the expected type was used for the coercion.
2920 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2924 // We also need to make sure we at least write the ty of the other
2925 // arguments which we skipped above.
2927 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2928 use structured_errors::{VariadicError, StructuredDiagnostic};
2929 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2932 for arg in args.iter().skip(expected_arg_count) {
2933 let arg_ty = self.check_expr(&arg);
2935 // There are a few types which get autopromoted when passed via varargs
2936 // in C but we just error out instead and require explicit casts.
2937 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2939 ty::Float(ast::FloatTy::F32) => {
2940 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2942 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2943 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2945 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2946 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2949 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2950 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2951 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2959 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2960 vec![self.tcx.types.err; len]
2963 // AST fragment checking
2966 expected: Expectation<'tcx>)
2972 ast::LitKind::Str(..) => tcx.mk_static_str(),
2973 ast::LitKind::ByteStr(ref v) => {
2974 tcx.mk_imm_ref(tcx.types.re_static,
2975 tcx.mk_array(tcx.types.u8, v.len() as u64))
2977 ast::LitKind::Byte(_) => tcx.types.u8,
2978 ast::LitKind::Char(_) => tcx.types.char,
2979 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2980 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2981 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2982 let opt_ty = expected.to_option(self).and_then(|ty| {
2984 ty::Int(_) | ty::Uint(_) => Some(ty),
2985 ty::Char => Some(tcx.types.u8),
2986 ty::RawPtr(..) => Some(tcx.types.usize),
2987 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2991 opt_ty.unwrap_or_else(
2992 || tcx.mk_int_var(self.next_int_var_id()))
2994 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2995 ast::LitKind::FloatUnsuffixed(_) => {
2996 let opt_ty = expected.to_option(self).and_then(|ty| {
2998 ty::Float(_) => Some(ty),
3002 opt_ty.unwrap_or_else(
3003 || tcx.mk_float_var(self.next_float_var_id()))
3005 ast::LitKind::Bool(_) => tcx.types.bool
3009 fn check_expr_eq_type(&self,
3010 expr: &'gcx hir::Expr,
3011 expected: Ty<'tcx>) {
3012 let ty = self.check_expr_with_hint(expr, expected);
3013 self.demand_eqtype(expr.span, expected, ty);
3016 pub fn check_expr_has_type_or_error(&self,
3017 expr: &'gcx hir::Expr,
3018 expected: Ty<'tcx>) -> Ty<'tcx> {
3019 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3022 fn check_expr_meets_expectation_or_error(&self,
3023 expr: &'gcx hir::Expr,
3024 expected: Expectation<'tcx>) -> Ty<'tcx> {
3025 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3026 let mut ty = self.check_expr_with_expectation(expr, expected);
3028 // While we don't allow *arbitrary* coercions here, we *do* allow
3029 // coercions from ! to `expected`.
3031 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3032 "expression with never type wound up being adjusted");
3033 let adj_ty = self.next_diverging_ty_var(
3034 TypeVariableOrigin::AdjustmentType(expr.span));
3035 self.apply_adjustments(expr, vec![Adjustment {
3036 kind: Adjust::NeverToAny,
3042 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3043 // Add help to type error if this is an `if` condition with an assignment
3044 if let (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs))
3045 = (expected, &expr.node)
3047 let msg = "try comparing for equality";
3048 if let (Ok(left), Ok(right)) = (
3049 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3050 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3052 err.span_suggestion_with_applicability(
3055 format!("{} == {}", left, right),
3056 Applicability::MaybeIncorrect);
3066 fn check_expr_coercable_to_type(&self,
3067 expr: &'gcx hir::Expr,
3068 expected: Ty<'tcx>) -> Ty<'tcx> {
3069 let ty = self.check_expr_with_hint(expr, expected);
3070 // checks don't need two phase
3071 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3074 fn check_expr_with_hint(&self,
3075 expr: &'gcx hir::Expr,
3076 expected: Ty<'tcx>) -> Ty<'tcx> {
3077 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3080 fn check_expr_with_expectation(&self,
3081 expr: &'gcx hir::Expr,
3082 expected: Expectation<'tcx>) -> Ty<'tcx> {
3083 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3086 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3087 self.check_expr_with_expectation(expr, NoExpectation)
3090 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3091 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3094 // determine the `self` type, using fresh variables for all variables
3095 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3096 // would return ($0, $1) where $0 and $1 are freshly instantiated type
3098 pub fn impl_self_ty(&self,
3099 span: Span, // (potential) receiver for this impl
3101 -> TypeAndSubsts<'tcx> {
3102 let ity = self.tcx.type_of(did);
3103 debug!("impl_self_ty: ity={:?}", ity);
3105 let substs = self.fresh_substs_for_item(span, did);
3106 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3108 TypeAndSubsts { substs: substs, ty: substd_ty }
3111 /// Unifies the output type with the expected type early, for more coercions
3112 /// and forward type information on the input expressions.
3113 fn expected_inputs_for_expected_output(&self,
3115 expected_ret: Expectation<'tcx>,
3116 formal_ret: Ty<'tcx>,
3117 formal_args: &[Ty<'tcx>])
3119 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3120 let ret_ty = match expected_ret.only_has_type(self) {
3122 None => return Vec::new()
3124 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3125 // Attempt to apply a subtyping relationship between the formal
3126 // return type (likely containing type variables if the function
3127 // is polymorphic) and the expected return type.
3128 // No argument expectations are produced if unification fails.
3129 let origin = self.misc(call_span);
3130 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3132 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3133 // to identity so the resulting type is not constrained.
3136 // Process any obligations locally as much as
3137 // we can. We don't care if some things turn
3138 // out unconstrained or ambiguous, as we're
3139 // just trying to get hints here.
3140 self.save_and_restore_in_snapshot_flag(|_| {
3141 let mut fulfill = TraitEngine::new(self.tcx);
3142 for obligation in ok.obligations {
3143 fulfill.register_predicate_obligation(self, obligation);
3145 fulfill.select_where_possible(self)
3146 }).map_err(|_| ())?;
3148 Err(_) => return Err(()),
3151 // Record all the argument types, with the substitutions
3152 // produced from the above subtyping unification.
3153 Ok(formal_args.iter().map(|ty| {
3154 self.resolve_type_vars_if_possible(ty)
3156 }).unwrap_or_default();
3157 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3158 formal_args, formal_ret,
3159 expect_args, expected_ret);
3163 // Checks a method call.
3164 fn check_method_call(&self,
3165 expr: &'gcx hir::Expr,
3166 segment: &hir::PathSegment,
3168 args: &'gcx [hir::Expr],
3169 expected: Expectation<'tcx>,
3170 needs: Needs) -> Ty<'tcx> {
3171 let rcvr = &args[0];
3172 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3173 // no need to check for bot/err -- callee does that
3174 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3176 let method = match self.lookup_method(rcvr_t,
3182 self.write_method_call(expr.hir_id, method);
3186 if segment.ident.name != keywords::Invalid.name() {
3187 self.report_method_error(span,
3198 // Call the generic checker.
3199 self.check_method_argument_types(span,
3207 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3211 .unwrap_or_else(|| span_bug!(return_expr.span,
3212 "check_return_expr called outside fn body"));
3214 let ret_ty = ret_coercion.borrow().expected_ty();
3215 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3216 ret_coercion.borrow_mut()
3218 &self.cause(return_expr.span,
3219 ObligationCauseCode::ReturnType(return_expr.id)),
3224 // A generic function for checking the then and else in an if
3226 fn check_then_else(&self,
3227 cond_expr: &'gcx hir::Expr,
3228 then_expr: &'gcx hir::Expr,
3229 opt_else_expr: Option<&'gcx hir::Expr>,
3231 expected: Expectation<'tcx>) -> Ty<'tcx> {
3232 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3233 let cond_diverges = self.diverges.get();
3234 self.diverges.set(Diverges::Maybe);
3236 let expected = expected.adjust_for_branches(self);
3237 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3238 let then_diverges = self.diverges.get();
3239 self.diverges.set(Diverges::Maybe);
3241 // We've already taken the expected type's preferences
3242 // into account when typing the `then` branch. To figure
3243 // out the initial shot at a LUB, we thus only consider
3244 // `expected` if it represents a *hard* constraint
3245 // (`only_has_type`); otherwise, we just go with a
3246 // fresh type variable.
3247 let coerce_to_ty = expected.coercion_target_type(self, sp);
3248 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3250 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3251 coerce.coerce(self, &if_cause, then_expr, then_ty);
3253 if let Some(else_expr) = opt_else_expr {
3254 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3255 let else_diverges = self.diverges.get();
3257 coerce.coerce(self, &if_cause, else_expr, else_ty);
3259 // We won't diverge unless both branches do (or the condition does).
3260 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3262 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3263 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3265 // If the condition is false we can't diverge.
3266 self.diverges.set(cond_diverges);
3269 let result_ty = coerce.complete(self);
3270 if cond_ty.references_error() {
3277 // Check field access expressions
3278 fn check_field(&self,
3279 expr: &'gcx hir::Expr,
3281 base: &'gcx hir::Expr,
3282 field: ast::Ident) -> Ty<'tcx> {
3283 let expr_t = self.check_expr_with_needs(base, needs);
3284 let expr_t = self.structurally_resolved_type(base.span,
3286 let mut private_candidate = None;
3287 let mut autoderef = self.autoderef(expr.span, expr_t);
3288 while let Some((base_t, _)) = autoderef.next() {
3290 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3291 debug!("struct named {:?}", base_t);
3292 let (ident, def_scope) =
3293 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3294 let fields = &base_def.non_enum_variant().fields;
3295 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3296 let field = &fields[index];
3297 let field_ty = self.field_ty(expr.span, field, substs);
3298 // Save the index of all fields regardless of their visibility in case
3299 // of error recovery.
3300 self.write_field_index(expr.id, index);
3301 if field.vis.is_accessible_from(def_scope, self.tcx) {
3302 let adjustments = autoderef.adjust_steps(needs);
3303 self.apply_adjustments(base, adjustments);
3304 autoderef.finalize();
3306 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3309 private_candidate = Some((base_def.did, field_ty));
3312 ty::Tuple(ref tys) => {
3313 let fstr = field.as_str();
3314 if let Ok(index) = fstr.parse::<usize>() {
3315 if fstr == index.to_string() {
3316 if let Some(field_ty) = tys.get(index) {
3317 let adjustments = autoderef.adjust_steps(needs);
3318 self.apply_adjustments(base, adjustments);
3319 autoderef.finalize();
3321 self.write_field_index(expr.id, index);
3330 autoderef.unambiguous_final_ty();
3332 if let Some((did, field_ty)) = private_candidate {
3333 let struct_path = self.tcx().item_path_str(did);
3334 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3335 "field `{}` of struct `{}` is private",
3336 field, struct_path);
3337 // Also check if an accessible method exists, which is often what is meant.
3338 if self.method_exists(field, expr_t, expr.id, false) {
3339 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3343 } else if field.name == keywords::Invalid.name() {
3344 self.tcx().types.err
3345 } else if self.method_exists(field, expr_t, expr.id, true) {
3346 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3347 "attempted to take value of method `{}` on type `{}`",
3349 .help("maybe a `()` to call it is missing?")
3351 self.tcx().types.err
3353 if !expr_t.is_primitive_ty() {
3354 let mut err = self.no_such_field_err(field.span, field, expr_t);
3357 ty::Adt(def, _) if !def.is_enum() => {
3358 if let Some(suggested_field_name) =
3359 Self::suggest_field_name(def.non_enum_variant(),
3360 &field.as_str(), vec![]) {
3361 err.span_label(field.span,
3362 format!("did you mean `{}`?", suggested_field_name));
3364 err.span_label(field.span, "unknown field");
3365 let struct_variant_def = def.non_enum_variant();
3366 let field_names = self.available_field_names(struct_variant_def);
3367 if !field_names.is_empty() {
3368 err.note(&format!("available fields are: {}",
3369 self.name_series_display(field_names)));
3373 ty::Array(_, len) => {
3374 if let (Some(len), Ok(user_index)) = (
3375 len.assert_usize(self.tcx),
3376 field.as_str().parse::<u64>()
3378 let base = self.tcx.hir.node_to_pretty_string(base.id);
3379 let help = "instead of using tuple indexing, use array indexing";
3380 let suggestion = format!("{}[{}]", base, field);
3381 let applicability = if len < user_index {
3382 Applicability::MachineApplicable
3384 Applicability::MaybeIncorrect
3386 err.span_suggestion_with_applicability(
3387 expr.span, help, suggestion, applicability
3392 let base = self.tcx.hir.node_to_pretty_string(base.id);
3393 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3394 let suggestion = format!("(*{}).{}", base, field);
3395 err.span_suggestion_with_applicability(
3399 Applicability::MaybeIncorrect,
3406 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3407 "`{}` is a primitive type and therefore doesn't have fields",
3410 self.tcx().types.err
3414 // Return an hint about the closest match in field names
3415 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3417 skip: Vec<LocalInternedString>)
3419 let names = variant.fields.iter().filter_map(|field| {
3420 // ignore already set fields and private fields from non-local crates
3421 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3422 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3425 Some(&field.ident.name)
3429 find_best_match_for_name(names, field, None)
3432 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3433 variant.fields.iter().filter(|field| {
3434 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3435 field.vis.is_accessible_from(def_scope, self.tcx)
3437 .map(|field| field.ident.name)
3441 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3442 // dynamic limit, to never omit just one field
3443 let limit = if names.len() == 6 { 6 } else { 5 };
3444 let mut display = names.iter().take(limit)
3445 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3446 if names.len() > limit {
3447 display = format!("{} ... and {} others", display, names.len() - limit);
3452 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3453 -> DiagnosticBuilder {
3454 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3455 "no field `{}` on type `{}`",
3459 fn report_unknown_field(&self,
3461 variant: &'tcx ty::VariantDef,
3463 skip_fields: &[hir::Field],
3465 let mut err = self.type_error_struct_with_diag(
3467 |actual| match ty.sty {
3468 ty::Adt(adt, ..) if adt.is_enum() => {
3469 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3470 "{} `{}::{}` has no field named `{}`",
3471 kind_name, actual, variant.name, field.ident)
3474 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3475 "{} `{}` has no field named `{}`",
3476 kind_name, actual, field.ident)
3480 // prevent all specified fields from being suggested
3481 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3482 if let Some(field_name) = Self::suggest_field_name(variant,
3483 &field.ident.as_str(),
3484 skip_fields.collect()) {
3485 err.span_label(field.ident.span,
3486 format!("field does not exist - did you mean `{}`?", field_name));
3489 ty::Adt(adt, ..) => {
3491 err.span_label(field.ident.span,
3492 format!("`{}::{}` does not have this field",
3495 err.span_label(field.ident.span,
3496 format!("`{}` does not have this field", ty));
3498 let available_field_names = self.available_field_names(variant);
3499 if !available_field_names.is_empty() {
3500 err.note(&format!("available fields are: {}",
3501 self.name_series_display(available_field_names)));
3504 _ => bug!("non-ADT passed to report_unknown_field")
3510 fn check_expr_struct_fields(&self,
3512 expected: Expectation<'tcx>,
3513 expr_id: ast::NodeId,
3515 variant: &'tcx ty::VariantDef,
3516 ast_fields: &'gcx [hir::Field],
3517 check_completeness: bool) -> bool {
3521 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3522 .get(0).cloned().unwrap_or(adt_ty);
3523 // re-link the regions that EIfEO can erase.
3524 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3526 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3527 &ty::Adt(adt, substs) => {
3528 (substs, adt.adt_kind(), adt.variant_descr())
3530 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3533 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3534 (field.ident.modern(), (i, field))
3535 ).collect::<FxHashMap<_, _>>();
3537 let mut seen_fields = FxHashMap::default();
3539 let mut error_happened = false;
3541 // Typecheck each field.
3542 for field in ast_fields {
3543 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3544 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3545 seen_fields.insert(ident, field.span);
3546 self.write_field_index(field.id, i);
3548 // we don't look at stability attributes on
3549 // struct-like enums (yet...), but it's definitely not
3550 // a bug to have construct one.
3551 if adt_kind != ty::AdtKind::Enum {
3552 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3555 self.field_ty(field.span, v_field, substs)
3557 error_happened = true;
3558 if let Some(prev_span) = seen_fields.get(&ident) {
3559 let mut err = struct_span_err!(self.tcx.sess,
3562 "field `{}` specified more than once",
3565 err.span_label(field.ident.span, "used more than once");
3566 err.span_label(*prev_span, format!("first use of `{}`", ident));
3570 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3576 // Make sure to give a type to the field even if there's
3577 // an error, so we can continue typechecking
3578 self.check_expr_coercable_to_type(&field.expr, field_type);
3581 // Make sure the programmer specified correct number of fields.
3582 if kind_name == "union" {
3583 if ast_fields.len() != 1 {
3584 tcx.sess.span_err(span, "union expressions should have exactly one field");
3586 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3587 let len = remaining_fields.len();
3589 let mut displayable_field_names = remaining_fields
3591 .map(|ident| ident.as_str())
3592 .collect::<Vec<_>>();
3594 displayable_field_names.sort();
3596 let truncated_fields_error = if len <= 3 {
3599 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3602 let remaining_fields_names = displayable_field_names.iter().take(3)
3603 .map(|n| format!("`{}`", n))
3604 .collect::<Vec<_>>()
3607 struct_span_err!(tcx.sess, span, E0063,
3608 "missing field{} {}{} in initializer of `{}`",
3609 if remaining_fields.len() == 1 { "" } else { "s" },
3610 remaining_fields_names,
3611 truncated_fields_error,
3613 .span_label(span, format!("missing {}{}",
3614 remaining_fields_names,
3615 truncated_fields_error))
3621 fn check_struct_fields_on_error(&self,
3622 fields: &'gcx [hir::Field],
3623 base_expr: &'gcx Option<P<hir::Expr>>) {
3624 for field in fields {
3625 self.check_expr(&field.expr);
3627 if let Some(ref base) = *base_expr {
3628 self.check_expr(&base);
3632 pub fn check_struct_path(&self,
3634 node_id: ast::NodeId)
3635 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3636 let path_span = match *qpath {
3637 hir::QPath::Resolved(_, ref path) => path.span,
3638 hir::QPath::TypeRelative(ref qself, _) => qself.span
3640 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3641 let variant = match def {
3643 self.set_tainted_by_errors();
3646 Def::Variant(..) => {
3648 ty::Adt(adt, substs) => {
3649 Some((adt.variant_of_def(def), adt.did, substs))
3651 _ => bug!("unexpected type: {:?}", ty.sty)
3654 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3655 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3657 ty::Adt(adt, substs) if !adt.is_enum() => {
3658 Some((adt.non_enum_variant(), adt.did, substs))
3663 _ => bug!("unexpected definition: {:?}", def)
3666 if let Some((variant, did, substs)) = variant {
3667 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3668 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
3669 self.write_user_substs_from_substs(hir_id, substs, None);
3671 // Check bounds on type arguments used in the path.
3672 let bounds = self.instantiate_bounds(path_span, did, substs);
3673 let cause = traits::ObligationCause::new(path_span, self.body_id,
3674 traits::ItemObligation(did));
3675 self.add_obligations_for_parameters(cause, &bounds);
3679 struct_span_err!(self.tcx.sess, path_span, E0071,
3680 "expected struct, variant or union type, found {}",
3681 ty.sort_string(self.tcx))
3682 .span_label(path_span, "not a struct")
3688 fn check_expr_struct(&self,
3690 expected: Expectation<'tcx>,
3692 fields: &'gcx [hir::Field],
3693 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3695 // Find the relevant variant
3696 let (variant, adt_ty) =
3697 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3700 self.check_struct_fields_on_error(fields, base_expr);
3701 return self.tcx.types.err;
3704 let path_span = match *qpath {
3705 hir::QPath::Resolved(_, ref path) => path.span,
3706 hir::QPath::TypeRelative(ref qself, _) => qself.span
3709 // Prohibit struct expressions when non exhaustive flag is set.
3710 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3711 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3712 span_err!(self.tcx.sess, expr.span, E0639,
3713 "cannot create non-exhaustive {} using struct expression",
3714 adt.variant_descr());
3717 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3718 variant, fields, base_expr.is_none());
3719 if let &Some(ref base_expr) = base_expr {
3720 // If check_expr_struct_fields hit an error, do not attempt to populate
3721 // the fields with the base_expr. This could cause us to hit errors later
3722 // when certain fields are assumed to exist that in fact do not.
3723 if !error_happened {
3724 self.check_expr_has_type_or_error(base_expr, adt_ty);
3726 ty::Adt(adt, substs) if adt.is_struct() => {
3727 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3728 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3733 .fru_field_types_mut()
3734 .insert(expr.hir_id, fru_field_types);
3737 span_err!(self.tcx.sess, base_expr.span, E0436,
3738 "functional record update syntax requires a struct");
3743 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3749 /// If an expression has any sub-expressions that result in a type error,
3750 /// inspecting that expression's type with `ty.references_error()` will return
3751 /// true. Likewise, if an expression is known to diverge, inspecting its
3752 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3753 /// strict, _|_ can appear in the type of an expression that does not,
3754 /// itself, diverge: for example, fn() -> _|_.)
3755 /// Note that inspecting a type's structure *directly* may expose the fact
3756 /// that there are actually multiple representations for `Error`, so avoid
3757 /// that when err needs to be handled differently.
3758 fn check_expr_with_expectation_and_needs(&self,
3759 expr: &'gcx hir::Expr,
3760 expected: Expectation<'tcx>,
3761 needs: Needs) -> Ty<'tcx> {
3762 debug!(">> typechecking: expr={:?} expected={:?}",
3765 // Warn for expressions after diverging siblings.
3766 self.warn_if_unreachable(expr.id, expr.span, "expression");
3768 // Hide the outer diverging and has_errors flags.
3769 let old_diverges = self.diverges.get();
3770 let old_has_errors = self.has_errors.get();
3771 self.diverges.set(Diverges::Maybe);
3772 self.has_errors.set(false);
3774 let ty = self.check_expr_kind(expr, expected, needs);
3776 // Warn for non-block expressions with diverging children.
3778 hir::ExprKind::Block(..) |
3779 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3780 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3782 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3785 // Any expression that produces a value of type `!` must have diverged
3787 self.diverges.set(self.diverges.get() | Diverges::Always);
3790 // Record the type, which applies it effects.
3791 // We need to do this after the warning above, so that
3792 // we don't warn for the diverging expression itself.
3793 self.write_ty(expr.hir_id, ty);
3795 // Combine the diverging and has_error flags.
3796 self.diverges.set(self.diverges.get() | old_diverges);
3797 self.has_errors.set(self.has_errors.get() | old_has_errors);
3799 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3800 debug!("... {:?}, expected is {:?}", ty, expected);
3807 expr: &'gcx hir::Expr,
3808 expected: Expectation<'tcx>,
3812 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3821 hir::ExprKind::Box(ref subexpr) => {
3822 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3824 ty::Adt(def, _) if def.is_box()
3825 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3829 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3830 tcx.mk_box(referent_ty)
3833 hir::ExprKind::Lit(ref lit) => {
3834 self.check_lit(&lit, expected)
3836 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3837 self.check_binop(expr, op, lhs, rhs)
3839 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3840 self.check_binop_assign(expr, op, lhs, rhs)
3842 hir::ExprKind::Unary(unop, ref oprnd) => {
3843 let expected_inner = match unop {
3844 hir::UnNot | hir::UnNeg => {
3851 let needs = match unop {
3852 hir::UnDeref => needs,
3855 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3859 if !oprnd_t.references_error() {
3860 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3863 if let Some(mt) = oprnd_t.builtin_deref(true) {
3865 } else if let Some(ok) = self.try_overloaded_deref(
3866 expr.span, oprnd_t, needs) {
3867 let method = self.register_infer_ok_obligations(ok);
3868 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3869 let mutbl = match mutbl {
3870 hir::MutImmutable => AutoBorrowMutability::Immutable,
3871 hir::MutMutable => AutoBorrowMutability::Mutable {
3872 // (It shouldn't actually matter for unary ops whether
3873 // we enable two-phase borrows or not, since a unary
3874 // op has no additional operands.)
3875 allow_two_phase_borrow: AllowTwoPhase::No,
3878 self.apply_adjustments(oprnd, vec![Adjustment {
3879 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3880 target: method.sig.inputs()[0]
3883 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3884 self.write_method_call(expr.hir_id, method);
3886 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3887 "type `{}` cannot be dereferenced",
3889 oprnd_t = tcx.types.err;
3893 let result = self.check_user_unop(expr, oprnd_t, unop);
3894 // If it's builtin, we can reuse the type, this helps inference.
3895 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3900 let result = self.check_user_unop(expr, oprnd_t, unop);
3901 // If it's builtin, we can reuse the type, this helps inference.
3902 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3910 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3911 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3913 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3914 if oprnd.is_place_expr() {
3915 // Places may legitimately have unsized types.
3916 // For example, dereferences of a fat pointer and
3917 // the last field of a struct can be unsized.
3920 Expectation::rvalue_hint(self, ty)
3926 let needs = Needs::maybe_mut_place(mutbl);
3927 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3929 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3930 if tm.ty.references_error() {
3933 // Note: at this point, we cannot say what the best lifetime
3934 // is to use for resulting pointer. We want to use the
3935 // shortest lifetime possible so as to avoid spurious borrowck
3936 // errors. Moreover, the longest lifetime will depend on the
3937 // precise details of the value whose address is being taken
3938 // (and how long it is valid), which we don't know yet until type
3939 // inference is complete.
3941 // Therefore, here we simply generate a region variable. The
3942 // region inferencer will then select the ultimate value.
3943 // Finally, borrowck is charged with guaranteeing that the
3944 // value whose address was taken can actually be made to live
3945 // as long as it needs to live.
3946 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3947 tcx.mk_ref(region, tm)
3950 hir::ExprKind::Path(ref qpath) => {
3951 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3952 let ty = if def != Def::Err {
3953 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
3955 self.set_tainted_by_errors();
3959 if let ty::FnDef(..) = ty.sty {
3960 let fn_sig = ty.fn_sig(tcx);
3961 if !tcx.features().unsized_locals {
3962 // We want to remove some Sized bounds from std functions,
3963 // but don't want to expose the removal to stable Rust.
3964 // i.e. we don't want to allow
3970 // to work in stable even if the Sized bound on `drop` is relaxed.
3971 for i in 0..fn_sig.inputs().skip_binder().len() {
3972 let input = tcx.erase_late_bound_regions(&fn_sig.input(i));
3973 self.require_type_is_sized_deferred(input, expr.span,
3974 traits::SizedArgumentType);
3977 // Here we want to prevent struct constructors from returning unsized types.
3978 // There were two cases this happened: fn pointer coercion in stable
3979 // and usual function call in presense of unsized_locals.
3980 let output = tcx.erase_late_bound_regions(&fn_sig.output());
3981 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
3984 // We always require that the type provided as the value for
3985 // a type parameter outlives the moment of instantiation.
3986 let substs = self.tables.borrow().node_substs(expr.hir_id);
3987 self.add_wf_bounds(substs, expr);
3991 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3992 for expr in outputs.iter().chain(inputs.iter()) {
3993 self.check_expr(expr);
3997 hir::ExprKind::Break(destination, ref expr_opt) => {
3998 if let Ok(target_id) = destination.target_id {
4000 if let Some(ref e) = *expr_opt {
4001 // If this is a break with a value, we need to type-check
4002 // the expression. Get an expected type from the loop context.
4003 let opt_coerce_to = {
4004 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4005 enclosing_breakables.find_breakable(target_id)
4008 .map(|coerce| coerce.expected_ty())
4011 // If the loop context is not a `loop { }`, then break with
4012 // a value is illegal, and `opt_coerce_to` will be `None`.
4013 // Just set expectation to error in that case.
4014 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4016 // Recurse without `enclosing_breakables` borrowed.
4017 e_ty = self.check_expr_with_hint(e, coerce_to);
4018 cause = self.misc(e.span);
4020 // Otherwise, this is a break *without* a value. That's
4021 // always legal, and is equivalent to `break ()`.
4022 e_ty = tcx.mk_unit();
4023 cause = self.misc(expr.span);
4026 // Now that we have type-checked `expr_opt`, borrow
4027 // the `enclosing_loops` field and let's coerce the
4028 // type of `expr_opt` into what is expected.
4029 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4030 let ctxt = enclosing_breakables.find_breakable(target_id);
4031 if let Some(ref mut coerce) = ctxt.coerce {
4032 if let Some(ref e) = *expr_opt {
4033 coerce.coerce(self, &cause, e, e_ty);
4035 assert!(e_ty.is_unit());
4036 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4039 // If `ctxt.coerce` is `None`, we can just ignore
4040 // the type of the expresison. This is because
4041 // either this was a break *without* a value, in
4042 // which case it is always a legal type (`()`), or
4043 // else an error would have been flagged by the
4044 // `loops` pass for using break with an expression
4045 // where you are not supposed to.
4046 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4049 ctxt.may_break = true;
4051 // the type of a `break` is always `!`, since it diverges
4054 // Otherwise, we failed to find the enclosing loop;
4055 // this can only happen if the `break` was not
4056 // inside a loop at all, which is caught by the
4057 // loop-checking pass.
4058 if self.tcx.sess.err_count() == 0 {
4059 self.tcx.sess.delay_span_bug(expr.span,
4060 "break was outside loop, but no error was emitted");
4063 // We still need to assign a type to the inner expression to
4064 // prevent the ICE in #43162.
4065 if let Some(ref e) = *expr_opt {
4066 self.check_expr_with_hint(e, tcx.types.err);
4068 // ... except when we try to 'break rust;'.
4069 // ICE this expression in particular (see #43162).
4070 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
4071 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4072 fatally_break_rust(self.tcx.sess);
4076 // There was an error, make typecheck fail
4081 hir::ExprKind::Continue(destination) => {
4082 if destination.target_id.is_ok() {
4085 // There was an error, make typecheck fail
4089 hir::ExprKind::Ret(ref expr_opt) => {
4090 if self.ret_coercion.is_none() {
4091 struct_span_err!(self.tcx.sess, expr.span, E0572,
4092 "return statement outside of function body").emit();
4093 } else if let Some(ref e) = *expr_opt {
4094 self.check_return_expr(e);
4096 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4097 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4098 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4102 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4103 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4105 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4108 ExpectIfCondition => {
4109 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4110 expected error elsehwere");
4113 // Only check this if not in an `if` condition, as the
4114 // mistyped comparison help is more appropriate.
4115 if !lhs.is_place_expr() {
4116 struct_span_err!(self.tcx.sess, expr.span, E0070,
4117 "invalid left-hand side expression")
4118 .span_label(expr.span, "left-hand of expression not valid")
4124 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4126 if lhs_ty.references_error() || rhs_ty.references_error() {
4132 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4133 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4134 expr.span, expected)
4136 hir::ExprKind::While(ref cond, ref body, _) => {
4137 let ctxt = BreakableCtxt {
4138 // cannot use break with a value from a while loop
4140 may_break: false, // Will get updated if/when we find a `break`.
4143 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4144 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4145 let cond_diverging = self.diverges.get();
4146 self.check_block_no_value(&body);
4148 // We may never reach the body so it diverging means nothing.
4149 self.diverges.set(cond_diverging);
4153 // No way to know whether it's diverging because
4154 // of a `break` or an outer `break` or `return`.
4155 self.diverges.set(Diverges::Maybe);
4160 hir::ExprKind::Loop(ref body, _, source) => {
4161 let coerce = match source {
4162 // you can only use break with a value from a normal `loop { }`
4163 hir::LoopSource::Loop => {
4164 let coerce_to = expected.coercion_target_type(self, body.span);
4165 Some(CoerceMany::new(coerce_to))
4168 hir::LoopSource::WhileLet |
4169 hir::LoopSource::ForLoop => {
4174 let ctxt = BreakableCtxt {
4176 may_break: false, // Will get updated if/when we find a `break`.
4179 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4180 self.check_block_no_value(&body);
4184 // No way to know whether it's diverging because
4185 // of a `break` or an outer `break` or `return`.
4186 self.diverges.set(Diverges::Maybe);
4189 // If we permit break with a value, then result type is
4190 // the LUB of the breaks (possibly ! if none); else, it
4191 // is nil. This makes sense because infinite loops
4192 // (which would have type !) are only possible iff we
4193 // permit break with a value [1].
4194 if ctxt.coerce.is_none() && !ctxt.may_break {
4196 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4198 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4200 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4201 self.check_match(expr, &discrim, arms, expected, match_src)
4203 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4204 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4206 hir::ExprKind::Block(ref body, _) => {
4207 self.check_block_with_expected(&body, expected)
4209 hir::ExprKind::Call(ref callee, ref args) => {
4210 self.check_call(expr, &callee, args, expected)
4212 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4213 self.check_method_call(expr, segment, span, args, expected, needs)
4215 hir::ExprKind::Cast(ref e, ref t) => {
4216 // Find the type of `e`. Supply hints based on the type we are casting to,
4218 let t_cast = self.to_ty_saving_user_provided_ty(t);
4219 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4220 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4221 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4223 // Eagerly check for some obvious errors.
4224 if t_expr.references_error() || t_cast.references_error() {
4227 // Defer other checks until we're done type checking.
4228 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4229 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4231 deferred_cast_checks.push(cast_check);
4234 Err(ErrorReported) => {
4240 hir::ExprKind::Type(ref e, ref t) => {
4241 let ty = self.to_ty_saving_user_provided_ty(&t);
4242 self.check_expr_eq_type(&e, ty);
4245 hir::ExprKind::Array(ref args) => {
4246 let uty = expected.to_option(self).and_then(|uty| {
4248 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4253 let element_ty = if !args.is_empty() {
4254 let coerce_to = uty.unwrap_or_else(
4255 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4256 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4257 assert_eq!(self.diverges.get(), Diverges::Maybe);
4259 let e_ty = self.check_expr_with_hint(e, coerce_to);
4260 let cause = self.misc(e.span);
4261 coerce.coerce(self, &cause, e, e_ty);
4263 coerce.complete(self)
4265 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4267 tcx.mk_array(element_ty, args.len() as u64)
4269 hir::ExprKind::Repeat(ref element, ref count) => {
4270 let count_def_id = tcx.hir.local_def_id(count.id);
4271 let param_env = ty::ParamEnv::empty();
4272 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4273 let instance = ty::Instance::resolve(
4279 let global_id = GlobalId {
4283 let count = tcx.const_eval(param_env.and(global_id));
4285 let uty = match expected {
4286 ExpectHasType(uty) => {
4288 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4295 let (element_ty, t) = match uty {
4297 self.check_expr_coercable_to_type(&element, uty);
4301 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4302 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4307 if let Ok(count) = count {
4308 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4310 // For [foo, ..n] where n > 1, `foo` must have
4312 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4313 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4317 if element_ty.references_error() {
4319 } else if let Ok(count) = count {
4320 tcx.mk_ty(ty::Array(t, count))
4325 hir::ExprKind::Tup(ref elts) => {
4326 let flds = expected.only_has_type(self).and_then(|ty| {
4327 let ty = self.resolve_type_vars_with_obligations(ty);
4329 ty::Tuple(ref flds) => Some(&flds[..]),
4334 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4335 let t = match flds {
4336 Some(ref fs) if i < fs.len() => {
4338 self.check_expr_coercable_to_type(&e, ety);
4342 self.check_expr_with_expectation(&e, NoExpectation)
4347 let tuple = tcx.mk_tup(elt_ts_iter);
4348 if tuple.references_error() {
4351 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4355 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4356 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4358 hir::ExprKind::Field(ref base, field) => {
4359 self.check_field(expr, needs, &base, field)
4361 hir::ExprKind::Index(ref base, ref idx) => {
4362 let base_t = self.check_expr_with_needs(&base, needs);
4363 let idx_t = self.check_expr(&idx);
4365 if base_t.references_error() {
4367 } else if idx_t.references_error() {
4370 let base_t = self.structurally_resolved_type(base.span, base_t);
4371 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4372 Some((index_ty, element_ty)) => {
4373 // two-phase not needed because index_ty is never mutable
4374 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4379 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4380 "cannot index into a value of type `{}`",
4382 // Try to give some advice about indexing tuples.
4383 if let ty::Tuple(..) = base_t.sty {
4384 let mut needs_note = true;
4385 // If the index is an integer, we can show the actual
4386 // fixed expression:
4387 if let hir::ExprKind::Lit(ref lit) = idx.node {
4388 if let ast::LitKind::Int(i,
4389 ast::LitIntType::Unsuffixed) = lit.node {
4390 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4391 if let Ok(snip) = snip {
4392 err.span_suggestion_with_applicability(
4394 "to access tuple elements, use",
4395 format!("{}.{}", snip, i),
4396 Applicability::MachineApplicable);
4402 err.help("to access tuple elements, use tuple indexing \
4403 syntax (e.g. `tuple.0`)");
4412 hir::ExprKind::Yield(ref value) => {
4413 match self.yield_ty {
4415 self.check_expr_coercable_to_type(&value, ty);
4418 struct_span_err!(self.tcx.sess, expr.span, E0627,
4419 "yield statement outside of generator literal").emit();
4427 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4428 // The newly resolved definition is written into `type_dependent_defs`.
4429 fn finish_resolving_struct_path(&self,
4432 node_id: ast::NodeId)
4436 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4437 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4438 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4441 hir::QPath::TypeRelative(ref qself, ref segment) => {
4442 let ty = self.to_ty(qself);
4444 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4449 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4452 // Write back the new resolution.
4453 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4454 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4461 // Resolve associated value path into a base type and associated constant or method definition.
4462 // The newly resolved definition is written into `type_dependent_defs`.
4463 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4464 qpath: &'b hir::QPath,
4465 node_id: ast::NodeId,
4467 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4469 let (ty, item_segment) = match *qpath {
4470 hir::QPath::Resolved(ref opt_qself, ref path) => {
4472 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4473 &path.segments[..]);
4475 hir::QPath::TypeRelative(ref qself, ref segment) => {
4476 (self.to_ty(qself), segment)
4479 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4480 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4481 // Return directly on cache hit. This is useful to avoid doubly reporting
4482 // errors with default match binding modes. See #44614.
4483 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4485 let item_name = item_segment.ident;
4486 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4489 let def = match error {
4490 method::MethodError::PrivateMatch(def, _) => def,
4493 if item_name.name != keywords::Invalid.name() {
4494 self.report_method_error(span, ty, item_name, None, error, None);
4500 // Write back the new resolution.
4501 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4502 (def, Some(ty), slice::from_ref(&**item_segment))
4505 pub fn check_decl_initializer(&self,
4506 local: &'gcx hir::Local,
4507 init: &'gcx hir::Expr) -> Ty<'tcx>
4509 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4510 // for #42640 (default match binding modes).
4513 let ref_bindings = local.pat.contains_explicit_ref_binding();
4515 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4516 if let Some(m) = ref_bindings {
4517 // Somewhat subtle: if we have a `ref` binding in the pattern,
4518 // we want to avoid introducing coercions for the RHS. This is
4519 // both because it helps preserve sanity and, in the case of
4520 // ref mut, for soundness (issue #23116). In particular, in
4521 // the latter case, we need to be clear that the type of the
4522 // referent for the reference that results is *equal to* the
4523 // type of the place it is referencing, and not some
4524 // supertype thereof.
4525 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4526 self.demand_eqtype(init.span, local_ty, init_ty);
4529 self.check_expr_coercable_to_type(init, local_ty)
4533 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4534 let t = self.local_ty(local.span, local.id).decl_ty;
4535 self.write_ty(local.hir_id, t);
4537 if let Some(ref init) = local.init {
4538 let init_ty = self.check_decl_initializer(local, &init);
4539 if init_ty.references_error() {
4540 self.write_ty(local.hir_id, init_ty);
4544 self.check_pat_walk(&local.pat, t,
4545 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4547 let pat_ty = self.node_ty(local.pat.hir_id);
4548 if pat_ty.references_error() {
4549 self.write_ty(local.hir_id, pat_ty);
4553 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4554 // Don't do all the complex logic below for DeclItem.
4556 hir::StmtKind::Decl(ref decl, _) => {
4557 if let hir::DeclKind::Item(_) = decl.node {
4561 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4564 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4566 // Hide the outer diverging and has_errors flags.
4567 let old_diverges = self.diverges.get();
4568 let old_has_errors = self.has_errors.get();
4569 self.diverges.set(Diverges::Maybe);
4570 self.has_errors.set(false);
4573 hir::StmtKind::Decl(ref decl, _) => {
4575 hir::DeclKind::Local(ref l) => {
4576 self.check_decl_local(&l);
4578 hir::DeclKind::Item(_) => {/* ignore for now */}
4581 hir::StmtKind::Expr(ref expr, _) => {
4582 // Check with expected type of ()
4583 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4585 hir::StmtKind::Semi(ref expr, _) => {
4586 self.check_expr(&expr);
4590 // Combine the diverging and has_error flags.
4591 self.diverges.set(self.diverges.get() | old_diverges);
4592 self.has_errors.set(self.has_errors.get() | old_has_errors);
4595 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4596 let unit = self.tcx.mk_unit();
4597 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4599 // if the block produces a `!` value, that can always be
4600 // (effectively) coerced to unit.
4602 self.demand_suptype(blk.span, unit, ty);
4606 fn check_block_with_expected(&self,
4607 blk: &'gcx hir::Block,
4608 expected: Expectation<'tcx>) -> Ty<'tcx> {
4610 let mut fcx_ps = self.ps.borrow_mut();
4611 let unsafety_state = fcx_ps.recurse(blk);
4612 replace(&mut *fcx_ps, unsafety_state)
4615 // In some cases, blocks have just one exit, but other blocks
4616 // can be targeted by multiple breaks. This can happen both
4617 // with labeled blocks as well as when we desugar
4618 // a `try { ... }` expression.
4622 // 'a: { if true { break 'a Err(()); } Ok(()) }
4624 // Here we would wind up with two coercions, one from
4625 // `Err(())` and the other from the tail expression
4626 // `Ok(())`. If the tail expression is omitted, that's a
4627 // "forced unit" -- unless the block diverges, in which
4628 // case we can ignore the tail expression (e.g., `'a: {
4629 // break 'a 22; }` would not force the type of the block
4631 let tail_expr = blk.expr.as_ref();
4632 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4633 let coerce = if blk.targeted_by_break {
4634 CoerceMany::new(coerce_to_ty)
4636 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4637 Some(e) => slice::from_ref(e),
4640 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4643 let prev_diverges = self.diverges.get();
4644 let ctxt = BreakableCtxt {
4645 coerce: Some(coerce),
4649 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4650 for s in &blk.stmts {
4654 // check the tail expression **without** holding the
4655 // `enclosing_breakables` lock below.
4656 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4658 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4659 let ctxt = enclosing_breakables.find_breakable(blk.id);
4660 let coerce = ctxt.coerce.as_mut().unwrap();
4661 if let Some(tail_expr_ty) = tail_expr_ty {
4662 let tail_expr = tail_expr.unwrap();
4663 let cause = self.cause(tail_expr.span,
4664 ObligationCauseCode::BlockTailExpression(blk.id));
4670 // Subtle: if there is no explicit tail expression,
4671 // that is typically equivalent to a tail expression
4672 // of `()` -- except if the block diverges. In that
4673 // case, there is no value supplied from the tail
4674 // expression (assuming there are no other breaks,
4675 // this implies that the type of the block will be
4678 // #41425 -- label the implicit `()` as being the
4679 // "found type" here, rather than the "expected type".
4681 // #44579 -- if the block was recovered during parsing,
4682 // the type would be nonsensical and it is not worth it
4683 // to perform the type check, so we avoid generating the
4684 // diagnostic output.
4685 if !self.diverges.get().always() && !blk.recovered {
4686 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4687 if let Some(expected_ty) = expected.only_has_type(self) {
4688 self.consider_hint_about_removing_semicolon(blk,
4698 // If we can break from the block, then the block's exit is always reachable
4699 // (... as long as the entry is reachable) - regardless of the tail of the block.
4700 self.diverges.set(prev_diverges);
4703 let mut ty = ctxt.coerce.unwrap().complete(self);
4705 if self.has_errors.get() || ty.references_error() {
4706 ty = self.tcx.types.err
4709 self.write_ty(blk.hir_id, ty);
4711 *self.ps.borrow_mut() = prev;
4715 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4716 /// suggestion can be made, `None` otherwise.
4717 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4718 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4719 // `while` before reaching it, as block tail returns are not available in them.
4720 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4721 let parent = self.tcx.hir.get(fn_id);
4723 if let Node::Item(&hir::Item {
4724 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4726 decl.clone().and_then(|decl| {
4727 // This is less than ideal, it will not suggest a return type span on any
4728 // method called `main`, regardless of whether it is actually the entry point,
4729 // but it will still present it as the reason for the expected type.
4730 Some((decl, name != Symbol::intern("main")))
4732 } else if let Node::TraitItem(&hir::TraitItem {
4733 node: hir::TraitItemKind::Method(hir::MethodSig {
4737 decl.clone().and_then(|decl| {
4740 } else if let Node::ImplItem(&hir::ImplItem {
4741 node: hir::ImplItemKind::Method(hir::MethodSig {
4745 decl.clone().and_then(|decl| {
4756 /// On implicit return expressions with mismatched types, provide the following suggestions:
4758 /// - Point out the method's return type as the reason for the expected type
4759 /// - Possible missing semicolon
4760 /// - Possible missing return type if the return type is the default, and not `fn main()`
4761 pub fn suggest_mismatched_types_on_tail(&self,
4762 err: &mut DiagnosticBuilder<'tcx>,
4763 expression: &'gcx hir::Expr,
4767 blk_id: ast::NodeId) {
4768 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4769 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4770 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4772 self.suggest_ref_or_into(err, expression, expected, found);
4775 pub fn suggest_ref_or_into(
4777 err: &mut DiagnosticBuilder<'tcx>,
4782 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4783 err.span_suggestion_with_applicability(
4787 Applicability::MachineApplicable,
4789 } else if !self.check_for_cast(err, expr, found, expected) {
4790 let methods = self.get_conversion_methods(expr.span, expected, found);
4791 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4792 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4793 .filter_map(|(receiver, method)| {
4794 let method_call = format!(".{}()", method.ident);
4795 if receiver.ends_with(&method_call) {
4796 None // do not suggest code that is already there (#53348)
4798 let method_call_list = [".to_vec()", ".to_string()"];
4799 if receiver.ends_with(".clone()")
4800 && method_call_list.contains(&method_call.as_str()) {
4801 let max_len = receiver.rfind(".").unwrap();
4802 Some(format!("{}{}", &receiver[..max_len], method_call))
4805 Some(format!("{}{}", receiver, method_call))
4809 if suggestions.peek().is_some() {
4810 err.span_suggestions_with_applicability(
4812 "try using a conversion method",
4814 Applicability::MaybeIncorrect,
4821 /// A common error is to forget to add a semicolon at the end of a block:
4825 /// bar_that_returns_u32()
4829 /// This routine checks if the return expression in a block would make sense on its own as a
4830 /// statement and the return type has been left as default or has been specified as `()`. If so,
4831 /// it suggests adding a semicolon.
4832 fn suggest_missing_semicolon(&self,
4833 err: &mut DiagnosticBuilder<'tcx>,
4834 expression: &'gcx hir::Expr,
4837 if expected.is_unit() {
4838 // `BlockTailExpression` only relevant if the tail expr would be
4839 // useful on its own.
4840 match expression.node {
4841 hir::ExprKind::Call(..) |
4842 hir::ExprKind::MethodCall(..) |
4843 hir::ExprKind::If(..) |
4844 hir::ExprKind::While(..) |
4845 hir::ExprKind::Loop(..) |
4846 hir::ExprKind::Match(..) |
4847 hir::ExprKind::Block(..) => {
4848 let sp = self.tcx.sess.source_map().next_point(cause_span);
4849 err.span_suggestion_with_applicability(
4851 "try adding a semicolon",
4853 Applicability::MachineApplicable);
4860 /// A possible error is to forget to add a return type that is needed:
4864 /// bar_that_returns_u32()
4868 /// This routine checks if the return type is left as default, the method is not part of an
4869 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4871 fn suggest_missing_return_type(&self,
4872 err: &mut DiagnosticBuilder<'tcx>,
4873 fn_decl: &hir::FnDecl,
4876 can_suggest: bool) {
4877 // Only suggest changing the return type for methods that
4878 // haven't set a return type at all (and aren't `fn main()` or an impl).
4879 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4880 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4881 err.span_suggestion_with_applicability(
4883 "try adding a return type",
4884 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4885 Applicability::MachineApplicable);
4887 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4888 err.span_label(span, "possibly return type missing here?");
4890 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4891 // `fn main()` must return `()`, do not suggest changing return type
4892 err.span_label(span, "expected `()` because of default return type");
4894 // expectation was caused by something else, not the default return
4895 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4896 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4897 // Only point to return type if the expected type is the return type, as if they
4898 // are not, the expectation must have been caused by something else.
4899 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4901 let ty = AstConv::ast_ty_to_ty(self, ty);
4902 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4903 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4904 if ty.sty == expected.sty {
4905 err.span_label(sp, format!("expected `{}` because of return type",
4913 /// A common error is to add an extra semicolon:
4916 /// fn foo() -> usize {
4921 /// This routine checks if the final statement in a block is an
4922 /// expression with an explicit semicolon whose type is compatible
4923 /// with `expected_ty`. If so, it suggests removing the semicolon.
4924 fn consider_hint_about_removing_semicolon(&self,
4925 blk: &'gcx hir::Block,
4926 expected_ty: Ty<'tcx>,
4927 err: &mut DiagnosticBuilder) {
4928 // Be helpful when the user wrote `{... expr;}` and
4929 // taking the `;` off is enough to fix the error.
4930 let last_stmt = match blk.stmts.last() {
4934 let last_expr = match last_stmt.node {
4935 hir::StmtKind::Semi(ref e, _) => e,
4938 let last_expr_ty = self.node_ty(last_expr.hir_id);
4939 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4942 let original_span = original_sp(last_stmt.span, blk.span);
4943 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4944 err.span_suggestion_with_applicability(
4946 "consider removing this semicolon",
4948 Applicability::MachineApplicable);
4951 fn def_ids_for_path_segments(&self,
4952 segments: &[hir::PathSegment],
4955 // We need to extract the type parameters supplied by the user in
4956 // the path `path`. Due to the current setup, this is a bit of a
4957 // tricky-process; the problem is that resolve only tells us the
4958 // end-point of the path resolution, and not the intermediate steps.
4959 // Luckily, we can (at least for now) deduce the intermediate steps
4960 // just from the end-point.
4962 // There are basically four cases to consider:
4964 // 1. Reference to a constructor of enum variant or struct:
4966 // struct Foo<T>(...)
4967 // enum E<T> { Foo(...) }
4969 // In these cases, the parameters are declared in the type
4972 // 2. Reference to a fn item or a free constant:
4976 // In this case, the path will again always have the form
4977 // `a::b::foo::<T>` where only the final segment should have
4978 // type parameters. However, in this case, those parameters are
4979 // declared on a value, and hence are in the `FnSpace`.
4981 // 3. Reference to a method or an associated constant:
4983 // impl<A> SomeStruct<A> {
4987 // Here we can have a path like
4988 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4989 // may appear in two places. The penultimate segment,
4990 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4991 // final segment, `foo::<B>` contains parameters in fn space.
4993 // 4. Reference to a local variable
4995 // Local variables can't have any type parameters.
4997 // The first step then is to categorize the segments appropriately.
4999 assert!(!segments.is_empty());
5000 let last = segments.len() - 1;
5002 let mut path_segs = vec![];
5005 // Case 1. Reference to a struct/variant constructor.
5006 Def::StructCtor(def_id, ..) |
5007 Def::VariantCtor(def_id, ..) |
5008 Def::SelfCtor(.., def_id) => {
5009 // Everything but the final segment should have no
5010 // parameters at all.
5011 let generics = self.tcx.generics_of(def_id);
5012 // Variant and struct constructors use the
5013 // generics of their parent type definition.
5014 let generics_def_id = generics.parent.unwrap_or(def_id);
5015 path_segs.push(PathSeg(generics_def_id, last));
5018 // Case 2. Reference to a top-level value.
5020 Def::Const(def_id) |
5021 Def::Static(def_id, _) => {
5022 path_segs.push(PathSeg(def_id, last));
5025 // Case 3. Reference to a method or associated const.
5026 Def::Method(def_id) |
5027 Def::AssociatedConst(def_id) => {
5028 if segments.len() >= 2 {
5029 let generics = self.tcx.generics_of(def_id);
5030 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
5032 path_segs.push(PathSeg(def_id, last));
5035 // Case 4. Local variable, no generics.
5036 Def::Local(..) | Def::Upvar(..) => {}
5038 _ => bug!("unexpected definition: {:?}", def),
5041 debug!("path_segs = {:?}", path_segs);
5046 // Instantiates the given path, which must refer to an item with the given
5047 // number of type parameters and type.
5048 pub fn instantiate_value_path(&self,
5049 segments: &[hir::PathSegment],
5050 self_ty: Option<Ty<'tcx>>,
5053 node_id: ast::NodeId)
5054 -> (Ty<'tcx>, Def) {
5056 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5063 let path_segs = self.def_ids_for_path_segments(segments, def);
5065 let mut user_self_ty = None;
5067 Def::Method(def_id) |
5068 Def::AssociatedConst(def_id) => {
5069 let container = self.tcx.associated_item(def_id).container;
5071 ty::TraitContainer(trait_did) => {
5072 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5074 ty::ImplContainer(impl_def_id) => {
5075 if segments.len() == 1 {
5076 // `<T>::assoc` will end up here, and so
5077 // can `T::assoc`. It this came from an
5078 // inherent impl, we need to record the
5079 // `T` for posterity (see `UserSelfTy` for
5081 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5082 user_self_ty = Some(UserSelfTy {
5093 // Now that we have categorized what space the parameters for each
5094 // segment belong to, let's sort out the parameters that the user
5095 // provided (if any) into their appropriate spaces. We'll also report
5096 // errors if type parameters are provided in an inappropriate place.
5098 let generic_segs = path_segs.iter().map(|PathSeg(_, index)| index)
5099 .collect::<FxHashSet<_>>();
5100 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5101 if !generic_segs.contains(&index) {
5109 Def::Local(nid) | Def::Upvar(nid, ..) => {
5110 let ty = self.local_ty(span, nid).decl_ty;
5111 let ty = self.normalize_associated_types_in(span, &ty);
5112 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
5118 // Now we have to compare the types that the user *actually*
5119 // provided against the types that were *expected*. If the user
5120 // did not provide any types, then we want to substitute inference
5121 // variables. If the user provided some types, we may still need
5122 // to add defaults. If the user provided *too many* types, that's
5125 let mut infer_args_for_err = FxHashSet::default();
5126 for &PathSeg(def_id, index) in &path_segs {
5127 let seg = &segments[index];
5128 let generics = self.tcx.generics_of(def_id);
5129 // Argument-position `impl Trait` is treated as a normal generic
5130 // parameter internally, but we don't allow users to specify the
5131 // parameter's value explicitly, so we have to do some error-
5133 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5138 false, // `is_method_call`
5140 if suppress_errors {
5141 infer_args_for_err.insert(index);
5142 self.set_tainted_by_errors(); // See issue #53251.
5146 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5147 self.tcx.generics_of(*def_id).has_self
5148 }).unwrap_or(false);
5150 let mut new_def = def;
5151 let (def_id, ty) = if let Def::SelfCtor(impl_def_id) = def {
5152 let ty = self.impl_self_ty(span, impl_def_id).ty;
5154 match ty.ty_adt_def() {
5155 Some(adt_def) if adt_def.is_struct() => {
5156 let variant = adt_def.non_enum_variant();
5157 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5158 (variant.did, self.tcx.type_of(variant.did))
5161 (impl_def_id, self.tcx.types.err)
5165 let def_id = def.def_id();
5167 // The things we are substituting into the type should not contain
5168 // escaping late-bound regions, and nor should the base type scheme.
5169 let ty = self.tcx.type_of(def_id);
5173 let substs = AstConv::create_substs_for_generic_args(
5179 // Provide the generic args, and whether types should be inferred.
5181 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5184 // If we've encountered an `impl Trait`-related error, we're just
5185 // going to infer the arguments for better error messages.
5186 if !infer_args_for_err.contains(&index) {
5187 // Check whether the user has provided generic arguments.
5188 if let Some(ref data) = segments[index].args {
5189 return (Some(data), segments[index].infer_types);
5192 return (None, segments[index].infer_types);
5197 // Provide substitutions for parameters for which (valid) arguments have been provided.
5199 match (¶m.kind, arg) {
5200 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5201 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5203 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5204 self.to_ty(ty).into()
5206 _ => unreachable!(),
5209 // Provide substitutions for parameters for which arguments are inferred.
5210 |substs, param, infer_types| {
5212 GenericParamDefKind::Lifetime => {
5213 self.re_infer(span, Some(param)).unwrap().into()
5215 GenericParamDefKind::Type { has_default, .. } => {
5216 if !infer_types && has_default {
5217 // If we have a default, then we it doesn't matter that we're not
5218 // inferring the type arguments: we provide the default where any
5220 let default = self.tcx.type_of(param.def_id);
5223 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5226 // If no type arguments were provided, we have to infer them.
5227 // This case also occurs as a result of some malformed input, e.g.
5228 // a lifetime argument being given instead of a type parameter.
5229 // Using inference instead of `Error` gives better error messages.
5230 self.var_for_def(span, param)
5236 assert!(!substs.has_escaping_bound_vars());
5237 assert!(!ty.has_escaping_bound_vars());
5239 // Write the "user substs" down first thing for later.
5240 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
5241 self.write_user_substs_from_substs(hir_id, substs, user_self_ty);
5243 // Add all the obligations that are required, substituting and
5244 // normalized appropriately.
5245 let bounds = self.instantiate_bounds(span, def_id, &substs);
5246 self.add_obligations_for_parameters(
5247 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5250 // Substitute the values for the type parameters into the type of
5251 // the referenced item.
5252 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5254 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5255 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5256 // is inherent, there is no `Self` parameter, instead, the impl needs
5257 // type parameters, which we can infer by unifying the provided `Self`
5258 // with the substituted impl type.
5259 let ty = self.tcx.type_of(impl_def_id);
5261 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5262 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5263 Ok(ok) => self.register_infer_ok_obligations(ok),
5266 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5273 self.check_rustc_args_require_const(def_id, node_id, span);
5275 debug!("instantiate_value_path: type of {:?} is {:?}",
5278 self.write_substs(hir_id, substs);
5280 (ty_substituted, new_def)
5283 fn check_rustc_args_require_const(&self,
5285 node_id: ast::NodeId,
5287 // We're only interested in functions tagged with
5288 // #[rustc_args_required_const], so ignore anything that's not.
5289 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5293 // If our calling expression is indeed the function itself, we're good!
5294 // If not, generate an error that this can only be called directly.
5295 if let Node::Expr(expr) = self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5296 if let hir::ExprKind::Call(ref callee, ..) = expr.node {
5297 if callee.id == node_id {
5303 self.tcx.sess.span_err(span, "this function can only be invoked \
5304 directly, not through a function pointer");
5307 // Resolves `typ` by a single level if `typ` is a type variable.
5308 // If no resolution is possible, then an error is reported.
5309 // Numeric inference variables may be left unresolved.
5310 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5311 let ty = self.resolve_type_vars_with_obligations(ty);
5312 if !ty.is_ty_var() {
5315 if !self.is_tainted_by_errors() {
5316 self.need_type_info_err((**self).body_id, sp, ty)
5317 .note("type must be known at this point")
5320 self.demand_suptype(sp, self.tcx.types.err, ty);
5325 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5326 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5327 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5330 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5331 index = enclosing_breakables.stack.len();
5332 enclosing_breakables.by_id.insert(id, index);
5333 enclosing_breakables.stack.push(ctxt);
5337 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5338 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5339 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5340 enclosing_breakables.stack.pop().expect("missing breakable context")
5346 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5347 generics: &ty::Generics,
5349 let own_counts = generics.own_counts();
5350 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5352 if own_counts.types == 0 {
5355 // Make a vector of booleans initially false, set to true when used.
5356 let mut types_used = vec![false; own_counts.types];
5358 for leaf_ty in ty.walk() {
5359 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5360 debug!("Found use of ty param num {}", idx);
5361 types_used[idx as usize - own_counts.lifetimes] = true;
5362 } else if let ty::Error = leaf_ty.sty {
5363 // If there is already another error, do not emit
5364 // an error for not using a type Parameter.
5365 assert!(tcx.sess.err_count() > 0);
5370 let types = generics.params.iter().filter(|param| match param.kind {
5371 ty::GenericParamDefKind::Type { .. } => true,
5374 for (&used, param) in types_used.iter().zip(types) {
5376 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5377 let span = tcx.hir.span(id);
5378 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5379 .span_label(span, "unused type parameter")
5385 fn fatally_break_rust(sess: &Session) {
5386 let handler = sess.diagnostic();
5387 handler.span_bug_no_panic(
5389 "It looks like you're trying to break rust; would you like some ICE?",
5391 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5392 handler.note_without_error(
5393 "we would appreciate a joke overview: \
5394 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5396 handler.note_without_error(&format!("rustc {} running on {}",
5397 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5398 ::session::config::host_triple(),
5402 fn potentially_plural_count(count: usize, word: &str) -> String {
5403 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })