1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are unknown.
19 By far the most complex case is checking the body of a function. This
20 can be broken down into several distinct phases:
22 - gather: creates type variables to represent the type of each local
23 variable and pattern binding.
25 - main: the main pass does the lion's share of the work: it
26 determines the types of all expressions, resolves
27 methods, checks for most invalid conditions, and so forth. In
28 some cases, where a type is unknown, it may create a type or region
29 variable and use that as the type of an expression.
31 In the process of checking, various constraints will be placed on
32 these type variables through the subtyping relationships requested
33 through the `demand` module. The `infer` module is in charge
34 of resolving those constraints.
36 - regionck: after main is complete, the regionck pass goes over all
37 types looking for regions and making sure that they did not escape
38 into places they are not in scope. This may also influence the
39 final assignments of the various region variables if there is some
42 - vtable: find and records the impls to use for each trait bound that
43 appears on a type parameter.
45 - writeback: writes the final types within a function body, replacing
46 type variables with their final inferred types. These final types
47 are written into the `tcx.node_types` table, which should *never* contain
48 any reference to a type variable.
52 While type checking a function, the intermediate types for the
53 expressions, blocks, and so forth contained within the function are
54 stored in `fcx.node_types` and `fcx.node_substs`. These types
55 may contain unresolved type variables. After type checking is
56 complete, the functions in the writeback module are used to take the
57 types from this table, resolve them, and then write them into their
58 permanent home in the type context `tcx`.
60 This means that during inferencing you should use `fcx.write_ty()`
61 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
62 nodes within the function.
64 The types of top-level items, which never contain unbound type
65 variables, are stored directly into the `tcx` tables.
67 N.B., a type variable is not the same thing as a type parameter. A
68 type variable is rather an "instance" of a type parameter: that is,
69 given a generic function `fn foo<T>(t: T)`: while checking the
70 function `foo`, the type `ty_param(0)` refers to the type `T`, which
71 is treated in abstract. When `foo()` is called, however, `T` will be
72 substituted for a fresh type variable `N`. This variable will
73 eventually be resolved to some concrete type (which might itself be
92 mod generator_interior;
97 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
98 use rustc::hir::{self, GenericArg, Node, ItemKind, PatKind};
99 use rustc::hir::def::Def;
100 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
101 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
102 use rustc::hir::itemlikevisit::ItemLikeVisitor;
103 use middle::lang_items;
104 use namespace::Namespace;
105 use rustc_data_structures::indexed_vec::Idx;
106 use rustc_data_structures::sync::Lrc;
107 use rustc_target::spec::abi::Abi;
108 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
109 use rustc::infer::opaque_types::OpaqueTypeDecl;
110 use rustc::infer::type_variable::{TypeVariableOrigin};
111 use rustc::middle::region;
112 use rustc::mir::interpret::{ConstValue, GlobalId};
113 use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
114 UserSelfTy, UserSubsts};
115 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
116 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
117 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
118 use rustc::ty::fold::TypeFoldable;
119 use rustc::ty::query::Providers;
120 use rustc::ty::util::{Representability, IntTypeExt, Discr};
121 use rustc::ty::layout::VariantIdx;
122 use syntax_pos::{self, BytePos, Span, MultiSpan};
125 use syntax::feature_gate::{GateIssue, emit_feature_err};
127 use syntax::source_map::{DUMMY_SP, original_sp};
128 use syntax::symbol::{Symbol, LocalInternedString, keywords};
129 use syntax::util::lev_distance::find_best_match_for_name;
131 use std::cell::{Cell, RefCell, Ref, RefMut};
132 use std::collections::hash_map::Entry;
134 use std::fmt::Display;
136 use std::mem::replace;
137 use std::ops::{self, Deref};
140 use require_c_abi_if_variadic;
141 use session::{CompileIncomplete, config, Session};
144 use util::common::{ErrorReported, indenter};
145 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
147 pub use self::Expectation::*;
148 use self::autoderef::Autoderef;
149 use self::callee::DeferredCallResolution;
150 use self::coercion::{CoerceMany, DynamicCoerceMany};
151 pub use self::compare_method::{compare_impl_method, compare_const_impl};
152 use self::method::MethodCallee;
153 use self::TupleArgumentsFlag::*;
155 /// The type of a local binding, including the revealed type for anon types.
156 #[derive(Copy, Clone)]
157 pub struct LocalTy<'tcx> {
159 revealed_ty: Ty<'tcx>
162 /// A wrapper for InferCtxt's `in_progress_tables` field.
163 #[derive(Copy, Clone)]
164 struct MaybeInProgressTables<'a, 'tcx: 'a> {
165 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
168 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
169 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
170 match self.maybe_tables {
171 Some(tables) => tables.borrow(),
173 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
178 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
179 match self.maybe_tables {
180 Some(tables) => tables.borrow_mut(),
182 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
188 /// closures defined within the function. For example:
191 /// bar(move|| { ... })
194 /// Here, the function `foo()` and the closure passed to
195 /// `bar()` will each have their own `FnCtxt`, but they will
196 /// share the inherited fields.
197 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
198 infcx: InferCtxt<'a, 'gcx, 'tcx>,
200 tables: MaybeInProgressTables<'a, 'tcx>,
202 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
204 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
206 // Some additional `Sized` obligations badly affect type inference.
207 // These obligations are added in a later stage of typeck.
208 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
210 // When we process a call like `c()` where `c` is a closure type,
211 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
212 // `FnOnce` closure. In that case, we defer full resolution of the
213 // call until upvar inference can kick in and make the
214 // decision. We keep these deferred resolutions grouped by the
215 // def-id of the closure, so that once we decide, we can easily go
216 // back and process them.
217 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
219 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
221 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
223 // Opaque types found in explicit return types and their
224 // associated fresh inference variable. Writeback resolves these
225 // variables to get the concrete type, which can be used to
226 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
227 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
229 /// Each type parameter has an implicit region bound that
230 /// indicates it must outlive at least the function body (the user
231 /// may specify stronger requirements). This field indicates the
232 /// region of the callee. If it is `None`, then the parameter
233 /// environment is for an item or something where the "callee" is
235 implicit_region_bound: Option<ty::Region<'tcx>>,
237 body_id: Option<hir::BodyId>,
240 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
241 type Target = InferCtxt<'a, 'gcx, 'tcx>;
242 fn deref(&self) -> &Self::Target {
247 /// When type-checking an expression, we propagate downward
248 /// whatever type hint we are able in the form of an `Expectation`.
249 #[derive(Copy, Clone, Debug)]
250 pub enum Expectation<'tcx> {
251 /// We know nothing about what type this expression should have.
254 /// This expression is an `if` condition, it must resolve to `bool`.
257 /// This expression should have the type given (or some subtype)
258 ExpectHasType(Ty<'tcx>),
260 /// This expression will be cast to the `Ty`
261 ExpectCastableToType(Ty<'tcx>),
263 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
264 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
265 ExpectRvalueLikeUnsized(Ty<'tcx>),
268 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
269 // Disregard "castable to" expectations because they
270 // can lead us astray. Consider for example `if cond
271 // {22} else {c} as u8` -- if we propagate the
272 // "castable to u8" constraint to 22, it will pick the
273 // type 22u8, which is overly constrained (c might not
274 // be a u8). In effect, the problem is that the
275 // "castable to" expectation is not the tightest thing
276 // we can say, so we want to drop it in this case.
277 // The tightest thing we can say is "must unify with
278 // else branch". Note that in the case of a "has type"
279 // constraint, this limitation does not hold.
281 // If the expected type is just a type variable, then don't use
282 // an expected type. Otherwise, we might write parts of the type
283 // when checking the 'then' block which are incompatible with the
285 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
287 ExpectHasType(ety) => {
288 let ety = fcx.shallow_resolve(ety);
289 if !ety.is_ty_var() {
295 ExpectRvalueLikeUnsized(ety) => {
296 ExpectRvalueLikeUnsized(ety)
302 /// Provide an expectation for an rvalue expression given an *optional*
303 /// hint, which is not required for type safety (the resulting type might
304 /// be checked higher up, as is the case with `&expr` and `box expr`), but
305 /// is useful in determining the concrete type.
307 /// The primary use case is where the expected type is a fat pointer,
308 /// like `&[isize]`. For example, consider the following statement:
310 /// let x: &[isize] = &[1, 2, 3];
312 /// In this case, the expected type for the `&[1, 2, 3]` expression is
313 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
314 /// expectation `ExpectHasType([isize])`, that would be too strong --
315 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
316 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
317 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
318 /// which still is useful, because it informs integer literals and the like.
319 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
320 /// for examples of where this comes up,.
321 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
322 match fcx.tcx.struct_tail(ty).sty {
323 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
324 ExpectRvalueLikeUnsized(ty)
326 _ => ExpectHasType(ty)
330 // Resolves `expected` by a single level if it is a variable. If
331 // there is no expected type or resolution is not possible (e.g.,
332 // no constraints yet present), just returns `None`.
333 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
335 NoExpectation => NoExpectation,
336 ExpectIfCondition => ExpectIfCondition,
337 ExpectCastableToType(t) => {
338 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
340 ExpectHasType(t) => {
341 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
343 ExpectRvalueLikeUnsized(t) => {
344 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
349 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
350 match self.resolve(fcx) {
351 NoExpectation => None,
352 ExpectIfCondition => Some(fcx.tcx.types.bool),
353 ExpectCastableToType(ty) |
355 ExpectRvalueLikeUnsized(ty) => Some(ty),
359 /// It sometimes happens that we want to turn an expectation into
360 /// a **hard constraint** (i.e., something that must be satisfied
361 /// for the program to type-check). `only_has_type` will return
362 /// such a constraint, if it exists.
363 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
364 match self.resolve(fcx) {
365 ExpectHasType(ty) => Some(ty),
366 ExpectIfCondition => Some(fcx.tcx.types.bool),
367 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
371 /// Like `only_has_type`, but instead of returning `None` if no
372 /// hard constraint exists, creates a fresh type variable.
373 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
374 self.only_has_type(fcx)
375 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
379 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
386 fn maybe_mut_place(m: hir::Mutability) -> Self {
388 hir::MutMutable => Needs::MutPlace,
389 hir::MutImmutable => Needs::None,
394 #[derive(Copy, Clone)]
395 pub struct UnsafetyState {
396 pub def: ast::NodeId,
397 pub unsafety: hir::Unsafety,
398 pub unsafe_push_count: u32,
403 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
404 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
407 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
408 match self.unsafety {
409 // If this unsafe, then if the outer function was already marked as
410 // unsafe we shouldn't attribute the unsafe'ness to the block. This
411 // way the block can be warned about instead of ignoring this
412 // extraneous block (functions are never warned about).
413 hir::Unsafety::Unsafe if self.from_fn => *self,
416 let (unsafety, def, count) = match blk.rules {
417 hir::PushUnsafeBlock(..) =>
418 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
419 hir::PopUnsafeBlock(..) =>
420 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
421 hir::UnsafeBlock(..) =>
422 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
424 (unsafety, self.def, self.unsafe_push_count),
428 unsafe_push_count: count,
435 #[derive(Debug, Copy, Clone)]
441 /// Tracks whether executing a node may exit normally (versus
442 /// return/break/panic, which "diverge", leaving dead code in their
443 /// wake). Tracked semi-automatically (through type variables marked
444 /// as diverging), with some manual adjustments for control-flow
445 /// primitives (approximating a CFG).
446 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
448 /// Potentially unknown, some cases converge,
449 /// others require a CFG to determine them.
452 /// Definitely known to diverge and therefore
453 /// not reach the next sibling or its parent.
456 /// Same as `Always` but with a reachability
457 /// warning already emitted
461 // Convenience impls for combinig `Diverges`.
463 impl ops::BitAnd for Diverges {
465 fn bitand(self, other: Self) -> Self {
466 cmp::min(self, other)
470 impl ops::BitOr for Diverges {
472 fn bitor(self, other: Self) -> Self {
473 cmp::max(self, other)
477 impl ops::BitAndAssign for Diverges {
478 fn bitand_assign(&mut self, other: Self) {
479 *self = *self & other;
483 impl ops::BitOrAssign for Diverges {
484 fn bitor_assign(&mut self, other: Self) {
485 *self = *self | other;
490 fn always(self) -> bool {
491 self >= Diverges::Always
495 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
498 // this is `null` for loops where break with a value is illegal,
499 // such as `while`, `for`, and `while let`
500 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
503 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
504 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
505 by_id: NodeMap<usize>,
508 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
509 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
510 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
511 bug!("could not find enclosing breakable with id {}", target_id);
518 struct PathSeg(DefId, usize);
520 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
521 body_id: ast::NodeId,
523 /// The parameter environment used for proving trait obligations
524 /// in this function. This can change when we descend into
525 /// closures (as they bring new things into scope), hence it is
526 /// not part of `Inherited` (as of the time of this writing,
527 /// closures do not yet change the environment, but they will
529 param_env: ty::ParamEnv<'tcx>,
531 // Number of errors that had been reported when we started
532 // checking this function. On exit, if we find that *more* errors
533 // have been reported, we will skip regionck and other work that
534 // expects the types within the function to be consistent.
535 err_count_on_creation: usize,
537 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
539 yield_ty: Option<Ty<'tcx>>,
541 ps: RefCell<UnsafetyState>,
543 /// Whether the last checked node generates a divergence (e.g.,
544 /// `return` will set this to Always). In general, when entering
545 /// an expression or other node in the tree, the initial value
546 /// indicates whether prior parts of the containing expression may
547 /// have diverged. It is then typically set to `Maybe` (and the
548 /// old value remembered) for processing the subparts of the
549 /// current expression. As each subpart is processed, they may set
550 /// the flag to `Always` etc. Finally, at the end, we take the
551 /// result and "union" it with the original value, so that when we
552 /// return the flag indicates if any subpart of the parent
553 /// expression (up to and including this part) has diverged. So,
554 /// if you read it after evaluating a subexpression `X`, the value
555 /// you get indicates whether any subexpression that was
556 /// evaluating up to and including `X` diverged.
558 /// We currently use this flag only for diagnostic purposes:
560 /// - To warn about unreachable code: if, after processing a
561 /// sub-expression but before we have applied the effects of the
562 /// current node, we see that the flag is set to `Always`, we
563 /// can issue a warning. This corresponds to something like
564 /// `foo(return)`; we warn on the `foo()` expression. (We then
565 /// update the flag to `WarnedAlways` to suppress duplicate
566 /// reports.) Similarly, if we traverse to a fresh statement (or
567 /// tail expression) from a `Always` setting, we will issue a
568 /// warning. This corresponds to something like `{return;
569 /// foo();}` or `{return; 22}`, where we would warn on the
572 /// An expression represents dead-code if, after checking it,
573 /// the diverges flag is set to something other than `Maybe`.
574 diverges: Cell<Diverges>,
576 /// Whether any child nodes have any type errors.
577 has_errors: Cell<bool>,
579 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
581 inh: &'a Inherited<'a, 'gcx, 'tcx>,
584 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
585 type Target = Inherited<'a, 'gcx, 'tcx>;
586 fn deref(&self) -> &Self::Target {
591 /// Helper type of a temporary returned by Inherited::build(...).
592 /// Necessary because we can't write the following bound:
593 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
594 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
595 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
599 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
600 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
601 -> InheritedBuilder<'a, 'gcx, 'tcx> {
602 let hir_id_root = if def_id.is_local() {
603 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
604 let hir_id = tcx.hir().definitions().node_to_hir_id(node_id);
605 DefId::local(hir_id.owner)
611 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
617 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
618 fn enter<F, R>(&'tcx mut self, f: F) -> R
619 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
621 let def_id = self.def_id;
622 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
626 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
627 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
629 let item_id = tcx.hir().as_local_node_id(def_id);
630 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
631 let implicit_region_bound = body_id.map(|body_id| {
632 let body = tcx.hir().body(body_id);
633 tcx.mk_region(ty::ReScope(region::Scope {
634 id: body.value.hir_id.local_id,
635 data: region::ScopeData::CallSite
640 tables: MaybeInProgressTables {
641 maybe_tables: infcx.in_progress_tables,
644 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
645 locals: RefCell::new(Default::default()),
646 deferred_sized_obligations: RefCell::new(Vec::new()),
647 deferred_call_resolutions: RefCell::new(Default::default()),
648 deferred_cast_checks: RefCell::new(Vec::new()),
649 deferred_generator_interiors: RefCell::new(Vec::new()),
650 opaque_types: RefCell::new(Default::default()),
651 implicit_region_bound,
656 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
657 debug!("register_predicate({:?})", obligation);
658 if obligation.has_escaping_bound_vars() {
659 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
664 .register_predicate_obligation(self, obligation);
667 fn register_predicates<I>(&self, obligations: I)
668 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
670 for obligation in obligations {
671 self.register_predicate(obligation);
675 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
676 self.register_predicates(infer_ok.obligations);
680 fn normalize_associated_types_in<T>(&self,
682 body_id: ast::NodeId,
683 param_env: ty::ParamEnv<'tcx>,
685 where T : TypeFoldable<'tcx>
687 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
688 self.register_infer_ok_obligations(ok)
692 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
694 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
695 fn visit_item(&mut self, i: &'tcx hir::Item) {
696 check_item_type(self.tcx, i);
698 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
699 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
702 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
703 tcx.sess.track_errors(|| {
704 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
705 tcx.hir().krate().visit_all_item_likes(&mut visit.as_deep_visitor());
709 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
710 tcx.sess.track_errors(|| {
711 tcx.hir().krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
715 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
716 tcx.typeck_item_bodies(LOCAL_CRATE)
719 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
720 -> Result<(), CompileIncomplete>
722 debug_assert!(crate_num == LOCAL_CRATE);
723 Ok(tcx.sess.track_errors(|| {
724 tcx.par_body_owners(|body_owner_def_id| {
725 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
730 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
731 wfcheck::check_item_well_formed(tcx, def_id);
734 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
735 wfcheck::check_trait_item(tcx, def_id);
738 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
739 wfcheck::check_impl_item(tcx, def_id);
742 pub fn provide(providers: &mut Providers) {
743 method::provide(providers);
744 *providers = Providers {
750 check_item_well_formed,
751 check_trait_item_well_formed,
752 check_impl_item_well_formed,
757 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
759 -> Option<ty::Destructor> {
760 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
763 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
764 /// with information about it's body-id and fn-decl (if any). Otherwise,
767 /// If this function returns "some", then `typeck_tables(def_id)` will
768 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
769 /// may not succeed. In some cases where this function returns `None`
770 /// (notably closures), `typeck_tables(def_id)` would wind up
771 /// redirecting to the owning function.
772 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
774 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
776 match tcx.hir().get(id) {
777 Node::Item(item) => {
779 hir::ItemKind::Const(_, body) |
780 hir::ItemKind::Static(_, _, body) =>
782 hir::ItemKind::Fn(ref decl, .., body) =>
783 Some((body, Some(decl))),
788 Node::TraitItem(item) => {
790 hir::TraitItemKind::Const(_, Some(body)) =>
792 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
793 Some((body, Some(&sig.decl))),
798 Node::ImplItem(item) => {
800 hir::ImplItemKind::Const(_, body) =>
802 hir::ImplItemKind::Method(ref sig, body) =>
803 Some((body, Some(&sig.decl))),
808 Node::AnonConst(constant) => Some((constant.body, None)),
813 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
816 // Closures' tables come from their outermost function,
817 // as they are part of the same "inference environment".
818 let outer_def_id = tcx.closure_base_def_id(def_id);
819 if outer_def_id != def_id {
820 return tcx.has_typeck_tables(outer_def_id);
823 let id = tcx.hir().as_local_node_id(def_id).unwrap();
824 primary_body_of(tcx, id).is_some()
827 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
830 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
833 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
835 -> &'tcx ty::TypeckTables<'tcx> {
836 // Closures' tables come from their outermost function,
837 // as they are part of the same "inference environment".
838 let outer_def_id = tcx.closure_base_def_id(def_id);
839 if outer_def_id != def_id {
840 return tcx.typeck_tables_of(outer_def_id);
843 let id = tcx.hir().as_local_node_id(def_id).unwrap();
844 let span = tcx.hir().span(id);
846 // Figure out what primary body this item has.
847 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
848 span_bug!(span, "can't type-check body of {:?}", def_id);
850 let body = tcx.hir().body(body_id);
852 let tables = Inherited::build(tcx, def_id).enter(|inh| {
853 let param_env = tcx.param_env(def_id);
854 let fcx = if let Some(decl) = fn_decl {
855 let fn_sig = tcx.fn_sig(def_id);
857 check_abi(tcx, span, fn_sig.abi());
859 // Compute the fty from point of view of inside the fn.
861 tcx.liberate_late_bound_regions(def_id, &fn_sig);
863 inh.normalize_associated_types_in(body.value.span,
868 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
871 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
872 let expected_type = tcx.type_of(def_id);
873 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
874 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
876 let revealed_ty = if tcx.features().impl_trait_in_bindings {
877 fcx.instantiate_opaque_types_from_value(
885 // Gather locals in statics (because of block expressions).
886 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
888 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
893 // All type checking constraints were added, try to fallback unsolved variables.
894 fcx.select_obligations_where_possible(false);
895 let mut fallback_has_occurred = false;
896 for ty in &fcx.unsolved_variables() {
897 fallback_has_occurred |= fcx.fallback_if_possible(ty);
899 fcx.select_obligations_where_possible(fallback_has_occurred);
901 // Even though coercion casts provide type hints, we check casts after fallback for
902 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
905 // Closure and generator analysis may run after fallback
906 // because they don't constrain other type variables.
907 fcx.closure_analyze(body);
908 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
909 fcx.resolve_generator_interiors(def_id);
911 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
912 let ty = fcx.normalize_ty(span, ty);
913 fcx.require_type_is_sized(ty, span, code);
915 fcx.select_all_obligations_or_error();
917 if fn_decl.is_some() {
918 fcx.regionck_fn(id, body);
920 fcx.regionck_expr(body);
923 fcx.resolve_type_vars_in_body(body)
926 // Consistency check our TypeckTables instance can hold all ItemLocalIds
927 // it will need to hold.
928 assert_eq!(tables.local_id_root,
929 Some(DefId::local(tcx.hir().definitions().node_to_hir_id(id).owner)));
933 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
934 if !tcx.sess.target.target.is_abi_supported(abi) {
935 struct_span_err!(tcx.sess, span, E0570,
936 "The ABI `{}` is not supported for the current target", abi).emit()
940 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
941 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
942 parent_id: ast::NodeId,
945 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
946 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
949 // infer the variable's type
950 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
951 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
958 // take type that the user specified
959 self.fcx.locals.borrow_mut().insert(nid, typ);
966 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
967 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
968 NestedVisitorMap::None
971 // Add explicitly-declared locals.
972 fn visit_local(&mut self, local: &'gcx hir::Local) {
973 let local_ty = match local.ty {
975 let o_ty = self.fcx.to_ty(&ty);
977 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
978 self.fcx.instantiate_opaque_types_from_value(
986 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(&revealed_ty);
987 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
988 ty.hir_id, o_ty, revealed_ty, c_ty);
989 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
991 Some(LocalTy { decl_ty: o_ty, revealed_ty })
995 self.assign(local.span, local.id, local_ty);
997 debug!("Local variable {:?} is assigned type {}",
999 self.fcx.ty_to_string(
1000 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
1001 intravisit::walk_local(self, local);
1004 // Add pattern bindings.
1005 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1006 if let PatKind::Binding(_, _, ident, _) = p.node {
1007 let var_ty = self.assign(p.span, p.id, None);
1009 if !self.fcx.tcx.features().unsized_locals {
1010 self.fcx.require_type_is_sized(var_ty, p.span,
1011 traits::VariableType(p.id));
1014 debug!("Pattern binding {} is assigned to {} with type {:?}",
1016 self.fcx.ty_to_string(
1017 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1020 intravisit::walk_pat(self, p);
1023 // Don't descend into the bodies of nested closures
1024 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1025 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1028 /// When `check_fn` is invoked on a generator (i.e., a body that
1029 /// includes yield), it returns back some information about the yield
1031 struct GeneratorTypes<'tcx> {
1032 /// Type of value that is yielded.
1033 yield_ty: ty::Ty<'tcx>,
1035 /// Types that are captured (see `GeneratorInterior` for more).
1036 interior: ty::Ty<'tcx>,
1038 /// Indicates if the generator is movable or static (immovable)
1039 movability: hir::GeneratorMovability,
1042 /// Helper used for fns and closures. Does the grungy work of checking a function
1043 /// body and returns the function context used for that purpose, since in the case of a fn item
1044 /// there is still a bit more to do.
1047 /// * inherited: other fields inherited from the enclosing fn (if any)
1048 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1049 param_env: ty::ParamEnv<'tcx>,
1050 fn_sig: ty::FnSig<'tcx>,
1051 decl: &'gcx hir::FnDecl,
1053 body: &'gcx hir::Body,
1054 can_be_generator: Option<hir::GeneratorMovability>)
1055 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1057 let mut fn_sig = fn_sig.clone();
1059 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1061 // Create the function context. This is either derived from scratch or,
1062 // in the case of closures, based on the outer context.
1063 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1064 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1066 let declared_ret_ty = fn_sig.output();
1067 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1068 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1069 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1070 fn_sig = fcx.tcx.mk_fn_sig(
1071 fn_sig.inputs().iter().cloned(),
1078 let span = body.value.span;
1080 if body.is_generator && can_be_generator.is_some() {
1081 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1082 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1083 fcx.yield_ty = Some(yield_ty);
1086 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1087 let outer_node_id = fcx.tcx.hir().as_local_node_id(outer_def_id).unwrap();
1088 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1090 // Add formal parameters.
1091 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1092 // Check the pattern.
1093 fcx.check_pat_walk(&arg.pat, arg_ty,
1094 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1096 // Check that argument is Sized.
1097 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1098 // for simple cases like `fn foo(x: Trait)`,
1099 // where we would error once on the parameter as a whole, and once on the binding `x`.
1100 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1101 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1104 fcx.write_ty(arg.hir_id, arg_ty);
1107 let fn_hir_id = fcx.tcx.hir().node_to_hir_id(fn_id);
1108 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1110 fcx.check_return_expr(&body.value);
1112 // We insert the deferred_generator_interiors entry after visiting the body.
1113 // This ensures that all nested generators appear before the entry of this generator.
1114 // resolve_generator_interiors relies on this property.
1115 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1116 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1117 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1118 Some(GeneratorTypes {
1119 yield_ty: fcx.yield_ty.unwrap(),
1121 movability: can_be_generator.unwrap(),
1127 // Finalize the return check by taking the LUB of the return types
1128 // we saw and assigning it to the expected return type. This isn't
1129 // really expected to fail, since the coercions would have failed
1130 // earlier when trying to find a LUB.
1132 // However, the behavior around `!` is sort of complex. In the
1133 // event that the `actual_return_ty` comes back as `!`, that
1134 // indicates that the fn either does not return or "returns" only
1135 // values of type `!`. In this case, if there is an expected
1136 // return type that is *not* `!`, that should be ok. But if the
1137 // return type is being inferred, we want to "fallback" to `!`:
1139 // let x = move || panic!();
1141 // To allow for that, I am creating a type variable with diverging
1142 // fallback. This was deemed ever so slightly better than unifying
1143 // the return value with `!` because it allows for the caller to
1144 // make more assumptions about the return type (e.g., they could do
1146 // let y: Option<u32> = Some(x());
1148 // which would then cause this return type to become `u32`, not
1150 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1151 let mut actual_return_ty = coercion.complete(&fcx);
1152 if actual_return_ty.is_never() {
1153 actual_return_ty = fcx.next_diverging_ty_var(
1154 TypeVariableOrigin::DivergingFn(span));
1156 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1158 // Check that the main return type implements the termination trait.
1159 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1160 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1162 if let config::EntryFnType::Main = entry_type {
1163 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1164 let trait_ref = ty::TraitRef::new(term_id, substs);
1165 let return_ty_span = decl.output.span();
1166 let cause = traits::ObligationCause::new(
1167 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1169 inherited.register_predicate(
1170 traits::Obligation::new(
1171 cause, param_env, trait_ref.to_predicate()));
1177 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1178 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1179 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1180 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1181 // at this point we don't care if there are duplicate handlers or if the handler has
1182 // the wrong signature as this value we'll be used when writing metadata and that
1183 // only happens if compilation succeeded
1184 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1186 if declared_ret_ty.sty != ty::Never {
1187 fcx.tcx.sess.span_err(
1189 "return type should be `!`",
1193 let inputs = fn_sig.inputs();
1194 let span = fcx.tcx.hir().span(fn_id);
1195 if inputs.len() == 1 {
1196 let arg_is_panic_info = match inputs[0].sty {
1197 ty::Ref(region, ty, mutbl) => match ty.sty {
1198 ty::Adt(ref adt, _) => {
1199 adt.did == panic_info_did &&
1200 mutbl == hir::Mutability::MutImmutable &&
1201 *region != RegionKind::ReStatic
1208 if !arg_is_panic_info {
1209 fcx.tcx.sess.span_err(
1210 decl.inputs[0].span,
1211 "argument should be `&PanicInfo`",
1215 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1216 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1217 if !generics.params.is_empty() {
1218 fcx.tcx.sess.span_err(
1220 "should have no type parameters",
1226 let span = fcx.tcx.sess.source_map().def_span(span);
1227 fcx.tcx.sess.span_err(span, "function should have one argument");
1230 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1235 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1236 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1237 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1238 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1239 if declared_ret_ty.sty != ty::Never {
1240 fcx.tcx.sess.span_err(
1242 "return type should be `!`",
1246 let inputs = fn_sig.inputs();
1247 let span = fcx.tcx.hir().span(fn_id);
1248 if inputs.len() == 1 {
1249 let arg_is_alloc_layout = match inputs[0].sty {
1250 ty::Adt(ref adt, _) => {
1251 adt.did == alloc_layout_did
1256 if !arg_is_alloc_layout {
1257 fcx.tcx.sess.span_err(
1258 decl.inputs[0].span,
1259 "argument should be `Layout`",
1263 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1264 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1265 if !generics.params.is_empty() {
1266 fcx.tcx.sess.span_err(
1268 "`#[alloc_error_handler]` function should have no type \
1275 let span = fcx.tcx.sess.source_map().def_span(span);
1276 fcx.tcx.sess.span_err(span, "function should have one argument");
1279 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1287 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1290 let def_id = tcx.hir().local_def_id(id);
1291 let def = tcx.adt_def(def_id);
1292 def.destructor(tcx); // force the destructor to be evaluated
1293 check_representable(tcx, span, def_id);
1295 if def.repr.simd() {
1296 check_simd(tcx, span, def_id);
1299 check_transparent(tcx, span, def_id);
1300 check_packed(tcx, span, def_id);
1303 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1306 let def_id = tcx.hir().local_def_id(id);
1307 let def = tcx.adt_def(def_id);
1308 def.destructor(tcx); // force the destructor to be evaluated
1309 check_representable(tcx, span, def_id);
1311 check_packed(tcx, span, def_id);
1314 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1316 "check_item_type(it.id={}, it.name={})",
1318 tcx.item_path_str(tcx.hir().local_def_id(it.id))
1320 let _indenter = indenter();
1322 // Consts can play a role in type-checking, so they are included here.
1323 hir::ItemKind::Static(..) => {
1324 let def_id = tcx.hir().local_def_id(it.id);
1325 tcx.typeck_tables_of(def_id);
1326 maybe_check_static_with_link_section(tcx, def_id, it.span);
1328 hir::ItemKind::Const(..) => {
1329 tcx.typeck_tables_of(tcx.hir().local_def_id(it.id));
1331 hir::ItemKind::Enum(ref enum_definition, _) => {
1332 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1334 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1335 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1336 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1337 let impl_def_id = tcx.hir().local_def_id(it.id);
1338 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1339 check_impl_items_against_trait(
1346 let trait_def_id = impl_trait_ref.def_id;
1347 check_on_unimplemented(tcx, trait_def_id, it);
1350 hir::ItemKind::Trait(..) => {
1351 let def_id = tcx.hir().local_def_id(it.id);
1352 check_on_unimplemented(tcx, def_id, it);
1354 hir::ItemKind::Struct(..) => {
1355 check_struct(tcx, it.id, it.span);
1357 hir::ItemKind::Union(..) => {
1358 check_union(tcx, it.id, it.span);
1360 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1361 let def_id = tcx.hir().local_def_id(it.id);
1362 let pty_ty = tcx.type_of(def_id);
1363 let generics = tcx.generics_of(def_id);
1364 check_bounds_are_used(tcx, &generics, pty_ty);
1366 hir::ItemKind::ForeignMod(ref m) => {
1367 check_abi(tcx, it.span, m.abi);
1369 if m.abi == Abi::RustIntrinsic {
1370 for item in &m.items {
1371 intrinsic::check_intrinsic_type(tcx, item);
1373 } else if m.abi == Abi::PlatformIntrinsic {
1374 for item in &m.items {
1375 intrinsic::check_platform_intrinsic_type(tcx, item);
1378 for item in &m.items {
1379 let generics = tcx.generics_of(tcx.hir().local_def_id(item.id));
1380 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1381 let mut err = struct_span_err!(
1385 "foreign items may not have type parameters"
1387 err.span_label(item.span, "can't have type parameters");
1388 // FIXME: once we start storing spans for type arguments, turn this into a
1391 "use specialization instead of type parameters by replacing them \
1392 with concrete types like `u32`",
1397 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1398 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1403 _ => { /* nothing to do */ }
1407 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1408 // Only restricted on wasm32 target for now
1409 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1413 // If `#[link_section]` is missing, then nothing to verify
1414 let attrs = tcx.codegen_fn_attrs(id);
1415 if attrs.link_section.is_none() {
1419 // For the wasm32 target statics with #[link_section] are placed into custom
1420 // sections of the final output file, but this isn't link custom sections of
1421 // other executable formats. Namely we can only embed a list of bytes,
1422 // nothing with pointers to anything else or relocations. If any relocation
1423 // show up, reject them here.
1424 let instance = ty::Instance::mono(tcx, id);
1425 let cid = GlobalId {
1429 let param_env = ty::ParamEnv::reveal_all();
1430 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1431 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1434 bug!("Matching on non-ByRef static")
1436 if alloc.relocations.len() != 0 {
1437 let msg = "statics with a custom `#[link_section]` must be a \
1438 simple list of bytes on the wasm target with no \
1439 extra levels of indirection such as references";
1440 tcx.sess.span_err(span, msg);
1445 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1446 trait_def_id: DefId,
1448 let item_def_id = tcx.hir().local_def_id(item.id);
1449 // an error would be reported if this fails.
1450 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1453 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1454 impl_item: &hir::ImplItem,
1457 let mut err = struct_span_err!(
1458 tcx.sess, impl_item.span, E0520,
1459 "`{}` specializes an item from a parent `impl`, but \
1460 that item is not marked `default`",
1462 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1465 match tcx.span_of_impl(parent_impl) {
1467 err.span_label(span, "parent `impl` is here");
1468 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1472 err.note(&format!("parent implementation is in crate `{}`", cname));
1479 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1480 trait_def: &ty::TraitDef,
1481 trait_item: &ty::AssociatedItem,
1483 impl_item: &hir::ImplItem)
1485 let ancestors = trait_def.ancestors(tcx, impl_id);
1487 let kind = match impl_item.node {
1488 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1489 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1490 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1491 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1494 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1495 .map(|node_item| node_item.map(|parent| parent.defaultness));
1497 if let Some(parent) = parent {
1498 if tcx.impl_item_is_final(&parent) {
1499 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1505 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1508 impl_trait_ref: ty::TraitRef<'tcx>,
1509 impl_item_refs: &[hir::ImplItemRef]) {
1510 let impl_span = tcx.sess.source_map().def_span(impl_span);
1512 // If the trait reference itself is erroneous (so the compilation is going
1513 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1514 // isn't populated for such impls.
1515 if impl_trait_ref.references_error() { return; }
1517 // Locate trait definition and items
1518 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1519 let mut overridden_associated_type = None;
1521 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1523 // Check existing impl methods to see if they are both present in trait
1524 // and compatible with trait signature
1525 for impl_item in impl_items() {
1526 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.id));
1527 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1528 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1529 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1531 // Not compatible, but needed for the error message
1532 tcx.associated_items(impl_trait_ref.def_id)
1533 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1536 // Check that impl definition matches trait definition
1537 if let Some(ty_trait_item) = ty_trait_item {
1538 match impl_item.node {
1539 hir::ImplItemKind::Const(..) => {
1540 // Find associated const definition.
1541 if ty_trait_item.kind == ty::AssociatedKind::Const {
1542 compare_const_impl(tcx,
1548 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1549 "item `{}` is an associated const, \
1550 which doesn't match its trait `{}`",
1553 err.span_label(impl_item.span, "does not match trait");
1554 // We can only get the spans from local trait definition
1555 // Same for E0324 and E0325
1556 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1557 err.span_label(trait_span, "item in trait");
1562 hir::ImplItemKind::Method(..) => {
1563 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1564 if ty_trait_item.kind == ty::AssociatedKind::Method {
1565 compare_impl_method(tcx,
1572 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1573 "item `{}` is an associated method, \
1574 which doesn't match its trait `{}`",
1577 err.span_label(impl_item.span, "does not match trait");
1578 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1579 err.span_label(trait_span, "item in trait");
1584 hir::ImplItemKind::Existential(..) |
1585 hir::ImplItemKind::Type(_) => {
1586 if ty_trait_item.kind == ty::AssociatedKind::Type {
1587 if ty_trait_item.defaultness.has_value() {
1588 overridden_associated_type = Some(impl_item);
1591 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1592 "item `{}` is an associated type, \
1593 which doesn't match its trait `{}`",
1596 err.span_label(impl_item.span, "does not match trait");
1597 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1598 err.span_label(trait_span, "item in trait");
1605 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1609 // Check for missing items from trait
1610 let mut missing_items = Vec::new();
1611 let mut invalidated_items = Vec::new();
1612 let associated_type_overridden = overridden_associated_type.is_some();
1613 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1614 let is_implemented = trait_def.ancestors(tcx, impl_id)
1615 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1617 .map(|node_item| !node_item.node.is_from_trait())
1620 if !is_implemented && !tcx.impl_is_default(impl_id) {
1621 if !trait_item.defaultness.has_value() {
1622 missing_items.push(trait_item);
1623 } else if associated_type_overridden {
1624 invalidated_items.push(trait_item.ident);
1629 if !missing_items.is_empty() {
1630 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1631 "not all trait items implemented, missing: `{}`",
1632 missing_items.iter()
1633 .map(|trait_item| trait_item.ident.to_string())
1634 .collect::<Vec<_>>().join("`, `"));
1635 err.span_label(impl_span, format!("missing `{}` in implementation",
1636 missing_items.iter()
1637 .map(|trait_item| trait_item.ident.to_string())
1638 .collect::<Vec<_>>().join("`, `")));
1639 for trait_item in missing_items {
1640 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1641 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1643 err.note_trait_signature(trait_item.ident.to_string(),
1644 trait_item.signature(&tcx));
1650 if !invalidated_items.is_empty() {
1651 let invalidator = overridden_associated_type.unwrap();
1652 span_err!(tcx.sess, invalidator.span, E0399,
1653 "the following trait items need to be reimplemented \
1654 as `{}` was overridden: `{}`",
1656 invalidated_items.iter()
1657 .map(|name| name.to_string())
1658 .collect::<Vec<_>>().join("`, `"))
1662 /// Checks whether a type can be represented in memory. In particular, it
1663 /// identifies types that contain themselves without indirection through a
1664 /// pointer, which would mean their size is unbounded.
1665 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1669 let rty = tcx.type_of(item_def_id);
1671 // Check that it is possible to represent this type. This call identifies
1672 // (1) types that contain themselves and (2) types that contain a different
1673 // recursive type. It is only necessary to throw an error on those that
1674 // contain themselves. For case 2, there must be an inner type that will be
1675 // caught by case 1.
1676 match rty.is_representable(tcx, sp) {
1677 Representability::SelfRecursive(spans) => {
1678 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1680 err.span_label(span, "recursive without indirection");
1685 Representability::Representable | Representability::ContainsRecursive => (),
1690 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1691 let t = tcx.type_of(def_id);
1692 if let ty::Adt(def, substs) = t.sty {
1693 if def.is_struct() {
1694 let fields = &def.non_enum_variant().fields;
1695 if fields.is_empty() {
1696 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1699 let e = fields[0].ty(tcx, substs);
1700 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1701 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1702 .span_label(sp, "SIMD elements must have the same type")
1707 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1708 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1710 span_err!(tcx.sess, sp, E0077,
1711 "SIMD vector element type should be machine type");
1719 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1720 let repr = tcx.adt_def(def_id).repr;
1722 for attr in tcx.get_attrs(def_id).iter() {
1723 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1724 if let attr::ReprPacked(pack) = r {
1725 if pack != repr.pack {
1726 struct_span_err!(tcx.sess, sp, E0634,
1727 "type has conflicting packed representation hints").emit();
1733 struct_span_err!(tcx.sess, sp, E0587,
1734 "type has conflicting packed and align representation hints").emit();
1736 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1737 struct_span_err!(tcx.sess, sp, E0588,
1738 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1743 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1745 stack: &mut Vec<DefId>) -> bool {
1746 let t = tcx.type_of(def_id);
1747 if stack.contains(&def_id) {
1748 debug!("check_packed_inner: {:?} is recursive", t);
1751 if let ty::Adt(def, substs) = t.sty {
1752 if def.is_struct() || def.is_union() {
1753 if tcx.adt_def(def.did).repr.align > 0 {
1756 // push struct def_id before checking fields
1758 for field in &def.non_enum_variant().fields {
1759 let f = field.ty(tcx, substs);
1760 if let ty::Adt(def, _) = f.sty {
1761 if check_packed_inner(tcx, def.did, stack) {
1766 // only need to pop if not early out
1773 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1774 let adt = tcx.adt_def(def_id);
1775 if !adt.repr.transparent() {
1779 // For each field, figure out if it's known to be a ZST and align(1)
1780 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1781 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1782 let param_env = tcx.param_env(field.did);
1783 let layout = tcx.layout_of(param_env.and(ty));
1784 // We are currently checking the type this field came from, so it must be local
1785 let span = tcx.hir().span_if_local(field.did).unwrap();
1786 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1787 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1791 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1792 let non_zst_count = non_zst_fields.clone().count();
1793 if non_zst_count != 1 {
1794 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1795 struct_span_err!(tcx.sess, sp, E0690,
1796 "transparent struct needs exactly one non-zero-sized field, but has {}",
1798 .span_note(field_spans, "non-zero-sized field")
1801 for (span, zst, align1) in field_infos {
1803 span_err!(tcx.sess, span, E0691,
1804 "zero-sized field in transparent struct has alignment larger than 1");
1809 #[allow(trivial_numeric_casts)]
1810 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1812 vs: &'tcx [hir::Variant],
1814 let def_id = tcx.hir().local_def_id(id);
1815 let def = tcx.adt_def(def_id);
1816 def.destructor(tcx); // force the destructor to be evaluated
1819 let attributes = tcx.get_attrs(def_id);
1820 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1822 tcx.sess, attr.span, E0084,
1823 "unsupported representation for zero-variant enum")
1824 .span_label(sp, "zero-variant enum")
1829 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1830 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1831 if !tcx.features().repr128 {
1832 emit_feature_err(&tcx.sess.parse_sess,
1835 GateIssue::Language,
1836 "repr with 128-bit type is unstable");
1841 if let Some(ref e) = v.node.disr_expr {
1842 tcx.typeck_tables_of(tcx.hir().local_def_id(e.id));
1846 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1847 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1848 // Check for duplicate discriminant values
1849 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1850 let variant_did = def.variants[VariantIdx::new(i)].did;
1851 let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap();
1852 let variant_i = tcx.hir().expect_variant(variant_i_node_id);
1853 let i_span = match variant_i.node.disr_expr {
1854 Some(ref expr) => tcx.hir().span(expr.id),
1855 None => tcx.hir().span(variant_i_node_id)
1857 let span = match v.node.disr_expr {
1858 Some(ref expr) => tcx.hir().span(expr.id),
1861 struct_span_err!(tcx.sess, span, E0081,
1862 "discriminant value `{}` already exists", disr_vals[i])
1863 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1864 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1867 disr_vals.push(discr);
1870 check_representable(tcx, sp, def_id);
1873 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1874 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1876 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1877 -> Lrc<ty::GenericPredicates<'tcx>>
1880 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
1881 let item_id = tcx.hir().ty_param_owner(node_id);
1882 let item_def_id = tcx.hir().local_def_id(item_id);
1883 let generics = tcx.generics_of(item_def_id);
1884 let index = generics.param_def_id_to_index[&def_id];
1885 Lrc::new(ty::GenericPredicates {
1887 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1889 ty::Predicate::Trait(ref data)
1890 if data.skip_binder().self_ty().is_param(index) => {
1891 // HACK(eddyb) should get the original `Span`.
1892 let span = tcx.def_span(def_id);
1893 Some((predicate, span))
1901 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1902 -> Option<ty::Region<'tcx>> {
1904 Some(def) => infer::EarlyBoundRegion(span, def.name),
1905 None => infer::MiscVariable(span)
1907 Some(self.next_region_var(v))
1910 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1911 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1914 fn ty_infer_for_def(&self,
1915 ty_param_def: &ty::GenericParamDef,
1916 span: Span) -> Ty<'tcx> {
1917 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1923 fn projected_ty_from_poly_trait_ref(&self,
1926 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1929 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1931 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1935 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1938 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1939 if ty.has_escaping_bound_vars() {
1940 ty // FIXME: normalization and escaping regions
1942 self.normalize_associated_types_in(span, &ty)
1946 fn set_tainted_by_errors(&self) {
1947 self.infcx.set_tainted_by_errors()
1950 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1951 self.write_ty(hir_id, ty)
1955 /// Controls whether the arguments are tupled. This is used for the call
1958 /// Tupling means that all call-side arguments are packed into a tuple and
1959 /// passed as a single parameter. For example, if tupling is enabled, this
1962 /// fn f(x: (isize, isize))
1964 /// Can be called as:
1971 #[derive(Clone, Eq, PartialEq)]
1972 enum TupleArgumentsFlag {
1977 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1978 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1979 param_env: ty::ParamEnv<'tcx>,
1980 body_id: ast::NodeId)
1981 -> FnCtxt<'a, 'gcx, 'tcx> {
1985 err_count_on_creation: inh.tcx.sess.err_count(),
1988 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1989 ast::CRATE_NODE_ID)),
1990 diverges: Cell::new(Diverges::Maybe),
1991 has_errors: Cell::new(false),
1992 enclosing_breakables: RefCell::new(EnclosingBreakables {
1994 by_id: Default::default(),
2000 pub fn sess(&self) -> &Session {
2004 pub fn err_count_since_creation(&self) -> usize {
2005 self.tcx.sess.err_count() - self.err_count_on_creation
2008 /// Produce warning on the given node, if the current point in the
2009 /// function is unreachable, and there hasn't been another warning.
2010 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2011 if self.diverges.get() == Diverges::Always {
2012 self.diverges.set(Diverges::WarnedAlways);
2014 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2016 self.tcx().lint_node(
2017 lint::builtin::UNREACHABLE_CODE,
2019 &format!("unreachable {}", kind));
2025 code: ObligationCauseCode<'tcx>)
2026 -> ObligationCause<'tcx> {
2027 ObligationCause::new(span, self.body_id, code)
2030 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2031 self.cause(span, ObligationCauseCode::MiscObligation)
2034 /// Resolves type variables in `ty` if possible. Unlike the infcx
2035 /// version (resolve_type_vars_if_possible), this version will
2036 /// also select obligations if it seems useful, in an effort
2037 /// to get more type information.
2038 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2039 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2041 // No Infer()? Nothing needs doing.
2042 if !ty.has_infer_types() {
2043 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2047 // If `ty` is a type variable, see whether we already know what it is.
2048 ty = self.resolve_type_vars_if_possible(&ty);
2049 if !ty.has_infer_types() {
2050 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2054 // If not, try resolving pending obligations as much as
2055 // possible. This can help substantially when there are
2056 // indirect dependencies that don't seem worth tracking
2058 self.select_obligations_where_possible(false);
2059 ty = self.resolve_type_vars_if_possible(&ty);
2061 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2065 fn record_deferred_call_resolution(&self,
2066 closure_def_id: DefId,
2067 r: DeferredCallResolution<'gcx, 'tcx>) {
2068 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2069 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2072 fn remove_deferred_call_resolutions(&self,
2073 closure_def_id: DefId)
2074 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2076 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2077 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2080 pub fn tag(&self) -> String {
2081 let self_ptr: *const FnCtxt = self;
2082 format!("{:?}", self_ptr)
2085 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2086 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2087 span_bug!(span, "no type for local variable {}",
2088 self.tcx.hir().node_to_string(nid))
2093 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2094 debug!("write_ty({:?}, {:?}) in fcx {}",
2095 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2096 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2098 if ty.references_error() {
2099 self.has_errors.set(true);
2100 self.set_tainted_by_errors();
2104 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2105 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
2106 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2109 // The NodeId and the ItemLocalId must identify the same item. We just pass
2110 // both of them for consistency checking.
2111 pub fn write_method_call(&self,
2113 method: MethodCallee<'tcx>) {
2114 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2117 .type_dependent_defs_mut()
2118 .insert(hir_id, Def::Method(method.def_id));
2120 self.write_substs(hir_id, method.substs);
2122 // When the method is confirmed, the `method.substs` includes
2123 // parameters from not just the method, but also the impl of
2124 // the method -- in particular, the `Self` type will be fully
2125 // resolved. However, those are not something that the "user
2126 // specified" -- i.e., those types come from the inferred type
2127 // of the receiver, not something the user wrote. So when we
2128 // create the user-substs, we want to replace those earlier
2129 // types with just the types that the user actually wrote --
2130 // that is, those that appear on the *method itself*.
2132 // As an example, if the user wrote something like
2133 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2134 // type of `foo` (possibly adjusted), but we don't want to
2135 // include that. We want just the `[_, u32]` part.
2136 if !method.substs.is_noop() {
2137 let method_generics = self.tcx.generics_of(method.def_id);
2138 if !method_generics.params.is_empty() {
2139 let user_substs = self.infcx.probe(|_| {
2140 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2141 let i = param.index as usize;
2142 if i < method_generics.parent_count {
2143 self.infcx.var_for_def(DUMMY_SP, param)
2148 self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2149 substs: just_method_substs,
2150 user_self_ty: None, // not relevant here
2154 debug!("write_method_call: user_substs = {:?}", user_substs);
2155 self.write_user_substs(hir_id, user_substs);
2160 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2161 if !substs.is_noop() {
2162 debug!("write_substs({:?}, {:?}) in fcx {}",
2167 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2171 /// Given the substs that we just converted from the HIR, try to
2172 /// canonicalize them and store them as user-given substitutions
2173 /// (i.e., substitutions that must be respected by the NLL check).
2175 /// This should be invoked **before any unifications have
2176 /// occurred**, so that annotations like `Vec<_>` are preserved
2178 pub fn write_user_substs_from_substs(
2181 substs: &'tcx Substs<'tcx>,
2182 user_self_ty: Option<UserSelfTy<'tcx>>,
2185 "write_user_substs_from_substs({:?}, {:?}) in fcx {}",
2191 if !substs.is_noop() {
2192 let user_substs = self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2196 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2197 self.write_user_substs(hir_id, user_substs);
2201 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalUserSubsts<'tcx>) {
2203 "write_user_substs({:?}, {:?}) in fcx {}",
2209 if !substs.is_identity() {
2210 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2212 debug!("write_user_substs: skipping identity substs");
2216 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2217 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2223 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2224 Entry::Vacant(entry) => { entry.insert(adj); },
2225 Entry::Occupied(mut entry) => {
2226 debug!(" - composing on top of {:?}", entry.get());
2227 match (&entry.get()[..], &adj[..]) {
2228 // Applying any adjustment on top of a NeverToAny
2229 // is a valid NeverToAny adjustment, because it can't
2231 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2233 Adjustment { kind: Adjust::Deref(_), .. },
2234 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2236 Adjustment { kind: Adjust::Deref(_), .. },
2237 .. // Any following adjustments are allowed.
2239 // A reborrow has no effect before a dereference.
2241 // FIXME: currently we never try to compose autoderefs
2242 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2244 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2245 expr, entry.get(), adj)
2247 *entry.get_mut() = adj;
2252 /// Basically whenever we are converting from a type scheme into
2253 /// the fn body space, we always want to normalize associated
2254 /// types as well. This function combines the two.
2255 fn instantiate_type_scheme<T>(&self,
2257 substs: &Substs<'tcx>,
2260 where T : TypeFoldable<'tcx>
2262 let value = value.subst(self.tcx, substs);
2263 let result = self.normalize_associated_types_in(span, &value);
2264 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2271 /// As `instantiate_type_scheme`, but for the bounds found in a
2272 /// generic type scheme.
2273 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2274 -> ty::InstantiatedPredicates<'tcx> {
2275 let bounds = self.tcx.predicates_of(def_id);
2276 let result = bounds.instantiate(self.tcx, substs);
2277 let result = self.normalize_associated_types_in(span, &result);
2278 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2285 /// Replace the opaque types from the given value with type variables,
2286 /// and records the `OpaqueTypeMap` for later use during writeback. See
2287 /// `InferCtxt::instantiate_opaque_types` for more details.
2288 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2290 parent_id: ast::NodeId,
2293 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2294 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2298 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2299 self.instantiate_opaque_types(
2307 let mut opaque_types = self.opaque_types.borrow_mut();
2308 for (ty, decl) in opaque_type_map {
2309 let old_value = opaque_types.insert(ty, decl);
2310 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2316 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2317 where T : TypeFoldable<'tcx>
2319 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2322 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2324 where T : TypeFoldable<'tcx>
2326 self.inh.partially_normalize_associated_types_in(span,
2332 pub fn require_type_meets(&self,
2335 code: traits::ObligationCauseCode<'tcx>,
2338 self.register_bound(
2341 traits::ObligationCause::new(span, self.body_id, code));
2344 pub fn require_type_is_sized(&self,
2347 code: traits::ObligationCauseCode<'tcx>)
2349 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2350 self.require_type_meets(ty, span, code, lang_item);
2353 pub fn require_type_is_sized_deferred(&self,
2356 code: traits::ObligationCauseCode<'tcx>)
2358 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2361 pub fn register_bound(&self,
2364 cause: traits::ObligationCause<'tcx>)
2366 self.fulfillment_cx.borrow_mut()
2367 .register_bound(self, self.param_env, ty, def_id, cause);
2370 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2371 let t = AstConv::ast_ty_to_ty(self, ast_t);
2372 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2376 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2377 let ty = self.to_ty(ast_ty);
2379 // If the type given by the user has free regions, save it for
2380 // later, since NLL would like to enforce those. Also pass in
2381 // types that involve projections, since those can resolve to
2382 // `'static` bounds (modulo #54940, which hopefully will be
2383 // fixed by the time you see this comment, dear reader,
2384 // although I have my doubts). Other sorts of things are
2385 // already sufficiently enforced with erased regions. =)
2386 if ty.has_free_regions() || ty.has_projections() {
2387 let c_ty = self.infcx.canonicalize_response(&ty);
2388 self.tables.borrow_mut().user_provided_tys_mut().insert(ast_ty.hir_id, c_ty);
2394 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2395 match self.tables.borrow().node_types().get(id) {
2397 None if self.is_tainted_by_errors() => self.tcx.types.err,
2399 let node_id = self.tcx.hir().hir_to_node_id(id);
2400 bug!("no type for node {}: {} in fcx {}",
2401 node_id, self.tcx.hir().node_to_string(node_id),
2407 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2408 /// outlive the region `r`.
2409 pub fn register_wf_obligation(&self,
2412 code: traits::ObligationCauseCode<'tcx>)
2414 // WF obligations never themselves fail, so no real need to give a detailed cause:
2415 let cause = traits::ObligationCause::new(span, self.body_id, code);
2416 self.register_predicate(traits::Obligation::new(cause,
2418 ty::Predicate::WellFormed(ty)));
2421 /// Registers obligations that all types appearing in `substs` are well-formed.
2422 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2423 for ty in substs.types() {
2424 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2428 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2429 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2430 /// trait/region obligations.
2432 /// For example, if there is a function:
2435 /// fn foo<'a,T:'a>(...)
2438 /// and a reference:
2444 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2445 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2446 pub fn add_obligations_for_parameters(&self,
2447 cause: traits::ObligationCause<'tcx>,
2448 predicates: &ty::InstantiatedPredicates<'tcx>)
2450 assert!(!predicates.has_escaping_bound_vars());
2452 debug!("add_obligations_for_parameters(predicates={:?})",
2455 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2456 self.register_predicate(obligation);
2460 // FIXME(arielb1): use this instead of field.ty everywhere
2461 // Only for fields! Returns <none> for methods>
2462 // Indifferent to privacy flags
2463 pub fn field_ty(&self,
2465 field: &'tcx ty::FieldDef,
2466 substs: &Substs<'tcx>)
2469 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2472 fn check_casts(&self) {
2473 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2474 for cast in deferred_cast_checks.drain(..) {
2479 fn resolve_generator_interiors(&self, def_id: DefId) {
2480 let mut generators = self.deferred_generator_interiors.borrow_mut();
2481 for (body_id, interior) in generators.drain(..) {
2482 self.select_obligations_where_possible(false);
2483 generator_interior::resolve_interior(self, def_id, body_id, interior);
2487 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2488 // Non-numerics get replaced with ! or () (depending on whether
2489 // feature(never_type) is enabled, unconstrained ints with i32,
2490 // unconstrained floats with f64.
2491 // Fallback becomes very dubious if we have encountered type-checking errors.
2492 // In that case, fallback to Error.
2493 // The return value indicates whether fallback has occurred.
2494 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2495 use rustc::ty::error::UnconstrainedNumeric::Neither;
2496 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2498 assert!(ty.is_ty_infer());
2499 let fallback = match self.type_is_unconstrained_numeric(ty) {
2500 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2501 UnconstrainedInt => self.tcx.types.i32,
2502 UnconstrainedFloat => self.tcx.types.f64,
2503 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2504 Neither => return false,
2506 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2507 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2511 fn select_all_obligations_or_error(&self) {
2512 debug!("select_all_obligations_or_error");
2513 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2514 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2518 /// Select as many obligations as we can at present.
2519 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2520 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2521 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2525 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2526 /// returns a type of `&T`, but the actual type we assign to the
2527 /// *expression* is `T`. So this function just peels off the return
2528 /// type by one layer to yield `T`.
2529 fn make_overloaded_place_return_type(&self,
2530 method: MethodCallee<'tcx>)
2531 -> ty::TypeAndMut<'tcx>
2533 // extract method return type, which will be &T;
2534 let ret_ty = method.sig.output();
2536 // method returns &T, but the type as visible to user is T, so deref
2537 ret_ty.builtin_deref(true).unwrap()
2540 fn lookup_indexing(&self,
2542 base_expr: &'gcx hir::Expr,
2546 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2548 // FIXME(#18741) -- this is almost but not quite the same as the
2549 // autoderef that normal method probing does. They could likely be
2552 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2553 let mut result = None;
2554 while result.is_none() && autoderef.next().is_some() {
2555 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2557 autoderef.finalize();
2561 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2562 /// (and otherwise adjust) `base_expr`, looking for a type which either
2563 /// supports builtin indexing or overloaded indexing.
2564 /// This loop implements one step in that search; the autoderef loop
2565 /// is implemented by `lookup_indexing`.
2566 fn try_index_step(&self,
2568 base_expr: &hir::Expr,
2569 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2572 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2574 let adjusted_ty = autoderef.unambiguous_final_ty();
2575 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2582 for &unsize in &[false, true] {
2583 let mut self_ty = adjusted_ty;
2585 // We only unsize arrays here.
2586 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2587 self_ty = self.tcx.mk_slice(element_ty);
2593 // If some lookup succeeds, write callee into table and extract index/element
2594 // type from the method signature.
2595 // If some lookup succeeded, install method in table
2596 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2597 let method = self.try_overloaded_place_op(
2598 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2600 let result = method.map(|ok| {
2601 debug!("try_index_step: success, using overloaded indexing");
2602 let method = self.register_infer_ok_obligations(ok);
2604 let mut adjustments = autoderef.adjust_steps(needs);
2605 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2606 let mutbl = match r_mutbl {
2607 hir::MutImmutable => AutoBorrowMutability::Immutable,
2608 hir::MutMutable => AutoBorrowMutability::Mutable {
2609 // Indexing can be desugared to a method call,
2610 // so maybe we could use two-phase here.
2611 // See the documentation of AllowTwoPhase for why that's
2612 // not the case today.
2613 allow_two_phase_borrow: AllowTwoPhase::No,
2616 adjustments.push(Adjustment {
2617 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2618 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2625 adjustments.push(Adjustment {
2626 kind: Adjust::Unsize,
2627 target: method.sig.inputs()[0]
2630 self.apply_adjustments(base_expr, adjustments);
2632 self.write_method_call(expr.hir_id, method);
2633 (input_ty, self.make_overloaded_place_return_type(method).ty)
2635 if result.is_some() {
2643 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2644 let (tr, name) = match (op, is_mut) {
2645 (PlaceOp::Deref, false) =>
2646 (self.tcx.lang_items().deref_trait(), "deref"),
2647 (PlaceOp::Deref, true) =>
2648 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2649 (PlaceOp::Index, false) =>
2650 (self.tcx.lang_items().index_trait(), "index"),
2651 (PlaceOp::Index, true) =>
2652 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2654 (tr, ast::Ident::from_str(name))
2657 fn try_overloaded_place_op(&self,
2660 arg_tys: &[Ty<'tcx>],
2663 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2665 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2671 // Try Mut first, if needed.
2672 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2673 let method = match (needs, mut_tr) {
2674 (Needs::MutPlace, Some(trait_did)) => {
2675 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2680 // Otherwise, fall back to the immutable version.
2681 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2682 let method = match (method, imm_tr) {
2683 (None, Some(trait_did)) => {
2684 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2686 (method, _) => method,
2692 fn check_method_argument_types(&self,
2695 method: Result<MethodCallee<'tcx>, ()>,
2696 args_no_rcvr: &'gcx [hir::Expr],
2697 tuple_arguments: TupleArgumentsFlag,
2698 expected: Expectation<'tcx>)
2700 let has_error = match method {
2702 method.substs.references_error() || method.sig.references_error()
2707 let err_inputs = self.err_args(args_no_rcvr.len());
2709 let err_inputs = match tuple_arguments {
2710 DontTupleArguments => err_inputs,
2711 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2714 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2715 false, tuple_arguments, None);
2716 return self.tcx.types.err;
2719 let method = method.unwrap();
2720 // HACK(eddyb) ignore self in the definition (see above).
2721 let expected_arg_tys = self.expected_inputs_for_expected_output(
2724 method.sig.output(),
2725 &method.sig.inputs()[1..]
2727 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2728 args_no_rcvr, method.sig.variadic, tuple_arguments,
2729 self.tcx.hir().span_if_local(method.def_id));
2733 /// Generic function that factors out common logic from function calls,
2734 /// method calls and overloaded operators.
2735 fn check_argument_types(&self,
2738 fn_inputs: &[Ty<'tcx>],
2739 mut expected_arg_tys: &[Ty<'tcx>],
2740 args: &'gcx [hir::Expr],
2742 tuple_arguments: TupleArgumentsFlag,
2743 def_span: Option<Span>) {
2746 // Grab the argument types, supplying fresh type variables
2747 // if the wrong number of arguments were supplied
2748 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2754 // All the input types from the fn signature must outlive the call
2755 // so as to validate implied bounds.
2756 for &fn_input_ty in fn_inputs {
2757 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2760 let expected_arg_count = fn_inputs.len();
2762 let param_count_error = |expected_count: usize,
2767 let mut err = tcx.sess.struct_span_err_with_code(sp,
2768 &format!("this function takes {}{} but {} {} supplied",
2769 if variadic {"at least "} else {""},
2770 potentially_plural_count(expected_count, "parameter"),
2771 potentially_plural_count(arg_count, "parameter"),
2772 if arg_count == 1 {"was"} else {"were"}),
2773 DiagnosticId::Error(error_code.to_owned()));
2775 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2776 err.span_label(def_s, "defined here");
2779 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2780 // remove closing `)` from the span
2781 let sugg_span = sugg_span.shrink_to_lo();
2782 err.span_suggestion_with_applicability(
2784 "expected the unit value `()`; create it with empty parentheses",
2786 Applicability::MachineApplicable);
2788 err.span_label(sp, format!("expected {}{}",
2789 if variadic {"at least "} else {""},
2790 potentially_plural_count(expected_count, "parameter")));
2795 let formal_tys = if tuple_arguments == TupleArguments {
2796 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2797 match tuple_type.sty {
2798 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2799 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2800 expected_arg_tys = &[];
2801 self.err_args(args.len())
2803 ty::Tuple(arg_types) => {
2804 expected_arg_tys = match expected_arg_tys.get(0) {
2805 Some(&ty) => match ty.sty {
2806 ty::Tuple(ref tys) => &tys,
2814 span_err!(tcx.sess, sp, E0059,
2815 "cannot use call notation; the first type parameter \
2816 for the function trait is neither a tuple nor unit");
2817 expected_arg_tys = &[];
2818 self.err_args(args.len())
2821 } else if expected_arg_count == supplied_arg_count {
2823 } else if variadic {
2824 if supplied_arg_count >= expected_arg_count {
2827 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2828 expected_arg_tys = &[];
2829 self.err_args(supplied_arg_count)
2832 // is the missing argument of type `()`?
2833 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2834 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2835 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2836 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2840 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2842 expected_arg_tys = &[];
2843 self.err_args(supplied_arg_count)
2845 // If there is no expectation, expect formal_tys.
2846 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2852 debug!("check_argument_types: formal_tys={:?}",
2853 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2855 // Check the arguments.
2856 // We do this in a pretty awful way: first we type-check any arguments
2857 // that are not closures, then we type-check the closures. This is so
2858 // that we have more information about the types of arguments when we
2859 // type-check the functions. This isn't really the right way to do this.
2860 for &check_closures in &[false, true] {
2861 debug!("check_closures={}", check_closures);
2863 // More awful hacks: before we check argument types, try to do
2864 // an "opportunistic" vtable resolution of any trait bounds on
2865 // the call. This helps coercions.
2867 self.select_obligations_where_possible(false);
2870 // For variadic functions, we don't have a declared type for all of
2871 // the arguments hence we only do our usual type checking with
2872 // the arguments who's types we do know.
2873 let t = if variadic {
2875 } else if tuple_arguments == TupleArguments {
2880 for (i, arg) in args.iter().take(t).enumerate() {
2881 // Warn only for the first loop (the "no closures" one).
2882 // Closure arguments themselves can't be diverging, but
2883 // a previous argument can, e.g., `foo(panic!(), || {})`.
2884 if !check_closures {
2885 self.warn_if_unreachable(arg.id, arg.span, "expression");
2888 let is_closure = match arg.node {
2889 hir::ExprKind::Closure(..) => true,
2893 if is_closure != check_closures {
2897 debug!("checking the argument");
2898 let formal_ty = formal_tys[i];
2900 // The special-cased logic below has three functions:
2901 // 1. Provide as good of an expected type as possible.
2902 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2904 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2906 // 2. Coerce to the most detailed type that could be coerced
2907 // to, which is `expected_ty` if `rvalue_hint` returns an
2908 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2909 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2910 // We're processing function arguments so we definitely want to use
2911 // two-phase borrows.
2912 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2914 // 3. Relate the expected type and the formal one,
2915 // if the expected type was used for the coercion.
2916 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2920 // We also need to make sure we at least write the ty of the other
2921 // arguments which we skipped above.
2923 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2924 use structured_errors::{VariadicError, StructuredDiagnostic};
2925 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2928 for arg in args.iter().skip(expected_arg_count) {
2929 let arg_ty = self.check_expr(&arg);
2931 // There are a few types which get autopromoted when passed via varargs
2932 // in C but we just error out instead and require explicit casts.
2933 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2935 ty::Float(ast::FloatTy::F32) => {
2936 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2938 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2939 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2941 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2942 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2945 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2946 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2947 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2955 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2956 vec![self.tcx.types.err; len]
2959 // AST fragment checking
2962 expected: Expectation<'tcx>)
2968 ast::LitKind::Str(..) => tcx.mk_static_str(),
2969 ast::LitKind::ByteStr(ref v) => {
2970 tcx.mk_imm_ref(tcx.types.re_static,
2971 tcx.mk_array(tcx.types.u8, v.len() as u64))
2973 ast::LitKind::Byte(_) => tcx.types.u8,
2974 ast::LitKind::Char(_) => tcx.types.char,
2975 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2976 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2977 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2978 let opt_ty = expected.to_option(self).and_then(|ty| {
2980 ty::Int(_) | ty::Uint(_) => Some(ty),
2981 ty::Char => Some(tcx.types.u8),
2982 ty::RawPtr(..) => Some(tcx.types.usize),
2983 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2987 opt_ty.unwrap_or_else(
2988 || tcx.mk_int_var(self.next_int_var_id()))
2990 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2991 ast::LitKind::FloatUnsuffixed(_) => {
2992 let opt_ty = expected.to_option(self).and_then(|ty| {
2994 ty::Float(_) => Some(ty),
2998 opt_ty.unwrap_or_else(
2999 || tcx.mk_float_var(self.next_float_var_id()))
3001 ast::LitKind::Bool(_) => tcx.types.bool
3005 fn check_expr_eq_type(&self,
3006 expr: &'gcx hir::Expr,
3007 expected: Ty<'tcx>) {
3008 let ty = self.check_expr_with_hint(expr, expected);
3009 self.demand_eqtype(expr.span, expected, ty);
3012 pub fn check_expr_has_type_or_error(&self,
3013 expr: &'gcx hir::Expr,
3014 expected: Ty<'tcx>) -> Ty<'tcx> {
3015 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3018 fn check_expr_meets_expectation_or_error(&self,
3019 expr: &'gcx hir::Expr,
3020 expected: Expectation<'tcx>) -> Ty<'tcx> {
3021 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3022 let mut ty = self.check_expr_with_expectation(expr, expected);
3024 // While we don't allow *arbitrary* coercions here, we *do* allow
3025 // coercions from ! to `expected`.
3027 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3028 "expression with never type wound up being adjusted");
3029 let adj_ty = self.next_diverging_ty_var(
3030 TypeVariableOrigin::AdjustmentType(expr.span));
3031 self.apply_adjustments(expr, vec![Adjustment {
3032 kind: Adjust::NeverToAny,
3038 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3039 // Add help to type error if this is an `if` condition with an assignment
3040 if let (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs))
3041 = (expected, &expr.node)
3043 let msg = "try comparing for equality";
3044 if let (Ok(left), Ok(right)) = (
3045 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3046 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3048 err.span_suggestion_with_applicability(
3051 format!("{} == {}", left, right),
3052 Applicability::MaybeIncorrect);
3062 fn check_expr_coercable_to_type(&self,
3063 expr: &'gcx hir::Expr,
3064 expected: Ty<'tcx>) -> Ty<'tcx> {
3065 let ty = self.check_expr_with_hint(expr, expected);
3066 // checks don't need two phase
3067 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3070 fn check_expr_with_hint(&self,
3071 expr: &'gcx hir::Expr,
3072 expected: Ty<'tcx>) -> Ty<'tcx> {
3073 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3076 fn check_expr_with_expectation(&self,
3077 expr: &'gcx hir::Expr,
3078 expected: Expectation<'tcx>) -> Ty<'tcx> {
3079 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3082 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3083 self.check_expr_with_expectation(expr, NoExpectation)
3086 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3087 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3090 // Determine the `Self` type, using fresh variables for all variables
3091 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3092 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3094 pub fn impl_self_ty(&self,
3095 span: Span, // (potential) receiver for this impl
3097 -> TypeAndSubsts<'tcx> {
3098 let ity = self.tcx.type_of(did);
3099 debug!("impl_self_ty: ity={:?}", ity);
3101 let substs = self.fresh_substs_for_item(span, did);
3102 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3104 TypeAndSubsts { substs: substs, ty: substd_ty }
3107 /// Unifies the output type with the expected type early, for more coercions
3108 /// and forward type information on the input expressions.
3109 fn expected_inputs_for_expected_output(&self,
3111 expected_ret: Expectation<'tcx>,
3112 formal_ret: Ty<'tcx>,
3113 formal_args: &[Ty<'tcx>])
3115 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3116 let ret_ty = match expected_ret.only_has_type(self) {
3118 None => return Vec::new()
3120 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3121 // Attempt to apply a subtyping relationship between the formal
3122 // return type (likely containing type variables if the function
3123 // is polymorphic) and the expected return type.
3124 // No argument expectations are produced if unification fails.
3125 let origin = self.misc(call_span);
3126 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3128 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3129 // to identity so the resulting type is not constrained.
3132 // Process any obligations locally as much as
3133 // we can. We don't care if some things turn
3134 // out unconstrained or ambiguous, as we're
3135 // just trying to get hints here.
3136 self.save_and_restore_in_snapshot_flag(|_| {
3137 let mut fulfill = TraitEngine::new(self.tcx);
3138 for obligation in ok.obligations {
3139 fulfill.register_predicate_obligation(self, obligation);
3141 fulfill.select_where_possible(self)
3142 }).map_err(|_| ())?;
3144 Err(_) => return Err(()),
3147 // Record all the argument types, with the substitutions
3148 // produced from the above subtyping unification.
3149 Ok(formal_args.iter().map(|ty| {
3150 self.resolve_type_vars_if_possible(ty)
3152 }).unwrap_or_default();
3153 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3154 formal_args, formal_ret,
3155 expect_args, expected_ret);
3159 // Checks a method call.
3160 fn check_method_call(&self,
3161 expr: &'gcx hir::Expr,
3162 segment: &hir::PathSegment,
3164 args: &'gcx [hir::Expr],
3165 expected: Expectation<'tcx>,
3166 needs: Needs) -> Ty<'tcx> {
3167 let rcvr = &args[0];
3168 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3169 // no need to check for bot/err -- callee does that
3170 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3172 let method = match self.lookup_method(rcvr_t,
3178 self.write_method_call(expr.hir_id, method);
3182 if segment.ident.name != keywords::Invalid.name() {
3183 self.report_method_error(span,
3194 // Call the generic checker.
3195 self.check_method_argument_types(span,
3203 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3207 .unwrap_or_else(|| span_bug!(return_expr.span,
3208 "check_return_expr called outside fn body"));
3210 let ret_ty = ret_coercion.borrow().expected_ty();
3211 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3212 ret_coercion.borrow_mut()
3214 &self.cause(return_expr.span,
3215 ObligationCauseCode::ReturnType(return_expr.id)),
3220 // A generic function for checking the then and else in an if
3222 fn check_then_else(&self,
3223 cond_expr: &'gcx hir::Expr,
3224 then_expr: &'gcx hir::Expr,
3225 opt_else_expr: Option<&'gcx hir::Expr>,
3227 expected: Expectation<'tcx>) -> Ty<'tcx> {
3228 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3229 let cond_diverges = self.diverges.get();
3230 self.diverges.set(Diverges::Maybe);
3232 let expected = expected.adjust_for_branches(self);
3233 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3234 let then_diverges = self.diverges.get();
3235 self.diverges.set(Diverges::Maybe);
3237 // We've already taken the expected type's preferences
3238 // into account when typing the `then` branch. To figure
3239 // out the initial shot at a LUB, we thus only consider
3240 // `expected` if it represents a *hard* constraint
3241 // (`only_has_type`); otherwise, we just go with a
3242 // fresh type variable.
3243 let coerce_to_ty = expected.coercion_target_type(self, sp);
3244 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3246 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3247 coerce.coerce(self, &if_cause, then_expr, then_ty);
3249 if let Some(else_expr) = opt_else_expr {
3250 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3251 let else_diverges = self.diverges.get();
3253 coerce.coerce(self, &if_cause, else_expr, else_ty);
3255 // We won't diverge unless both branches do (or the condition does).
3256 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3258 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3259 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3261 // If the condition is false we can't diverge.
3262 self.diverges.set(cond_diverges);
3265 let result_ty = coerce.complete(self);
3266 if cond_ty.references_error() {
3273 // Check field access expressions
3274 fn check_field(&self,
3275 expr: &'gcx hir::Expr,
3277 base: &'gcx hir::Expr,
3278 field: ast::Ident) -> Ty<'tcx> {
3279 let expr_t = self.check_expr_with_needs(base, needs);
3280 let expr_t = self.structurally_resolved_type(base.span,
3282 let mut private_candidate = None;
3283 let mut autoderef = self.autoderef(expr.span, expr_t);
3284 while let Some((base_t, _)) = autoderef.next() {
3286 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3287 debug!("struct named {:?}", base_t);
3288 let (ident, def_scope) =
3289 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3290 let fields = &base_def.non_enum_variant().fields;
3291 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3292 let field = &fields[index];
3293 let field_ty = self.field_ty(expr.span, field, substs);
3294 // Save the index of all fields regardless of their visibility in case
3295 // of error recovery.
3296 self.write_field_index(expr.id, index);
3297 if field.vis.is_accessible_from(def_scope, self.tcx) {
3298 let adjustments = autoderef.adjust_steps(needs);
3299 self.apply_adjustments(base, adjustments);
3300 autoderef.finalize();
3302 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3305 private_candidate = Some((base_def.did, field_ty));
3308 ty::Tuple(ref tys) => {
3309 let fstr = field.as_str();
3310 if let Ok(index) = fstr.parse::<usize>() {
3311 if fstr == index.to_string() {
3312 if let Some(field_ty) = tys.get(index) {
3313 let adjustments = autoderef.adjust_steps(needs);
3314 self.apply_adjustments(base, adjustments);
3315 autoderef.finalize();
3317 self.write_field_index(expr.id, index);
3326 autoderef.unambiguous_final_ty();
3328 if let Some((did, field_ty)) = private_candidate {
3329 let struct_path = self.tcx().item_path_str(did);
3330 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3331 "field `{}` of struct `{}` is private",
3332 field, struct_path);
3333 // Also check if an accessible method exists, which is often what is meant.
3334 if self.method_exists(field, expr_t, expr.id, false) {
3335 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3339 } else if field.name == keywords::Invalid.name() {
3340 self.tcx().types.err
3341 } else if self.method_exists(field, expr_t, expr.id, true) {
3342 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3343 "attempted to take value of method `{}` on type `{}`",
3345 .help("maybe a `()` to call it is missing?")
3347 self.tcx().types.err
3349 if !expr_t.is_primitive_ty() {
3350 let mut err = self.no_such_field_err(field.span, field, expr_t);
3353 ty::Adt(def, _) if !def.is_enum() => {
3354 if let Some(suggested_field_name) =
3355 Self::suggest_field_name(def.non_enum_variant(),
3356 &field.as_str(), vec![]) {
3357 err.span_label(field.span,
3358 format!("did you mean `{}`?", suggested_field_name));
3360 err.span_label(field.span, "unknown field");
3361 let struct_variant_def = def.non_enum_variant();
3362 let field_names = self.available_field_names(struct_variant_def);
3363 if !field_names.is_empty() {
3364 err.note(&format!("available fields are: {}",
3365 self.name_series_display(field_names)));
3369 ty::Array(_, len) => {
3370 if let (Some(len), Ok(user_index)) = (
3371 len.assert_usize(self.tcx),
3372 field.as_str().parse::<u64>()
3374 let base = self.tcx.hir().node_to_pretty_string(base.id);
3375 let help = "instead of using tuple indexing, use array indexing";
3376 let suggestion = format!("{}[{}]", base, field);
3377 let applicability = if len < user_index {
3378 Applicability::MachineApplicable
3380 Applicability::MaybeIncorrect
3382 err.span_suggestion_with_applicability(
3383 expr.span, help, suggestion, applicability
3388 let base = self.tcx.hir().node_to_pretty_string(base.id);
3389 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3390 let suggestion = format!("(*{}).{}", base, field);
3391 err.span_suggestion_with_applicability(
3395 Applicability::MaybeIncorrect,
3402 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3403 "`{}` is a primitive type and therefore doesn't have fields",
3406 self.tcx().types.err
3410 // Return an hint about the closest match in field names
3411 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3413 skip: Vec<LocalInternedString>)
3415 let names = variant.fields.iter().filter_map(|field| {
3416 // ignore already set fields and private fields from non-local crates
3417 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3418 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3421 Some(&field.ident.name)
3425 find_best_match_for_name(names, field, None)
3428 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3429 variant.fields.iter().filter(|field| {
3430 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3431 field.vis.is_accessible_from(def_scope, self.tcx)
3433 .map(|field| field.ident.name)
3437 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3438 // dynamic limit, to never omit just one field
3439 let limit = if names.len() == 6 { 6 } else { 5 };
3440 let mut display = names.iter().take(limit)
3441 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3442 if names.len() > limit {
3443 display = format!("{} ... and {} others", display, names.len() - limit);
3448 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3449 -> DiagnosticBuilder {
3450 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3451 "no field `{}` on type `{}`",
3455 fn report_unknown_field(&self,
3457 variant: &'tcx ty::VariantDef,
3459 skip_fields: &[hir::Field],
3461 let mut err = self.type_error_struct_with_diag(
3463 |actual| match ty.sty {
3464 ty::Adt(adt, ..) if adt.is_enum() => {
3465 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3466 "{} `{}::{}` has no field named `{}`",
3467 kind_name, actual, variant.name, field.ident)
3470 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3471 "{} `{}` has no field named `{}`",
3472 kind_name, actual, field.ident)
3476 // prevent all specified fields from being suggested
3477 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3478 if let Some(field_name) = Self::suggest_field_name(variant,
3479 &field.ident.as_str(),
3480 skip_fields.collect()) {
3481 err.span_label(field.ident.span,
3482 format!("field does not exist - did you mean `{}`?", field_name));
3485 ty::Adt(adt, ..) => {
3487 err.span_label(field.ident.span,
3488 format!("`{}::{}` does not have this field",
3491 err.span_label(field.ident.span,
3492 format!("`{}` does not have this field", ty));
3494 let available_field_names = self.available_field_names(variant);
3495 if !available_field_names.is_empty() {
3496 err.note(&format!("available fields are: {}",
3497 self.name_series_display(available_field_names)));
3500 _ => bug!("non-ADT passed to report_unknown_field")
3506 fn check_expr_struct_fields(&self,
3508 expected: Expectation<'tcx>,
3509 expr_id: ast::NodeId,
3511 variant: &'tcx ty::VariantDef,
3512 ast_fields: &'gcx [hir::Field],
3513 check_completeness: bool) -> bool {
3517 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3518 .get(0).cloned().unwrap_or(adt_ty);
3519 // re-link the regions that EIfEO can erase.
3520 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3522 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3523 &ty::Adt(adt, substs) => {
3524 (substs, adt.adt_kind(), adt.variant_descr())
3526 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3529 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3530 (field.ident.modern(), (i, field))
3531 ).collect::<FxHashMap<_, _>>();
3533 let mut seen_fields = FxHashMap::default();
3535 let mut error_happened = false;
3537 // Type-check each field.
3538 for field in ast_fields {
3539 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3540 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3541 seen_fields.insert(ident, field.span);
3542 self.write_field_index(field.id, i);
3544 // We don't look at stability attributes on
3545 // struct-like enums (yet...), but it's definitely not
3546 // a bug to have constructed one.
3547 if adt_kind != ty::AdtKind::Enum {
3548 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3551 self.field_ty(field.span, v_field, substs)
3553 error_happened = true;
3554 if let Some(prev_span) = seen_fields.get(&ident) {
3555 let mut err = struct_span_err!(self.tcx.sess,
3558 "field `{}` specified more than once",
3561 err.span_label(field.ident.span, "used more than once");
3562 err.span_label(*prev_span, format!("first use of `{}`", ident));
3566 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3572 // Make sure to give a type to the field even if there's
3573 // an error, so we can continue type-checking.
3574 self.check_expr_coercable_to_type(&field.expr, field_type);
3577 // Make sure the programmer specified correct number of fields.
3578 if kind_name == "union" {
3579 if ast_fields.len() != 1 {
3580 tcx.sess.span_err(span, "union expressions should have exactly one field");
3582 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3583 let len = remaining_fields.len();
3585 let mut displayable_field_names = remaining_fields
3587 .map(|ident| ident.as_str())
3588 .collect::<Vec<_>>();
3590 displayable_field_names.sort();
3592 let truncated_fields_error = if len <= 3 {
3595 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3598 let remaining_fields_names = displayable_field_names.iter().take(3)
3599 .map(|n| format!("`{}`", n))
3600 .collect::<Vec<_>>()
3603 struct_span_err!(tcx.sess, span, E0063,
3604 "missing field{} {}{} in initializer of `{}`",
3605 if remaining_fields.len() == 1 { "" } else { "s" },
3606 remaining_fields_names,
3607 truncated_fields_error,
3609 .span_label(span, format!("missing {}{}",
3610 remaining_fields_names,
3611 truncated_fields_error))
3617 fn check_struct_fields_on_error(&self,
3618 fields: &'gcx [hir::Field],
3619 base_expr: &'gcx Option<P<hir::Expr>>) {
3620 for field in fields {
3621 self.check_expr(&field.expr);
3623 if let Some(ref base) = *base_expr {
3624 self.check_expr(&base);
3628 pub fn check_struct_path(&self,
3630 node_id: ast::NodeId)
3631 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3632 let path_span = match *qpath {
3633 hir::QPath::Resolved(_, ref path) => path.span,
3634 hir::QPath::TypeRelative(ref qself, _) => qself.span
3636 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3637 let variant = match def {
3639 self.set_tainted_by_errors();
3642 Def::Variant(..) => {
3644 ty::Adt(adt, substs) => {
3645 Some((adt.variant_of_def(def), adt.did, substs))
3647 _ => bug!("unexpected type: {:?}", ty.sty)
3650 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3651 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3653 ty::Adt(adt, substs) if !adt.is_enum() => {
3654 Some((adt.non_enum_variant(), adt.did, substs))
3659 _ => bug!("unexpected definition: {:?}", def)
3662 if let Some((variant, did, substs)) = variant {
3663 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3664 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
3665 self.write_user_substs_from_substs(hir_id, substs, None);
3667 // Check bounds on type arguments used in the path.
3668 let bounds = self.instantiate_bounds(path_span, did, substs);
3669 let cause = traits::ObligationCause::new(path_span, self.body_id,
3670 traits::ItemObligation(did));
3671 self.add_obligations_for_parameters(cause, &bounds);
3675 struct_span_err!(self.tcx.sess, path_span, E0071,
3676 "expected struct, variant or union type, found {}",
3677 ty.sort_string(self.tcx))
3678 .span_label(path_span, "not a struct")
3684 fn check_expr_struct(&self,
3686 expected: Expectation<'tcx>,
3688 fields: &'gcx [hir::Field],
3689 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3691 // Find the relevant variant
3692 let (variant, adt_ty) =
3693 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3696 self.check_struct_fields_on_error(fields, base_expr);
3697 return self.tcx.types.err;
3700 let path_span = match *qpath {
3701 hir::QPath::Resolved(_, ref path) => path.span,
3702 hir::QPath::TypeRelative(ref qself, _) => qself.span
3705 // Prohibit struct expressions when non-exhaustive flag is set.
3706 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3707 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3708 span_err!(self.tcx.sess, expr.span, E0639,
3709 "cannot create non-exhaustive {} using struct expression",
3710 adt.variant_descr());
3713 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3714 variant, fields, base_expr.is_none());
3715 if let &Some(ref base_expr) = base_expr {
3716 // If check_expr_struct_fields hit an error, do not attempt to populate
3717 // the fields with the base_expr. This could cause us to hit errors later
3718 // when certain fields are assumed to exist that in fact do not.
3719 if !error_happened {
3720 self.check_expr_has_type_or_error(base_expr, adt_ty);
3722 ty::Adt(adt, substs) if adt.is_struct() => {
3723 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3724 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3729 .fru_field_types_mut()
3730 .insert(expr.hir_id, fru_field_types);
3733 span_err!(self.tcx.sess, base_expr.span, E0436,
3734 "functional record update syntax requires a struct");
3739 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3745 /// If an expression has any sub-expressions that result in a type error,
3746 /// inspecting that expression's type with `ty.references_error()` will return
3747 /// true. Likewise, if an expression is known to diverge, inspecting its
3748 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3749 /// strict, _|_ can appear in the type of an expression that does not,
3750 /// itself, diverge: for example, fn() -> _|_.)
3751 /// Note that inspecting a type's structure *directly* may expose the fact
3752 /// that there are actually multiple representations for `Error`, so avoid
3753 /// that when err needs to be handled differently.
3754 fn check_expr_with_expectation_and_needs(&self,
3755 expr: &'gcx hir::Expr,
3756 expected: Expectation<'tcx>,
3757 needs: Needs) -> Ty<'tcx> {
3758 debug!(">> type-checking: expr={:?} expected={:?}",
3761 // Warn for expressions after diverging siblings.
3762 self.warn_if_unreachable(expr.id, expr.span, "expression");
3764 // Hide the outer diverging and has_errors flags.
3765 let old_diverges = self.diverges.get();
3766 let old_has_errors = self.has_errors.get();
3767 self.diverges.set(Diverges::Maybe);
3768 self.has_errors.set(false);
3770 let ty = self.check_expr_kind(expr, expected, needs);
3772 // Warn for non-block expressions with diverging children.
3774 hir::ExprKind::Block(..) |
3775 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3776 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3778 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3781 // Any expression that produces a value of type `!` must have diverged
3783 self.diverges.set(self.diverges.get() | Diverges::Always);
3786 // Record the type, which applies it effects.
3787 // We need to do this after the warning above, so that
3788 // we don't warn for the diverging expression itself.
3789 self.write_ty(expr.hir_id, ty);
3791 // Combine the diverging and has_error flags.
3792 self.diverges.set(self.diverges.get() | old_diverges);
3793 self.has_errors.set(self.has_errors.get() | old_has_errors);
3795 debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
3796 debug!("... {:?}, expected is {:?}", ty, expected);
3803 expr: &'gcx hir::Expr,
3804 expected: Expectation<'tcx>,
3808 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3817 hir::ExprKind::Box(ref subexpr) => {
3818 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3820 ty::Adt(def, _) if def.is_box()
3821 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3825 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3826 tcx.mk_box(referent_ty)
3829 hir::ExprKind::Lit(ref lit) => {
3830 self.check_lit(&lit, expected)
3832 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3833 self.check_binop(expr, op, lhs, rhs)
3835 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3836 self.check_binop_assign(expr, op, lhs, rhs)
3838 hir::ExprKind::Unary(unop, ref oprnd) => {
3839 let expected_inner = match unop {
3840 hir::UnNot | hir::UnNeg => {
3847 let needs = match unop {
3848 hir::UnDeref => needs,
3851 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3855 if !oprnd_t.references_error() {
3856 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3859 if let Some(mt) = oprnd_t.builtin_deref(true) {
3861 } else if let Some(ok) = self.try_overloaded_deref(
3862 expr.span, oprnd_t, needs) {
3863 let method = self.register_infer_ok_obligations(ok);
3864 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3865 let mutbl = match mutbl {
3866 hir::MutImmutable => AutoBorrowMutability::Immutable,
3867 hir::MutMutable => AutoBorrowMutability::Mutable {
3868 // (It shouldn't actually matter for unary ops whether
3869 // we enable two-phase borrows or not, since a unary
3870 // op has no additional operands.)
3871 allow_two_phase_borrow: AllowTwoPhase::No,
3874 self.apply_adjustments(oprnd, vec![Adjustment {
3875 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3876 target: method.sig.inputs()[0]
3879 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3880 self.write_method_call(expr.hir_id, method);
3882 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3883 "type `{}` cannot be dereferenced",
3885 oprnd_t = tcx.types.err;
3889 let result = self.check_user_unop(expr, oprnd_t, unop);
3890 // If it's builtin, we can reuse the type, this helps inference.
3891 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3896 let result = self.check_user_unop(expr, oprnd_t, unop);
3897 // If it's builtin, we can reuse the type, this helps inference.
3898 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3906 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3907 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3909 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3910 if oprnd.is_place_expr() {
3911 // Places may legitimately have unsized types.
3912 // For example, dereferences of a fat pointer and
3913 // the last field of a struct can be unsized.
3916 Expectation::rvalue_hint(self, ty)
3922 let needs = Needs::maybe_mut_place(mutbl);
3923 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3925 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3926 if tm.ty.references_error() {
3929 // Note: at this point, we cannot say what the best lifetime
3930 // is to use for resulting pointer. We want to use the
3931 // shortest lifetime possible so as to avoid spurious borrowck
3932 // errors. Moreover, the longest lifetime will depend on the
3933 // precise details of the value whose address is being taken
3934 // (and how long it is valid), which we don't know yet until type
3935 // inference is complete.
3937 // Therefore, here we simply generate a region variable. The
3938 // region inferencer will then select the ultimate value.
3939 // Finally, borrowck is charged with guaranteeing that the
3940 // value whose address was taken can actually be made to live
3941 // as long as it needs to live.
3942 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3943 tcx.mk_ref(region, tm)
3946 hir::ExprKind::Path(ref qpath) => {
3947 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3948 let ty = if def != Def::Err {
3949 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
3951 self.set_tainted_by_errors();
3955 if let ty::FnDef(..) = ty.sty {
3956 let fn_sig = ty.fn_sig(tcx);
3957 if !tcx.features().unsized_locals {
3958 // We want to remove some Sized bounds from std functions,
3959 // but don't want to expose the removal to stable Rust.
3960 // i.e., we don't want to allow
3966 // to work in stable even if the Sized bound on `drop` is relaxed.
3967 for i in 0..fn_sig.inputs().skip_binder().len() {
3968 // We just want to check sizedness, so instead of introducing
3969 // placeholder lifetimes with probing, we just replace higher lifetimes
3971 let input = self.replace_bound_vars_with_fresh_vars(
3973 infer::LateBoundRegionConversionTime::FnCall,
3974 &fn_sig.input(i)).0;
3975 self.require_type_is_sized_deferred(input, expr.span,
3976 traits::SizedArgumentType);
3979 // Here we want to prevent struct constructors from returning unsized types.
3980 // There were two cases this happened: fn pointer coercion in stable
3981 // and usual function call in presense of unsized_locals.
3982 // Also, as we just want to check sizedness, instead of introducing
3983 // placeholder lifetimes with probing, we just replace higher lifetimes
3985 let output = self.replace_bound_vars_with_fresh_vars(
3987 infer::LateBoundRegionConversionTime::FnCall,
3988 &fn_sig.output()).0;
3989 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
3992 // We always require that the type provided as the value for
3993 // a type parameter outlives the moment of instantiation.
3994 let substs = self.tables.borrow().node_substs(expr.hir_id);
3995 self.add_wf_bounds(substs, expr);
3999 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4000 for expr in outputs.iter().chain(inputs.iter()) {
4001 self.check_expr(expr);
4005 hir::ExprKind::Break(destination, ref expr_opt) => {
4006 if let Ok(target_id) = destination.target_id {
4008 if let Some(ref e) = *expr_opt {
4009 // If this is a break with a value, we need to type-check
4010 // the expression. Get an expected type from the loop context.
4011 let opt_coerce_to = {
4012 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4013 enclosing_breakables.find_breakable(target_id)
4016 .map(|coerce| coerce.expected_ty())
4019 // If the loop context is not a `loop { }`, then break with
4020 // a value is illegal, and `opt_coerce_to` will be `None`.
4021 // Just set expectation to error in that case.
4022 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4024 // Recurse without `enclosing_breakables` borrowed.
4025 e_ty = self.check_expr_with_hint(e, coerce_to);
4026 cause = self.misc(e.span);
4028 // Otherwise, this is a break *without* a value. That's
4029 // always legal, and is equivalent to `break ()`.
4030 e_ty = tcx.mk_unit();
4031 cause = self.misc(expr.span);
4034 // Now that we have type-checked `expr_opt`, borrow
4035 // the `enclosing_loops` field and let's coerce the
4036 // type of `expr_opt` into what is expected.
4037 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4038 let ctxt = enclosing_breakables.find_breakable(target_id);
4039 if let Some(ref mut coerce) = ctxt.coerce {
4040 if let Some(ref e) = *expr_opt {
4041 coerce.coerce(self, &cause, e, e_ty);
4043 assert!(e_ty.is_unit());
4044 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4047 // If `ctxt.coerce` is `None`, we can just ignore
4048 // the type of the expresison. This is because
4049 // either this was a break *without* a value, in
4050 // which case it is always a legal type (`()`), or
4051 // else an error would have been flagged by the
4052 // `loops` pass for using break with an expression
4053 // where you are not supposed to.
4054 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4057 ctxt.may_break = true;
4059 // the type of a `break` is always `!`, since it diverges
4062 // Otherwise, we failed to find the enclosing loop;
4063 // this can only happen if the `break` was not
4064 // inside a loop at all, which is caught by the
4065 // loop-checking pass.
4066 if self.tcx.sess.err_count() == 0 {
4067 self.tcx.sess.delay_span_bug(expr.span,
4068 "break was outside loop, but no error was emitted");
4071 // We still need to assign a type to the inner expression to
4072 // prevent the ICE in #43162.
4073 if let Some(ref e) = *expr_opt {
4074 self.check_expr_with_hint(e, tcx.types.err);
4076 // ... except when we try to 'break rust;'.
4077 // ICE this expression in particular (see #43162).
4078 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
4079 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4080 fatally_break_rust(self.tcx.sess);
4084 // There was an error; make type-check fail.
4089 hir::ExprKind::Continue(destination) => {
4090 if destination.target_id.is_ok() {
4093 // There was an error; make type-check fail.
4097 hir::ExprKind::Ret(ref expr_opt) => {
4098 if self.ret_coercion.is_none() {
4099 struct_span_err!(self.tcx.sess, expr.span, E0572,
4100 "return statement outside of function body").emit();
4101 } else if let Some(ref e) = *expr_opt {
4102 self.check_return_expr(e);
4104 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4105 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4106 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4110 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4111 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4113 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4116 ExpectIfCondition => {
4117 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4118 expected error elsehwere");
4121 // Only check this if not in an `if` condition, as the
4122 // mistyped comparison help is more appropriate.
4123 if !lhs.is_place_expr() {
4124 struct_span_err!(self.tcx.sess, expr.span, E0070,
4125 "invalid left-hand side expression")
4126 .span_label(expr.span, "left-hand of expression not valid")
4132 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4134 if lhs_ty.references_error() || rhs_ty.references_error() {
4140 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4141 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4142 expr.span, expected)
4144 hir::ExprKind::While(ref cond, ref body, _) => {
4145 let ctxt = BreakableCtxt {
4146 // cannot use break with a value from a while loop
4148 may_break: false, // Will get updated if/when we find a `break`.
4151 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4152 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4153 let cond_diverging = self.diverges.get();
4154 self.check_block_no_value(&body);
4156 // We may never reach the body so it diverging means nothing.
4157 self.diverges.set(cond_diverging);
4161 // No way to know whether it's diverging because
4162 // of a `break` or an outer `break` or `return`.
4163 self.diverges.set(Diverges::Maybe);
4168 hir::ExprKind::Loop(ref body, _, source) => {
4169 let coerce = match source {
4170 // you can only use break with a value from a normal `loop { }`
4171 hir::LoopSource::Loop => {
4172 let coerce_to = expected.coercion_target_type(self, body.span);
4173 Some(CoerceMany::new(coerce_to))
4176 hir::LoopSource::WhileLet |
4177 hir::LoopSource::ForLoop => {
4182 let ctxt = BreakableCtxt {
4184 may_break: false, // Will get updated if/when we find a `break`.
4187 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4188 self.check_block_no_value(&body);
4192 // No way to know whether it's diverging because
4193 // of a `break` or an outer `break` or `return`.
4194 self.diverges.set(Diverges::Maybe);
4197 // If we permit break with a value, then result type is
4198 // the LUB of the breaks (possibly ! if none); else, it
4199 // is nil. This makes sense because infinite loops
4200 // (which would have type !) are only possible iff we
4201 // permit break with a value [1].
4202 if ctxt.coerce.is_none() && !ctxt.may_break {
4204 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4206 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4208 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4209 self.check_match(expr, &discrim, arms, expected, match_src)
4211 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4212 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4214 hir::ExprKind::Block(ref body, _) => {
4215 self.check_block_with_expected(&body, expected)
4217 hir::ExprKind::Call(ref callee, ref args) => {
4218 self.check_call(expr, &callee, args, expected)
4220 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4221 self.check_method_call(expr, segment, span, args, expected, needs)
4223 hir::ExprKind::Cast(ref e, ref t) => {
4224 // Find the type of `e`. Supply hints based on the type we are casting to,
4226 let t_cast = self.to_ty_saving_user_provided_ty(t);
4227 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4228 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4229 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4231 // Eagerly check for some obvious errors.
4232 if t_expr.references_error() || t_cast.references_error() {
4235 // Defer other checks until we're done type checking.
4236 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4237 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4239 deferred_cast_checks.push(cast_check);
4242 Err(ErrorReported) => {
4248 hir::ExprKind::Type(ref e, ref t) => {
4249 let ty = self.to_ty_saving_user_provided_ty(&t);
4250 self.check_expr_eq_type(&e, ty);
4253 hir::ExprKind::Array(ref args) => {
4254 let uty = expected.to_option(self).and_then(|uty| {
4256 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4261 let element_ty = if !args.is_empty() {
4262 let coerce_to = uty.unwrap_or_else(
4263 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4264 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4265 assert_eq!(self.diverges.get(), Diverges::Maybe);
4267 let e_ty = self.check_expr_with_hint(e, coerce_to);
4268 let cause = self.misc(e.span);
4269 coerce.coerce(self, &cause, e, e_ty);
4271 coerce.complete(self)
4273 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4275 tcx.mk_array(element_ty, args.len() as u64)
4277 hir::ExprKind::Repeat(ref element, ref count) => {
4278 let count_def_id = tcx.hir().local_def_id(count.id);
4279 let param_env = ty::ParamEnv::empty();
4280 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4281 let instance = ty::Instance::resolve(
4287 let global_id = GlobalId {
4291 let count = tcx.const_eval(param_env.and(global_id));
4293 let uty = match expected {
4294 ExpectHasType(uty) => {
4296 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4303 let (element_ty, t) = match uty {
4305 self.check_expr_coercable_to_type(&element, uty);
4309 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4310 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4315 if let Ok(count) = count {
4316 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4318 // For [foo, ..n] where n > 1, `foo` must have
4320 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4321 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4325 if element_ty.references_error() {
4327 } else if let Ok(count) = count {
4328 tcx.mk_ty(ty::Array(t, count))
4333 hir::ExprKind::Tup(ref elts) => {
4334 let flds = expected.only_has_type(self).and_then(|ty| {
4335 let ty = self.resolve_type_vars_with_obligations(ty);
4337 ty::Tuple(ref flds) => Some(&flds[..]),
4342 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4343 let t = match flds {
4344 Some(ref fs) if i < fs.len() => {
4346 self.check_expr_coercable_to_type(&e, ety);
4350 self.check_expr_with_expectation(&e, NoExpectation)
4355 let tuple = tcx.mk_tup(elt_ts_iter);
4356 if tuple.references_error() {
4359 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4363 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4364 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4366 hir::ExprKind::Field(ref base, field) => {
4367 self.check_field(expr, needs, &base, field)
4369 hir::ExprKind::Index(ref base, ref idx) => {
4370 let base_t = self.check_expr_with_needs(&base, needs);
4371 let idx_t = self.check_expr(&idx);
4373 if base_t.references_error() {
4375 } else if idx_t.references_error() {
4378 let base_t = self.structurally_resolved_type(base.span, base_t);
4379 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4380 Some((index_ty, element_ty)) => {
4381 // two-phase not needed because index_ty is never mutable
4382 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4387 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4388 "cannot index into a value of type `{}`",
4390 // Try to give some advice about indexing tuples.
4391 if let ty::Tuple(..) = base_t.sty {
4392 let mut needs_note = true;
4393 // If the index is an integer, we can show the actual
4394 // fixed expression:
4395 if let hir::ExprKind::Lit(ref lit) = idx.node {
4396 if let ast::LitKind::Int(i,
4397 ast::LitIntType::Unsuffixed) = lit.node {
4398 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4399 if let Ok(snip) = snip {
4400 err.span_suggestion_with_applicability(
4402 "to access tuple elements, use",
4403 format!("{}.{}", snip, i),
4404 Applicability::MachineApplicable);
4410 err.help("to access tuple elements, use tuple indexing \
4411 syntax (e.g., `tuple.0`)");
4420 hir::ExprKind::Yield(ref value) => {
4421 match self.yield_ty {
4423 self.check_expr_coercable_to_type(&value, ty);
4426 struct_span_err!(self.tcx.sess, expr.span, E0627,
4427 "yield statement outside of generator literal").emit();
4435 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4436 // The newly resolved definition is written into `type_dependent_defs`.
4437 fn finish_resolving_struct_path(&self,
4440 node_id: ast::NodeId)
4444 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4445 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4446 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4449 hir::QPath::TypeRelative(ref qself, ref segment) => {
4450 let ty = self.to_ty(qself);
4452 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4457 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4460 // Write back the new resolution.
4461 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4462 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4469 // Resolve associated value path into a base type and associated constant or method definition.
4470 // The newly resolved definition is written into `type_dependent_defs`.
4471 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4472 qpath: &'b hir::QPath,
4473 node_id: ast::NodeId,
4475 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4477 let (ty, item_segment) = match *qpath {
4478 hir::QPath::Resolved(ref opt_qself, ref path) => {
4480 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4481 &path.segments[..]);
4483 hir::QPath::TypeRelative(ref qself, ref segment) => {
4484 (self.to_ty(qself), segment)
4487 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4488 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4489 // Return directly on cache hit. This is useful to avoid doubly reporting
4490 // errors with default match binding modes. See #44614.
4491 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4493 let item_name = item_segment.ident;
4494 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4497 let def = match error {
4498 method::MethodError::PrivateMatch(def, _) => def,
4501 if item_name.name != keywords::Invalid.name() {
4502 self.report_method_error(span, ty, item_name, None, error, None);
4508 // Write back the new resolution.
4509 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4510 (def, Some(ty), slice::from_ref(&**item_segment))
4513 pub fn check_decl_initializer(&self,
4514 local: &'gcx hir::Local,
4515 init: &'gcx hir::Expr) -> Ty<'tcx>
4517 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4518 // for #42640 (default match binding modes).
4521 let ref_bindings = local.pat.contains_explicit_ref_binding();
4523 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4524 if let Some(m) = ref_bindings {
4525 // Somewhat subtle: if we have a `ref` binding in the pattern,
4526 // we want to avoid introducing coercions for the RHS. This is
4527 // both because it helps preserve sanity and, in the case of
4528 // ref mut, for soundness (issue #23116). In particular, in
4529 // the latter case, we need to be clear that the type of the
4530 // referent for the reference that results is *equal to* the
4531 // type of the place it is referencing, and not some
4532 // supertype thereof.
4533 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4534 self.demand_eqtype(init.span, local_ty, init_ty);
4537 self.check_expr_coercable_to_type(init, local_ty)
4541 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4542 let t = self.local_ty(local.span, local.id).decl_ty;
4543 self.write_ty(local.hir_id, t);
4545 if let Some(ref init) = local.init {
4546 let init_ty = self.check_decl_initializer(local, &init);
4547 if init_ty.references_error() {
4548 self.write_ty(local.hir_id, init_ty);
4552 self.check_pat_walk(&local.pat, t,
4553 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4555 let pat_ty = self.node_ty(local.pat.hir_id);
4556 if pat_ty.references_error() {
4557 self.write_ty(local.hir_id, pat_ty);
4561 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4562 // Don't do all the complex logic below for DeclItem.
4564 hir::StmtKind::Decl(ref decl, _) => {
4565 if let hir::DeclKind::Item(_) = decl.node {
4569 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4572 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4574 // Hide the outer diverging and has_errors flags.
4575 let old_diverges = self.diverges.get();
4576 let old_has_errors = self.has_errors.get();
4577 self.diverges.set(Diverges::Maybe);
4578 self.has_errors.set(false);
4581 hir::StmtKind::Decl(ref decl, _) => {
4583 hir::DeclKind::Local(ref l) => {
4584 self.check_decl_local(&l);
4586 hir::DeclKind::Item(_) => {/* ignore for now */}
4589 hir::StmtKind::Expr(ref expr, _) => {
4590 // Check with expected type of ()
4591 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4593 hir::StmtKind::Semi(ref expr, _) => {
4594 self.check_expr(&expr);
4598 // Combine the diverging and has_error flags.
4599 self.diverges.set(self.diverges.get() | old_diverges);
4600 self.has_errors.set(self.has_errors.get() | old_has_errors);
4603 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4604 let unit = self.tcx.mk_unit();
4605 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4607 // if the block produces a `!` value, that can always be
4608 // (effectively) coerced to unit.
4610 self.demand_suptype(blk.span, unit, ty);
4614 fn check_block_with_expected(&self,
4615 blk: &'gcx hir::Block,
4616 expected: Expectation<'tcx>) -> Ty<'tcx> {
4618 let mut fcx_ps = self.ps.borrow_mut();
4619 let unsafety_state = fcx_ps.recurse(blk);
4620 replace(&mut *fcx_ps, unsafety_state)
4623 // In some cases, blocks have just one exit, but other blocks
4624 // can be targeted by multiple breaks. This can happen both
4625 // with labeled blocks as well as when we desugar
4626 // a `try { ... }` expression.
4630 // 'a: { if true { break 'a Err(()); } Ok(()) }
4632 // Here we would wind up with two coercions, one from
4633 // `Err(())` and the other from the tail expression
4634 // `Ok(())`. If the tail expression is omitted, that's a
4635 // "forced unit" -- unless the block diverges, in which
4636 // case we can ignore the tail expression (e.g., `'a: {
4637 // break 'a 22; }` would not force the type of the block
4639 let tail_expr = blk.expr.as_ref();
4640 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4641 let coerce = if blk.targeted_by_break {
4642 CoerceMany::new(coerce_to_ty)
4644 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4645 Some(e) => slice::from_ref(e),
4648 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4651 let prev_diverges = self.diverges.get();
4652 let ctxt = BreakableCtxt {
4653 coerce: Some(coerce),
4657 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4658 for s in &blk.stmts {
4662 // check the tail expression **without** holding the
4663 // `enclosing_breakables` lock below.
4664 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4666 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4667 let ctxt = enclosing_breakables.find_breakable(blk.id);
4668 let coerce = ctxt.coerce.as_mut().unwrap();
4669 if let Some(tail_expr_ty) = tail_expr_ty {
4670 let tail_expr = tail_expr.unwrap();
4671 let cause = self.cause(tail_expr.span,
4672 ObligationCauseCode::BlockTailExpression(blk.id));
4678 // Subtle: if there is no explicit tail expression,
4679 // that is typically equivalent to a tail expression
4680 // of `()` -- except if the block diverges. In that
4681 // case, there is no value supplied from the tail
4682 // expression (assuming there are no other breaks,
4683 // this implies that the type of the block will be
4686 // #41425 -- label the implicit `()` as being the
4687 // "found type" here, rather than the "expected type".
4689 // #44579 -- if the block was recovered during parsing,
4690 // the type would be nonsensical and it is not worth it
4691 // to perform the type check, so we avoid generating the
4692 // diagnostic output.
4693 if !self.diverges.get().always() && !blk.recovered {
4694 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4695 if let Some(expected_ty) = expected.only_has_type(self) {
4696 self.consider_hint_about_removing_semicolon(blk,
4706 // If we can break from the block, then the block's exit is always reachable
4707 // (... as long as the entry is reachable) - regardless of the tail of the block.
4708 self.diverges.set(prev_diverges);
4711 let mut ty = ctxt.coerce.unwrap().complete(self);
4713 if self.has_errors.get() || ty.references_error() {
4714 ty = self.tcx.types.err
4717 self.write_ty(blk.hir_id, ty);
4719 *self.ps.borrow_mut() = prev;
4723 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4724 /// suggestion can be made, `None` otherwise.
4725 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4726 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4727 // `while` before reaching it, as block tail returns are not available in them.
4728 if let Some(fn_id) = self.tcx.hir().get_return_block(blk_id) {
4729 let parent = self.tcx.hir().get(fn_id);
4731 if let Node::Item(&hir::Item {
4732 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4734 decl.clone().and_then(|decl| {
4735 // This is less than ideal, it will not suggest a return type span on any
4736 // method called `main`, regardless of whether it is actually the entry point,
4737 // but it will still present it as the reason for the expected type.
4738 Some((decl, name != Symbol::intern("main")))
4740 } else if let Node::TraitItem(&hir::TraitItem {
4741 node: hir::TraitItemKind::Method(hir::MethodSig {
4745 decl.clone().and_then(|decl| {
4748 } else if let Node::ImplItem(&hir::ImplItem {
4749 node: hir::ImplItemKind::Method(hir::MethodSig {
4753 decl.clone().and_then(|decl| {
4764 /// On implicit return expressions with mismatched types, provide the following suggestions:
4766 /// - Point out the method's return type as the reason for the expected type
4767 /// - Possible missing semicolon
4768 /// - Possible missing return type if the return type is the default, and not `fn main()`
4769 pub fn suggest_mismatched_types_on_tail(&self,
4770 err: &mut DiagnosticBuilder<'tcx>,
4771 expression: &'gcx hir::Expr,
4775 blk_id: ast::NodeId) {
4776 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4777 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4778 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4780 self.suggest_ref_or_into(err, expression, expected, found);
4783 pub fn suggest_ref_or_into(
4785 err: &mut DiagnosticBuilder<'tcx>,
4790 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4791 err.span_suggestion_with_applicability(
4795 Applicability::MachineApplicable,
4797 } else if !self.check_for_cast(err, expr, found, expected) {
4798 let methods = self.get_conversion_methods(expr.span, expected, found);
4799 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4800 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4801 .filter_map(|(receiver, method)| {
4802 let method_call = format!(".{}()", method.ident);
4803 if receiver.ends_with(&method_call) {
4804 None // do not suggest code that is already there (#53348)
4806 let method_call_list = [".to_vec()", ".to_string()"];
4807 if receiver.ends_with(".clone()")
4808 && method_call_list.contains(&method_call.as_str()) {
4809 let max_len = receiver.rfind(".").unwrap();
4810 Some(format!("{}{}", &receiver[..max_len], method_call))
4813 Some(format!("{}{}", receiver, method_call))
4817 if suggestions.peek().is_some() {
4818 err.span_suggestions_with_applicability(
4820 "try using a conversion method",
4822 Applicability::MaybeIncorrect,
4829 /// A common error is to forget to add a semicolon at the end of a block:
4833 /// bar_that_returns_u32()
4837 /// This routine checks if the return expression in a block would make sense on its own as a
4838 /// statement and the return type has been left as default or has been specified as `()`. If so,
4839 /// it suggests adding a semicolon.
4840 fn suggest_missing_semicolon(&self,
4841 err: &mut DiagnosticBuilder<'tcx>,
4842 expression: &'gcx hir::Expr,
4845 if expected.is_unit() {
4846 // `BlockTailExpression` only relevant if the tail expr would be
4847 // useful on its own.
4848 match expression.node {
4849 hir::ExprKind::Call(..) |
4850 hir::ExprKind::MethodCall(..) |
4851 hir::ExprKind::If(..) |
4852 hir::ExprKind::While(..) |
4853 hir::ExprKind::Loop(..) |
4854 hir::ExprKind::Match(..) |
4855 hir::ExprKind::Block(..) => {
4856 let sp = self.tcx.sess.source_map().next_point(cause_span);
4857 err.span_suggestion_with_applicability(
4859 "try adding a semicolon",
4861 Applicability::MachineApplicable);
4868 /// A possible error is to forget to add a return type that is needed:
4872 /// bar_that_returns_u32()
4876 /// This routine checks if the return type is left as default, the method is not part of an
4877 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4879 fn suggest_missing_return_type(&self,
4880 err: &mut DiagnosticBuilder<'tcx>,
4881 fn_decl: &hir::FnDecl,
4884 can_suggest: bool) {
4885 // Only suggest changing the return type for methods that
4886 // haven't set a return type at all (and aren't `fn main()` or an impl).
4887 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4888 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4889 err.span_suggestion_with_applicability(
4891 "try adding a return type",
4892 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4893 Applicability::MachineApplicable);
4895 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4896 err.span_label(span, "possibly return type missing here?");
4898 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4899 // `fn main()` must return `()`, do not suggest changing return type
4900 err.span_label(span, "expected `()` because of default return type");
4902 // expectation was caused by something else, not the default return
4903 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4904 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4905 // Only point to return type if the expected type is the return type, as if they
4906 // are not, the expectation must have been caused by something else.
4907 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4909 let ty = AstConv::ast_ty_to_ty(self, ty);
4910 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4911 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4912 if ty.sty == expected.sty {
4913 err.span_label(sp, format!("expected `{}` because of return type",
4921 /// A common error is to add an extra semicolon:
4924 /// fn foo() -> usize {
4929 /// This routine checks if the final statement in a block is an
4930 /// expression with an explicit semicolon whose type is compatible
4931 /// with `expected_ty`. If so, it suggests removing the semicolon.
4932 fn consider_hint_about_removing_semicolon(&self,
4933 blk: &'gcx hir::Block,
4934 expected_ty: Ty<'tcx>,
4935 err: &mut DiagnosticBuilder) {
4936 // Be helpful when the user wrote `{... expr;}` and
4937 // taking the `;` off is enough to fix the error.
4938 let last_stmt = match blk.stmts.last() {
4942 let last_expr = match last_stmt.node {
4943 hir::StmtKind::Semi(ref e, _) => e,
4946 let last_expr_ty = self.node_ty(last_expr.hir_id);
4947 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4950 let original_span = original_sp(last_stmt.span, blk.span);
4951 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4952 err.span_suggestion_with_applicability(
4954 "consider removing this semicolon",
4956 Applicability::MachineApplicable);
4959 fn def_ids_for_path_segments(&self,
4960 segments: &[hir::PathSegment],
4963 // We need to extract the type parameters supplied by the user in
4964 // the path `path`. Due to the current setup, this is a bit of a
4965 // tricky-process; the problem is that resolve only tells us the
4966 // end-point of the path resolution, and not the intermediate steps.
4967 // Luckily, we can (at least for now) deduce the intermediate steps
4968 // just from the end-point.
4970 // There are basically four cases to consider:
4972 // 1. Reference to a constructor of enum variant or struct:
4974 // struct Foo<T>(...)
4975 // enum E<T> { Foo(...) }
4977 // In these cases, the parameters are declared in the type
4980 // 2. Reference to a fn item or a free constant:
4984 // In this case, the path will again always have the form
4985 // `a::b::foo::<T>` where only the final segment should have
4986 // type parameters. However, in this case, those parameters are
4987 // declared on a value, and hence are in the `FnSpace`.
4989 // 3. Reference to a method or an associated constant:
4991 // impl<A> SomeStruct<A> {
4995 // Here we can have a path like
4996 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4997 // may appear in two places. The penultimate segment,
4998 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4999 // final segment, `foo::<B>` contains parameters in fn space.
5001 // 4. Reference to a local variable
5003 // Local variables can't have any type parameters.
5005 // The first step then is to categorize the segments appropriately.
5007 assert!(!segments.is_empty());
5008 let last = segments.len() - 1;
5010 let mut path_segs = vec![];
5013 // Case 1. Reference to a struct/variant constructor.
5014 Def::StructCtor(def_id, ..) |
5015 Def::VariantCtor(def_id, ..) |
5016 Def::SelfCtor(.., def_id) => {
5017 // Everything but the final segment should have no
5018 // parameters at all.
5019 let generics = self.tcx.generics_of(def_id);
5020 // Variant and struct constructors use the
5021 // generics of their parent type definition.
5022 let generics_def_id = generics.parent.unwrap_or(def_id);
5023 path_segs.push(PathSeg(generics_def_id, last));
5026 // Case 2. Reference to a top-level value.
5028 Def::Const(def_id) |
5029 Def::Static(def_id, _) => {
5030 path_segs.push(PathSeg(def_id, last));
5033 // Case 3. Reference to a method or associated const.
5034 Def::Method(def_id) |
5035 Def::AssociatedConst(def_id) => {
5036 if segments.len() >= 2 {
5037 let generics = self.tcx.generics_of(def_id);
5038 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
5040 path_segs.push(PathSeg(def_id, last));
5043 // Case 4. Local variable, no generics.
5044 Def::Local(..) | Def::Upvar(..) => {}
5046 _ => bug!("unexpected definition: {:?}", def),
5049 debug!("path_segs = {:?}", path_segs);
5054 // Instantiates the given path, which must refer to an item with the given
5055 // number of type parameters and type.
5056 pub fn instantiate_value_path(&self,
5057 segments: &[hir::PathSegment],
5058 self_ty: Option<Ty<'tcx>>,
5061 node_id: ast::NodeId)
5062 -> (Ty<'tcx>, Def) {
5064 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5071 let path_segs = self.def_ids_for_path_segments(segments, def);
5073 let mut user_self_ty = None;
5075 Def::Method(def_id) |
5076 Def::AssociatedConst(def_id) => {
5077 let container = self.tcx.associated_item(def_id).container;
5079 ty::TraitContainer(trait_did) => {
5080 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5082 ty::ImplContainer(impl_def_id) => {
5083 if segments.len() == 1 {
5084 // `<T>::assoc` will end up here, and so
5085 // can `T::assoc`. It this came from an
5086 // inherent impl, we need to record the
5087 // `T` for posterity (see `UserSelfTy` for
5089 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5090 user_self_ty = Some(UserSelfTy {
5101 // Now that we have categorized what space the parameters for each
5102 // segment belong to, let's sort out the parameters that the user
5103 // provided (if any) into their appropriate spaces. We'll also report
5104 // errors if type parameters are provided in an inappropriate place.
5106 let generic_segs = path_segs.iter().map(|PathSeg(_, index)| index)
5107 .collect::<FxHashSet<_>>();
5108 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5109 if !generic_segs.contains(&index) {
5117 Def::Local(nid) | Def::Upvar(nid, ..) => {
5118 let ty = self.local_ty(span, nid).decl_ty;
5119 let ty = self.normalize_associated_types_in(span, &ty);
5120 self.write_ty(self.tcx.hir().node_to_hir_id(node_id), ty);
5126 // Now we have to compare the types that the user *actually*
5127 // provided against the types that were *expected*. If the user
5128 // did not provide any types, then we want to substitute inference
5129 // variables. If the user provided some types, we may still need
5130 // to add defaults. If the user provided *too many* types, that's
5133 let mut infer_args_for_err = FxHashSet::default();
5134 for &PathSeg(def_id, index) in &path_segs {
5135 let seg = &segments[index];
5136 let generics = self.tcx.generics_of(def_id);
5137 // Argument-position `impl Trait` is treated as a normal generic
5138 // parameter internally, but we don't allow users to specify the
5139 // parameter's value explicitly, so we have to do some error-
5141 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5146 false, // `is_method_call`
5148 if suppress_errors {
5149 infer_args_for_err.insert(index);
5150 self.set_tainted_by_errors(); // See issue #53251.
5154 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5155 self.tcx.generics_of(*def_id).has_self
5156 }).unwrap_or(false);
5158 let mut new_def = def;
5159 let (def_id, ty) = if let Def::SelfCtor(impl_def_id) = def {
5160 let ty = self.impl_self_ty(span, impl_def_id).ty;
5162 match ty.ty_adt_def() {
5163 Some(adt_def) if adt_def.is_struct() => {
5164 let variant = adt_def.non_enum_variant();
5165 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5166 (variant.did, self.tcx.type_of(variant.did))
5169 (impl_def_id, self.tcx.types.err)
5173 let def_id = def.def_id();
5175 // The things we are substituting into the type should not contain
5176 // escaping late-bound regions, and nor should the base type scheme.
5177 let ty = self.tcx.type_of(def_id);
5181 let substs = AstConv::create_substs_for_generic_args(
5187 // Provide the generic args, and whether types should be inferred.
5189 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5192 // If we've encountered an `impl Trait`-related error, we're just
5193 // going to infer the arguments for better error messages.
5194 if !infer_args_for_err.contains(&index) {
5195 // Check whether the user has provided generic arguments.
5196 if let Some(ref data) = segments[index].args {
5197 return (Some(data), segments[index].infer_types);
5200 return (None, segments[index].infer_types);
5205 // Provide substitutions for parameters for which (valid) arguments have been provided.
5207 match (¶m.kind, arg) {
5208 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5209 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5211 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5212 self.to_ty(ty).into()
5214 _ => unreachable!(),
5217 // Provide substitutions for parameters for which arguments are inferred.
5218 |substs, param, infer_types| {
5220 GenericParamDefKind::Lifetime => {
5221 self.re_infer(span, Some(param)).unwrap().into()
5223 GenericParamDefKind::Type { has_default, .. } => {
5224 if !infer_types && has_default {
5225 // If we have a default, then we it doesn't matter that we're not
5226 // inferring the type arguments: we provide the default where any
5228 let default = self.tcx.type_of(param.def_id);
5231 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5234 // If no type arguments were provided, we have to infer them.
5235 // This case also occurs as a result of some malformed input, e.g.
5236 // a lifetime argument being given instead of a type parameter.
5237 // Using inference instead of `Error` gives better error messages.
5238 self.var_for_def(span, param)
5244 assert!(!substs.has_escaping_bound_vars());
5245 assert!(!ty.has_escaping_bound_vars());
5247 // First, store the "user substs" for later.
5248 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
5249 self.write_user_substs_from_substs(hir_id, substs, user_self_ty);
5251 // Add all the obligations that are required, substituting and
5252 // normalized appropriately.
5253 let bounds = self.instantiate_bounds(span, def_id, &substs);
5254 self.add_obligations_for_parameters(
5255 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5258 // Substitute the values for the type parameters into the type of
5259 // the referenced item.
5260 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5262 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5263 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5264 // is inherent, there is no `Self` parameter, instead, the impl needs
5265 // type parameters, which we can infer by unifying the provided `Self`
5266 // with the substituted impl type.
5267 let ty = self.tcx.type_of(impl_def_id);
5269 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5270 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5271 Ok(ok) => self.register_infer_ok_obligations(ok),
5274 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5281 self.check_rustc_args_require_const(def_id, node_id, span);
5283 debug!("instantiate_value_path: type of {:?} is {:?}",
5286 self.write_substs(hir_id, substs);
5288 (ty_substituted, new_def)
5291 fn check_rustc_args_require_const(&self,
5293 node_id: ast::NodeId,
5295 // We're only interested in functions tagged with
5296 // #[rustc_args_required_const], so ignore anything that's not.
5297 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5301 // If our calling expression is indeed the function itself, we're good!
5302 // If not, generate an error that this can only be called directly.
5303 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
5304 if let hir::ExprKind::Call(ref callee, ..) = expr.node {
5305 if callee.id == node_id {
5311 self.tcx.sess.span_err(span, "this function can only be invoked \
5312 directly, not through a function pointer");
5315 // Resolves `typ` by a single level if `typ` is a type variable.
5316 // If no resolution is possible, then an error is reported.
5317 // Numeric inference variables may be left unresolved.
5318 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5319 let ty = self.resolve_type_vars_with_obligations(ty);
5320 if !ty.is_ty_var() {
5323 if !self.is_tainted_by_errors() {
5324 self.need_type_info_err((**self).body_id, sp, ty)
5325 .note("type must be known at this point")
5328 self.demand_suptype(sp, self.tcx.types.err, ty);
5333 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5334 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5335 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5338 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5339 index = enclosing_breakables.stack.len();
5340 enclosing_breakables.by_id.insert(id, index);
5341 enclosing_breakables.stack.push(ctxt);
5345 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5346 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5347 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5348 enclosing_breakables.stack.pop().expect("missing breakable context")
5354 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5355 generics: &ty::Generics,
5357 let own_counts = generics.own_counts();
5358 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5360 if own_counts.types == 0 {
5363 // Make a vector of booleans initially false, set to true when used.
5364 let mut types_used = vec![false; own_counts.types];
5366 for leaf_ty in ty.walk() {
5367 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5368 debug!("Found use of ty param num {}", idx);
5369 types_used[idx as usize - own_counts.lifetimes] = true;
5370 } else if let ty::Error = leaf_ty.sty {
5371 // If there is already another error, do not emit
5372 // an error for not using a type Parameter.
5373 assert!(tcx.sess.err_count() > 0);
5378 let types = generics.params.iter().filter(|param| match param.kind {
5379 ty::GenericParamDefKind::Type { .. } => true,
5382 for (&used, param) in types_used.iter().zip(types) {
5384 let id = tcx.hir().as_local_node_id(param.def_id).unwrap();
5385 let span = tcx.hir().span(id);
5386 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5387 .span_label(span, "unused type parameter")
5393 fn fatally_break_rust(sess: &Session) {
5394 let handler = sess.diagnostic();
5395 handler.span_bug_no_panic(
5397 "It looks like you're trying to break rust; would you like some ICE?",
5399 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5400 handler.note_without_error(
5401 "we would appreciate a joke overview: \
5402 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5404 handler.note_without_error(&format!("rustc {} running on {}",
5405 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5406 ::session::config::host_triple(),
5410 fn potentially_plural_count(count: usize, word: &str) -> String {
5411 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })