1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 N.B.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
92 use namespace::Namespace;
93 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
94 use rustc::infer::opaque_types::OpaqueTypeDecl;
95 use rustc::infer::type_variable::{TypeVariableOrigin};
96 use rustc::middle::region;
97 use rustc::mir::interpret::{ConstValue, GlobalId};
98 use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
99 UserSelfTy, UserSubsts};
100 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
101 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
102 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
103 use rustc::ty::fold::TypeFoldable;
104 use rustc::ty::query::Providers;
105 use rustc::ty::util::{Representability, IntTypeExt, Discr};
106 use rustc::ty::layout::VariantIdx;
107 use rustc_data_structures::indexed_vec::Idx;
108 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
110 use require_c_abi_if_variadic;
111 use session::{CompileIncomplete, config, Session};
114 use util::common::{ErrorReported, indenter};
115 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
117 use std::cell::{Cell, RefCell, Ref, RefMut};
118 use rustc_data_structures::sync::Lrc;
119 use std::collections::hash_map::Entry;
121 use std::fmt::Display;
123 use std::mem::replace;
124 use std::ops::{self, Deref};
125 use rustc_target::spec::abi::Abi;
128 use syntax::source_map::DUMMY_SP;
129 use syntax::source_map::original_sp;
130 use syntax::feature_gate::{GateIssue, emit_feature_err};
132 use syntax::symbol::{Symbol, LocalInternedString, keywords};
133 use syntax::util::lev_distance::find_best_match_for_name;
134 use syntax_pos::{self, BytePos, Span, MultiSpan};
136 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
137 use rustc::hir::itemlikevisit::ItemLikeVisitor;
138 use rustc::hir::Node;
139 use rustc::hir::{self, PatKind, ItemKind};
140 use rustc::middle::lang_items;
156 mod generator_interior;
160 /// The type of a local binding, including the revealed type for anon types.
161 #[derive(Copy, Clone)]
162 pub struct LocalTy<'tcx> {
164 revealed_ty: Ty<'tcx>
167 /// A wrapper for InferCtxt's `in_progress_tables` field.
168 #[derive(Copy, Clone)]
169 struct MaybeInProgressTables<'a, 'tcx: 'a> {
170 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
173 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
174 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
175 match self.maybe_tables {
176 Some(tables) => tables.borrow(),
178 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
183 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
184 match self.maybe_tables {
185 Some(tables) => tables.borrow_mut(),
187 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
193 /// closures defined within the function. For example:
196 /// bar(move|| { ... })
199 /// Here, the function `foo()` and the closure passed to
200 /// `bar()` will each have their own `FnCtxt`, but they will
201 /// share the inherited fields.
202 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
203 infcx: InferCtxt<'a, 'gcx, 'tcx>,
205 tables: MaybeInProgressTables<'a, 'tcx>,
207 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
209 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
211 // When we process a call like `c()` where `c` is a closure type,
212 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
213 // `FnOnce` closure. In that case, we defer full resolution of the
214 // call until upvar inference can kick in and make the
215 // decision. We keep these deferred resolutions grouped by the
216 // def-id of the closure, so that once we decide, we can easily go
217 // back and process them.
218 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
220 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
222 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
224 // Opaque types found in explicit return types and their
225 // associated fresh inference variable. Writeback resolves these
226 // variables to get the concrete type, which can be used to
227 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
228 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
230 /// Each type parameter has an implicit region bound that
231 /// indicates it must outlive at least the function body (the user
232 /// may specify stronger requirements). This field indicates the
233 /// region of the callee. If it is `None`, then the parameter
234 /// environment is for an item or something where the "callee" is
236 implicit_region_bound: Option<ty::Region<'tcx>>,
238 body_id: Option<hir::BodyId>,
241 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
242 type Target = InferCtxt<'a, 'gcx, 'tcx>;
243 fn deref(&self) -> &Self::Target {
248 /// When type-checking an expression, we propagate downward
249 /// whatever type hint we are able in the form of an `Expectation`.
250 #[derive(Copy, Clone, Debug)]
251 pub enum Expectation<'tcx> {
252 /// We know nothing about what type this expression should have.
255 /// This expression is an `if` condition, it must resolve to `bool`.
258 /// This expression should have the type given (or some subtype)
259 ExpectHasType(Ty<'tcx>),
261 /// This expression will be cast to the `Ty`
262 ExpectCastableToType(Ty<'tcx>),
264 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
265 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
266 ExpectRvalueLikeUnsized(Ty<'tcx>),
269 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
270 // Disregard "castable to" expectations because they
271 // can lead us astray. Consider for example `if cond
272 // {22} else {c} as u8` -- if we propagate the
273 // "castable to u8" constraint to 22, it will pick the
274 // type 22u8, which is overly constrained (c might not
275 // be a u8). In effect, the problem is that the
276 // "castable to" expectation is not the tightest thing
277 // we can say, so we want to drop it in this case.
278 // The tightest thing we can say is "must unify with
279 // else branch". Note that in the case of a "has type"
280 // constraint, this limitation does not hold.
282 // If the expected type is just a type variable, then don't use
283 // an expected type. Otherwise, we might write parts of the type
284 // when checking the 'then' block which are incompatible with the
286 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
288 ExpectHasType(ety) => {
289 let ety = fcx.shallow_resolve(ety);
290 if !ety.is_ty_var() {
296 ExpectRvalueLikeUnsized(ety) => {
297 ExpectRvalueLikeUnsized(ety)
303 /// Provide an expectation for an rvalue expression given an *optional*
304 /// hint, which is not required for type safety (the resulting type might
305 /// be checked higher up, as is the case with `&expr` and `box expr`), but
306 /// is useful in determining the concrete type.
308 /// The primary use case is where the expected type is a fat pointer,
309 /// like `&[isize]`. For example, consider the following statement:
311 /// let x: &[isize] = &[1, 2, 3];
313 /// In this case, the expected type for the `&[1, 2, 3]` expression is
314 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
315 /// expectation `ExpectHasType([isize])`, that would be too strong --
316 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
317 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
318 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
319 /// which still is useful, because it informs integer literals and the like.
320 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
321 /// for examples of where this comes up,.
322 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
323 match fcx.tcx.struct_tail(ty).sty {
324 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
325 ExpectRvalueLikeUnsized(ty)
327 _ => ExpectHasType(ty)
331 // Resolves `expected` by a single level if it is a variable. If
332 // there is no expected type or resolution is not possible (e.g.,
333 // no constraints yet present), just returns `None`.
334 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
336 NoExpectation => NoExpectation,
337 ExpectIfCondition => ExpectIfCondition,
338 ExpectCastableToType(t) => {
339 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
341 ExpectHasType(t) => {
342 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
344 ExpectRvalueLikeUnsized(t) => {
345 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
350 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
351 match self.resolve(fcx) {
352 NoExpectation => None,
353 ExpectIfCondition => Some(fcx.tcx.types.bool),
354 ExpectCastableToType(ty) |
356 ExpectRvalueLikeUnsized(ty) => Some(ty),
360 /// It sometimes happens that we want to turn an expectation into
361 /// a **hard constraint** (i.e., something that must be satisfied
362 /// for the program to type-check). `only_has_type` will return
363 /// such a constraint, if it exists.
364 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
365 match self.resolve(fcx) {
366 ExpectHasType(ty) => Some(ty),
367 ExpectIfCondition => Some(fcx.tcx.types.bool),
368 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
372 /// Like `only_has_type`, but instead of returning `None` if no
373 /// hard constraint exists, creates a fresh type variable.
374 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
375 self.only_has_type(fcx)
376 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
380 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
387 fn maybe_mut_place(m: hir::Mutability) -> Self {
389 hir::MutMutable => Needs::MutPlace,
390 hir::MutImmutable => Needs::None,
395 #[derive(Copy, Clone)]
396 pub struct UnsafetyState {
397 pub def: ast::NodeId,
398 pub unsafety: hir::Unsafety,
399 pub unsafe_push_count: u32,
404 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
405 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
408 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
409 match self.unsafety {
410 // If this unsafe, then if the outer function was already marked as
411 // unsafe we shouldn't attribute the unsafe'ness to the block. This
412 // way the block can be warned about instead of ignoring this
413 // extraneous block (functions are never warned about).
414 hir::Unsafety::Unsafe if self.from_fn => *self,
417 let (unsafety, def, count) = match blk.rules {
418 hir::PushUnsafeBlock(..) =>
419 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
420 hir::PopUnsafeBlock(..) =>
421 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
422 hir::UnsafeBlock(..) =>
423 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
425 (unsafety, self.def, self.unsafe_push_count),
429 unsafe_push_count: count,
436 #[derive(Debug, Copy, Clone)]
442 /// Tracks whether executing a node may exit normally (versus
443 /// return/break/panic, which "diverge", leaving dead code in their
444 /// wake). Tracked semi-automatically (through type variables marked
445 /// as diverging), with some manual adjustments for control-flow
446 /// primitives (approximating a CFG).
447 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
449 /// Potentially unknown, some cases converge,
450 /// others require a CFG to determine them.
453 /// Definitely known to diverge and therefore
454 /// not reach the next sibling or its parent.
457 /// Same as `Always` but with a reachability
458 /// warning already emitted
462 // Convenience impls for combinig `Diverges`.
464 impl ops::BitAnd for Diverges {
466 fn bitand(self, other: Self) -> Self {
467 cmp::min(self, other)
471 impl ops::BitOr for Diverges {
473 fn bitor(self, other: Self) -> Self {
474 cmp::max(self, other)
478 impl ops::BitAndAssign for Diverges {
479 fn bitand_assign(&mut self, other: Self) {
480 *self = *self & other;
484 impl ops::BitOrAssign for Diverges {
485 fn bitor_assign(&mut self, other: Self) {
486 *self = *self | other;
491 fn always(self) -> bool {
492 self >= Diverges::Always
496 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
499 // this is `null` for loops where break with a value is illegal,
500 // such as `while`, `for`, and `while let`
501 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
504 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
505 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
506 by_id: NodeMap<usize>,
509 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
510 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
511 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
512 bug!("could not find enclosing breakable with id {}", target_id);
519 struct PathSeg(DefId, usize);
521 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
522 body_id: ast::NodeId,
524 /// The parameter environment used for proving trait obligations
525 /// in this function. This can change when we descend into
526 /// closures (as they bring new things into scope), hence it is
527 /// not part of `Inherited` (as of the time of this writing,
528 /// closures do not yet change the environment, but they will
530 param_env: ty::ParamEnv<'tcx>,
532 // Number of errors that had been reported when we started
533 // checking this function. On exit, if we find that *more* errors
534 // have been reported, we will skip regionck and other work that
535 // expects the types within the function to be consistent.
536 err_count_on_creation: usize,
538 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
540 yield_ty: Option<Ty<'tcx>>,
542 ps: RefCell<UnsafetyState>,
544 /// Whether the last checked node generates a divergence (e.g.,
545 /// `return` will set this to Always). In general, when entering
546 /// an expression or other node in the tree, the initial value
547 /// indicates whether prior parts of the containing expression may
548 /// have diverged. It is then typically set to `Maybe` (and the
549 /// old value remembered) for processing the subparts of the
550 /// current expression. As each subpart is processed, they may set
551 /// the flag to `Always` etc. Finally, at the end, we take the
552 /// result and "union" it with the original value, so that when we
553 /// return the flag indicates if any subpart of the parent
554 /// expression (up to and including this part) has diverged. So,
555 /// if you read it after evaluating a subexpression `X`, the value
556 /// you get indicates whether any subexpression that was
557 /// evaluating up to and including `X` diverged.
559 /// We currently use this flag only for diagnostic purposes:
561 /// - To warn about unreachable code: if, after processing a
562 /// sub-expression but before we have applied the effects of the
563 /// current node, we see that the flag is set to `Always`, we
564 /// can issue a warning. This corresponds to something like
565 /// `foo(return)`; we warn on the `foo()` expression. (We then
566 /// update the flag to `WarnedAlways` to suppress duplicate
567 /// reports.) Similarly, if we traverse to a fresh statement (or
568 /// tail expression) from a `Always` setting, we will issue a
569 /// warning. This corresponds to something like `{return;
570 /// foo();}` or `{return; 22}`, where we would warn on the
573 /// An expression represents dead-code if, after checking it,
574 /// the diverges flag is set to something other than `Maybe`.
575 diverges: Cell<Diverges>,
577 /// Whether any child nodes have any type errors.
578 has_errors: Cell<bool>,
580 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
582 inh: &'a Inherited<'a, 'gcx, 'tcx>,
585 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
586 type Target = Inherited<'a, 'gcx, 'tcx>;
587 fn deref(&self) -> &Self::Target {
592 /// Helper type of a temporary returned by Inherited::build(...).
593 /// Necessary because we can't write the following bound:
594 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
595 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
596 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
600 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
601 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
602 -> InheritedBuilder<'a, 'gcx, 'tcx> {
603 let hir_id_root = if def_id.is_local() {
604 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
605 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
606 DefId::local(hir_id.owner)
612 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
618 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
619 fn enter<F, R>(&'tcx mut self, f: F) -> R
620 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
622 let def_id = self.def_id;
623 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
627 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
628 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
630 let item_id = tcx.hir.as_local_node_id(def_id);
631 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
632 let implicit_region_bound = body_id.map(|body_id| {
633 let body = tcx.hir.body(body_id);
634 tcx.mk_region(ty::ReScope(region::Scope {
635 id: body.value.hir_id.local_id,
636 data: region::ScopeData::CallSite
641 tables: MaybeInProgressTables {
642 maybe_tables: infcx.in_progress_tables,
645 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
646 locals: RefCell::new(NodeMap()),
647 deferred_call_resolutions: RefCell::new(DefIdMap()),
648 deferred_cast_checks: RefCell::new(Vec::new()),
649 deferred_generator_interiors: RefCell::new(Vec::new()),
650 opaque_types: RefCell::new(DefIdMap()),
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);
910 fcx.select_all_obligations_or_error();
912 if fn_decl.is_some() {
913 fcx.regionck_fn(id, body);
915 fcx.regionck_expr(body);
918 fcx.resolve_type_vars_in_body(body)
921 // Consistency check our TypeckTables instance can hold all ItemLocalIds
922 // it will need to hold.
923 assert_eq!(tables.local_id_root,
924 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
928 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
929 if !tcx.sess.target.target.is_abi_supported(abi) {
930 struct_span_err!(tcx.sess, span, E0570,
931 "The ABI `{}` is not supported for the current target", abi).emit()
935 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
936 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
937 parent_id: ast::NodeId,
940 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
941 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
944 // infer the variable's type
945 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
946 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
953 // take type that the user specified
954 self.fcx.locals.borrow_mut().insert(nid, typ);
961 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
962 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
963 NestedVisitorMap::None
966 // Add explicitly-declared locals.
967 fn visit_local(&mut self, local: &'gcx hir::Local) {
968 let local_ty = match local.ty {
970 let o_ty = self.fcx.to_ty(&ty);
972 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
973 self.fcx.instantiate_opaque_types_from_value(
981 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(&revealed_ty);
982 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
983 ty.hir_id, o_ty, revealed_ty, c_ty);
984 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
986 Some(LocalTy { decl_ty: o_ty, revealed_ty })
990 self.assign(local.span, local.id, local_ty);
992 debug!("Local variable {:?} is assigned type {}",
994 self.fcx.ty_to_string(
995 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
996 intravisit::walk_local(self, local);
999 // Add pattern bindings.
1000 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1001 if let PatKind::Binding(_, _, ident, _) = p.node {
1002 let var_ty = self.assign(p.span, p.id, None);
1004 if !self.fcx.tcx.features().unsized_locals {
1005 self.fcx.require_type_is_sized(var_ty, p.span,
1006 traits::VariableType(p.id));
1009 debug!("Pattern binding {} is assigned to {} with type {:?}",
1011 self.fcx.ty_to_string(
1012 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1015 intravisit::walk_pat(self, p);
1018 // Don't descend into the bodies of nested closures
1019 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1020 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1023 /// When `check_fn` is invoked on a generator (i.e., a body that
1024 /// includes yield), it returns back some information about the yield
1026 struct GeneratorTypes<'tcx> {
1027 /// Type of value that is yielded.
1028 yield_ty: ty::Ty<'tcx>,
1030 /// Types that are captured (see `GeneratorInterior` for more).
1031 interior: ty::Ty<'tcx>,
1033 /// Indicates if the generator is movable or static (immovable)
1034 movability: hir::GeneratorMovability,
1037 /// Helper used for fns and closures. Does the grungy work of checking a function
1038 /// body and returns the function context used for that purpose, since in the case of a fn item
1039 /// there is still a bit more to do.
1042 /// * inherited: other fields inherited from the enclosing fn (if any)
1043 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1044 param_env: ty::ParamEnv<'tcx>,
1045 fn_sig: ty::FnSig<'tcx>,
1046 decl: &'gcx hir::FnDecl,
1048 body: &'gcx hir::Body,
1049 can_be_generator: Option<hir::GeneratorMovability>)
1050 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1052 let mut fn_sig = fn_sig.clone();
1054 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1056 // Create the function context. This is either derived from scratch or,
1057 // in the case of closures, based on the outer context.
1058 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1059 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1061 let declared_ret_ty = fn_sig.output();
1062 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1063 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1064 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1065 fn_sig = fcx.tcx.mk_fn_sig(
1066 fn_sig.inputs().iter().cloned(),
1073 let span = body.value.span;
1075 if body.is_generator && can_be_generator.is_some() {
1076 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1077 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1078 fcx.yield_ty = Some(yield_ty);
1081 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir.local_def_id(fn_id));
1082 let outer_node_id = fcx.tcx.hir.as_local_node_id(outer_def_id).unwrap();
1083 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1085 // Add formal parameters.
1086 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1087 // Check the pattern.
1088 fcx.check_pat_walk(&arg.pat, arg_ty,
1089 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1091 // Check that argument is Sized.
1092 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1093 // for simple cases like `fn foo(x: Trait)`,
1094 // where we would error once on the parameter as a whole, and once on the binding `x`.
1095 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1096 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1099 fcx.write_ty(arg.hir_id, arg_ty);
1102 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1103 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1105 fcx.check_return_expr(&body.value);
1107 // We insert the deferred_generator_interiors entry after visiting the body.
1108 // This ensures that all nested generators appear before the entry of this generator.
1109 // resolve_generator_interiors relies on this property.
1110 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1111 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1112 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1113 Some(GeneratorTypes {
1114 yield_ty: fcx.yield_ty.unwrap(),
1116 movability: can_be_generator.unwrap(),
1122 // Finalize the return check by taking the LUB of the return types
1123 // we saw and assigning it to the expected return type. This isn't
1124 // really expected to fail, since the coercions would have failed
1125 // earlier when trying to find a LUB.
1127 // However, the behavior around `!` is sort of complex. In the
1128 // event that the `actual_return_ty` comes back as `!`, that
1129 // indicates that the fn either does not return or "returns" only
1130 // values of type `!`. In this case, if there is an expected
1131 // return type that is *not* `!`, that should be ok. But if the
1132 // return type is being inferred, we want to "fallback" to `!`:
1134 // let x = move || panic!();
1136 // To allow for that, I am creating a type variable with diverging
1137 // fallback. This was deemed ever so slightly better than unifying
1138 // the return value with `!` because it allows for the caller to
1139 // make more assumptions about the return type (e.g., they could do
1141 // let y: Option<u32> = Some(x());
1143 // which would then cause this return type to become `u32`, not
1145 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1146 let mut actual_return_ty = coercion.complete(&fcx);
1147 if actual_return_ty.is_never() {
1148 actual_return_ty = fcx.next_diverging_ty_var(
1149 TypeVariableOrigin::DivergingFn(span));
1151 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1153 // Check that the main return type implements the termination trait.
1154 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1155 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1157 if let config::EntryFnType::Main = entry_type {
1158 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1159 let trait_ref = ty::TraitRef::new(term_id, substs);
1160 let return_ty_span = decl.output.span();
1161 let cause = traits::ObligationCause::new(
1162 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1164 inherited.register_predicate(
1165 traits::Obligation::new(
1166 cause, param_env, trait_ref.to_predicate()));
1172 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1173 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1174 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1175 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1176 // at this point we don't care if there are duplicate handlers or if the handler has
1177 // the wrong signature as this value we'll be used when writing metadata and that
1178 // only happens if compilation succeeded
1179 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1181 if declared_ret_ty.sty != ty::Never {
1182 fcx.tcx.sess.span_err(
1184 "return type should be `!`",
1188 let inputs = fn_sig.inputs();
1189 let span = fcx.tcx.hir.span(fn_id);
1190 if inputs.len() == 1 {
1191 let arg_is_panic_info = match inputs[0].sty {
1192 ty::Ref(region, ty, mutbl) => match ty.sty {
1193 ty::Adt(ref adt, _) => {
1194 adt.did == panic_info_did &&
1195 mutbl == hir::Mutability::MutImmutable &&
1196 *region != RegionKind::ReStatic
1203 if !arg_is_panic_info {
1204 fcx.tcx.sess.span_err(
1205 decl.inputs[0].span,
1206 "argument should be `&PanicInfo`",
1210 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1211 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1212 if !generics.params.is_empty() {
1213 fcx.tcx.sess.span_err(
1215 "should have no type parameters",
1221 let span = fcx.tcx.sess.source_map().def_span(span);
1222 fcx.tcx.sess.span_err(span, "function should have one argument");
1225 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1230 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1231 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1232 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1233 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1234 if declared_ret_ty.sty != ty::Never {
1235 fcx.tcx.sess.span_err(
1237 "return type should be `!`",
1241 let inputs = fn_sig.inputs();
1242 let span = fcx.tcx.hir.span(fn_id);
1243 if inputs.len() == 1 {
1244 let arg_is_alloc_layout = match inputs[0].sty {
1245 ty::Adt(ref adt, _) => {
1246 adt.did == alloc_layout_did
1251 if !arg_is_alloc_layout {
1252 fcx.tcx.sess.span_err(
1253 decl.inputs[0].span,
1254 "argument should be `Layout`",
1258 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1259 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1260 if !generics.params.is_empty() {
1261 fcx.tcx.sess.span_err(
1263 "`#[alloc_error_handler]` function should have no type \
1270 let span = fcx.tcx.sess.source_map().def_span(span);
1271 fcx.tcx.sess.span_err(span, "function should have one argument");
1274 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1282 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1285 let def_id = tcx.hir.local_def_id(id);
1286 let def = tcx.adt_def(def_id);
1287 def.destructor(tcx); // force the destructor to be evaluated
1288 check_representable(tcx, span, def_id);
1290 if def.repr.simd() {
1291 check_simd(tcx, span, def_id);
1294 check_transparent(tcx, span, def_id);
1295 check_packed(tcx, span, def_id);
1298 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1301 let def_id = tcx.hir.local_def_id(id);
1302 let def = tcx.adt_def(def_id);
1303 def.destructor(tcx); // force the destructor to be evaluated
1304 check_representable(tcx, span, def_id);
1306 check_packed(tcx, span, def_id);
1309 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1311 "check_item_type(it.id={}, it.name={})",
1313 tcx.item_path_str(tcx.hir.local_def_id(it.id))
1315 let _indenter = indenter();
1317 // Consts can play a role in type-checking, so they are included here.
1318 hir::ItemKind::Static(..) => {
1319 let def_id = tcx.hir.local_def_id(it.id);
1320 tcx.typeck_tables_of(def_id);
1321 maybe_check_static_with_link_section(tcx, def_id, it.span);
1323 hir::ItemKind::Const(..) => {
1324 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1326 hir::ItemKind::Enum(ref enum_definition, _) => {
1327 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1329 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1330 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1331 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1332 let impl_def_id = tcx.hir.local_def_id(it.id);
1333 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1334 check_impl_items_against_trait(
1341 let trait_def_id = impl_trait_ref.def_id;
1342 check_on_unimplemented(tcx, trait_def_id, it);
1345 hir::ItemKind::Trait(..) => {
1346 let def_id = tcx.hir.local_def_id(it.id);
1347 check_on_unimplemented(tcx, def_id, it);
1349 hir::ItemKind::Struct(..) => {
1350 check_struct(tcx, it.id, it.span);
1352 hir::ItemKind::Union(..) => {
1353 check_union(tcx, it.id, it.span);
1355 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1356 let def_id = tcx.hir.local_def_id(it.id);
1357 let pty_ty = tcx.type_of(def_id);
1358 let generics = tcx.generics_of(def_id);
1359 check_bounds_are_used(tcx, &generics, pty_ty);
1361 hir::ItemKind::ForeignMod(ref m) => {
1362 check_abi(tcx, it.span, m.abi);
1364 if m.abi == Abi::RustIntrinsic {
1365 for item in &m.items {
1366 intrinsic::check_intrinsic_type(tcx, item);
1368 } else if m.abi == Abi::PlatformIntrinsic {
1369 for item in &m.items {
1370 intrinsic::check_platform_intrinsic_type(tcx, item);
1373 for item in &m.items {
1374 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1375 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1376 let mut err = struct_span_err!(
1380 "foreign items may not have type parameters"
1382 err.span_label(item.span, "can't have type parameters");
1383 // FIXME: once we start storing spans for type arguments, turn this into a
1386 "use specialization instead of type parameters by replacing them \
1387 with concrete types like `u32`",
1392 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1393 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1398 _ => { /* nothing to do */ }
1402 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1403 // Only restricted on wasm32 target for now
1404 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1408 // If `#[link_section]` is missing, then nothing to verify
1409 let attrs = tcx.codegen_fn_attrs(id);
1410 if attrs.link_section.is_none() {
1414 // For the wasm32 target statics with #[link_section] are placed into custom
1415 // sections of the final output file, but this isn't link custom sections of
1416 // other executable formats. Namely we can only embed a list of bytes,
1417 // nothing with pointers to anything else or relocations. If any relocation
1418 // show up, reject them here.
1419 let instance = ty::Instance::mono(tcx, id);
1420 let cid = GlobalId {
1424 let param_env = ty::ParamEnv::reveal_all();
1425 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1426 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1429 bug!("Matching on non-ByRef static")
1431 if alloc.relocations.len() != 0 {
1432 let msg = "statics with a custom `#[link_section]` must be a \
1433 simple list of bytes on the wasm target with no \
1434 extra levels of indirection such as references";
1435 tcx.sess.span_err(span, msg);
1440 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1441 trait_def_id: DefId,
1443 let item_def_id = tcx.hir.local_def_id(item.id);
1444 // an error would be reported if this fails.
1445 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1448 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1449 impl_item: &hir::ImplItem,
1452 let mut err = struct_span_err!(
1453 tcx.sess, impl_item.span, E0520,
1454 "`{}` specializes an item from a parent `impl`, but \
1455 that item is not marked `default`",
1457 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1460 match tcx.span_of_impl(parent_impl) {
1462 err.span_label(span, "parent `impl` is here");
1463 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1467 err.note(&format!("parent implementation is in crate `{}`", cname));
1474 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1475 trait_def: &ty::TraitDef,
1476 trait_item: &ty::AssociatedItem,
1478 impl_item: &hir::ImplItem)
1480 let ancestors = trait_def.ancestors(tcx, impl_id);
1482 let kind = match impl_item.node {
1483 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1484 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1485 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1486 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1489 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1490 .map(|node_item| node_item.map(|parent| parent.defaultness));
1492 if let Some(parent) = parent {
1493 if tcx.impl_item_is_final(&parent) {
1494 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1500 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1503 impl_trait_ref: ty::TraitRef<'tcx>,
1504 impl_item_refs: &[hir::ImplItemRef]) {
1505 let impl_span = tcx.sess.source_map().def_span(impl_span);
1507 // If the trait reference itself is erroneous (so the compilation is going
1508 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1509 // isn't populated for such impls.
1510 if impl_trait_ref.references_error() { return; }
1512 // Locate trait definition and items
1513 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1514 let mut overridden_associated_type = None;
1516 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1518 // Check existing impl methods to see if they are both present in trait
1519 // and compatible with trait signature
1520 for impl_item in impl_items() {
1521 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1522 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1523 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1524 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1526 // Not compatible, but needed for the error message
1527 tcx.associated_items(impl_trait_ref.def_id)
1528 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1531 // Check that impl definition matches trait definition
1532 if let Some(ty_trait_item) = ty_trait_item {
1533 match impl_item.node {
1534 hir::ImplItemKind::Const(..) => {
1535 // Find associated const definition.
1536 if ty_trait_item.kind == ty::AssociatedKind::Const {
1537 compare_const_impl(tcx,
1543 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1544 "item `{}` is an associated const, \
1545 which doesn't match its trait `{}`",
1548 err.span_label(impl_item.span, "does not match trait");
1549 // We can only get the spans from local trait definition
1550 // Same for E0324 and E0325
1551 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1552 err.span_label(trait_span, "item in trait");
1557 hir::ImplItemKind::Method(..) => {
1558 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1559 if ty_trait_item.kind == ty::AssociatedKind::Method {
1560 compare_impl_method(tcx,
1567 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1568 "item `{}` is an associated method, \
1569 which doesn't match its trait `{}`",
1572 err.span_label(impl_item.span, "does not match trait");
1573 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1574 err.span_label(trait_span, "item in trait");
1579 hir::ImplItemKind::Existential(..) |
1580 hir::ImplItemKind::Type(_) => {
1581 if ty_trait_item.kind == ty::AssociatedKind::Type {
1582 if ty_trait_item.defaultness.has_value() {
1583 overridden_associated_type = Some(impl_item);
1586 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1587 "item `{}` is an associated type, \
1588 which doesn't match its trait `{}`",
1591 err.span_label(impl_item.span, "does not match trait");
1592 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1593 err.span_label(trait_span, "item in trait");
1600 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1604 // Check for missing items from trait
1605 let mut missing_items = Vec::new();
1606 let mut invalidated_items = Vec::new();
1607 let associated_type_overridden = overridden_associated_type.is_some();
1608 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1609 let is_implemented = trait_def.ancestors(tcx, impl_id)
1610 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1612 .map(|node_item| !node_item.node.is_from_trait())
1615 if !is_implemented && !tcx.impl_is_default(impl_id) {
1616 if !trait_item.defaultness.has_value() {
1617 missing_items.push(trait_item);
1618 } else if associated_type_overridden {
1619 invalidated_items.push(trait_item.ident);
1624 if !missing_items.is_empty() {
1625 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1626 "not all trait items implemented, missing: `{}`",
1627 missing_items.iter()
1628 .map(|trait_item| trait_item.ident.to_string())
1629 .collect::<Vec<_>>().join("`, `"));
1630 err.span_label(impl_span, format!("missing `{}` in implementation",
1631 missing_items.iter()
1632 .map(|trait_item| trait_item.ident.to_string())
1633 .collect::<Vec<_>>().join("`, `")));
1634 for trait_item in missing_items {
1635 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1636 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1638 err.note_trait_signature(trait_item.ident.to_string(),
1639 trait_item.signature(&tcx));
1645 if !invalidated_items.is_empty() {
1646 let invalidator = overridden_associated_type.unwrap();
1647 span_err!(tcx.sess, invalidator.span, E0399,
1648 "the following trait items need to be reimplemented \
1649 as `{}` was overridden: `{}`",
1651 invalidated_items.iter()
1652 .map(|name| name.to_string())
1653 .collect::<Vec<_>>().join("`, `"))
1657 /// Checks whether a type can be represented in memory. In particular, it
1658 /// identifies types that contain themselves without indirection through a
1659 /// pointer, which would mean their size is unbounded.
1660 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1664 let rty = tcx.type_of(item_def_id);
1666 // Check that it is possible to represent this type. This call identifies
1667 // (1) types that contain themselves and (2) types that contain a different
1668 // recursive type. It is only necessary to throw an error on those that
1669 // contain themselves. For case 2, there must be an inner type that will be
1670 // caught by case 1.
1671 match rty.is_representable(tcx, sp) {
1672 Representability::SelfRecursive(spans) => {
1673 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1675 err.span_label(span, "recursive without indirection");
1680 Representability::Representable | Representability::ContainsRecursive => (),
1685 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1686 let t = tcx.type_of(def_id);
1687 if let ty::Adt(def, substs) = t.sty {
1688 if def.is_struct() {
1689 let fields = &def.non_enum_variant().fields;
1690 if fields.is_empty() {
1691 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1694 let e = fields[0].ty(tcx, substs);
1695 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1696 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1697 .span_label(sp, "SIMD elements must have the same type")
1702 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1703 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1705 span_err!(tcx.sess, sp, E0077,
1706 "SIMD vector element type should be machine type");
1714 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1715 let repr = tcx.adt_def(def_id).repr;
1717 for attr in tcx.get_attrs(def_id).iter() {
1718 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1719 if let attr::ReprPacked(pack) = r {
1720 if pack != repr.pack {
1721 struct_span_err!(tcx.sess, sp, E0634,
1722 "type has conflicting packed representation hints").emit();
1728 struct_span_err!(tcx.sess, sp, E0587,
1729 "type has conflicting packed and align representation hints").emit();
1731 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1732 struct_span_err!(tcx.sess, sp, E0588,
1733 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1738 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1740 stack: &mut Vec<DefId>) -> bool {
1741 let t = tcx.type_of(def_id);
1742 if stack.contains(&def_id) {
1743 debug!("check_packed_inner: {:?} is recursive", t);
1746 if let ty::Adt(def, substs) = t.sty {
1747 if def.is_struct() || def.is_union() {
1748 if tcx.adt_def(def.did).repr.align > 0 {
1751 // push struct def_id before checking fields
1753 for field in &def.non_enum_variant().fields {
1754 let f = field.ty(tcx, substs);
1755 if let ty::Adt(def, _) = f.sty {
1756 if check_packed_inner(tcx, def.did, stack) {
1761 // only need to pop if not early out
1768 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1769 let adt = tcx.adt_def(def_id);
1770 if !adt.repr.transparent() {
1774 // For each field, figure out if it's known to be a ZST and align(1)
1775 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1776 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1777 let param_env = tcx.param_env(field.did);
1778 let layout = tcx.layout_of(param_env.and(ty));
1779 // We are currently checking the type this field came from, so it must be local
1780 let span = tcx.hir.span_if_local(field.did).unwrap();
1781 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1782 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1786 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1787 let non_zst_count = non_zst_fields.clone().count();
1788 if non_zst_count != 1 {
1789 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1790 struct_span_err!(tcx.sess, sp, E0690,
1791 "transparent struct needs exactly one non-zero-sized field, but has {}",
1793 .span_note(field_spans, "non-zero-sized field")
1796 for (span, zst, align1) in field_infos {
1798 span_err!(tcx.sess, span, E0691,
1799 "zero-sized field in transparent struct has alignment larger than 1");
1804 #[allow(trivial_numeric_casts)]
1805 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1807 vs: &'tcx [hir::Variant],
1809 let def_id = tcx.hir.local_def_id(id);
1810 let def = tcx.adt_def(def_id);
1811 def.destructor(tcx); // force the destructor to be evaluated
1814 let attributes = tcx.get_attrs(def_id);
1815 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1817 tcx.sess, attr.span, E0084,
1818 "unsupported representation for zero-variant enum")
1819 .span_label(sp, "zero-variant enum")
1824 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1825 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1826 if !tcx.features().repr128 {
1827 emit_feature_err(&tcx.sess.parse_sess,
1830 GateIssue::Language,
1831 "repr with 128-bit type is unstable");
1836 if let Some(ref e) = v.node.disr_expr {
1837 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1841 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1842 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1843 // Check for duplicate discriminant values
1844 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1845 let variant_did = def.variants[VariantIdx::new(i)].did;
1846 let variant_i_node_id = tcx.hir.as_local_node_id(variant_did).unwrap();
1847 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1848 let i_span = match variant_i.node.disr_expr {
1849 Some(ref expr) => tcx.hir.span(expr.id),
1850 None => tcx.hir.span(variant_i_node_id)
1852 let span = match v.node.disr_expr {
1853 Some(ref expr) => tcx.hir.span(expr.id),
1856 struct_span_err!(tcx.sess, span, E0081,
1857 "discriminant value `{}` already exists", disr_vals[i])
1858 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1859 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1862 disr_vals.push(discr);
1865 check_representable(tcx, sp, def_id);
1868 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1869 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1871 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1872 -> Lrc<ty::GenericPredicates<'tcx>>
1875 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1876 let item_id = tcx.hir.ty_param_owner(node_id);
1877 let item_def_id = tcx.hir.local_def_id(item_id);
1878 let generics = tcx.generics_of(item_def_id);
1879 let index = generics.param_def_id_to_index[&def_id];
1880 Lrc::new(ty::GenericPredicates {
1882 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1884 ty::Predicate::Trait(ref data)
1885 if data.skip_binder().self_ty().is_param(index) => {
1886 // HACK(eddyb) should get the original `Span`.
1887 let span = tcx.def_span(def_id);
1888 Some((predicate, span))
1896 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1897 -> Option<ty::Region<'tcx>> {
1899 Some(def) => infer::EarlyBoundRegion(span, def.name),
1900 None => infer::MiscVariable(span)
1902 Some(self.next_region_var(v))
1905 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1906 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1909 fn ty_infer_for_def(&self,
1910 ty_param_def: &ty::GenericParamDef,
1911 span: Span) -> Ty<'tcx> {
1912 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1918 fn projected_ty_from_poly_trait_ref(&self,
1921 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1924 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1926 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1930 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1933 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1934 if ty.has_escaping_bound_vars() {
1935 ty // FIXME: normalization and escaping regions
1937 self.normalize_associated_types_in(span, &ty)
1941 fn set_tainted_by_errors(&self) {
1942 self.infcx.set_tainted_by_errors()
1945 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1946 self.write_ty(hir_id, ty)
1950 /// Controls whether the arguments are tupled. This is used for the call
1953 /// Tupling means that all call-side arguments are packed into a tuple and
1954 /// passed as a single parameter. For example, if tupling is enabled, this
1957 /// fn f(x: (isize, isize))
1959 /// Can be called as:
1966 #[derive(Clone, Eq, PartialEq)]
1967 enum TupleArgumentsFlag {
1972 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1973 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1974 param_env: ty::ParamEnv<'tcx>,
1975 body_id: ast::NodeId)
1976 -> FnCtxt<'a, 'gcx, 'tcx> {
1980 err_count_on_creation: inh.tcx.sess.err_count(),
1983 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1984 ast::CRATE_NODE_ID)),
1985 diverges: Cell::new(Diverges::Maybe),
1986 has_errors: Cell::new(false),
1987 enclosing_breakables: RefCell::new(EnclosingBreakables {
1995 pub fn sess(&self) -> &Session {
1999 pub fn err_count_since_creation(&self) -> usize {
2000 self.tcx.sess.err_count() - self.err_count_on_creation
2003 /// Produce warning on the given node, if the current point in the
2004 /// function is unreachable, and there hasn't been another warning.
2005 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2006 if self.diverges.get() == Diverges::Always {
2007 self.diverges.set(Diverges::WarnedAlways);
2009 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2011 self.tcx().lint_node(
2012 lint::builtin::UNREACHABLE_CODE,
2014 &format!("unreachable {}", kind));
2020 code: ObligationCauseCode<'tcx>)
2021 -> ObligationCause<'tcx> {
2022 ObligationCause::new(span, self.body_id, code)
2025 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2026 self.cause(span, ObligationCauseCode::MiscObligation)
2029 /// Resolves type variables in `ty` if possible. Unlike the infcx
2030 /// version (resolve_type_vars_if_possible), this version will
2031 /// also select obligations if it seems useful, in an effort
2032 /// to get more type information.
2033 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2034 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2036 // No Infer()? Nothing needs doing.
2037 if !ty.has_infer_types() {
2038 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2042 // If `ty` is a type variable, see whether we already know what it is.
2043 ty = self.resolve_type_vars_if_possible(&ty);
2044 if !ty.has_infer_types() {
2045 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2049 // If not, try resolving pending obligations as much as
2050 // possible. This can help substantially when there are
2051 // indirect dependencies that don't seem worth tracking
2053 self.select_obligations_where_possible(false);
2054 ty = self.resolve_type_vars_if_possible(&ty);
2056 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2060 fn record_deferred_call_resolution(&self,
2061 closure_def_id: DefId,
2062 r: DeferredCallResolution<'gcx, 'tcx>) {
2063 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2064 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2067 fn remove_deferred_call_resolutions(&self,
2068 closure_def_id: DefId)
2069 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2071 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2072 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2075 pub fn tag(&self) -> String {
2076 let self_ptr: *const FnCtxt = self;
2077 format!("{:?}", self_ptr)
2080 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2081 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2082 span_bug!(span, "no type for local variable {}",
2083 self.tcx.hir.node_to_string(nid))
2088 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2089 debug!("write_ty({:?}, {:?}) in fcx {}",
2090 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2091 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2093 if ty.references_error() {
2094 self.has_errors.set(true);
2095 self.set_tainted_by_errors();
2099 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2100 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2101 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2104 // The NodeId and the ItemLocalId must identify the same item. We just pass
2105 // both of them for consistency checking.
2106 pub fn write_method_call(&self,
2108 method: MethodCallee<'tcx>) {
2109 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2112 .type_dependent_defs_mut()
2113 .insert(hir_id, Def::Method(method.def_id));
2115 self.write_substs(hir_id, method.substs);
2117 // When the method is confirmed, the `method.substs` includes
2118 // parameters from not just the method, but also the impl of
2119 // the method -- in particular, the `Self` type will be fully
2120 // resolved. However, those are not something that the "user
2121 // specified" -- i.e., those types come from the inferred type
2122 // of the receiver, not something the user wrote. So when we
2123 // create the user-substs, we want to replace those earlier
2124 // types with just the types that the user actually wrote --
2125 // that is, those that appear on the *method itself*.
2127 // As an example, if the user wrote something like
2128 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2129 // type of `foo` (possibly adjusted), but we don't want to
2130 // include that. We want just the `[_, u32]` part.
2131 if !method.substs.is_noop() {
2132 let method_generics = self.tcx.generics_of(method.def_id);
2133 if !method_generics.params.is_empty() {
2134 let user_substs = self.infcx.probe(|_| {
2135 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2136 let i = param.index as usize;
2137 if i < method_generics.parent_count {
2138 self.infcx.var_for_def(DUMMY_SP, param)
2143 self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2144 substs: just_method_substs,
2145 user_self_ty: None, // not relevant here
2149 debug!("write_method_call: user_substs = {:?}", user_substs);
2150 self.write_user_substs(hir_id, user_substs);
2155 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2156 if !substs.is_noop() {
2157 debug!("write_substs({:?}, {:?}) in fcx {}",
2162 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2166 /// Given the substs that we just converted from the HIR, try to
2167 /// canonicalize them and store them as user-given substitutions
2168 /// (i.e., substitutions that must be respected by the NLL check).
2170 /// This should be invoked **before any unifications have
2171 /// occurred**, so that annotations like `Vec<_>` are preserved
2173 pub fn write_user_substs_from_substs(
2176 substs: &'tcx Substs<'tcx>,
2177 user_self_ty: Option<UserSelfTy<'tcx>>,
2180 "write_user_substs_from_substs({:?}, {:?}) in fcx {}",
2186 if !substs.is_noop() {
2187 let user_substs = self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2191 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2192 self.write_user_substs(hir_id, user_substs);
2196 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalUserSubsts<'tcx>) {
2198 "write_user_substs({:?}, {:?}) in fcx {}",
2204 if !substs.is_identity() {
2205 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2207 debug!("write_user_substs: skipping identity substs");
2211 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2212 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2218 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2219 Entry::Vacant(entry) => { entry.insert(adj); },
2220 Entry::Occupied(mut entry) => {
2221 debug!(" - composing on top of {:?}", entry.get());
2222 match (&entry.get()[..], &adj[..]) {
2223 // Applying any adjustment on top of a NeverToAny
2224 // is a valid NeverToAny adjustment, because it can't
2226 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2228 Adjustment { kind: Adjust::Deref(_), .. },
2229 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2231 Adjustment { kind: Adjust::Deref(_), .. },
2232 .. // Any following adjustments are allowed.
2234 // A reborrow has no effect before a dereference.
2236 // FIXME: currently we never try to compose autoderefs
2237 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2239 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2240 expr, entry.get(), adj)
2242 *entry.get_mut() = adj;
2247 /// Basically whenever we are converting from a type scheme into
2248 /// the fn body space, we always want to normalize associated
2249 /// types as well. This function combines the two.
2250 fn instantiate_type_scheme<T>(&self,
2252 substs: &Substs<'tcx>,
2255 where T : TypeFoldable<'tcx>
2257 let value = value.subst(self.tcx, substs);
2258 let result = self.normalize_associated_types_in(span, &value);
2259 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2266 /// As `instantiate_type_scheme`, but for the bounds found in a
2267 /// generic type scheme.
2268 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2269 -> ty::InstantiatedPredicates<'tcx> {
2270 let bounds = self.tcx.predicates_of(def_id);
2271 let result = bounds.instantiate(self.tcx, substs);
2272 let result = self.normalize_associated_types_in(span, &result);
2273 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2280 /// Replace the opaque types from the given value with type variables,
2281 /// and records the `OpaqueTypeMap` for later use during writeback. See
2282 /// `InferCtxt::instantiate_opaque_types` for more details.
2283 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2285 parent_id: ast::NodeId,
2288 let parent_def_id = self.tcx.hir.local_def_id(parent_id);
2289 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2293 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2294 self.instantiate_opaque_types(
2302 let mut opaque_types = self.opaque_types.borrow_mut();
2303 for (ty, decl) in opaque_type_map {
2304 let old_value = opaque_types.insert(ty, decl);
2305 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2311 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2312 where T : TypeFoldable<'tcx>
2314 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2317 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2319 where T : TypeFoldable<'tcx>
2321 self.inh.partially_normalize_associated_types_in(span,
2327 pub fn require_type_meets(&self,
2330 code: traits::ObligationCauseCode<'tcx>,
2333 self.register_bound(
2336 traits::ObligationCause::new(span, self.body_id, code));
2339 pub fn require_type_is_sized(&self,
2342 code: traits::ObligationCauseCode<'tcx>)
2344 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2345 self.require_type_meets(ty, span, code, lang_item);
2348 pub fn register_bound(&self,
2351 cause: traits::ObligationCause<'tcx>)
2353 self.fulfillment_cx.borrow_mut()
2354 .register_bound(self, self.param_env, ty, def_id, cause);
2357 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2358 let t = AstConv::ast_ty_to_ty(self, ast_t);
2359 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2363 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2364 let ty = self.to_ty(ast_ty);
2366 // If the type given by the user has free regions, save it for
2367 // later, since NLL would like to enforce those. Also pass in
2368 // types that involve projections, since those can resolve to
2369 // `'static` bounds (modulo #54940, which hopefully will be
2370 // fixed by the time you see this comment, dear reader,
2371 // although I have my doubts). Other sorts of things are
2372 // already sufficiently enforced with erased regions. =)
2373 if ty.has_free_regions() || ty.has_projections() {
2374 let c_ty = self.infcx.canonicalize_response(&ty);
2375 self.tables.borrow_mut().user_provided_tys_mut().insert(ast_ty.hir_id, c_ty);
2381 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2382 match self.tables.borrow().node_types().get(id) {
2384 None if self.is_tainted_by_errors() => self.tcx.types.err,
2386 let node_id = self.tcx.hir.hir_to_node_id(id);
2387 bug!("no type for node {}: {} in fcx {}",
2388 node_id, self.tcx.hir.node_to_string(node_id),
2394 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2395 /// outlive the region `r`.
2396 pub fn register_wf_obligation(&self,
2399 code: traits::ObligationCauseCode<'tcx>)
2401 // WF obligations never themselves fail, so no real need to give a detailed cause:
2402 let cause = traits::ObligationCause::new(span, self.body_id, code);
2403 self.register_predicate(traits::Obligation::new(cause,
2405 ty::Predicate::WellFormed(ty)));
2408 /// Registers obligations that all types appearing in `substs` are well-formed.
2409 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2410 for ty in substs.types() {
2411 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2415 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2416 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2417 /// trait/region obligations.
2419 /// For example, if there is a function:
2422 /// fn foo<'a,T:'a>(...)
2425 /// and a reference:
2431 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2432 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2433 pub fn add_obligations_for_parameters(&self,
2434 cause: traits::ObligationCause<'tcx>,
2435 predicates: &ty::InstantiatedPredicates<'tcx>)
2437 assert!(!predicates.has_escaping_bound_vars());
2439 debug!("add_obligations_for_parameters(predicates={:?})",
2442 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2443 self.register_predicate(obligation);
2447 // FIXME(arielb1): use this instead of field.ty everywhere
2448 // Only for fields! Returns <none> for methods>
2449 // Indifferent to privacy flags
2450 pub fn field_ty(&self,
2452 field: &'tcx ty::FieldDef,
2453 substs: &Substs<'tcx>)
2456 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2459 fn check_casts(&self) {
2460 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2461 for cast in deferred_cast_checks.drain(..) {
2466 fn resolve_generator_interiors(&self, def_id: DefId) {
2467 let mut generators = self.deferred_generator_interiors.borrow_mut();
2468 for (body_id, interior) in generators.drain(..) {
2469 self.select_obligations_where_possible(false);
2470 generator_interior::resolve_interior(self, def_id, body_id, interior);
2474 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2475 // Non-numerics get replaced with ! or () (depending on whether
2476 // feature(never_type) is enabled, unconstrained ints with i32,
2477 // unconstrained floats with f64.
2478 // Fallback becomes very dubious if we have encountered type-checking errors.
2479 // In that case, fallback to Error.
2480 // The return value indicates whether fallback has occurred.
2481 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2482 use rustc::ty::error::UnconstrainedNumeric::Neither;
2483 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2485 assert!(ty.is_ty_infer());
2486 let fallback = match self.type_is_unconstrained_numeric(ty) {
2487 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2488 UnconstrainedInt => self.tcx.types.i32,
2489 UnconstrainedFloat => self.tcx.types.f64,
2490 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2491 Neither => return false,
2493 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2494 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2498 fn select_all_obligations_or_error(&self) {
2499 debug!("select_all_obligations_or_error");
2500 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2501 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2505 /// Select as many obligations as we can at present.
2506 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2507 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2508 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2512 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2513 /// returns a type of `&T`, but the actual type we assign to the
2514 /// *expression* is `T`. So this function just peels off the return
2515 /// type by one layer to yield `T`.
2516 fn make_overloaded_place_return_type(&self,
2517 method: MethodCallee<'tcx>)
2518 -> ty::TypeAndMut<'tcx>
2520 // extract method return type, which will be &T;
2521 let ret_ty = method.sig.output();
2523 // method returns &T, but the type as visible to user is T, so deref
2524 ret_ty.builtin_deref(true).unwrap()
2527 fn lookup_indexing(&self,
2529 base_expr: &'gcx hir::Expr,
2533 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2535 // FIXME(#18741) -- this is almost but not quite the same as the
2536 // autoderef that normal method probing does. They could likely be
2539 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2540 let mut result = None;
2541 while result.is_none() && autoderef.next().is_some() {
2542 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2544 autoderef.finalize();
2548 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2549 /// (and otherwise adjust) `base_expr`, looking for a type which either
2550 /// supports builtin indexing or overloaded indexing.
2551 /// This loop implements one step in that search; the autoderef loop
2552 /// is implemented by `lookup_indexing`.
2553 fn try_index_step(&self,
2555 base_expr: &hir::Expr,
2556 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2559 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2561 let adjusted_ty = autoderef.unambiguous_final_ty();
2562 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2569 for &unsize in &[false, true] {
2570 let mut self_ty = adjusted_ty;
2572 // We only unsize arrays here.
2573 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2574 self_ty = self.tcx.mk_slice(element_ty);
2580 // If some lookup succeeds, write callee into table and extract index/element
2581 // type from the method signature.
2582 // If some lookup succeeded, install method in table
2583 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2584 let method = self.try_overloaded_place_op(
2585 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2587 let result = method.map(|ok| {
2588 debug!("try_index_step: success, using overloaded indexing");
2589 let method = self.register_infer_ok_obligations(ok);
2591 let mut adjustments = autoderef.adjust_steps(needs);
2592 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2593 let mutbl = match r_mutbl {
2594 hir::MutImmutable => AutoBorrowMutability::Immutable,
2595 hir::MutMutable => AutoBorrowMutability::Mutable {
2596 // Indexing can be desugared to a method call,
2597 // so maybe we could use two-phase here.
2598 // See the documentation of AllowTwoPhase for why that's
2599 // not the case today.
2600 allow_two_phase_borrow: AllowTwoPhase::No,
2603 adjustments.push(Adjustment {
2604 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2605 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2612 adjustments.push(Adjustment {
2613 kind: Adjust::Unsize,
2614 target: method.sig.inputs()[0]
2617 self.apply_adjustments(base_expr, adjustments);
2619 self.write_method_call(expr.hir_id, method);
2620 (input_ty, self.make_overloaded_place_return_type(method).ty)
2622 if result.is_some() {
2630 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2631 let (tr, name) = match (op, is_mut) {
2632 (PlaceOp::Deref, false) =>
2633 (self.tcx.lang_items().deref_trait(), "deref"),
2634 (PlaceOp::Deref, true) =>
2635 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2636 (PlaceOp::Index, false) =>
2637 (self.tcx.lang_items().index_trait(), "index"),
2638 (PlaceOp::Index, true) =>
2639 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2641 (tr, ast::Ident::from_str(name))
2644 fn try_overloaded_place_op(&self,
2647 arg_tys: &[Ty<'tcx>],
2650 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2652 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2658 // Try Mut first, if needed.
2659 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2660 let method = match (needs, mut_tr) {
2661 (Needs::MutPlace, Some(trait_did)) => {
2662 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2667 // Otherwise, fall back to the immutable version.
2668 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2669 let method = match (method, imm_tr) {
2670 (None, Some(trait_did)) => {
2671 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2673 (method, _) => method,
2679 fn check_method_argument_types(&self,
2682 method: Result<MethodCallee<'tcx>, ()>,
2683 args_no_rcvr: &'gcx [hir::Expr],
2684 tuple_arguments: TupleArgumentsFlag,
2685 expected: Expectation<'tcx>)
2687 let has_error = match method {
2689 method.substs.references_error() || method.sig.references_error()
2694 let err_inputs = self.err_args(args_no_rcvr.len());
2696 let err_inputs = match tuple_arguments {
2697 DontTupleArguments => err_inputs,
2698 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2701 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2702 false, tuple_arguments, None);
2703 return self.tcx.types.err;
2706 let method = method.unwrap();
2707 // HACK(eddyb) ignore self in the definition (see above).
2708 let expected_arg_tys = self.expected_inputs_for_expected_output(
2711 method.sig.output(),
2712 &method.sig.inputs()[1..]
2714 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2715 args_no_rcvr, method.sig.variadic, tuple_arguments,
2716 self.tcx.hir.span_if_local(method.def_id));
2720 /// Generic function that factors out common logic from function calls,
2721 /// method calls and overloaded operators.
2722 fn check_argument_types(&self,
2725 fn_inputs: &[Ty<'tcx>],
2726 mut expected_arg_tys: &[Ty<'tcx>],
2727 args: &'gcx [hir::Expr],
2729 tuple_arguments: TupleArgumentsFlag,
2730 def_span: Option<Span>) {
2733 // Grab the argument types, supplying fresh type variables
2734 // if the wrong number of arguments were supplied
2735 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2741 // All the input types from the fn signature must outlive the call
2742 // so as to validate implied bounds.
2743 for &fn_input_ty in fn_inputs {
2744 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2747 let expected_arg_count = fn_inputs.len();
2749 let param_count_error = |expected_count: usize,
2754 let mut err = tcx.sess.struct_span_err_with_code(sp,
2755 &format!("this function takes {}{} but {} {} supplied",
2756 if variadic {"at least "} else {""},
2757 potentially_plural_count(expected_count, "parameter"),
2758 potentially_plural_count(arg_count, "parameter"),
2759 if arg_count == 1 {"was"} else {"were"}),
2760 DiagnosticId::Error(error_code.to_owned()));
2762 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2763 err.span_label(def_s, "defined here");
2766 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2767 // remove closing `)` from the span
2768 let sugg_span = sugg_span.shrink_to_lo();
2769 err.span_suggestion_with_applicability(
2771 "expected the unit value `()`; create it with empty parentheses",
2773 Applicability::MachineApplicable);
2775 err.span_label(sp, format!("expected {}{}",
2776 if variadic {"at least "} else {""},
2777 potentially_plural_count(expected_count, "parameter")));
2782 let formal_tys = if tuple_arguments == TupleArguments {
2783 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2784 match tuple_type.sty {
2785 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2786 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2787 expected_arg_tys = &[];
2788 self.err_args(args.len())
2790 ty::Tuple(arg_types) => {
2791 expected_arg_tys = match expected_arg_tys.get(0) {
2792 Some(&ty) => match ty.sty {
2793 ty::Tuple(ref tys) => &tys,
2801 span_err!(tcx.sess, sp, E0059,
2802 "cannot use call notation; the first type parameter \
2803 for the function trait is neither a tuple nor unit");
2804 expected_arg_tys = &[];
2805 self.err_args(args.len())
2808 } else if expected_arg_count == supplied_arg_count {
2810 } else if variadic {
2811 if supplied_arg_count >= expected_arg_count {
2814 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2815 expected_arg_tys = &[];
2816 self.err_args(supplied_arg_count)
2819 // is the missing argument of type `()`?
2820 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2821 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2822 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2823 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2827 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2829 expected_arg_tys = &[];
2830 self.err_args(supplied_arg_count)
2832 // If there is no expectation, expect formal_tys.
2833 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2839 debug!("check_argument_types: formal_tys={:?}",
2840 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2842 // Check the arguments.
2843 // We do this in a pretty awful way: first we typecheck any arguments
2844 // that are not closures, then we typecheck the closures. This is so
2845 // that we have more information about the types of arguments when we
2846 // typecheck the functions. This isn't really the right way to do this.
2847 for &check_closures in &[false, true] {
2848 debug!("check_closures={}", check_closures);
2850 // More awful hacks: before we check argument types, try to do
2851 // an "opportunistic" vtable resolution of any trait bounds on
2852 // the call. This helps coercions.
2854 self.select_obligations_where_possible(false);
2857 // For variadic functions, we don't have a declared type for all of
2858 // the arguments hence we only do our usual type checking with
2859 // the arguments who's types we do know.
2860 let t = if variadic {
2862 } else if tuple_arguments == TupleArguments {
2867 for (i, arg) in args.iter().take(t).enumerate() {
2868 // Warn only for the first loop (the "no closures" one).
2869 // Closure arguments themselves can't be diverging, but
2870 // a previous argument can, e.g. `foo(panic!(), || {})`.
2871 if !check_closures {
2872 self.warn_if_unreachable(arg.id, arg.span, "expression");
2875 let is_closure = match arg.node {
2876 hir::ExprKind::Closure(..) => true,
2880 if is_closure != check_closures {
2884 debug!("checking the argument");
2885 let formal_ty = formal_tys[i];
2887 // The special-cased logic below has three functions:
2888 // 1. Provide as good of an expected type as possible.
2889 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2891 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2893 // 2. Coerce to the most detailed type that could be coerced
2894 // to, which is `expected_ty` if `rvalue_hint` returns an
2895 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2896 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2897 // We're processing function arguments so we definitely want to use
2898 // two-phase borrows.
2899 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2901 // 3. Relate the expected type and the formal one,
2902 // if the expected type was used for the coercion.
2903 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2907 // We also need to make sure we at least write the ty of the other
2908 // arguments which we skipped above.
2910 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2911 use structured_errors::{VariadicError, StructuredDiagnostic};
2912 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2915 for arg in args.iter().skip(expected_arg_count) {
2916 let arg_ty = self.check_expr(&arg);
2918 // There are a few types which get autopromoted when passed via varargs
2919 // in C but we just error out instead and require explicit casts.
2920 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2922 ty::Float(ast::FloatTy::F32) => {
2923 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2925 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2926 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2928 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2929 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2932 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2933 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2934 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2942 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2943 vec![self.tcx.types.err; len]
2946 // AST fragment checking
2949 expected: Expectation<'tcx>)
2955 ast::LitKind::Str(..) => tcx.mk_static_str(),
2956 ast::LitKind::ByteStr(ref v) => {
2957 tcx.mk_imm_ref(tcx.types.re_static,
2958 tcx.mk_array(tcx.types.u8, v.len() as u64))
2960 ast::LitKind::Byte(_) => tcx.types.u8,
2961 ast::LitKind::Char(_) => tcx.types.char,
2962 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2963 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2964 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2965 let opt_ty = expected.to_option(self).and_then(|ty| {
2967 ty::Int(_) | ty::Uint(_) => Some(ty),
2968 ty::Char => Some(tcx.types.u8),
2969 ty::RawPtr(..) => Some(tcx.types.usize),
2970 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2974 opt_ty.unwrap_or_else(
2975 || tcx.mk_int_var(self.next_int_var_id()))
2977 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2978 ast::LitKind::FloatUnsuffixed(_) => {
2979 let opt_ty = expected.to_option(self).and_then(|ty| {
2981 ty::Float(_) => Some(ty),
2985 opt_ty.unwrap_or_else(
2986 || tcx.mk_float_var(self.next_float_var_id()))
2988 ast::LitKind::Bool(_) => tcx.types.bool
2992 fn check_expr_eq_type(&self,
2993 expr: &'gcx hir::Expr,
2994 expected: Ty<'tcx>) {
2995 let ty = self.check_expr_with_hint(expr, expected);
2996 self.demand_eqtype(expr.span, expected, ty);
2999 pub fn check_expr_has_type_or_error(&self,
3000 expr: &'gcx hir::Expr,
3001 expected: Ty<'tcx>) -> Ty<'tcx> {
3002 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3005 fn check_expr_meets_expectation_or_error(&self,
3006 expr: &'gcx hir::Expr,
3007 expected: Expectation<'tcx>) -> Ty<'tcx> {
3008 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3009 let mut ty = self.check_expr_with_expectation(expr, expected);
3011 // While we don't allow *arbitrary* coercions here, we *do* allow
3012 // coercions from ! to `expected`.
3014 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3015 "expression with never type wound up being adjusted");
3016 let adj_ty = self.next_diverging_ty_var(
3017 TypeVariableOrigin::AdjustmentType(expr.span));
3018 self.apply_adjustments(expr, vec![Adjustment {
3019 kind: Adjust::NeverToAny,
3025 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3026 // Add help to type error if this is an `if` condition with an assignment
3027 if let (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs))
3028 = (expected, &expr.node)
3030 let msg = "try comparing for equality";
3031 if let (Ok(left), Ok(right)) = (
3032 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3033 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3035 err.span_suggestion_with_applicability(
3038 format!("{} == {}", left, right),
3039 Applicability::MaybeIncorrect);
3049 fn check_expr_coercable_to_type(&self,
3050 expr: &'gcx hir::Expr,
3051 expected: Ty<'tcx>) -> Ty<'tcx> {
3052 let ty = self.check_expr_with_hint(expr, expected);
3053 // checks don't need two phase
3054 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3057 fn check_expr_with_hint(&self,
3058 expr: &'gcx hir::Expr,
3059 expected: Ty<'tcx>) -> Ty<'tcx> {
3060 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3063 fn check_expr_with_expectation(&self,
3064 expr: &'gcx hir::Expr,
3065 expected: Expectation<'tcx>) -> Ty<'tcx> {
3066 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3069 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3070 self.check_expr_with_expectation(expr, NoExpectation)
3073 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3074 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3077 // determine the `self` type, using fresh variables for all variables
3078 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3079 // would return ($0, $1) where $0 and $1 are freshly instantiated type
3081 pub fn impl_self_ty(&self,
3082 span: Span, // (potential) receiver for this impl
3084 -> TypeAndSubsts<'tcx> {
3085 let ity = self.tcx.type_of(did);
3086 debug!("impl_self_ty: ity={:?}", ity);
3088 let substs = self.fresh_substs_for_item(span, did);
3089 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3091 TypeAndSubsts { substs: substs, ty: substd_ty }
3094 /// Unifies the output type with the expected type early, for more coercions
3095 /// and forward type information on the input expressions.
3096 fn expected_inputs_for_expected_output(&self,
3098 expected_ret: Expectation<'tcx>,
3099 formal_ret: Ty<'tcx>,
3100 formal_args: &[Ty<'tcx>])
3102 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3103 let ret_ty = match expected_ret.only_has_type(self) {
3105 None => return Vec::new()
3107 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3108 // Attempt to apply a subtyping relationship between the formal
3109 // return type (likely containing type variables if the function
3110 // is polymorphic) and the expected return type.
3111 // No argument expectations are produced if unification fails.
3112 let origin = self.misc(call_span);
3113 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3115 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3116 // to identity so the resulting type is not constrained.
3119 // Process any obligations locally as much as
3120 // we can. We don't care if some things turn
3121 // out unconstrained or ambiguous, as we're
3122 // just trying to get hints here.
3123 self.save_and_restore_in_snapshot_flag(|_| {
3124 let mut fulfill = TraitEngine::new(self.tcx);
3125 for obligation in ok.obligations {
3126 fulfill.register_predicate_obligation(self, obligation);
3128 fulfill.select_where_possible(self)
3129 }).map_err(|_| ())?;
3131 Err(_) => return Err(()),
3134 // Record all the argument types, with the substitutions
3135 // produced from the above subtyping unification.
3136 Ok(formal_args.iter().map(|ty| {
3137 self.resolve_type_vars_if_possible(ty)
3139 }).unwrap_or_default();
3140 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3141 formal_args, formal_ret,
3142 expect_args, expected_ret);
3146 // Checks a method call.
3147 fn check_method_call(&self,
3148 expr: &'gcx hir::Expr,
3149 segment: &hir::PathSegment,
3151 args: &'gcx [hir::Expr],
3152 expected: Expectation<'tcx>,
3153 needs: Needs) -> Ty<'tcx> {
3154 let rcvr = &args[0];
3155 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3156 // no need to check for bot/err -- callee does that
3157 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3159 let method = match self.lookup_method(rcvr_t,
3165 self.write_method_call(expr.hir_id, method);
3169 if segment.ident.name != keywords::Invalid.name() {
3170 self.report_method_error(span,
3181 // Call the generic checker.
3182 self.check_method_argument_types(span,
3190 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3194 .unwrap_or_else(|| span_bug!(return_expr.span,
3195 "check_return_expr called outside fn body"));
3197 let ret_ty = ret_coercion.borrow().expected_ty();
3198 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3199 ret_coercion.borrow_mut()
3201 &self.cause(return_expr.span,
3202 ObligationCauseCode::ReturnType(return_expr.id)),
3207 // A generic function for checking the then and else in an if
3209 fn check_then_else(&self,
3210 cond_expr: &'gcx hir::Expr,
3211 then_expr: &'gcx hir::Expr,
3212 opt_else_expr: Option<&'gcx hir::Expr>,
3214 expected: Expectation<'tcx>) -> Ty<'tcx> {
3215 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3216 let cond_diverges = self.diverges.get();
3217 self.diverges.set(Diverges::Maybe);
3219 let expected = expected.adjust_for_branches(self);
3220 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3221 let then_diverges = self.diverges.get();
3222 self.diverges.set(Diverges::Maybe);
3224 // We've already taken the expected type's preferences
3225 // into account when typing the `then` branch. To figure
3226 // out the initial shot at a LUB, we thus only consider
3227 // `expected` if it represents a *hard* constraint
3228 // (`only_has_type`); otherwise, we just go with a
3229 // fresh type variable.
3230 let coerce_to_ty = expected.coercion_target_type(self, sp);
3231 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3233 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3234 coerce.coerce(self, &if_cause, then_expr, then_ty);
3236 if let Some(else_expr) = opt_else_expr {
3237 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3238 let else_diverges = self.diverges.get();
3240 coerce.coerce(self, &if_cause, else_expr, else_ty);
3242 // We won't diverge unless both branches do (or the condition does).
3243 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3245 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3246 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3248 // If the condition is false we can't diverge.
3249 self.diverges.set(cond_diverges);
3252 let result_ty = coerce.complete(self);
3253 if cond_ty.references_error() {
3260 // Check field access expressions
3261 fn check_field(&self,
3262 expr: &'gcx hir::Expr,
3264 base: &'gcx hir::Expr,
3265 field: ast::Ident) -> Ty<'tcx> {
3266 let expr_t = self.check_expr_with_needs(base, needs);
3267 let expr_t = self.structurally_resolved_type(base.span,
3269 let mut private_candidate = None;
3270 let mut autoderef = self.autoderef(expr.span, expr_t);
3271 while let Some((base_t, _)) = autoderef.next() {
3273 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3274 debug!("struct named {:?}", base_t);
3275 let (ident, def_scope) =
3276 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3277 let fields = &base_def.non_enum_variant().fields;
3278 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3279 let field = &fields[index];
3280 let field_ty = self.field_ty(expr.span, field, substs);
3281 // Save the index of all fields regardless of their visibility in case
3282 // of error recovery.
3283 self.write_field_index(expr.id, index);
3284 if field.vis.is_accessible_from(def_scope, self.tcx) {
3285 let adjustments = autoderef.adjust_steps(needs);
3286 self.apply_adjustments(base, adjustments);
3287 autoderef.finalize();
3289 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3292 private_candidate = Some((base_def.did, field_ty));
3295 ty::Tuple(ref tys) => {
3296 let fstr = field.as_str();
3297 if let Ok(index) = fstr.parse::<usize>() {
3298 if fstr == index.to_string() {
3299 if let Some(field_ty) = tys.get(index) {
3300 let adjustments = autoderef.adjust_steps(needs);
3301 self.apply_adjustments(base, adjustments);
3302 autoderef.finalize();
3304 self.write_field_index(expr.id, index);
3313 autoderef.unambiguous_final_ty();
3315 if let Some((did, field_ty)) = private_candidate {
3316 let struct_path = self.tcx().item_path_str(did);
3317 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3318 "field `{}` of struct `{}` is private",
3319 field, struct_path);
3320 // Also check if an accessible method exists, which is often what is meant.
3321 if self.method_exists(field, expr_t, expr.id, false) {
3322 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3326 } else if field.name == keywords::Invalid.name() {
3327 self.tcx().types.err
3328 } else if self.method_exists(field, expr_t, expr.id, true) {
3329 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3330 "attempted to take value of method `{}` on type `{}`",
3332 .help("maybe a `()` to call it is missing?")
3334 self.tcx().types.err
3336 if !expr_t.is_primitive_ty() {
3337 let mut err = self.no_such_field_err(field.span, field, expr_t);
3340 ty::Adt(def, _) if !def.is_enum() => {
3341 if let Some(suggested_field_name) =
3342 Self::suggest_field_name(def.non_enum_variant(),
3343 &field.as_str(), vec![]) {
3344 err.span_label(field.span,
3345 format!("did you mean `{}`?", suggested_field_name));
3347 err.span_label(field.span, "unknown field");
3348 let struct_variant_def = def.non_enum_variant();
3349 let field_names = self.available_field_names(struct_variant_def);
3350 if !field_names.is_empty() {
3351 err.note(&format!("available fields are: {}",
3352 self.name_series_display(field_names)));
3356 ty::Array(_, len) => {
3357 if let (Some(len), Ok(user_index)) = (
3358 len.assert_usize(self.tcx),
3359 field.as_str().parse::<u64>()
3361 let base = self.tcx.hir.node_to_pretty_string(base.id);
3362 let help = "instead of using tuple indexing, use array indexing";
3363 let suggestion = format!("{}[{}]", base, field);
3364 let applicability = if len < user_index {
3365 Applicability::MachineApplicable
3367 Applicability::MaybeIncorrect
3369 err.span_suggestion_with_applicability(
3370 expr.span, help, suggestion, applicability
3375 let base = self.tcx.hir.node_to_pretty_string(base.id);
3376 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3377 let suggestion = format!("(*{}).{}", base, field);
3378 err.span_suggestion_with_applicability(
3382 Applicability::MaybeIncorrect,
3389 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3390 "`{}` is a primitive type and therefore doesn't have fields",
3393 self.tcx().types.err
3397 // Return an hint about the closest match in field names
3398 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3400 skip: Vec<LocalInternedString>)
3402 let names = variant.fields.iter().filter_map(|field| {
3403 // ignore already set fields and private fields from non-local crates
3404 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3405 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3408 Some(&field.ident.name)
3412 find_best_match_for_name(names, field, None)
3415 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3416 variant.fields.iter().filter(|field| {
3417 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3418 field.vis.is_accessible_from(def_scope, self.tcx)
3420 .map(|field| field.ident.name)
3424 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3425 // dynamic limit, to never omit just one field
3426 let limit = if names.len() == 6 { 6 } else { 5 };
3427 let mut display = names.iter().take(limit)
3428 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3429 if names.len() > limit {
3430 display = format!("{} ... and {} others", display, names.len() - limit);
3435 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3436 -> DiagnosticBuilder {
3437 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3438 "no field `{}` on type `{}`",
3442 fn report_unknown_field(&self,
3444 variant: &'tcx ty::VariantDef,
3446 skip_fields: &[hir::Field],
3448 let mut err = self.type_error_struct_with_diag(
3450 |actual| match ty.sty {
3451 ty::Adt(adt, ..) if adt.is_enum() => {
3452 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3453 "{} `{}::{}` has no field named `{}`",
3454 kind_name, actual, variant.name, field.ident)
3457 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3458 "{} `{}` has no field named `{}`",
3459 kind_name, actual, field.ident)
3463 // prevent all specified fields from being suggested
3464 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3465 if let Some(field_name) = Self::suggest_field_name(variant,
3466 &field.ident.as_str(),
3467 skip_fields.collect()) {
3468 err.span_label(field.ident.span,
3469 format!("field does not exist - did you mean `{}`?", field_name));
3472 ty::Adt(adt, ..) => {
3474 err.span_label(field.ident.span,
3475 format!("`{}::{}` does not have this field",
3478 err.span_label(field.ident.span,
3479 format!("`{}` does not have this field", ty));
3481 let available_field_names = self.available_field_names(variant);
3482 if !available_field_names.is_empty() {
3483 err.note(&format!("available fields are: {}",
3484 self.name_series_display(available_field_names)));
3487 _ => bug!("non-ADT passed to report_unknown_field")
3493 fn check_expr_struct_fields(&self,
3495 expected: Expectation<'tcx>,
3496 expr_id: ast::NodeId,
3498 variant: &'tcx ty::VariantDef,
3499 ast_fields: &'gcx [hir::Field],
3500 check_completeness: bool) -> bool {
3504 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3505 .get(0).cloned().unwrap_or(adt_ty);
3506 // re-link the regions that EIfEO can erase.
3507 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3509 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3510 &ty::Adt(adt, substs) => {
3511 (substs, adt.adt_kind(), adt.variant_descr())
3513 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3516 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3517 (field.ident.modern(), (i, field))
3518 ).collect::<FxHashMap<_, _>>();
3520 let mut seen_fields = FxHashMap::default();
3522 let mut error_happened = false;
3524 // Typecheck each field.
3525 for field in ast_fields {
3526 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3527 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3528 seen_fields.insert(ident, field.span);
3529 self.write_field_index(field.id, i);
3531 // we don't look at stability attributes on
3532 // struct-like enums (yet...), but it's definitely not
3533 // a bug to have construct one.
3534 if adt_kind != ty::AdtKind::Enum {
3535 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3538 self.field_ty(field.span, v_field, substs)
3540 error_happened = true;
3541 if let Some(prev_span) = seen_fields.get(&ident) {
3542 let mut err = struct_span_err!(self.tcx.sess,
3545 "field `{}` specified more than once",
3548 err.span_label(field.ident.span, "used more than once");
3549 err.span_label(*prev_span, format!("first use of `{}`", ident));
3553 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3559 // Make sure to give a type to the field even if there's
3560 // an error, so we can continue typechecking
3561 self.check_expr_coercable_to_type(&field.expr, field_type);
3564 // Make sure the programmer specified correct number of fields.
3565 if kind_name == "union" {
3566 if ast_fields.len() != 1 {
3567 tcx.sess.span_err(span, "union expressions should have exactly one field");
3569 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3570 let len = remaining_fields.len();
3572 let mut displayable_field_names = remaining_fields
3574 .map(|ident| ident.as_str())
3575 .collect::<Vec<_>>();
3577 displayable_field_names.sort();
3579 let truncated_fields_error = if len <= 3 {
3582 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3585 let remaining_fields_names = displayable_field_names.iter().take(3)
3586 .map(|n| format!("`{}`", n))
3587 .collect::<Vec<_>>()
3590 struct_span_err!(tcx.sess, span, E0063,
3591 "missing field{} {}{} in initializer of `{}`",
3592 if remaining_fields.len() == 1 { "" } else { "s" },
3593 remaining_fields_names,
3594 truncated_fields_error,
3596 .span_label(span, format!("missing {}{}",
3597 remaining_fields_names,
3598 truncated_fields_error))
3604 fn check_struct_fields_on_error(&self,
3605 fields: &'gcx [hir::Field],
3606 base_expr: &'gcx Option<P<hir::Expr>>) {
3607 for field in fields {
3608 self.check_expr(&field.expr);
3610 if let Some(ref base) = *base_expr {
3611 self.check_expr(&base);
3615 pub fn check_struct_path(&self,
3617 node_id: ast::NodeId)
3618 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3619 let path_span = match *qpath {
3620 hir::QPath::Resolved(_, ref path) => path.span,
3621 hir::QPath::TypeRelative(ref qself, _) => qself.span
3623 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3624 let variant = match def {
3626 self.set_tainted_by_errors();
3629 Def::Variant(..) => {
3631 ty::Adt(adt, substs) => {
3632 Some((adt.variant_of_def(def), adt.did, substs))
3634 _ => bug!("unexpected type: {:?}", ty.sty)
3637 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3638 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3640 ty::Adt(adt, substs) if !adt.is_enum() => {
3641 Some((adt.non_enum_variant(), adt.did, substs))
3646 _ => bug!("unexpected definition: {:?}", def)
3649 if let Some((variant, did, substs)) = variant {
3650 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3651 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
3652 self.write_user_substs_from_substs(hir_id, substs, None);
3654 // Check bounds on type arguments used in the path.
3655 let bounds = self.instantiate_bounds(path_span, did, substs);
3656 let cause = traits::ObligationCause::new(path_span, self.body_id,
3657 traits::ItemObligation(did));
3658 self.add_obligations_for_parameters(cause, &bounds);
3662 struct_span_err!(self.tcx.sess, path_span, E0071,
3663 "expected struct, variant or union type, found {}",
3664 ty.sort_string(self.tcx))
3665 .span_label(path_span, "not a struct")
3671 fn check_expr_struct(&self,
3673 expected: Expectation<'tcx>,
3675 fields: &'gcx [hir::Field],
3676 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3678 // Find the relevant variant
3679 let (variant, adt_ty) =
3680 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3683 self.check_struct_fields_on_error(fields, base_expr);
3684 return self.tcx.types.err;
3687 let path_span = match *qpath {
3688 hir::QPath::Resolved(_, ref path) => path.span,
3689 hir::QPath::TypeRelative(ref qself, _) => qself.span
3692 // Prohibit struct expressions when non exhaustive flag is set.
3693 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3694 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3695 span_err!(self.tcx.sess, expr.span, E0639,
3696 "cannot create non-exhaustive {} using struct expression",
3697 adt.variant_descr());
3700 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3701 variant, fields, base_expr.is_none());
3702 if let &Some(ref base_expr) = base_expr {
3703 // If check_expr_struct_fields hit an error, do not attempt to populate
3704 // the fields with the base_expr. This could cause us to hit errors later
3705 // when certain fields are assumed to exist that in fact do not.
3706 if !error_happened {
3707 self.check_expr_has_type_or_error(base_expr, adt_ty);
3709 ty::Adt(adt, substs) if adt.is_struct() => {
3710 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3711 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3716 .fru_field_types_mut()
3717 .insert(expr.hir_id, fru_field_types);
3720 span_err!(self.tcx.sess, base_expr.span, E0436,
3721 "functional record update syntax requires a struct");
3726 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3732 /// If an expression has any sub-expressions that result in a type error,
3733 /// inspecting that expression's type with `ty.references_error()` will return
3734 /// true. Likewise, if an expression is known to diverge, inspecting its
3735 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3736 /// strict, _|_ can appear in the type of an expression that does not,
3737 /// itself, diverge: for example, fn() -> _|_.)
3738 /// Note that inspecting a type's structure *directly* may expose the fact
3739 /// that there are actually multiple representations for `Error`, so avoid
3740 /// that when err needs to be handled differently.
3741 fn check_expr_with_expectation_and_needs(&self,
3742 expr: &'gcx hir::Expr,
3743 expected: Expectation<'tcx>,
3744 needs: Needs) -> Ty<'tcx> {
3745 debug!(">> typechecking: expr={:?} expected={:?}",
3748 // Warn for expressions after diverging siblings.
3749 self.warn_if_unreachable(expr.id, expr.span, "expression");
3751 // Hide the outer diverging and has_errors flags.
3752 let old_diverges = self.diverges.get();
3753 let old_has_errors = self.has_errors.get();
3754 self.diverges.set(Diverges::Maybe);
3755 self.has_errors.set(false);
3757 let ty = self.check_expr_kind(expr, expected, needs);
3759 // Warn for non-block expressions with diverging children.
3761 hir::ExprKind::Block(..) |
3762 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3763 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3765 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3768 // Any expression that produces a value of type `!` must have diverged
3770 self.diverges.set(self.diverges.get() | Diverges::Always);
3773 // Record the type, which applies it effects.
3774 // We need to do this after the warning above, so that
3775 // we don't warn for the diverging expression itself.
3776 self.write_ty(expr.hir_id, ty);
3778 // Combine the diverging and has_error flags.
3779 self.diverges.set(self.diverges.get() | old_diverges);
3780 self.has_errors.set(self.has_errors.get() | old_has_errors);
3782 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3783 debug!("... {:?}, expected is {:?}", ty, expected);
3790 expr: &'gcx hir::Expr,
3791 expected: Expectation<'tcx>,
3795 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3804 hir::ExprKind::Box(ref subexpr) => {
3805 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3807 ty::Adt(def, _) if def.is_box()
3808 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3812 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3813 tcx.mk_box(referent_ty)
3816 hir::ExprKind::Lit(ref lit) => {
3817 self.check_lit(&lit, expected)
3819 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3820 self.check_binop(expr, op, lhs, rhs)
3822 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3823 self.check_binop_assign(expr, op, lhs, rhs)
3825 hir::ExprKind::Unary(unop, ref oprnd) => {
3826 let expected_inner = match unop {
3827 hir::UnNot | hir::UnNeg => {
3834 let needs = match unop {
3835 hir::UnDeref => needs,
3838 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3842 if !oprnd_t.references_error() {
3843 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3846 if let Some(mt) = oprnd_t.builtin_deref(true) {
3848 } else if let Some(ok) = self.try_overloaded_deref(
3849 expr.span, oprnd_t, needs) {
3850 let method = self.register_infer_ok_obligations(ok);
3851 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3852 let mutbl = match mutbl {
3853 hir::MutImmutable => AutoBorrowMutability::Immutable,
3854 hir::MutMutable => AutoBorrowMutability::Mutable {
3855 // (It shouldn't actually matter for unary ops whether
3856 // we enable two-phase borrows or not, since a unary
3857 // op has no additional operands.)
3858 allow_two_phase_borrow: AllowTwoPhase::No,
3861 self.apply_adjustments(oprnd, vec![Adjustment {
3862 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3863 target: method.sig.inputs()[0]
3866 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3867 self.write_method_call(expr.hir_id, method);
3869 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3870 "type `{}` cannot be dereferenced",
3872 oprnd_t = tcx.types.err;
3876 let result = self.check_user_unop(expr, oprnd_t, unop);
3877 // If it's builtin, we can reuse the type, this helps inference.
3878 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3883 let result = self.check_user_unop(expr, oprnd_t, unop);
3884 // If it's builtin, we can reuse the type, this helps inference.
3885 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3893 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3894 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3896 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3897 if oprnd.is_place_expr() {
3898 // Places may legitimately have unsized types.
3899 // For example, dereferences of a fat pointer and
3900 // the last field of a struct can be unsized.
3903 Expectation::rvalue_hint(self, ty)
3909 let needs = Needs::maybe_mut_place(mutbl);
3910 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3912 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3913 if tm.ty.references_error() {
3916 // Note: at this point, we cannot say what the best lifetime
3917 // is to use for resulting pointer. We want to use the
3918 // shortest lifetime possible so as to avoid spurious borrowck
3919 // errors. Moreover, the longest lifetime will depend on the
3920 // precise details of the value whose address is being taken
3921 // (and how long it is valid), which we don't know yet until type
3922 // inference is complete.
3924 // Therefore, here we simply generate a region variable. The
3925 // region inferencer will then select the ultimate value.
3926 // Finally, borrowck is charged with guaranteeing that the
3927 // value whose address was taken can actually be made to live
3928 // as long as it needs to live.
3929 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3930 tcx.mk_ref(region, tm)
3933 hir::ExprKind::Path(ref qpath) => {
3934 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3935 let ty = if def != Def::Err {
3936 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
3938 self.set_tainted_by_errors();
3942 // We always require that the type provided as the value for
3943 // a type parameter outlives the moment of instantiation.
3944 let substs = self.tables.borrow().node_substs(expr.hir_id);
3945 self.add_wf_bounds(substs, expr);
3949 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3950 for expr in outputs.iter().chain(inputs.iter()) {
3951 self.check_expr(expr);
3955 hir::ExprKind::Break(destination, ref expr_opt) => {
3956 if let Ok(target_id) = destination.target_id {
3958 if let Some(ref e) = *expr_opt {
3959 // If this is a break with a value, we need to type-check
3960 // the expression. Get an expected type from the loop context.
3961 let opt_coerce_to = {
3962 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3963 enclosing_breakables.find_breakable(target_id)
3966 .map(|coerce| coerce.expected_ty())
3969 // If the loop context is not a `loop { }`, then break with
3970 // a value is illegal, and `opt_coerce_to` will be `None`.
3971 // Just set expectation to error in that case.
3972 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3974 // Recurse without `enclosing_breakables` borrowed.
3975 e_ty = self.check_expr_with_hint(e, coerce_to);
3976 cause = self.misc(e.span);
3978 // Otherwise, this is a break *without* a value. That's
3979 // always legal, and is equivalent to `break ()`.
3980 e_ty = tcx.mk_unit();
3981 cause = self.misc(expr.span);
3984 // Now that we have type-checked `expr_opt`, borrow
3985 // the `enclosing_loops` field and let's coerce the
3986 // type of `expr_opt` into what is expected.
3987 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3988 let ctxt = enclosing_breakables.find_breakable(target_id);
3989 if let Some(ref mut coerce) = ctxt.coerce {
3990 if let Some(ref e) = *expr_opt {
3991 coerce.coerce(self, &cause, e, e_ty);
3993 assert!(e_ty.is_unit());
3994 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3997 // If `ctxt.coerce` is `None`, we can just ignore
3998 // the type of the expresison. This is because
3999 // either this was a break *without* a value, in
4000 // which case it is always a legal type (`()`), or
4001 // else an error would have been flagged by the
4002 // `loops` pass for using break with an expression
4003 // where you are not supposed to.
4004 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4007 ctxt.may_break = true;
4009 // the type of a `break` is always `!`, since it diverges
4012 // Otherwise, we failed to find the enclosing loop;
4013 // this can only happen if the `break` was not
4014 // inside a loop at all, which is caught by the
4015 // loop-checking pass.
4016 if self.tcx.sess.err_count() == 0 {
4017 self.tcx.sess.delay_span_bug(expr.span,
4018 "break was outside loop, but no error was emitted");
4021 // We still need to assign a type to the inner expression to
4022 // prevent the ICE in #43162.
4023 if let Some(ref e) = *expr_opt {
4024 self.check_expr_with_hint(e, tcx.types.err);
4026 // ... except when we try to 'break rust;'.
4027 // ICE this expression in particular (see #43162).
4028 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
4029 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4030 fatally_break_rust(self.tcx.sess);
4034 // There was an error, make typecheck fail
4039 hir::ExprKind::Continue(destination) => {
4040 if destination.target_id.is_ok() {
4043 // There was an error, make typecheck fail
4047 hir::ExprKind::Ret(ref expr_opt) => {
4048 if self.ret_coercion.is_none() {
4049 struct_span_err!(self.tcx.sess, expr.span, E0572,
4050 "return statement outside of function body").emit();
4051 } else if let Some(ref e) = *expr_opt {
4052 self.check_return_expr(e);
4054 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4055 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4056 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4060 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4061 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4063 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4066 ExpectIfCondition => {
4067 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4068 expected error elsehwere");
4071 // Only check this if not in an `if` condition, as the
4072 // mistyped comparison help is more appropriate.
4073 if !lhs.is_place_expr() {
4074 struct_span_err!(self.tcx.sess, expr.span, E0070,
4075 "invalid left-hand side expression")
4076 .span_label(expr.span, "left-hand of expression not valid")
4082 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4084 if lhs_ty.references_error() || rhs_ty.references_error() {
4090 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4091 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4092 expr.span, expected)
4094 hir::ExprKind::While(ref cond, ref body, _) => {
4095 let ctxt = BreakableCtxt {
4096 // cannot use break with a value from a while loop
4098 may_break: false, // Will get updated if/when we find a `break`.
4101 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4102 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4103 let cond_diverging = self.diverges.get();
4104 self.check_block_no_value(&body);
4106 // We may never reach the body so it diverging means nothing.
4107 self.diverges.set(cond_diverging);
4111 // No way to know whether it's diverging because
4112 // of a `break` or an outer `break` or `return`.
4113 self.diverges.set(Diverges::Maybe);
4118 hir::ExprKind::Loop(ref body, _, source) => {
4119 let coerce = match source {
4120 // you can only use break with a value from a normal `loop { }`
4121 hir::LoopSource::Loop => {
4122 let coerce_to = expected.coercion_target_type(self, body.span);
4123 Some(CoerceMany::new(coerce_to))
4126 hir::LoopSource::WhileLet |
4127 hir::LoopSource::ForLoop => {
4132 let ctxt = BreakableCtxt {
4134 may_break: false, // Will get updated if/when we find a `break`.
4137 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4138 self.check_block_no_value(&body);
4142 // No way to know whether it's diverging because
4143 // of a `break` or an outer `break` or `return`.
4144 self.diverges.set(Diverges::Maybe);
4147 // If we permit break with a value, then result type is
4148 // the LUB of the breaks (possibly ! if none); else, it
4149 // is nil. This makes sense because infinite loops
4150 // (which would have type !) are only possible iff we
4151 // permit break with a value [1].
4152 if ctxt.coerce.is_none() && !ctxt.may_break {
4154 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4156 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4158 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4159 self.check_match(expr, &discrim, arms, expected, match_src)
4161 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4162 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4164 hir::ExprKind::Block(ref body, _) => {
4165 self.check_block_with_expected(&body, expected)
4167 hir::ExprKind::Call(ref callee, ref args) => {
4168 self.check_call(expr, &callee, args, expected)
4170 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4171 self.check_method_call(expr, segment, span, args, expected, needs)
4173 hir::ExprKind::Cast(ref e, ref t) => {
4174 // Find the type of `e`. Supply hints based on the type we are casting to,
4176 let t_cast = self.to_ty_saving_user_provided_ty(t);
4177 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4178 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4179 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4181 // Eagerly check for some obvious errors.
4182 if t_expr.references_error() || t_cast.references_error() {
4185 // Defer other checks until we're done type checking.
4186 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4187 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4189 deferred_cast_checks.push(cast_check);
4192 Err(ErrorReported) => {
4198 hir::ExprKind::Type(ref e, ref t) => {
4199 let ty = self.to_ty_saving_user_provided_ty(&t);
4200 self.check_expr_eq_type(&e, ty);
4203 hir::ExprKind::Array(ref args) => {
4204 let uty = expected.to_option(self).and_then(|uty| {
4206 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4211 let element_ty = if !args.is_empty() {
4212 let coerce_to = uty.unwrap_or_else(
4213 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4214 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4215 assert_eq!(self.diverges.get(), Diverges::Maybe);
4217 let e_ty = self.check_expr_with_hint(e, coerce_to);
4218 let cause = self.misc(e.span);
4219 coerce.coerce(self, &cause, e, e_ty);
4221 coerce.complete(self)
4223 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4225 tcx.mk_array(element_ty, args.len() as u64)
4227 hir::ExprKind::Repeat(ref element, ref count) => {
4228 let count_def_id = tcx.hir.local_def_id(count.id);
4229 let param_env = ty::ParamEnv::empty();
4230 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4231 let instance = ty::Instance::resolve(
4237 let global_id = GlobalId {
4241 let count = tcx.const_eval(param_env.and(global_id));
4243 let uty = match expected {
4244 ExpectHasType(uty) => {
4246 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4253 let (element_ty, t) = match uty {
4255 self.check_expr_coercable_to_type(&element, uty);
4259 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4260 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4265 if let Ok(count) = count {
4266 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4268 // For [foo, ..n] where n > 1, `foo` must have
4270 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4271 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4275 if element_ty.references_error() {
4277 } else if let Ok(count) = count {
4278 tcx.mk_ty(ty::Array(t, count))
4283 hir::ExprKind::Tup(ref elts) => {
4284 let flds = expected.only_has_type(self).and_then(|ty| {
4285 let ty = self.resolve_type_vars_with_obligations(ty);
4287 ty::Tuple(ref flds) => Some(&flds[..]),
4292 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4293 let t = match flds {
4294 Some(ref fs) if i < fs.len() => {
4296 self.check_expr_coercable_to_type(&e, ety);
4300 self.check_expr_with_expectation(&e, NoExpectation)
4305 let tuple = tcx.mk_tup(elt_ts_iter);
4306 if tuple.references_error() {
4309 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4313 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4314 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4316 hir::ExprKind::Field(ref base, field) => {
4317 self.check_field(expr, needs, &base, field)
4319 hir::ExprKind::Index(ref base, ref idx) => {
4320 let base_t = self.check_expr_with_needs(&base, needs);
4321 let idx_t = self.check_expr(&idx);
4323 if base_t.references_error() {
4325 } else if idx_t.references_error() {
4328 let base_t = self.structurally_resolved_type(base.span, base_t);
4329 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4330 Some((index_ty, element_ty)) => {
4331 // two-phase not needed because index_ty is never mutable
4332 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4337 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4338 "cannot index into a value of type `{}`",
4340 // Try to give some advice about indexing tuples.
4341 if let ty::Tuple(..) = base_t.sty {
4342 let mut needs_note = true;
4343 // If the index is an integer, we can show the actual
4344 // fixed expression:
4345 if let hir::ExprKind::Lit(ref lit) = idx.node {
4346 if let ast::LitKind::Int(i,
4347 ast::LitIntType::Unsuffixed) = lit.node {
4348 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4349 if let Ok(snip) = snip {
4350 err.span_suggestion_with_applicability(
4352 "to access tuple elements, use",
4353 format!("{}.{}", snip, i),
4354 Applicability::MachineApplicable);
4360 err.help("to access tuple elements, use tuple indexing \
4361 syntax (e.g. `tuple.0`)");
4370 hir::ExprKind::Yield(ref value) => {
4371 match self.yield_ty {
4373 self.check_expr_coercable_to_type(&value, ty);
4376 struct_span_err!(self.tcx.sess, expr.span, E0627,
4377 "yield statement outside of generator literal").emit();
4385 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4386 // The newly resolved definition is written into `type_dependent_defs`.
4387 fn finish_resolving_struct_path(&self,
4390 node_id: ast::NodeId)
4394 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4395 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4396 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4399 hir::QPath::TypeRelative(ref qself, ref segment) => {
4400 let ty = self.to_ty(qself);
4402 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4407 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4410 // Write back the new resolution.
4411 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4412 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4419 // Resolve associated value path into a base type and associated constant or method definition.
4420 // The newly resolved definition is written into `type_dependent_defs`.
4421 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4422 qpath: &'b hir::QPath,
4423 node_id: ast::NodeId,
4425 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4427 let (ty, item_segment) = match *qpath {
4428 hir::QPath::Resolved(ref opt_qself, ref path) => {
4430 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4431 &path.segments[..]);
4433 hir::QPath::TypeRelative(ref qself, ref segment) => {
4434 (self.to_ty(qself), segment)
4437 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4438 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4439 // Return directly on cache hit. This is useful to avoid doubly reporting
4440 // errors with default match binding modes. See #44614.
4441 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4443 let item_name = item_segment.ident;
4444 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4447 let def = match error {
4448 method::MethodError::PrivateMatch(def, _) => def,
4451 if item_name.name != keywords::Invalid.name() {
4452 self.report_method_error(span, ty, item_name, None, error, None);
4458 // Write back the new resolution.
4459 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4460 (def, Some(ty), slice::from_ref(&**item_segment))
4463 pub fn check_decl_initializer(&self,
4464 local: &'gcx hir::Local,
4465 init: &'gcx hir::Expr) -> Ty<'tcx>
4467 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4468 // for #42640 (default match binding modes).
4471 let ref_bindings = local.pat.contains_explicit_ref_binding();
4473 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4474 if let Some(m) = ref_bindings {
4475 // Somewhat subtle: if we have a `ref` binding in the pattern,
4476 // we want to avoid introducing coercions for the RHS. This is
4477 // both because it helps preserve sanity and, in the case of
4478 // ref mut, for soundness (issue #23116). In particular, in
4479 // the latter case, we need to be clear that the type of the
4480 // referent for the reference that results is *equal to* the
4481 // type of the place it is referencing, and not some
4482 // supertype thereof.
4483 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4484 self.demand_eqtype(init.span, local_ty, init_ty);
4487 self.check_expr_coercable_to_type(init, local_ty)
4491 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4492 let t = self.local_ty(local.span, local.id).decl_ty;
4493 self.write_ty(local.hir_id, t);
4495 if let Some(ref init) = local.init {
4496 let init_ty = self.check_decl_initializer(local, &init);
4497 if init_ty.references_error() {
4498 self.write_ty(local.hir_id, init_ty);
4502 self.check_pat_walk(&local.pat, t,
4503 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4505 let pat_ty = self.node_ty(local.pat.hir_id);
4506 if pat_ty.references_error() {
4507 self.write_ty(local.hir_id, pat_ty);
4511 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4512 // Don't do all the complex logic below for DeclItem.
4514 hir::StmtKind::Decl(ref decl, _) => {
4515 if let hir::DeclKind::Item(_) = decl.node {
4519 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4522 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4524 // Hide the outer diverging and has_errors flags.
4525 let old_diverges = self.diverges.get();
4526 let old_has_errors = self.has_errors.get();
4527 self.diverges.set(Diverges::Maybe);
4528 self.has_errors.set(false);
4531 hir::StmtKind::Decl(ref decl, _) => {
4533 hir::DeclKind::Local(ref l) => {
4534 self.check_decl_local(&l);
4536 hir::DeclKind::Item(_) => {/* ignore for now */}
4539 hir::StmtKind::Expr(ref expr, _) => {
4540 // Check with expected type of ()
4541 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4543 hir::StmtKind::Semi(ref expr, _) => {
4544 self.check_expr(&expr);
4548 // Combine the diverging and has_error flags.
4549 self.diverges.set(self.diverges.get() | old_diverges);
4550 self.has_errors.set(self.has_errors.get() | old_has_errors);
4553 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4554 let unit = self.tcx.mk_unit();
4555 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4557 // if the block produces a `!` value, that can always be
4558 // (effectively) coerced to unit.
4560 self.demand_suptype(blk.span, unit, ty);
4564 fn check_block_with_expected(&self,
4565 blk: &'gcx hir::Block,
4566 expected: Expectation<'tcx>) -> Ty<'tcx> {
4568 let mut fcx_ps = self.ps.borrow_mut();
4569 let unsafety_state = fcx_ps.recurse(blk);
4570 replace(&mut *fcx_ps, unsafety_state)
4573 // In some cases, blocks have just one exit, but other blocks
4574 // can be targeted by multiple breaks. This can happen both
4575 // with labeled blocks as well as when we desugar
4576 // a `try { ... }` expression.
4580 // 'a: { if true { break 'a Err(()); } Ok(()) }
4582 // Here we would wind up with two coercions, one from
4583 // `Err(())` and the other from the tail expression
4584 // `Ok(())`. If the tail expression is omitted, that's a
4585 // "forced unit" -- unless the block diverges, in which
4586 // case we can ignore the tail expression (e.g., `'a: {
4587 // break 'a 22; }` would not force the type of the block
4589 let tail_expr = blk.expr.as_ref();
4590 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4591 let coerce = if blk.targeted_by_break {
4592 CoerceMany::new(coerce_to_ty)
4594 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4595 Some(e) => slice::from_ref(e),
4598 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4601 let prev_diverges = self.diverges.get();
4602 let ctxt = BreakableCtxt {
4603 coerce: Some(coerce),
4607 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4608 for s in &blk.stmts {
4612 // check the tail expression **without** holding the
4613 // `enclosing_breakables` lock below.
4614 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4616 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4617 let ctxt = enclosing_breakables.find_breakable(blk.id);
4618 let coerce = ctxt.coerce.as_mut().unwrap();
4619 if let Some(tail_expr_ty) = tail_expr_ty {
4620 let tail_expr = tail_expr.unwrap();
4621 let cause = self.cause(tail_expr.span,
4622 ObligationCauseCode::BlockTailExpression(blk.id));
4628 // Subtle: if there is no explicit tail expression,
4629 // that is typically equivalent to a tail expression
4630 // of `()` -- except if the block diverges. In that
4631 // case, there is no value supplied from the tail
4632 // expression (assuming there are no other breaks,
4633 // this implies that the type of the block will be
4636 // #41425 -- label the implicit `()` as being the
4637 // "found type" here, rather than the "expected type".
4639 // #44579 -- if the block was recovered during parsing,
4640 // the type would be nonsensical and it is not worth it
4641 // to perform the type check, so we avoid generating the
4642 // diagnostic output.
4643 if !self.diverges.get().always() && !blk.recovered {
4644 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4645 if let Some(expected_ty) = expected.only_has_type(self) {
4646 self.consider_hint_about_removing_semicolon(blk,
4656 // If we can break from the block, then the block's exit is always reachable
4657 // (... as long as the entry is reachable) - regardless of the tail of the block.
4658 self.diverges.set(prev_diverges);
4661 let mut ty = ctxt.coerce.unwrap().complete(self);
4663 if self.has_errors.get() || ty.references_error() {
4664 ty = self.tcx.types.err
4667 self.write_ty(blk.hir_id, ty);
4669 *self.ps.borrow_mut() = prev;
4673 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4674 /// suggestion can be made, `None` otherwise.
4675 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4676 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4677 // `while` before reaching it, as block tail returns are not available in them.
4678 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4679 let parent = self.tcx.hir.get(fn_id);
4681 if let Node::Item(&hir::Item {
4682 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4684 decl.clone().and_then(|decl| {
4685 // This is less than ideal, it will not suggest a return type span on any
4686 // method called `main`, regardless of whether it is actually the entry point,
4687 // but it will still present it as the reason for the expected type.
4688 Some((decl, name != Symbol::intern("main")))
4690 } else if let Node::TraitItem(&hir::TraitItem {
4691 node: hir::TraitItemKind::Method(hir::MethodSig {
4695 decl.clone().and_then(|decl| {
4698 } else if let Node::ImplItem(&hir::ImplItem {
4699 node: hir::ImplItemKind::Method(hir::MethodSig {
4703 decl.clone().and_then(|decl| {
4714 /// On implicit return expressions with mismatched types, provide the following suggestions:
4716 /// - Point out the method's return type as the reason for the expected type
4717 /// - Possible missing semicolon
4718 /// - Possible missing return type if the return type is the default, and not `fn main()`
4719 pub fn suggest_mismatched_types_on_tail(&self,
4720 err: &mut DiagnosticBuilder<'tcx>,
4721 expression: &'gcx hir::Expr,
4725 blk_id: ast::NodeId) {
4726 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4727 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4728 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4730 self.suggest_ref_or_into(err, expression, expected, found);
4733 pub fn suggest_ref_or_into(
4735 err: &mut DiagnosticBuilder<'tcx>,
4740 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4741 err.span_suggestion_with_applicability(
4745 Applicability::MachineApplicable,
4747 } else if !self.check_for_cast(err, expr, found, expected) {
4748 let methods = self.get_conversion_methods(expr.span, expected, found);
4749 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4750 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4751 .filter_map(|(receiver, method)| {
4752 let method_call = format!(".{}()", method.ident);
4753 if receiver.ends_with(&method_call) {
4754 None // do not suggest code that is already there (#53348)
4756 let method_call_list = [".to_vec()", ".to_string()"];
4757 if receiver.ends_with(".clone()")
4758 && method_call_list.contains(&method_call.as_str()) {
4759 let max_len = receiver.rfind(".").unwrap();
4760 Some(format!("{}{}", &receiver[..max_len], method_call))
4763 Some(format!("{}{}", receiver, method_call))
4767 if suggestions.peek().is_some() {
4768 err.span_suggestions_with_applicability(
4770 "try using a conversion method",
4772 Applicability::MaybeIncorrect,
4779 /// A common error is to forget to add a semicolon at the end of a block:
4783 /// bar_that_returns_u32()
4787 /// This routine checks if the return expression in a block would make sense on its own as a
4788 /// statement and the return type has been left as default or has been specified as `()`. If so,
4789 /// it suggests adding a semicolon.
4790 fn suggest_missing_semicolon(&self,
4791 err: &mut DiagnosticBuilder<'tcx>,
4792 expression: &'gcx hir::Expr,
4795 if expected.is_unit() {
4796 // `BlockTailExpression` only relevant if the tail expr would be
4797 // useful on its own.
4798 match expression.node {
4799 hir::ExprKind::Call(..) |
4800 hir::ExprKind::MethodCall(..) |
4801 hir::ExprKind::If(..) |
4802 hir::ExprKind::While(..) |
4803 hir::ExprKind::Loop(..) |
4804 hir::ExprKind::Match(..) |
4805 hir::ExprKind::Block(..) => {
4806 let sp = self.tcx.sess.source_map().next_point(cause_span);
4807 err.span_suggestion_with_applicability(
4809 "try adding a semicolon",
4811 Applicability::MachineApplicable);
4818 /// A possible error is to forget to add a return type that is needed:
4822 /// bar_that_returns_u32()
4826 /// This routine checks if the return type is left as default, the method is not part of an
4827 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4829 fn suggest_missing_return_type(&self,
4830 err: &mut DiagnosticBuilder<'tcx>,
4831 fn_decl: &hir::FnDecl,
4834 can_suggest: bool) {
4835 // Only suggest changing the return type for methods that
4836 // haven't set a return type at all (and aren't `fn main()` or an impl).
4837 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4838 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4839 err.span_suggestion_with_applicability(
4841 "try adding a return type",
4842 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4843 Applicability::MachineApplicable);
4845 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4846 err.span_label(span, "possibly return type missing here?");
4848 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4849 // `fn main()` must return `()`, do not suggest changing return type
4850 err.span_label(span, "expected `()` because of default return type");
4852 // expectation was caused by something else, not the default return
4853 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4854 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4855 // Only point to return type if the expected type is the return type, as if they
4856 // are not, the expectation must have been caused by something else.
4857 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4859 let ty = AstConv::ast_ty_to_ty(self, ty);
4860 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4861 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4862 if ty.sty == expected.sty {
4863 err.span_label(sp, format!("expected `{}` because of return type",
4871 /// A common error is to add an extra semicolon:
4874 /// fn foo() -> usize {
4879 /// This routine checks if the final statement in a block is an
4880 /// expression with an explicit semicolon whose type is compatible
4881 /// with `expected_ty`. If so, it suggests removing the semicolon.
4882 fn consider_hint_about_removing_semicolon(&self,
4883 blk: &'gcx hir::Block,
4884 expected_ty: Ty<'tcx>,
4885 err: &mut DiagnosticBuilder) {
4886 // Be helpful when the user wrote `{... expr;}` and
4887 // taking the `;` off is enough to fix the error.
4888 let last_stmt = match blk.stmts.last() {
4892 let last_expr = match last_stmt.node {
4893 hir::StmtKind::Semi(ref e, _) => e,
4896 let last_expr_ty = self.node_ty(last_expr.hir_id);
4897 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4900 let original_span = original_sp(last_stmt.span, blk.span);
4901 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4902 err.span_suggestion_with_applicability(
4904 "consider removing this semicolon",
4906 Applicability::MachineApplicable);
4909 fn def_ids_for_path_segments(&self,
4910 segments: &[hir::PathSegment],
4913 // We need to extract the type parameters supplied by the user in
4914 // the path `path`. Due to the current setup, this is a bit of a
4915 // tricky-process; the problem is that resolve only tells us the
4916 // end-point of the path resolution, and not the intermediate steps.
4917 // Luckily, we can (at least for now) deduce the intermediate steps
4918 // just from the end-point.
4920 // There are basically four cases to consider:
4922 // 1. Reference to a constructor of enum variant or struct:
4924 // struct Foo<T>(...)
4925 // enum E<T> { Foo(...) }
4927 // In these cases, the parameters are declared in the type
4930 // 2. Reference to a fn item or a free constant:
4934 // In this case, the path will again always have the form
4935 // `a::b::foo::<T>` where only the final segment should have
4936 // type parameters. However, in this case, those parameters are
4937 // declared on a value, and hence are in the `FnSpace`.
4939 // 3. Reference to a method or an associated constant:
4941 // impl<A> SomeStruct<A> {
4945 // Here we can have a path like
4946 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4947 // may appear in two places. The penultimate segment,
4948 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4949 // final segment, `foo::<B>` contains parameters in fn space.
4951 // 4. Reference to a local variable
4953 // Local variables can't have any type parameters.
4955 // The first step then is to categorize the segments appropriately.
4957 assert!(!segments.is_empty());
4958 let last = segments.len() - 1;
4960 let mut path_segs = vec![];
4963 // Case 1. Reference to a struct/variant constructor.
4964 Def::StructCtor(def_id, ..) |
4965 Def::VariantCtor(def_id, ..) |
4966 Def::SelfCtor(.., def_id) => {
4967 // Everything but the final segment should have no
4968 // parameters at all.
4969 let generics = self.tcx.generics_of(def_id);
4970 // Variant and struct constructors use the
4971 // generics of their parent type definition.
4972 let generics_def_id = generics.parent.unwrap_or(def_id);
4973 path_segs.push(PathSeg(generics_def_id, last));
4976 // Case 2. Reference to a top-level value.
4978 Def::Const(def_id) |
4979 Def::Static(def_id, _) => {
4980 path_segs.push(PathSeg(def_id, last));
4983 // Case 3. Reference to a method or associated const.
4984 Def::Method(def_id) |
4985 Def::AssociatedConst(def_id) => {
4986 if segments.len() >= 2 {
4987 let generics = self.tcx.generics_of(def_id);
4988 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
4990 path_segs.push(PathSeg(def_id, last));
4993 // Case 4. Local variable, no generics.
4994 Def::Local(..) | Def::Upvar(..) => {}
4996 _ => bug!("unexpected definition: {:?}", def),
4999 debug!("path_segs = {:?}", path_segs);
5004 // Instantiates the given path, which must refer to an item with the given
5005 // number of type parameters and type.
5006 pub fn instantiate_value_path(&self,
5007 segments: &[hir::PathSegment],
5008 self_ty: Option<Ty<'tcx>>,
5011 node_id: ast::NodeId)
5012 -> (Ty<'tcx>, Def) {
5014 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5021 let path_segs = self.def_ids_for_path_segments(segments, def);
5023 let mut user_self_ty = None;
5025 Def::Method(def_id) |
5026 Def::AssociatedConst(def_id) => {
5027 let container = self.tcx.associated_item(def_id).container;
5029 ty::TraitContainer(trait_did) => {
5030 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5032 ty::ImplContainer(impl_def_id) => {
5033 if segments.len() == 1 {
5034 // `<T>::assoc` will end up here, and so
5035 // can `T::assoc`. It this came from an
5036 // inherent impl, we need to record the
5037 // `T` for posterity (see `UserSelfTy` for
5039 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5040 user_self_ty = Some(UserSelfTy {
5051 // Now that we have categorized what space the parameters for each
5052 // segment belong to, let's sort out the parameters that the user
5053 // provided (if any) into their appropriate spaces. We'll also report
5054 // errors if type parameters are provided in an inappropriate place.
5056 let generic_segs = path_segs.iter().map(|PathSeg(_, index)| index)
5057 .collect::<FxHashSet<_>>();
5058 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5059 if !generic_segs.contains(&index) {
5067 Def::Local(nid) | Def::Upvar(nid, ..) => {
5068 let ty = self.local_ty(span, nid).decl_ty;
5069 let ty = self.normalize_associated_types_in(span, &ty);
5070 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
5076 // Now we have to compare the types that the user *actually*
5077 // provided against the types that were *expected*. If the user
5078 // did not provide any types, then we want to substitute inference
5079 // variables. If the user provided some types, we may still need
5080 // to add defaults. If the user provided *too many* types, that's
5083 let mut infer_args_for_err = FxHashSet::default();
5084 for &PathSeg(def_id, index) in &path_segs {
5085 let seg = &segments[index];
5086 let generics = self.tcx.generics_of(def_id);
5087 // Argument-position `impl Trait` is treated as a normal generic
5088 // parameter internally, but we don't allow users to specify the
5089 // parameter's value explicitly, so we have to do some error-
5091 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5096 false, // `is_method_call`
5098 if suppress_errors {
5099 infer_args_for_err.insert(index);
5100 self.set_tainted_by_errors(); // See issue #53251.
5104 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5105 self.tcx.generics_of(*def_id).has_self
5106 }).unwrap_or(false);
5108 let mut new_def = def;
5109 let (def_id, ty) = if let Def::SelfCtor(impl_def_id) = def {
5110 let ty = self.impl_self_ty(span, impl_def_id).ty;
5112 match ty.ty_adt_def() {
5113 Some(adt_def) if adt_def.is_struct() => {
5114 let variant = adt_def.non_enum_variant();
5115 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5116 (variant.did, self.tcx.type_of(variant.did))
5119 (impl_def_id, self.tcx.types.err)
5123 let def_id = def.def_id();
5125 // The things we are substituting into the type should not contain
5126 // escaping late-bound regions, and nor should the base type scheme.
5127 let ty = self.tcx.type_of(def_id);
5131 let substs = AstConv::create_substs_for_generic_args(
5137 // Provide the generic args, and whether types should be inferred.
5139 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5142 // If we've encountered an `impl Trait`-related error, we're just
5143 // going to infer the arguments for better error messages.
5144 if !infer_args_for_err.contains(&index) {
5145 // Check whether the user has provided generic arguments.
5146 if let Some(ref data) = segments[index].args {
5147 return (Some(data), segments[index].infer_types);
5150 return (None, segments[index].infer_types);
5155 // Provide substitutions for parameters for which (valid) arguments have been provided.
5157 match (¶m.kind, arg) {
5158 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5159 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5161 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5162 self.to_ty(ty).into()
5164 _ => unreachable!(),
5167 // Provide substitutions for parameters for which arguments are inferred.
5168 |substs, param, infer_types| {
5170 GenericParamDefKind::Lifetime => {
5171 self.re_infer(span, Some(param)).unwrap().into()
5173 GenericParamDefKind::Type { has_default, .. } => {
5174 if !infer_types && has_default {
5175 // If we have a default, then we it doesn't matter that we're not
5176 // inferring the type arguments: we provide the default where any
5178 let default = self.tcx.type_of(param.def_id);
5181 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5184 // If no type arguments were provided, we have to infer them.
5185 // This case also occurs as a result of some malformed input, e.g.
5186 // a lifetime argument being given instead of a type parameter.
5187 // Using inference instead of `Error` gives better error messages.
5188 self.var_for_def(span, param)
5194 assert!(!substs.has_escaping_bound_vars());
5195 assert!(!ty.has_escaping_bound_vars());
5197 // Write the "user substs" down first thing for later.
5198 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
5199 self.write_user_substs_from_substs(hir_id, substs, user_self_ty);
5201 // Add all the obligations that are required, substituting and
5202 // normalized appropriately.
5203 let bounds = self.instantiate_bounds(span, def_id, &substs);
5204 self.add_obligations_for_parameters(
5205 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5208 // Substitute the values for the type parameters into the type of
5209 // the referenced item.
5210 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5212 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5213 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5214 // is inherent, there is no `Self` parameter, instead, the impl needs
5215 // type parameters, which we can infer by unifying the provided `Self`
5216 // with the substituted impl type.
5217 let ty = self.tcx.type_of(impl_def_id);
5219 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5220 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5221 Ok(ok) => self.register_infer_ok_obligations(ok),
5224 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5231 self.check_rustc_args_require_const(def_id, node_id, span);
5233 debug!("instantiate_value_path: type of {:?} is {:?}",
5236 self.write_substs(hir_id, substs);
5238 (ty_substituted, new_def)
5241 fn check_rustc_args_require_const(&self,
5243 node_id: ast::NodeId,
5245 // We're only interested in functions tagged with
5246 // #[rustc_args_required_const], so ignore anything that's not.
5247 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5251 // If our calling expression is indeed the function itself, we're good!
5252 // If not, generate an error that this can only be called directly.
5253 if let Node::Expr(expr) = self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5254 if let hir::ExprKind::Call(ref callee, ..) = expr.node {
5255 if callee.id == node_id {
5261 self.tcx.sess.span_err(span, "this function can only be invoked \
5262 directly, not through a function pointer");
5265 // Resolves `typ` by a single level if `typ` is a type variable.
5266 // If no resolution is possible, then an error is reported.
5267 // Numeric inference variables may be left unresolved.
5268 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5269 let ty = self.resolve_type_vars_with_obligations(ty);
5270 if !ty.is_ty_var() {
5273 if !self.is_tainted_by_errors() {
5274 self.need_type_info_err((**self).body_id, sp, ty)
5275 .note("type must be known at this point")
5278 self.demand_suptype(sp, self.tcx.types.err, ty);
5283 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5284 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5285 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5288 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5289 index = enclosing_breakables.stack.len();
5290 enclosing_breakables.by_id.insert(id, index);
5291 enclosing_breakables.stack.push(ctxt);
5295 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5296 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5297 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5298 enclosing_breakables.stack.pop().expect("missing breakable context")
5304 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5305 generics: &ty::Generics,
5307 let own_counts = generics.own_counts();
5308 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5310 if own_counts.types == 0 {
5313 // Make a vector of booleans initially false, set to true when used.
5314 let mut types_used = vec![false; own_counts.types];
5316 for leaf_ty in ty.walk() {
5317 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5318 debug!("Found use of ty param num {}", idx);
5319 types_used[idx as usize - own_counts.lifetimes] = true;
5320 } else if let ty::Error = leaf_ty.sty {
5321 // If there is already another error, do not emit
5322 // an error for not using a type Parameter.
5323 assert!(tcx.sess.err_count() > 0);
5328 let types = generics.params.iter().filter(|param| match param.kind {
5329 ty::GenericParamDefKind::Type { .. } => true,
5332 for (&used, param) in types_used.iter().zip(types) {
5334 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5335 let span = tcx.hir.span(id);
5336 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5337 .span_label(span, "unused type parameter")
5343 fn fatally_break_rust(sess: &Session) {
5344 let handler = sess.diagnostic();
5345 handler.span_bug_no_panic(
5347 "It looks like you're trying to break rust; would you like some ICE?",
5349 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5350 handler.note_without_error(
5351 "we would appreciate a joke overview: \
5352 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5354 handler.note_without_error(&format!("rustc {} running on {}",
5355 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5356 ::session::config::host_triple(),
5360 fn potentially_plural_count(count: usize, word: &str) -> String {
5361 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })