1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 N.B.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
92 use namespace::Namespace;
93 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
94 use rustc::infer::opaque_types::OpaqueTypeDecl;
95 use rustc::infer::type_variable::{TypeVariableOrigin};
96 use rustc::middle::region;
97 use rustc::mir::interpret::{ConstValue, GlobalId};
98 use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
99 UserSelfTy, UserSubsts};
100 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
101 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
102 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
103 use rustc::ty::fold::TypeFoldable;
104 use rustc::ty::query::Providers;
105 use rustc::ty::util::{Representability, IntTypeExt, Discr};
106 use rustc::ty::layout::VariantIdx;
107 use rustc_data_structures::indexed_vec::Idx;
108 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
110 use require_c_abi_if_variadic;
111 use session::{CompileIncomplete, config, Session};
114 use util::common::{ErrorReported, indenter};
115 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
117 use std::cell::{Cell, RefCell, Ref, RefMut};
118 use rustc_data_structures::sync::Lrc;
119 use std::collections::hash_map::Entry;
121 use std::fmt::Display;
123 use std::mem::replace;
124 use std::ops::{self, Deref};
125 use rustc_target::spec::abi::Abi;
128 use syntax::source_map::DUMMY_SP;
129 use syntax::source_map::original_sp;
130 use syntax::feature_gate::{GateIssue, emit_feature_err};
132 use syntax::symbol::{Symbol, LocalInternedString, keywords};
133 use syntax::util::lev_distance::find_best_match_for_name;
134 use syntax_pos::{self, BytePos, Span, MultiSpan};
136 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
137 use rustc::hir::itemlikevisit::ItemLikeVisitor;
138 use rustc::hir::Node;
139 use rustc::hir::{self, PatKind, ItemKind};
140 use rustc::middle::lang_items;
156 mod generator_interior;
160 /// The type of a local binding, including the revealed type for anon types.
161 #[derive(Copy, Clone)]
162 pub struct LocalTy<'tcx> {
164 revealed_ty: Ty<'tcx>
167 /// A wrapper for InferCtxt's `in_progress_tables` field.
168 #[derive(Copy, Clone)]
169 struct MaybeInProgressTables<'a, 'tcx: 'a> {
170 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
173 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
174 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
175 match self.maybe_tables {
176 Some(tables) => tables.borrow(),
178 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
183 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
184 match self.maybe_tables {
185 Some(tables) => tables.borrow_mut(),
187 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
193 /// closures defined within the function. For example:
196 /// bar(move|| { ... })
199 /// Here, the function `foo()` and the closure passed to
200 /// `bar()` will each have their own `FnCtxt`, but they will
201 /// share the inherited fields.
202 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
203 infcx: InferCtxt<'a, 'gcx, 'tcx>,
205 tables: MaybeInProgressTables<'a, 'tcx>,
207 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
209 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
211 // Some additional `Sized` obligations badly affect type inference.
212 // These obligations are added in a later stage of typeck.
213 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
215 // When we process a call like `c()` where `c` is a closure type,
216 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
217 // `FnOnce` closure. In that case, we defer full resolution of the
218 // call until upvar inference can kick in and make the
219 // decision. We keep these deferred resolutions grouped by the
220 // def-id of the closure, so that once we decide, we can easily go
221 // back and process them.
222 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
224 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
226 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
228 // Opaque types found in explicit return types and their
229 // associated fresh inference variable. Writeback resolves these
230 // variables to get the concrete type, which can be used to
231 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
232 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
234 /// Each type parameter has an implicit region bound that
235 /// indicates it must outlive at least the function body (the user
236 /// may specify stronger requirements). This field indicates the
237 /// region of the callee. If it is `None`, then the parameter
238 /// environment is for an item or something where the "callee" is
240 implicit_region_bound: Option<ty::Region<'tcx>>,
242 body_id: Option<hir::BodyId>,
245 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
246 type Target = InferCtxt<'a, 'gcx, 'tcx>;
247 fn deref(&self) -> &Self::Target {
252 /// When type-checking an expression, we propagate downward
253 /// whatever type hint we are able in the form of an `Expectation`.
254 #[derive(Copy, Clone, Debug)]
255 pub enum Expectation<'tcx> {
256 /// We know nothing about what type this expression should have.
259 /// This expression is an `if` condition, it must resolve to `bool`.
262 /// This expression should have the type given (or some subtype)
263 ExpectHasType(Ty<'tcx>),
265 /// This expression will be cast to the `Ty`
266 ExpectCastableToType(Ty<'tcx>),
268 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
269 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
270 ExpectRvalueLikeUnsized(Ty<'tcx>),
273 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
274 // Disregard "castable to" expectations because they
275 // can lead us astray. Consider for example `if cond
276 // {22} else {c} as u8` -- if we propagate the
277 // "castable to u8" constraint to 22, it will pick the
278 // type 22u8, which is overly constrained (c might not
279 // be a u8). In effect, the problem is that the
280 // "castable to" expectation is not the tightest thing
281 // we can say, so we want to drop it in this case.
282 // The tightest thing we can say is "must unify with
283 // else branch". Note that in the case of a "has type"
284 // constraint, this limitation does not hold.
286 // If the expected type is just a type variable, then don't use
287 // an expected type. Otherwise, we might write parts of the type
288 // when checking the 'then' block which are incompatible with the
290 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
292 ExpectHasType(ety) => {
293 let ety = fcx.shallow_resolve(ety);
294 if !ety.is_ty_var() {
300 ExpectRvalueLikeUnsized(ety) => {
301 ExpectRvalueLikeUnsized(ety)
307 /// Provide an expectation for an rvalue expression given an *optional*
308 /// hint, which is not required for type safety (the resulting type might
309 /// be checked higher up, as is the case with `&expr` and `box expr`), but
310 /// is useful in determining the concrete type.
312 /// The primary use case is where the expected type is a fat pointer,
313 /// like `&[isize]`. For example, consider the following statement:
315 /// let x: &[isize] = &[1, 2, 3];
317 /// In this case, the expected type for the `&[1, 2, 3]` expression is
318 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
319 /// expectation `ExpectHasType([isize])`, that would be too strong --
320 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
321 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
322 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
323 /// which still is useful, because it informs integer literals and the like.
324 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
325 /// for examples of where this comes up,.
326 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
327 match fcx.tcx.struct_tail(ty).sty {
328 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
329 ExpectRvalueLikeUnsized(ty)
331 _ => ExpectHasType(ty)
335 // Resolves `expected` by a single level if it is a variable. If
336 // there is no expected type or resolution is not possible (e.g.,
337 // no constraints yet present), just returns `None`.
338 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
340 NoExpectation => NoExpectation,
341 ExpectIfCondition => ExpectIfCondition,
342 ExpectCastableToType(t) => {
343 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
345 ExpectHasType(t) => {
346 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
348 ExpectRvalueLikeUnsized(t) => {
349 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
354 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
355 match self.resolve(fcx) {
356 NoExpectation => None,
357 ExpectIfCondition => Some(fcx.tcx.types.bool),
358 ExpectCastableToType(ty) |
360 ExpectRvalueLikeUnsized(ty) => Some(ty),
364 /// It sometimes happens that we want to turn an expectation into
365 /// a **hard constraint** (i.e., something that must be satisfied
366 /// for the program to type-check). `only_has_type` will return
367 /// such a constraint, if it exists.
368 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
369 match self.resolve(fcx) {
370 ExpectHasType(ty) => Some(ty),
371 ExpectIfCondition => Some(fcx.tcx.types.bool),
372 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
376 /// Like `only_has_type`, but instead of returning `None` if no
377 /// hard constraint exists, creates a fresh type variable.
378 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
379 self.only_has_type(fcx)
380 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
384 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
391 fn maybe_mut_place(m: hir::Mutability) -> Self {
393 hir::MutMutable => Needs::MutPlace,
394 hir::MutImmutable => Needs::None,
399 #[derive(Copy, Clone)]
400 pub struct UnsafetyState {
401 pub def: ast::NodeId,
402 pub unsafety: hir::Unsafety,
403 pub unsafe_push_count: u32,
408 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
409 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
412 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
413 match self.unsafety {
414 // If this unsafe, then if the outer function was already marked as
415 // unsafe we shouldn't attribute the unsafe'ness to the block. This
416 // way the block can be warned about instead of ignoring this
417 // extraneous block (functions are never warned about).
418 hir::Unsafety::Unsafe if self.from_fn => *self,
421 let (unsafety, def, count) = match blk.rules {
422 hir::PushUnsafeBlock(..) =>
423 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
424 hir::PopUnsafeBlock(..) =>
425 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
426 hir::UnsafeBlock(..) =>
427 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
429 (unsafety, self.def, self.unsafe_push_count),
433 unsafe_push_count: count,
440 #[derive(Debug, Copy, Clone)]
446 /// Tracks whether executing a node may exit normally (versus
447 /// return/break/panic, which "diverge", leaving dead code in their
448 /// wake). Tracked semi-automatically (through type variables marked
449 /// as diverging), with some manual adjustments for control-flow
450 /// primitives (approximating a CFG).
451 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
453 /// Potentially unknown, some cases converge,
454 /// others require a CFG to determine them.
457 /// Definitely known to diverge and therefore
458 /// not reach the next sibling or its parent.
461 /// Same as `Always` but with a reachability
462 /// warning already emitted
466 // Convenience impls for combinig `Diverges`.
468 impl ops::BitAnd for Diverges {
470 fn bitand(self, other: Self) -> Self {
471 cmp::min(self, other)
475 impl ops::BitOr for Diverges {
477 fn bitor(self, other: Self) -> Self {
478 cmp::max(self, other)
482 impl ops::BitAndAssign for Diverges {
483 fn bitand_assign(&mut self, other: Self) {
484 *self = *self & other;
488 impl ops::BitOrAssign for Diverges {
489 fn bitor_assign(&mut self, other: Self) {
490 *self = *self | other;
495 fn always(self) -> bool {
496 self >= Diverges::Always
500 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
503 // this is `null` for loops where break with a value is illegal,
504 // such as `while`, `for`, and `while let`
505 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
508 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
509 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
510 by_id: NodeMap<usize>,
513 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
514 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
515 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
516 bug!("could not find enclosing breakable with id {}", target_id);
523 struct PathSeg(DefId, usize);
525 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
526 body_id: ast::NodeId,
528 /// The parameter environment used for proving trait obligations
529 /// in this function. This can change when we descend into
530 /// closures (as they bring new things into scope), hence it is
531 /// not part of `Inherited` (as of the time of this writing,
532 /// closures do not yet change the environment, but they will
534 param_env: ty::ParamEnv<'tcx>,
536 // Number of errors that had been reported when we started
537 // checking this function. On exit, if we find that *more* errors
538 // have been reported, we will skip regionck and other work that
539 // expects the types within the function to be consistent.
540 err_count_on_creation: usize,
542 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
544 yield_ty: Option<Ty<'tcx>>,
546 ps: RefCell<UnsafetyState>,
548 /// Whether the last checked node generates a divergence (e.g.,
549 /// `return` will set this to Always). In general, when entering
550 /// an expression or other node in the tree, the initial value
551 /// indicates whether prior parts of the containing expression may
552 /// have diverged. It is then typically set to `Maybe` (and the
553 /// old value remembered) for processing the subparts of the
554 /// current expression. As each subpart is processed, they may set
555 /// the flag to `Always` etc. Finally, at the end, we take the
556 /// result and "union" it with the original value, so that when we
557 /// return the flag indicates if any subpart of the parent
558 /// expression (up to and including this part) has diverged. So,
559 /// if you read it after evaluating a subexpression `X`, the value
560 /// you get indicates whether any subexpression that was
561 /// evaluating up to and including `X` diverged.
563 /// We currently use this flag only for diagnostic purposes:
565 /// - To warn about unreachable code: if, after processing a
566 /// sub-expression but before we have applied the effects of the
567 /// current node, we see that the flag is set to `Always`, we
568 /// can issue a warning. This corresponds to something like
569 /// `foo(return)`; we warn on the `foo()` expression. (We then
570 /// update the flag to `WarnedAlways` to suppress duplicate
571 /// reports.) Similarly, if we traverse to a fresh statement (or
572 /// tail expression) from a `Always` setting, we will issue a
573 /// warning. This corresponds to something like `{return;
574 /// foo();}` or `{return; 22}`, where we would warn on the
577 /// An expression represents dead-code if, after checking it,
578 /// the diverges flag is set to something other than `Maybe`.
579 diverges: Cell<Diverges>,
581 /// Whether any child nodes have any type errors.
582 has_errors: Cell<bool>,
584 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
586 inh: &'a Inherited<'a, 'gcx, 'tcx>,
589 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
590 type Target = Inherited<'a, 'gcx, 'tcx>;
591 fn deref(&self) -> &Self::Target {
596 /// Helper type of a temporary returned by Inherited::build(...).
597 /// Necessary because we can't write the following bound:
598 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
599 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
600 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
604 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
605 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
606 -> InheritedBuilder<'a, 'gcx, 'tcx> {
607 let hir_id_root = if def_id.is_local() {
608 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
609 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
610 DefId::local(hir_id.owner)
616 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
622 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
623 fn enter<F, R>(&'tcx mut self, f: F) -> R
624 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
626 let def_id = self.def_id;
627 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
631 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
632 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
634 let item_id = tcx.hir.as_local_node_id(def_id);
635 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
636 let implicit_region_bound = body_id.map(|body_id| {
637 let body = tcx.hir.body(body_id);
638 tcx.mk_region(ty::ReScope(region::Scope {
639 id: body.value.hir_id.local_id,
640 data: region::ScopeData::CallSite
645 tables: MaybeInProgressTables {
646 maybe_tables: infcx.in_progress_tables,
649 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
650 locals: RefCell::new(Default::default()),
651 deferred_sized_obligations: RefCell::new(Vec::new()),
652 deferred_call_resolutions: RefCell::new(Default::default()),
653 deferred_cast_checks: RefCell::new(Vec::new()),
654 deferred_generator_interiors: RefCell::new(Vec::new()),
655 opaque_types: RefCell::new(Default::default()),
656 implicit_region_bound,
661 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
662 debug!("register_predicate({:?})", obligation);
663 if obligation.has_escaping_bound_vars() {
664 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
669 .register_predicate_obligation(self, obligation);
672 fn register_predicates<I>(&self, obligations: I)
673 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
675 for obligation in obligations {
676 self.register_predicate(obligation);
680 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
681 self.register_predicates(infer_ok.obligations);
685 fn normalize_associated_types_in<T>(&self,
687 body_id: ast::NodeId,
688 param_env: ty::ParamEnv<'tcx>,
690 where T : TypeFoldable<'tcx>
692 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
693 self.register_infer_ok_obligations(ok)
697 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
699 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
700 fn visit_item(&mut self, i: &'tcx hir::Item) {
701 check_item_type(self.tcx, i);
703 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
704 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
707 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
708 tcx.sess.track_errors(|| {
709 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
710 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
714 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
715 tcx.sess.track_errors(|| {
716 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
720 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
721 tcx.typeck_item_bodies(LOCAL_CRATE)
724 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
725 -> Result<(), CompileIncomplete>
727 debug_assert!(crate_num == LOCAL_CRATE);
728 Ok(tcx.sess.track_errors(|| {
729 tcx.par_body_owners(|body_owner_def_id| {
730 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
735 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
736 wfcheck::check_item_well_formed(tcx, def_id);
739 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
740 wfcheck::check_trait_item(tcx, def_id);
743 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
744 wfcheck::check_impl_item(tcx, def_id);
747 pub fn provide(providers: &mut Providers) {
748 method::provide(providers);
749 *providers = Providers {
755 check_item_well_formed,
756 check_trait_item_well_formed,
757 check_impl_item_well_formed,
762 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
764 -> Option<ty::Destructor> {
765 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
768 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
769 /// with information about it's body-id and fn-decl (if any). Otherwise,
772 /// If this function returns "some", then `typeck_tables(def_id)` will
773 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
774 /// may not succeed. In some cases where this function returns `None`
775 /// (notably closures), `typeck_tables(def_id)` would wind up
776 /// redirecting to the owning function.
777 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
779 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
781 match tcx.hir.get(id) {
782 Node::Item(item) => {
784 hir::ItemKind::Const(_, body) |
785 hir::ItemKind::Static(_, _, body) =>
787 hir::ItemKind::Fn(ref decl, .., body) =>
788 Some((body, Some(decl))),
793 Node::TraitItem(item) => {
795 hir::TraitItemKind::Const(_, Some(body)) =>
797 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
798 Some((body, Some(&sig.decl))),
803 Node::ImplItem(item) => {
805 hir::ImplItemKind::Const(_, body) =>
807 hir::ImplItemKind::Method(ref sig, body) =>
808 Some((body, Some(&sig.decl))),
813 Node::AnonConst(constant) => Some((constant.body, None)),
818 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
821 // Closures' tables come from their outermost function,
822 // as they are part of the same "inference environment".
823 let outer_def_id = tcx.closure_base_def_id(def_id);
824 if outer_def_id != def_id {
825 return tcx.has_typeck_tables(outer_def_id);
828 let id = tcx.hir.as_local_node_id(def_id).unwrap();
829 primary_body_of(tcx, id).is_some()
832 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
835 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
838 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
840 -> &'tcx ty::TypeckTables<'tcx> {
841 // Closures' tables come from their outermost function,
842 // as they are part of the same "inference environment".
843 let outer_def_id = tcx.closure_base_def_id(def_id);
844 if outer_def_id != def_id {
845 return tcx.typeck_tables_of(outer_def_id);
848 let id = tcx.hir.as_local_node_id(def_id).unwrap();
849 let span = tcx.hir.span(id);
851 // Figure out what primary body this item has.
852 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
853 span_bug!(span, "can't type-check body of {:?}", def_id);
855 let body = tcx.hir.body(body_id);
857 let tables = Inherited::build(tcx, def_id).enter(|inh| {
858 let param_env = tcx.param_env(def_id);
859 let fcx = if let Some(decl) = fn_decl {
860 let fn_sig = tcx.fn_sig(def_id);
862 check_abi(tcx, span, fn_sig.abi());
864 // Compute the fty from point of view of inside the fn.
866 tcx.liberate_late_bound_regions(def_id, &fn_sig);
868 inh.normalize_associated_types_in(body.value.span,
873 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
876 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
877 let expected_type = tcx.type_of(def_id);
878 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
879 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
881 let revealed_ty = if tcx.features().impl_trait_in_bindings {
882 fcx.instantiate_opaque_types_from_value(
890 // Gather locals in statics (because of block expressions).
891 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
893 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
898 // All type checking constraints were added, try to fallback unsolved variables.
899 fcx.select_obligations_where_possible(false);
900 let mut fallback_has_occurred = false;
901 for ty in &fcx.unsolved_variables() {
902 fallback_has_occurred |= fcx.fallback_if_possible(ty);
904 fcx.select_obligations_where_possible(fallback_has_occurred);
906 // Even though coercion casts provide type hints, we check casts after fallback for
907 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
910 // Closure and generator analysis may run after fallback
911 // because they don't constrain other type variables.
912 fcx.closure_analyze(body);
913 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
914 fcx.resolve_generator_interiors(def_id);
916 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
917 let ty = fcx.normalize_ty(span, ty);
918 fcx.require_type_is_sized(ty, span, code);
920 fcx.select_all_obligations_or_error();
922 if fn_decl.is_some() {
923 fcx.regionck_fn(id, body);
925 fcx.regionck_expr(body);
928 fcx.resolve_type_vars_in_body(body)
931 // Consistency check our TypeckTables instance can hold all ItemLocalIds
932 // it will need to hold.
933 assert_eq!(tables.local_id_root,
934 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
938 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
939 if !tcx.sess.target.target.is_abi_supported(abi) {
940 struct_span_err!(tcx.sess, span, E0570,
941 "The ABI `{}` is not supported for the current target", abi).emit()
945 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
946 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
947 parent_id: ast::NodeId,
950 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
951 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
954 // infer the variable's type
955 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
956 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
963 // take type that the user specified
964 self.fcx.locals.borrow_mut().insert(nid, typ);
971 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
972 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
973 NestedVisitorMap::None
976 // Add explicitly-declared locals.
977 fn visit_local(&mut self, local: &'gcx hir::Local) {
978 let local_ty = match local.ty {
980 let o_ty = self.fcx.to_ty(&ty);
982 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
983 self.fcx.instantiate_opaque_types_from_value(
991 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(&revealed_ty);
992 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
993 ty.hir_id, o_ty, revealed_ty, c_ty);
994 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
996 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1000 self.assign(local.span, local.id, local_ty);
1002 debug!("Local variable {:?} is assigned type {}",
1004 self.fcx.ty_to_string(
1005 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
1006 intravisit::walk_local(self, local);
1009 // Add pattern bindings.
1010 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1011 if let PatKind::Binding(_, _, ident, _) = p.node {
1012 let var_ty = self.assign(p.span, p.id, None);
1014 if !self.fcx.tcx.features().unsized_locals {
1015 self.fcx.require_type_is_sized(var_ty, p.span,
1016 traits::VariableType(p.id));
1019 debug!("Pattern binding {} is assigned to {} with type {:?}",
1021 self.fcx.ty_to_string(
1022 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1025 intravisit::walk_pat(self, p);
1028 // Don't descend into the bodies of nested closures
1029 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1030 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1033 /// When `check_fn` is invoked on a generator (i.e., a body that
1034 /// includes yield), it returns back some information about the yield
1036 struct GeneratorTypes<'tcx> {
1037 /// Type of value that is yielded.
1038 yield_ty: ty::Ty<'tcx>,
1040 /// Types that are captured (see `GeneratorInterior` for more).
1041 interior: ty::Ty<'tcx>,
1043 /// Indicates if the generator is movable or static (immovable)
1044 movability: hir::GeneratorMovability,
1047 /// Helper used for fns and closures. Does the grungy work of checking a function
1048 /// body and returns the function context used for that purpose, since in the case of a fn item
1049 /// there is still a bit more to do.
1052 /// * inherited: other fields inherited from the enclosing fn (if any)
1053 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1054 param_env: ty::ParamEnv<'tcx>,
1055 fn_sig: ty::FnSig<'tcx>,
1056 decl: &'gcx hir::FnDecl,
1058 body: &'gcx hir::Body,
1059 can_be_generator: Option<hir::GeneratorMovability>)
1060 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1062 let mut fn_sig = fn_sig.clone();
1064 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1066 // Create the function context. This is either derived from scratch or,
1067 // in the case of closures, based on the outer context.
1068 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1069 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1071 let declared_ret_ty = fn_sig.output();
1072 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1073 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1074 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1075 fn_sig = fcx.tcx.mk_fn_sig(
1076 fn_sig.inputs().iter().cloned(),
1083 let span = body.value.span;
1085 if body.is_generator && can_be_generator.is_some() {
1086 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1087 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1088 fcx.yield_ty = Some(yield_ty);
1091 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir.local_def_id(fn_id));
1092 let outer_node_id = fcx.tcx.hir.as_local_node_id(outer_def_id).unwrap();
1093 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1095 // Add formal parameters.
1096 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1097 // Check the pattern.
1098 fcx.check_pat_walk(&arg.pat, arg_ty,
1099 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1101 // Check that argument is Sized.
1102 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1103 // for simple cases like `fn foo(x: Trait)`,
1104 // where we would error once on the parameter as a whole, and once on the binding `x`.
1105 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1106 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1109 fcx.write_ty(arg.hir_id, arg_ty);
1112 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1113 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1115 fcx.check_return_expr(&body.value);
1117 // We insert the deferred_generator_interiors entry after visiting the body.
1118 // This ensures that all nested generators appear before the entry of this generator.
1119 // resolve_generator_interiors relies on this property.
1120 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1121 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1122 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1123 Some(GeneratorTypes {
1124 yield_ty: fcx.yield_ty.unwrap(),
1126 movability: can_be_generator.unwrap(),
1132 // Finalize the return check by taking the LUB of the return types
1133 // we saw and assigning it to the expected return type. This isn't
1134 // really expected to fail, since the coercions would have failed
1135 // earlier when trying to find a LUB.
1137 // However, the behavior around `!` is sort of complex. In the
1138 // event that the `actual_return_ty` comes back as `!`, that
1139 // indicates that the fn either does not return or "returns" only
1140 // values of type `!`. In this case, if there is an expected
1141 // return type that is *not* `!`, that should be ok. But if the
1142 // return type is being inferred, we want to "fallback" to `!`:
1144 // let x = move || panic!();
1146 // To allow for that, I am creating a type variable with diverging
1147 // fallback. This was deemed ever so slightly better than unifying
1148 // the return value with `!` because it allows for the caller to
1149 // make more assumptions about the return type (e.g., they could do
1151 // let y: Option<u32> = Some(x());
1153 // which would then cause this return type to become `u32`, not
1155 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1156 let mut actual_return_ty = coercion.complete(&fcx);
1157 if actual_return_ty.is_never() {
1158 actual_return_ty = fcx.next_diverging_ty_var(
1159 TypeVariableOrigin::DivergingFn(span));
1161 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1163 // Check that the main return type implements the termination trait.
1164 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1165 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1167 if let config::EntryFnType::Main = entry_type {
1168 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1169 let trait_ref = ty::TraitRef::new(term_id, substs);
1170 let return_ty_span = decl.output.span();
1171 let cause = traits::ObligationCause::new(
1172 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1174 inherited.register_predicate(
1175 traits::Obligation::new(
1176 cause, param_env, trait_ref.to_predicate()));
1182 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1183 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1184 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1185 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1186 // at this point we don't care if there are duplicate handlers or if the handler has
1187 // the wrong signature as this value we'll be used when writing metadata and that
1188 // only happens if compilation succeeded
1189 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1191 if declared_ret_ty.sty != ty::Never {
1192 fcx.tcx.sess.span_err(
1194 "return type should be `!`",
1198 let inputs = fn_sig.inputs();
1199 let span = fcx.tcx.hir.span(fn_id);
1200 if inputs.len() == 1 {
1201 let arg_is_panic_info = match inputs[0].sty {
1202 ty::Ref(region, ty, mutbl) => match ty.sty {
1203 ty::Adt(ref adt, _) => {
1204 adt.did == panic_info_did &&
1205 mutbl == hir::Mutability::MutImmutable &&
1206 *region != RegionKind::ReStatic
1213 if !arg_is_panic_info {
1214 fcx.tcx.sess.span_err(
1215 decl.inputs[0].span,
1216 "argument should be `&PanicInfo`",
1220 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1221 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1222 if !generics.params.is_empty() {
1223 fcx.tcx.sess.span_err(
1225 "should have no type parameters",
1231 let span = fcx.tcx.sess.source_map().def_span(span);
1232 fcx.tcx.sess.span_err(span, "function should have one argument");
1235 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1240 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1241 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1242 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1243 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1244 if declared_ret_ty.sty != ty::Never {
1245 fcx.tcx.sess.span_err(
1247 "return type should be `!`",
1251 let inputs = fn_sig.inputs();
1252 let span = fcx.tcx.hir.span(fn_id);
1253 if inputs.len() == 1 {
1254 let arg_is_alloc_layout = match inputs[0].sty {
1255 ty::Adt(ref adt, _) => {
1256 adt.did == alloc_layout_did
1261 if !arg_is_alloc_layout {
1262 fcx.tcx.sess.span_err(
1263 decl.inputs[0].span,
1264 "argument should be `Layout`",
1268 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1269 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1270 if !generics.params.is_empty() {
1271 fcx.tcx.sess.span_err(
1273 "`#[alloc_error_handler]` function should have no type \
1280 let span = fcx.tcx.sess.source_map().def_span(span);
1281 fcx.tcx.sess.span_err(span, "function should have one argument");
1284 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1292 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1295 let def_id = tcx.hir.local_def_id(id);
1296 let def = tcx.adt_def(def_id);
1297 def.destructor(tcx); // force the destructor to be evaluated
1298 check_representable(tcx, span, def_id);
1300 if def.repr.simd() {
1301 check_simd(tcx, span, def_id);
1304 check_transparent(tcx, span, def_id);
1305 check_packed(tcx, span, def_id);
1308 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1311 let def_id = tcx.hir.local_def_id(id);
1312 let def = tcx.adt_def(def_id);
1313 def.destructor(tcx); // force the destructor to be evaluated
1314 check_representable(tcx, span, def_id);
1316 check_packed(tcx, span, def_id);
1319 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1321 "check_item_type(it.id={}, it.name={})",
1323 tcx.item_path_str(tcx.hir.local_def_id(it.id))
1325 let _indenter = indenter();
1327 // Consts can play a role in type-checking, so they are included here.
1328 hir::ItemKind::Static(..) => {
1329 let def_id = tcx.hir.local_def_id(it.id);
1330 tcx.typeck_tables_of(def_id);
1331 maybe_check_static_with_link_section(tcx, def_id, it.span);
1333 hir::ItemKind::Const(..) => {
1334 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1336 hir::ItemKind::Enum(ref enum_definition, _) => {
1337 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1339 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1340 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1341 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1342 let impl_def_id = tcx.hir.local_def_id(it.id);
1343 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1344 check_impl_items_against_trait(
1351 let trait_def_id = impl_trait_ref.def_id;
1352 check_on_unimplemented(tcx, trait_def_id, it);
1355 hir::ItemKind::Trait(..) => {
1356 let def_id = tcx.hir.local_def_id(it.id);
1357 check_on_unimplemented(tcx, def_id, it);
1359 hir::ItemKind::Struct(..) => {
1360 check_struct(tcx, it.id, it.span);
1362 hir::ItemKind::Union(..) => {
1363 check_union(tcx, it.id, it.span);
1365 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1366 let def_id = tcx.hir.local_def_id(it.id);
1367 let pty_ty = tcx.type_of(def_id);
1368 let generics = tcx.generics_of(def_id);
1369 check_bounds_are_used(tcx, &generics, pty_ty);
1371 hir::ItemKind::ForeignMod(ref m) => {
1372 check_abi(tcx, it.span, m.abi);
1374 if m.abi == Abi::RustIntrinsic {
1375 for item in &m.items {
1376 intrinsic::check_intrinsic_type(tcx, item);
1378 } else if m.abi == Abi::PlatformIntrinsic {
1379 for item in &m.items {
1380 intrinsic::check_platform_intrinsic_type(tcx, item);
1383 for item in &m.items {
1384 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1385 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1386 let mut err = struct_span_err!(
1390 "foreign items may not have type parameters"
1392 err.span_label(item.span, "can't have type parameters");
1393 // FIXME: once we start storing spans for type arguments, turn this into a
1396 "use specialization instead of type parameters by replacing them \
1397 with concrete types like `u32`",
1402 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1403 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1408 _ => { /* nothing to do */ }
1412 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1413 // Only restricted on wasm32 target for now
1414 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1418 // If `#[link_section]` is missing, then nothing to verify
1419 let attrs = tcx.codegen_fn_attrs(id);
1420 if attrs.link_section.is_none() {
1424 // For the wasm32 target statics with #[link_section] are placed into custom
1425 // sections of the final output file, but this isn't link custom sections of
1426 // other executable formats. Namely we can only embed a list of bytes,
1427 // nothing with pointers to anything else or relocations. If any relocation
1428 // show up, reject them here.
1429 let instance = ty::Instance::mono(tcx, id);
1430 let cid = GlobalId {
1434 let param_env = ty::ParamEnv::reveal_all();
1435 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1436 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1439 bug!("Matching on non-ByRef static")
1441 if alloc.relocations.len() != 0 {
1442 let msg = "statics with a custom `#[link_section]` must be a \
1443 simple list of bytes on the wasm target with no \
1444 extra levels of indirection such as references";
1445 tcx.sess.span_err(span, msg);
1450 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1451 trait_def_id: DefId,
1453 let item_def_id = tcx.hir.local_def_id(item.id);
1454 // an error would be reported if this fails.
1455 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1458 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1459 impl_item: &hir::ImplItem,
1462 let mut err = struct_span_err!(
1463 tcx.sess, impl_item.span, E0520,
1464 "`{}` specializes an item from a parent `impl`, but \
1465 that item is not marked `default`",
1467 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1470 match tcx.span_of_impl(parent_impl) {
1472 err.span_label(span, "parent `impl` is here");
1473 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1477 err.note(&format!("parent implementation is in crate `{}`", cname));
1484 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1485 trait_def: &ty::TraitDef,
1486 trait_item: &ty::AssociatedItem,
1488 impl_item: &hir::ImplItem)
1490 let ancestors = trait_def.ancestors(tcx, impl_id);
1492 let kind = match impl_item.node {
1493 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1494 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1495 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1496 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1499 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1500 .map(|node_item| node_item.map(|parent| parent.defaultness));
1502 if let Some(parent) = parent {
1503 if tcx.impl_item_is_final(&parent) {
1504 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1510 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1513 impl_trait_ref: ty::TraitRef<'tcx>,
1514 impl_item_refs: &[hir::ImplItemRef]) {
1515 let impl_span = tcx.sess.source_map().def_span(impl_span);
1517 // If the trait reference itself is erroneous (so the compilation is going
1518 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1519 // isn't populated for such impls.
1520 if impl_trait_ref.references_error() { return; }
1522 // Locate trait definition and items
1523 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1524 let mut overridden_associated_type = None;
1526 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1528 // Check existing impl methods to see if they are both present in trait
1529 // and compatible with trait signature
1530 for impl_item in impl_items() {
1531 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1532 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1533 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1534 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1536 // Not compatible, but needed for the error message
1537 tcx.associated_items(impl_trait_ref.def_id)
1538 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1541 // Check that impl definition matches trait definition
1542 if let Some(ty_trait_item) = ty_trait_item {
1543 match impl_item.node {
1544 hir::ImplItemKind::Const(..) => {
1545 // Find associated const definition.
1546 if ty_trait_item.kind == ty::AssociatedKind::Const {
1547 compare_const_impl(tcx,
1553 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1554 "item `{}` is an associated const, \
1555 which doesn't match its trait `{}`",
1558 err.span_label(impl_item.span, "does not match trait");
1559 // We can only get the spans from local trait definition
1560 // Same for E0324 and E0325
1561 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1562 err.span_label(trait_span, "item in trait");
1567 hir::ImplItemKind::Method(..) => {
1568 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1569 if ty_trait_item.kind == ty::AssociatedKind::Method {
1570 compare_impl_method(tcx,
1577 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1578 "item `{}` is an associated method, \
1579 which doesn't match its trait `{}`",
1582 err.span_label(impl_item.span, "does not match trait");
1583 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1584 err.span_label(trait_span, "item in trait");
1589 hir::ImplItemKind::Existential(..) |
1590 hir::ImplItemKind::Type(_) => {
1591 if ty_trait_item.kind == ty::AssociatedKind::Type {
1592 if ty_trait_item.defaultness.has_value() {
1593 overridden_associated_type = Some(impl_item);
1596 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1597 "item `{}` is an associated type, \
1598 which doesn't match its trait `{}`",
1601 err.span_label(impl_item.span, "does not match trait");
1602 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1603 err.span_label(trait_span, "item in trait");
1610 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1614 // Check for missing items from trait
1615 let mut missing_items = Vec::new();
1616 let mut invalidated_items = Vec::new();
1617 let associated_type_overridden = overridden_associated_type.is_some();
1618 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1619 let is_implemented = trait_def.ancestors(tcx, impl_id)
1620 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1622 .map(|node_item| !node_item.node.is_from_trait())
1625 if !is_implemented && !tcx.impl_is_default(impl_id) {
1626 if !trait_item.defaultness.has_value() {
1627 missing_items.push(trait_item);
1628 } else if associated_type_overridden {
1629 invalidated_items.push(trait_item.ident);
1634 if !missing_items.is_empty() {
1635 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1636 "not all trait items implemented, missing: `{}`",
1637 missing_items.iter()
1638 .map(|trait_item| trait_item.ident.to_string())
1639 .collect::<Vec<_>>().join("`, `"));
1640 err.span_label(impl_span, format!("missing `{}` in implementation",
1641 missing_items.iter()
1642 .map(|trait_item| trait_item.ident.to_string())
1643 .collect::<Vec<_>>().join("`, `")));
1644 for trait_item in missing_items {
1645 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1646 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1648 err.note_trait_signature(trait_item.ident.to_string(),
1649 trait_item.signature(&tcx));
1655 if !invalidated_items.is_empty() {
1656 let invalidator = overridden_associated_type.unwrap();
1657 span_err!(tcx.sess, invalidator.span, E0399,
1658 "the following trait items need to be reimplemented \
1659 as `{}` was overridden: `{}`",
1661 invalidated_items.iter()
1662 .map(|name| name.to_string())
1663 .collect::<Vec<_>>().join("`, `"))
1667 /// Checks whether a type can be represented in memory. In particular, it
1668 /// identifies types that contain themselves without indirection through a
1669 /// pointer, which would mean their size is unbounded.
1670 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1674 let rty = tcx.type_of(item_def_id);
1676 // Check that it is possible to represent this type. This call identifies
1677 // (1) types that contain themselves and (2) types that contain a different
1678 // recursive type. It is only necessary to throw an error on those that
1679 // contain themselves. For case 2, there must be an inner type that will be
1680 // caught by case 1.
1681 match rty.is_representable(tcx, sp) {
1682 Representability::SelfRecursive(spans) => {
1683 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1685 err.span_label(span, "recursive without indirection");
1690 Representability::Representable | Representability::ContainsRecursive => (),
1695 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1696 let t = tcx.type_of(def_id);
1697 if let ty::Adt(def, substs) = t.sty {
1698 if def.is_struct() {
1699 let fields = &def.non_enum_variant().fields;
1700 if fields.is_empty() {
1701 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1704 let e = fields[0].ty(tcx, substs);
1705 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1706 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1707 .span_label(sp, "SIMD elements must have the same type")
1712 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1713 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1715 span_err!(tcx.sess, sp, E0077,
1716 "SIMD vector element type should be machine type");
1724 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1725 let repr = tcx.adt_def(def_id).repr;
1727 for attr in tcx.get_attrs(def_id).iter() {
1728 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1729 if let attr::ReprPacked(pack) = r {
1730 if pack != repr.pack {
1731 struct_span_err!(tcx.sess, sp, E0634,
1732 "type has conflicting packed representation hints").emit();
1738 struct_span_err!(tcx.sess, sp, E0587,
1739 "type has conflicting packed and align representation hints").emit();
1741 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1742 struct_span_err!(tcx.sess, sp, E0588,
1743 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1748 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1750 stack: &mut Vec<DefId>) -> bool {
1751 let t = tcx.type_of(def_id);
1752 if stack.contains(&def_id) {
1753 debug!("check_packed_inner: {:?} is recursive", t);
1756 if let ty::Adt(def, substs) = t.sty {
1757 if def.is_struct() || def.is_union() {
1758 if tcx.adt_def(def.did).repr.align > 0 {
1761 // push struct def_id before checking fields
1763 for field in &def.non_enum_variant().fields {
1764 let f = field.ty(tcx, substs);
1765 if let ty::Adt(def, _) = f.sty {
1766 if check_packed_inner(tcx, def.did, stack) {
1771 // only need to pop if not early out
1778 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1779 let adt = tcx.adt_def(def_id);
1780 if !adt.repr.transparent() {
1784 // For each field, figure out if it's known to be a ZST and align(1)
1785 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1786 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1787 let param_env = tcx.param_env(field.did);
1788 let layout = tcx.layout_of(param_env.and(ty));
1789 // We are currently checking the type this field came from, so it must be local
1790 let span = tcx.hir.span_if_local(field.did).unwrap();
1791 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1792 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1796 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1797 let non_zst_count = non_zst_fields.clone().count();
1798 if non_zst_count != 1 {
1799 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1800 struct_span_err!(tcx.sess, sp, E0690,
1801 "transparent struct needs exactly one non-zero-sized field, but has {}",
1803 .span_note(field_spans, "non-zero-sized field")
1806 for (span, zst, align1) in field_infos {
1808 span_err!(tcx.sess, span, E0691,
1809 "zero-sized field in transparent struct has alignment larger than 1");
1814 #[allow(trivial_numeric_casts)]
1815 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1817 vs: &'tcx [hir::Variant],
1819 let def_id = tcx.hir.local_def_id(id);
1820 let def = tcx.adt_def(def_id);
1821 def.destructor(tcx); // force the destructor to be evaluated
1824 let attributes = tcx.get_attrs(def_id);
1825 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1827 tcx.sess, attr.span, E0084,
1828 "unsupported representation for zero-variant enum")
1829 .span_label(sp, "zero-variant enum")
1834 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1835 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1836 if !tcx.features().repr128 {
1837 emit_feature_err(&tcx.sess.parse_sess,
1840 GateIssue::Language,
1841 "repr with 128-bit type is unstable");
1846 if let Some(ref e) = v.node.disr_expr {
1847 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1851 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1852 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1853 // Check for duplicate discriminant values
1854 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1855 let variant_did = def.variants[VariantIdx::new(i)].did;
1856 let variant_i_node_id = tcx.hir.as_local_node_id(variant_did).unwrap();
1857 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1858 let i_span = match variant_i.node.disr_expr {
1859 Some(ref expr) => tcx.hir.span(expr.id),
1860 None => tcx.hir.span(variant_i_node_id)
1862 let span = match v.node.disr_expr {
1863 Some(ref expr) => tcx.hir.span(expr.id),
1866 struct_span_err!(tcx.sess, span, E0081,
1867 "discriminant value `{}` already exists", disr_vals[i])
1868 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1869 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1872 disr_vals.push(discr);
1875 check_representable(tcx, sp, def_id);
1878 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1879 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1881 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1882 -> Lrc<ty::GenericPredicates<'tcx>>
1885 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1886 let item_id = tcx.hir.ty_param_owner(node_id);
1887 let item_def_id = tcx.hir.local_def_id(item_id);
1888 let generics = tcx.generics_of(item_def_id);
1889 let index = generics.param_def_id_to_index[&def_id];
1890 Lrc::new(ty::GenericPredicates {
1892 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1894 ty::Predicate::Trait(ref data)
1895 if data.skip_binder().self_ty().is_param(index) => {
1896 // HACK(eddyb) should get the original `Span`.
1897 let span = tcx.def_span(def_id);
1898 Some((predicate, span))
1906 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1907 -> Option<ty::Region<'tcx>> {
1909 Some(def) => infer::EarlyBoundRegion(span, def.name),
1910 None => infer::MiscVariable(span)
1912 Some(self.next_region_var(v))
1915 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1916 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1919 fn ty_infer_for_def(&self,
1920 ty_param_def: &ty::GenericParamDef,
1921 span: Span) -> Ty<'tcx> {
1922 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1928 fn projected_ty_from_poly_trait_ref(&self,
1931 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1934 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1936 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1940 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1943 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1944 if ty.has_escaping_bound_vars() {
1945 ty // FIXME: normalization and escaping regions
1947 self.normalize_associated_types_in(span, &ty)
1951 fn set_tainted_by_errors(&self) {
1952 self.infcx.set_tainted_by_errors()
1955 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1956 self.write_ty(hir_id, ty)
1960 /// Controls whether the arguments are tupled. This is used for the call
1963 /// Tupling means that all call-side arguments are packed into a tuple and
1964 /// passed as a single parameter. For example, if tupling is enabled, this
1967 /// fn f(x: (isize, isize))
1969 /// Can be called as:
1976 #[derive(Clone, Eq, PartialEq)]
1977 enum TupleArgumentsFlag {
1982 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1983 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1984 param_env: ty::ParamEnv<'tcx>,
1985 body_id: ast::NodeId)
1986 -> FnCtxt<'a, 'gcx, 'tcx> {
1990 err_count_on_creation: inh.tcx.sess.err_count(),
1993 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1994 ast::CRATE_NODE_ID)),
1995 diverges: Cell::new(Diverges::Maybe),
1996 has_errors: Cell::new(false),
1997 enclosing_breakables: RefCell::new(EnclosingBreakables {
1999 by_id: Default::default(),
2005 pub fn sess(&self) -> &Session {
2009 pub fn err_count_since_creation(&self) -> usize {
2010 self.tcx.sess.err_count() - self.err_count_on_creation
2013 /// Produce warning on the given node, if the current point in the
2014 /// function is unreachable, and there hasn't been another warning.
2015 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2016 if self.diverges.get() == Diverges::Always {
2017 self.diverges.set(Diverges::WarnedAlways);
2019 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2021 self.tcx().lint_node(
2022 lint::builtin::UNREACHABLE_CODE,
2024 &format!("unreachable {}", kind));
2030 code: ObligationCauseCode<'tcx>)
2031 -> ObligationCause<'tcx> {
2032 ObligationCause::new(span, self.body_id, code)
2035 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2036 self.cause(span, ObligationCauseCode::MiscObligation)
2039 /// Resolves type variables in `ty` if possible. Unlike the infcx
2040 /// version (resolve_type_vars_if_possible), this version will
2041 /// also select obligations if it seems useful, in an effort
2042 /// to get more type information.
2043 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2044 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2046 // No Infer()? Nothing needs doing.
2047 if !ty.has_infer_types() {
2048 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2052 // If `ty` is a type variable, see whether we already know what it is.
2053 ty = self.resolve_type_vars_if_possible(&ty);
2054 if !ty.has_infer_types() {
2055 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2059 // If not, try resolving pending obligations as much as
2060 // possible. This can help substantially when there are
2061 // indirect dependencies that don't seem worth tracking
2063 self.select_obligations_where_possible(false);
2064 ty = self.resolve_type_vars_if_possible(&ty);
2066 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2070 fn record_deferred_call_resolution(&self,
2071 closure_def_id: DefId,
2072 r: DeferredCallResolution<'gcx, 'tcx>) {
2073 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2074 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2077 fn remove_deferred_call_resolutions(&self,
2078 closure_def_id: DefId)
2079 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2081 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2082 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2085 pub fn tag(&self) -> String {
2086 let self_ptr: *const FnCtxt = self;
2087 format!("{:?}", self_ptr)
2090 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2091 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2092 span_bug!(span, "no type for local variable {}",
2093 self.tcx.hir.node_to_string(nid))
2098 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2099 debug!("write_ty({:?}, {:?}) in fcx {}",
2100 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2101 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2103 if ty.references_error() {
2104 self.has_errors.set(true);
2105 self.set_tainted_by_errors();
2109 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2110 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2111 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2114 // The NodeId and the ItemLocalId must identify the same item. We just pass
2115 // both of them for consistency checking.
2116 pub fn write_method_call(&self,
2118 method: MethodCallee<'tcx>) {
2119 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2122 .type_dependent_defs_mut()
2123 .insert(hir_id, Def::Method(method.def_id));
2125 self.write_substs(hir_id, method.substs);
2127 // When the method is confirmed, the `method.substs` includes
2128 // parameters from not just the method, but also the impl of
2129 // the method -- in particular, the `Self` type will be fully
2130 // resolved. However, those are not something that the "user
2131 // specified" -- i.e., those types come from the inferred type
2132 // of the receiver, not something the user wrote. So when we
2133 // create the user-substs, we want to replace those earlier
2134 // types with just the types that the user actually wrote --
2135 // that is, those that appear on the *method itself*.
2137 // As an example, if the user wrote something like
2138 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2139 // type of `foo` (possibly adjusted), but we don't want to
2140 // include that. We want just the `[_, u32]` part.
2141 if !method.substs.is_noop() {
2142 let method_generics = self.tcx.generics_of(method.def_id);
2143 if !method_generics.params.is_empty() {
2144 let user_substs = self.infcx.probe(|_| {
2145 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2146 let i = param.index as usize;
2147 if i < method_generics.parent_count {
2148 self.infcx.var_for_def(DUMMY_SP, param)
2153 self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2154 substs: just_method_substs,
2155 user_self_ty: None, // not relevant here
2159 debug!("write_method_call: user_substs = {:?}", user_substs);
2160 self.write_user_substs(hir_id, user_substs);
2165 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2166 if !substs.is_noop() {
2167 debug!("write_substs({:?}, {:?}) in fcx {}",
2172 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2176 /// Given the substs that we just converted from the HIR, try to
2177 /// canonicalize them and store them as user-given substitutions
2178 /// (i.e., substitutions that must be respected by the NLL check).
2180 /// This should be invoked **before any unifications have
2181 /// occurred**, so that annotations like `Vec<_>` are preserved
2183 pub fn write_user_substs_from_substs(
2186 substs: &'tcx Substs<'tcx>,
2187 user_self_ty: Option<UserSelfTy<'tcx>>,
2190 "write_user_substs_from_substs({:?}, {:?}) in fcx {}",
2196 if !substs.is_noop() {
2197 let user_substs = self.infcx.canonicalize_user_type_annotation(&UserSubsts {
2201 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2202 self.write_user_substs(hir_id, user_substs);
2206 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalUserSubsts<'tcx>) {
2208 "write_user_substs({:?}, {:?}) in fcx {}",
2214 if !substs.is_identity() {
2215 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2217 debug!("write_user_substs: skipping identity substs");
2221 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2222 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2228 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2229 Entry::Vacant(entry) => { entry.insert(adj); },
2230 Entry::Occupied(mut entry) => {
2231 debug!(" - composing on top of {:?}", entry.get());
2232 match (&entry.get()[..], &adj[..]) {
2233 // Applying any adjustment on top of a NeverToAny
2234 // is a valid NeverToAny adjustment, because it can't
2236 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2238 Adjustment { kind: Adjust::Deref(_), .. },
2239 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2241 Adjustment { kind: Adjust::Deref(_), .. },
2242 .. // Any following adjustments are allowed.
2244 // A reborrow has no effect before a dereference.
2246 // FIXME: currently we never try to compose autoderefs
2247 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2249 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2250 expr, entry.get(), adj)
2252 *entry.get_mut() = adj;
2257 /// Basically whenever we are converting from a type scheme into
2258 /// the fn body space, we always want to normalize associated
2259 /// types as well. This function combines the two.
2260 fn instantiate_type_scheme<T>(&self,
2262 substs: &Substs<'tcx>,
2265 where T : TypeFoldable<'tcx>
2267 let value = value.subst(self.tcx, substs);
2268 let result = self.normalize_associated_types_in(span, &value);
2269 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2276 /// As `instantiate_type_scheme`, but for the bounds found in a
2277 /// generic type scheme.
2278 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2279 -> ty::InstantiatedPredicates<'tcx> {
2280 let bounds = self.tcx.predicates_of(def_id);
2281 let result = bounds.instantiate(self.tcx, substs);
2282 let result = self.normalize_associated_types_in(span, &result);
2283 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2290 /// Replace the opaque types from the given value with type variables,
2291 /// and records the `OpaqueTypeMap` for later use during writeback. See
2292 /// `InferCtxt::instantiate_opaque_types` for more details.
2293 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2295 parent_id: ast::NodeId,
2298 let parent_def_id = self.tcx.hir.local_def_id(parent_id);
2299 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2303 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2304 self.instantiate_opaque_types(
2312 let mut opaque_types = self.opaque_types.borrow_mut();
2313 for (ty, decl) in opaque_type_map {
2314 let old_value = opaque_types.insert(ty, decl);
2315 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2321 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2322 where T : TypeFoldable<'tcx>
2324 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2327 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2329 where T : TypeFoldable<'tcx>
2331 self.inh.partially_normalize_associated_types_in(span,
2337 pub fn require_type_meets(&self,
2340 code: traits::ObligationCauseCode<'tcx>,
2343 self.register_bound(
2346 traits::ObligationCause::new(span, self.body_id, code));
2349 pub fn require_type_is_sized(&self,
2352 code: traits::ObligationCauseCode<'tcx>)
2354 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2355 self.require_type_meets(ty, span, code, lang_item);
2358 pub fn require_type_is_sized_deferred(&self,
2361 code: traits::ObligationCauseCode<'tcx>)
2363 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2366 pub fn register_bound(&self,
2369 cause: traits::ObligationCause<'tcx>)
2371 self.fulfillment_cx.borrow_mut()
2372 .register_bound(self, self.param_env, ty, def_id, cause);
2375 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2376 let t = AstConv::ast_ty_to_ty(self, ast_t);
2377 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2381 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2382 let ty = self.to_ty(ast_ty);
2384 // If the type given by the user has free regions, save it for
2385 // later, since NLL would like to enforce those. Also pass in
2386 // types that involve projections, since those can resolve to
2387 // `'static` bounds (modulo #54940, which hopefully will be
2388 // fixed by the time you see this comment, dear reader,
2389 // although I have my doubts). Other sorts of things are
2390 // already sufficiently enforced with erased regions. =)
2391 if ty.has_free_regions() || ty.has_projections() {
2392 let c_ty = self.infcx.canonicalize_response(&ty);
2393 self.tables.borrow_mut().user_provided_tys_mut().insert(ast_ty.hir_id, c_ty);
2399 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2400 match self.tables.borrow().node_types().get(id) {
2402 None if self.is_tainted_by_errors() => self.tcx.types.err,
2404 let node_id = self.tcx.hir.hir_to_node_id(id);
2405 bug!("no type for node {}: {} in fcx {}",
2406 node_id, self.tcx.hir.node_to_string(node_id),
2412 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2413 /// outlive the region `r`.
2414 pub fn register_wf_obligation(&self,
2417 code: traits::ObligationCauseCode<'tcx>)
2419 // WF obligations never themselves fail, so no real need to give a detailed cause:
2420 let cause = traits::ObligationCause::new(span, self.body_id, code);
2421 self.register_predicate(traits::Obligation::new(cause,
2423 ty::Predicate::WellFormed(ty)));
2426 /// Registers obligations that all types appearing in `substs` are well-formed.
2427 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2428 for ty in substs.types() {
2429 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2433 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2434 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2435 /// trait/region obligations.
2437 /// For example, if there is a function:
2440 /// fn foo<'a,T:'a>(...)
2443 /// and a reference:
2449 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2450 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2451 pub fn add_obligations_for_parameters(&self,
2452 cause: traits::ObligationCause<'tcx>,
2453 predicates: &ty::InstantiatedPredicates<'tcx>)
2455 assert!(!predicates.has_escaping_bound_vars());
2457 debug!("add_obligations_for_parameters(predicates={:?})",
2460 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2461 self.register_predicate(obligation);
2465 // FIXME(arielb1): use this instead of field.ty everywhere
2466 // Only for fields! Returns <none> for methods>
2467 // Indifferent to privacy flags
2468 pub fn field_ty(&self,
2470 field: &'tcx ty::FieldDef,
2471 substs: &Substs<'tcx>)
2474 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2477 fn check_casts(&self) {
2478 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2479 for cast in deferred_cast_checks.drain(..) {
2484 fn resolve_generator_interiors(&self, def_id: DefId) {
2485 let mut generators = self.deferred_generator_interiors.borrow_mut();
2486 for (body_id, interior) in generators.drain(..) {
2487 self.select_obligations_where_possible(false);
2488 generator_interior::resolve_interior(self, def_id, body_id, interior);
2492 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2493 // Non-numerics get replaced with ! or () (depending on whether
2494 // feature(never_type) is enabled, unconstrained ints with i32,
2495 // unconstrained floats with f64.
2496 // Fallback becomes very dubious if we have encountered type-checking errors.
2497 // In that case, fallback to Error.
2498 // The return value indicates whether fallback has occurred.
2499 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2500 use rustc::ty::error::UnconstrainedNumeric::Neither;
2501 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2503 assert!(ty.is_ty_infer());
2504 let fallback = match self.type_is_unconstrained_numeric(ty) {
2505 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2506 UnconstrainedInt => self.tcx.types.i32,
2507 UnconstrainedFloat => self.tcx.types.f64,
2508 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2509 Neither => return false,
2511 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2512 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2516 fn select_all_obligations_or_error(&self) {
2517 debug!("select_all_obligations_or_error");
2518 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2519 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2523 /// Select as many obligations as we can at present.
2524 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2525 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2526 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2530 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2531 /// returns a type of `&T`, but the actual type we assign to the
2532 /// *expression* is `T`. So this function just peels off the return
2533 /// type by one layer to yield `T`.
2534 fn make_overloaded_place_return_type(&self,
2535 method: MethodCallee<'tcx>)
2536 -> ty::TypeAndMut<'tcx>
2538 // extract method return type, which will be &T;
2539 let ret_ty = method.sig.output();
2541 // method returns &T, but the type as visible to user is T, so deref
2542 ret_ty.builtin_deref(true).unwrap()
2545 fn lookup_indexing(&self,
2547 base_expr: &'gcx hir::Expr,
2551 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2553 // FIXME(#18741) -- this is almost but not quite the same as the
2554 // autoderef that normal method probing does. They could likely be
2557 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2558 let mut result = None;
2559 while result.is_none() && autoderef.next().is_some() {
2560 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2562 autoderef.finalize();
2566 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2567 /// (and otherwise adjust) `base_expr`, looking for a type which either
2568 /// supports builtin indexing or overloaded indexing.
2569 /// This loop implements one step in that search; the autoderef loop
2570 /// is implemented by `lookup_indexing`.
2571 fn try_index_step(&self,
2573 base_expr: &hir::Expr,
2574 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2577 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2579 let adjusted_ty = autoderef.unambiguous_final_ty();
2580 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2587 for &unsize in &[false, true] {
2588 let mut self_ty = adjusted_ty;
2590 // We only unsize arrays here.
2591 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2592 self_ty = self.tcx.mk_slice(element_ty);
2598 // If some lookup succeeds, write callee into table and extract index/element
2599 // type from the method signature.
2600 // If some lookup succeeded, install method in table
2601 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2602 let method = self.try_overloaded_place_op(
2603 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2605 let result = method.map(|ok| {
2606 debug!("try_index_step: success, using overloaded indexing");
2607 let method = self.register_infer_ok_obligations(ok);
2609 let mut adjustments = autoderef.adjust_steps(needs);
2610 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2611 let mutbl = match r_mutbl {
2612 hir::MutImmutable => AutoBorrowMutability::Immutable,
2613 hir::MutMutable => AutoBorrowMutability::Mutable {
2614 // Indexing can be desugared to a method call,
2615 // so maybe we could use two-phase here.
2616 // See the documentation of AllowTwoPhase for why that's
2617 // not the case today.
2618 allow_two_phase_borrow: AllowTwoPhase::No,
2621 adjustments.push(Adjustment {
2622 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2623 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2630 adjustments.push(Adjustment {
2631 kind: Adjust::Unsize,
2632 target: method.sig.inputs()[0]
2635 self.apply_adjustments(base_expr, adjustments);
2637 self.write_method_call(expr.hir_id, method);
2638 (input_ty, self.make_overloaded_place_return_type(method).ty)
2640 if result.is_some() {
2648 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2649 let (tr, name) = match (op, is_mut) {
2650 (PlaceOp::Deref, false) =>
2651 (self.tcx.lang_items().deref_trait(), "deref"),
2652 (PlaceOp::Deref, true) =>
2653 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2654 (PlaceOp::Index, false) =>
2655 (self.tcx.lang_items().index_trait(), "index"),
2656 (PlaceOp::Index, true) =>
2657 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2659 (tr, ast::Ident::from_str(name))
2662 fn try_overloaded_place_op(&self,
2665 arg_tys: &[Ty<'tcx>],
2668 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2670 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2676 // Try Mut first, if needed.
2677 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2678 let method = match (needs, mut_tr) {
2679 (Needs::MutPlace, Some(trait_did)) => {
2680 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2685 // Otherwise, fall back to the immutable version.
2686 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2687 let method = match (method, imm_tr) {
2688 (None, Some(trait_did)) => {
2689 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2691 (method, _) => method,
2697 fn check_method_argument_types(&self,
2700 method: Result<MethodCallee<'tcx>, ()>,
2701 args_no_rcvr: &'gcx [hir::Expr],
2702 tuple_arguments: TupleArgumentsFlag,
2703 expected: Expectation<'tcx>)
2705 let has_error = match method {
2707 method.substs.references_error() || method.sig.references_error()
2712 let err_inputs = self.err_args(args_no_rcvr.len());
2714 let err_inputs = match tuple_arguments {
2715 DontTupleArguments => err_inputs,
2716 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2719 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2720 false, tuple_arguments, None);
2721 return self.tcx.types.err;
2724 let method = method.unwrap();
2725 // HACK(eddyb) ignore self in the definition (see above).
2726 let expected_arg_tys = self.expected_inputs_for_expected_output(
2729 method.sig.output(),
2730 &method.sig.inputs()[1..]
2732 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2733 args_no_rcvr, method.sig.variadic, tuple_arguments,
2734 self.tcx.hir.span_if_local(method.def_id));
2738 /// Generic function that factors out common logic from function calls,
2739 /// method calls and overloaded operators.
2740 fn check_argument_types(&self,
2743 fn_inputs: &[Ty<'tcx>],
2744 mut expected_arg_tys: &[Ty<'tcx>],
2745 args: &'gcx [hir::Expr],
2747 tuple_arguments: TupleArgumentsFlag,
2748 def_span: Option<Span>) {
2751 // Grab the argument types, supplying fresh type variables
2752 // if the wrong number of arguments were supplied
2753 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2759 // All the input types from the fn signature must outlive the call
2760 // so as to validate implied bounds.
2761 for &fn_input_ty in fn_inputs {
2762 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2765 let expected_arg_count = fn_inputs.len();
2767 let param_count_error = |expected_count: usize,
2772 let mut err = tcx.sess.struct_span_err_with_code(sp,
2773 &format!("this function takes {}{} but {} {} supplied",
2774 if variadic {"at least "} else {""},
2775 potentially_plural_count(expected_count, "parameter"),
2776 potentially_plural_count(arg_count, "parameter"),
2777 if arg_count == 1 {"was"} else {"were"}),
2778 DiagnosticId::Error(error_code.to_owned()));
2780 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2781 err.span_label(def_s, "defined here");
2784 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2785 // remove closing `)` from the span
2786 let sugg_span = sugg_span.shrink_to_lo();
2787 err.span_suggestion_with_applicability(
2789 "expected the unit value `()`; create it with empty parentheses",
2791 Applicability::MachineApplicable);
2793 err.span_label(sp, format!("expected {}{}",
2794 if variadic {"at least "} else {""},
2795 potentially_plural_count(expected_count, "parameter")));
2800 let formal_tys = if tuple_arguments == TupleArguments {
2801 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2802 match tuple_type.sty {
2803 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2804 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2805 expected_arg_tys = &[];
2806 self.err_args(args.len())
2808 ty::Tuple(arg_types) => {
2809 expected_arg_tys = match expected_arg_tys.get(0) {
2810 Some(&ty) => match ty.sty {
2811 ty::Tuple(ref tys) => &tys,
2819 span_err!(tcx.sess, sp, E0059,
2820 "cannot use call notation; the first type parameter \
2821 for the function trait is neither a tuple nor unit");
2822 expected_arg_tys = &[];
2823 self.err_args(args.len())
2826 } else if expected_arg_count == supplied_arg_count {
2828 } else if variadic {
2829 if supplied_arg_count >= expected_arg_count {
2832 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2833 expected_arg_tys = &[];
2834 self.err_args(supplied_arg_count)
2837 // is the missing argument of type `()`?
2838 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2839 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2840 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2841 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2845 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2847 expected_arg_tys = &[];
2848 self.err_args(supplied_arg_count)
2850 // If there is no expectation, expect formal_tys.
2851 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2857 debug!("check_argument_types: formal_tys={:?}",
2858 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2860 // Check the arguments.
2861 // We do this in a pretty awful way: first we typecheck any arguments
2862 // that are not closures, then we typecheck the closures. This is so
2863 // that we have more information about the types of arguments when we
2864 // typecheck the functions. This isn't really the right way to do this.
2865 for &check_closures in &[false, true] {
2866 debug!("check_closures={}", check_closures);
2868 // More awful hacks: before we check argument types, try to do
2869 // an "opportunistic" vtable resolution of any trait bounds on
2870 // the call. This helps coercions.
2872 self.select_obligations_where_possible(false);
2875 // For variadic functions, we don't have a declared type for all of
2876 // the arguments hence we only do our usual type checking with
2877 // the arguments who's types we do know.
2878 let t = if variadic {
2880 } else if tuple_arguments == TupleArguments {
2885 for (i, arg) in args.iter().take(t).enumerate() {
2886 // Warn only for the first loop (the "no closures" one).
2887 // Closure arguments themselves can't be diverging, but
2888 // a previous argument can, e.g. `foo(panic!(), || {})`.
2889 if !check_closures {
2890 self.warn_if_unreachable(arg.id, arg.span, "expression");
2893 let is_closure = match arg.node {
2894 hir::ExprKind::Closure(..) => true,
2898 if is_closure != check_closures {
2902 debug!("checking the argument");
2903 let formal_ty = formal_tys[i];
2905 // The special-cased logic below has three functions:
2906 // 1. Provide as good of an expected type as possible.
2907 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2909 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2911 // 2. Coerce to the most detailed type that could be coerced
2912 // to, which is `expected_ty` if `rvalue_hint` returns an
2913 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2914 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2915 // We're processing function arguments so we definitely want to use
2916 // two-phase borrows.
2917 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2919 // 3. Relate the expected type and the formal one,
2920 // if the expected type was used for the coercion.
2921 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2925 // We also need to make sure we at least write the ty of the other
2926 // arguments which we skipped above.
2928 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2929 use structured_errors::{VariadicError, StructuredDiagnostic};
2930 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2933 for arg in args.iter().skip(expected_arg_count) {
2934 let arg_ty = self.check_expr(&arg);
2936 // There are a few types which get autopromoted when passed via varargs
2937 // in C but we just error out instead and require explicit casts.
2938 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2940 ty::Float(ast::FloatTy::F32) => {
2941 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2943 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2944 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2946 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2947 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2950 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2951 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2952 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2960 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2961 vec![self.tcx.types.err; len]
2964 // AST fragment checking
2967 expected: Expectation<'tcx>)
2973 ast::LitKind::Str(..) => tcx.mk_static_str(),
2974 ast::LitKind::ByteStr(ref v) => {
2975 tcx.mk_imm_ref(tcx.types.re_static,
2976 tcx.mk_array(tcx.types.u8, v.len() as u64))
2978 ast::LitKind::Byte(_) => tcx.types.u8,
2979 ast::LitKind::Char(_) => tcx.types.char,
2980 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2981 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2982 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2983 let opt_ty = expected.to_option(self).and_then(|ty| {
2985 ty::Int(_) | ty::Uint(_) => Some(ty),
2986 ty::Char => Some(tcx.types.u8),
2987 ty::RawPtr(..) => Some(tcx.types.usize),
2988 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2992 opt_ty.unwrap_or_else(
2993 || tcx.mk_int_var(self.next_int_var_id()))
2995 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2996 ast::LitKind::FloatUnsuffixed(_) => {
2997 let opt_ty = expected.to_option(self).and_then(|ty| {
2999 ty::Float(_) => Some(ty),
3003 opt_ty.unwrap_or_else(
3004 || tcx.mk_float_var(self.next_float_var_id()))
3006 ast::LitKind::Bool(_) => tcx.types.bool
3010 fn check_expr_eq_type(&self,
3011 expr: &'gcx hir::Expr,
3012 expected: Ty<'tcx>) {
3013 let ty = self.check_expr_with_hint(expr, expected);
3014 self.demand_eqtype(expr.span, expected, ty);
3017 pub fn check_expr_has_type_or_error(&self,
3018 expr: &'gcx hir::Expr,
3019 expected: Ty<'tcx>) -> Ty<'tcx> {
3020 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3023 fn check_expr_meets_expectation_or_error(&self,
3024 expr: &'gcx hir::Expr,
3025 expected: Expectation<'tcx>) -> Ty<'tcx> {
3026 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3027 let mut ty = self.check_expr_with_expectation(expr, expected);
3029 // While we don't allow *arbitrary* coercions here, we *do* allow
3030 // coercions from ! to `expected`.
3032 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3033 "expression with never type wound up being adjusted");
3034 let adj_ty = self.next_diverging_ty_var(
3035 TypeVariableOrigin::AdjustmentType(expr.span));
3036 self.apply_adjustments(expr, vec![Adjustment {
3037 kind: Adjust::NeverToAny,
3043 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3044 // Add help to type error if this is an `if` condition with an assignment
3045 if let (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs))
3046 = (expected, &expr.node)
3048 let msg = "try comparing for equality";
3049 if let (Ok(left), Ok(right)) = (
3050 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3051 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3053 err.span_suggestion_with_applicability(
3056 format!("{} == {}", left, right),
3057 Applicability::MaybeIncorrect);
3067 fn check_expr_coercable_to_type(&self,
3068 expr: &'gcx hir::Expr,
3069 expected: Ty<'tcx>) -> Ty<'tcx> {
3070 let ty = self.check_expr_with_hint(expr, expected);
3071 // checks don't need two phase
3072 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3075 fn check_expr_with_hint(&self,
3076 expr: &'gcx hir::Expr,
3077 expected: Ty<'tcx>) -> Ty<'tcx> {
3078 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3081 fn check_expr_with_expectation(&self,
3082 expr: &'gcx hir::Expr,
3083 expected: Expectation<'tcx>) -> Ty<'tcx> {
3084 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3087 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3088 self.check_expr_with_expectation(expr, NoExpectation)
3091 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3092 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3095 // determine the `self` type, using fresh variables for all variables
3096 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3097 // would return ($0, $1) where $0 and $1 are freshly instantiated type
3099 pub fn impl_self_ty(&self,
3100 span: Span, // (potential) receiver for this impl
3102 -> TypeAndSubsts<'tcx> {
3103 let ity = self.tcx.type_of(did);
3104 debug!("impl_self_ty: ity={:?}", ity);
3106 let substs = self.fresh_substs_for_item(span, did);
3107 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3109 TypeAndSubsts { substs: substs, ty: substd_ty }
3112 /// Unifies the output type with the expected type early, for more coercions
3113 /// and forward type information on the input expressions.
3114 fn expected_inputs_for_expected_output(&self,
3116 expected_ret: Expectation<'tcx>,
3117 formal_ret: Ty<'tcx>,
3118 formal_args: &[Ty<'tcx>])
3120 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3121 let ret_ty = match expected_ret.only_has_type(self) {
3123 None => return Vec::new()
3125 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3126 // Attempt to apply a subtyping relationship between the formal
3127 // return type (likely containing type variables if the function
3128 // is polymorphic) and the expected return type.
3129 // No argument expectations are produced if unification fails.
3130 let origin = self.misc(call_span);
3131 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3133 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3134 // to identity so the resulting type is not constrained.
3137 // Process any obligations locally as much as
3138 // we can. We don't care if some things turn
3139 // out unconstrained or ambiguous, as we're
3140 // just trying to get hints here.
3141 self.save_and_restore_in_snapshot_flag(|_| {
3142 let mut fulfill = TraitEngine::new(self.tcx);
3143 for obligation in ok.obligations {
3144 fulfill.register_predicate_obligation(self, obligation);
3146 fulfill.select_where_possible(self)
3147 }).map_err(|_| ())?;
3149 Err(_) => return Err(()),
3152 // Record all the argument types, with the substitutions
3153 // produced from the above subtyping unification.
3154 Ok(formal_args.iter().map(|ty| {
3155 self.resolve_type_vars_if_possible(ty)
3157 }).unwrap_or_default();
3158 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3159 formal_args, formal_ret,
3160 expect_args, expected_ret);
3164 // Checks a method call.
3165 fn check_method_call(&self,
3166 expr: &'gcx hir::Expr,
3167 segment: &hir::PathSegment,
3169 args: &'gcx [hir::Expr],
3170 expected: Expectation<'tcx>,
3171 needs: Needs) -> Ty<'tcx> {
3172 let rcvr = &args[0];
3173 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3174 // no need to check for bot/err -- callee does that
3175 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3177 let method = match self.lookup_method(rcvr_t,
3183 self.write_method_call(expr.hir_id, method);
3187 if segment.ident.name != keywords::Invalid.name() {
3188 self.report_method_error(span,
3199 // Call the generic checker.
3200 self.check_method_argument_types(span,
3208 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3212 .unwrap_or_else(|| span_bug!(return_expr.span,
3213 "check_return_expr called outside fn body"));
3215 let ret_ty = ret_coercion.borrow().expected_ty();
3216 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3217 ret_coercion.borrow_mut()
3219 &self.cause(return_expr.span,
3220 ObligationCauseCode::ReturnType(return_expr.id)),
3225 // A generic function for checking the then and else in an if
3227 fn check_then_else(&self,
3228 cond_expr: &'gcx hir::Expr,
3229 then_expr: &'gcx hir::Expr,
3230 opt_else_expr: Option<&'gcx hir::Expr>,
3232 expected: Expectation<'tcx>) -> Ty<'tcx> {
3233 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3234 let cond_diverges = self.diverges.get();
3235 self.diverges.set(Diverges::Maybe);
3237 let expected = expected.adjust_for_branches(self);
3238 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3239 let then_diverges = self.diverges.get();
3240 self.diverges.set(Diverges::Maybe);
3242 // We've already taken the expected type's preferences
3243 // into account when typing the `then` branch. To figure
3244 // out the initial shot at a LUB, we thus only consider
3245 // `expected` if it represents a *hard* constraint
3246 // (`only_has_type`); otherwise, we just go with a
3247 // fresh type variable.
3248 let coerce_to_ty = expected.coercion_target_type(self, sp);
3249 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3251 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3252 coerce.coerce(self, &if_cause, then_expr, then_ty);
3254 if let Some(else_expr) = opt_else_expr {
3255 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3256 let else_diverges = self.diverges.get();
3258 coerce.coerce(self, &if_cause, else_expr, else_ty);
3260 // We won't diverge unless both branches do (or the condition does).
3261 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3263 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3264 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3266 // If the condition is false we can't diverge.
3267 self.diverges.set(cond_diverges);
3270 let result_ty = coerce.complete(self);
3271 if cond_ty.references_error() {
3278 // Check field access expressions
3279 fn check_field(&self,
3280 expr: &'gcx hir::Expr,
3282 base: &'gcx hir::Expr,
3283 field: ast::Ident) -> Ty<'tcx> {
3284 let expr_t = self.check_expr_with_needs(base, needs);
3285 let expr_t = self.structurally_resolved_type(base.span,
3287 let mut private_candidate = None;
3288 let mut autoderef = self.autoderef(expr.span, expr_t);
3289 while let Some((base_t, _)) = autoderef.next() {
3291 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3292 debug!("struct named {:?}", base_t);
3293 let (ident, def_scope) =
3294 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3295 let fields = &base_def.non_enum_variant().fields;
3296 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3297 let field = &fields[index];
3298 let field_ty = self.field_ty(expr.span, field, substs);
3299 // Save the index of all fields regardless of their visibility in case
3300 // of error recovery.
3301 self.write_field_index(expr.id, index);
3302 if field.vis.is_accessible_from(def_scope, self.tcx) {
3303 let adjustments = autoderef.adjust_steps(needs);
3304 self.apply_adjustments(base, adjustments);
3305 autoderef.finalize();
3307 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3310 private_candidate = Some((base_def.did, field_ty));
3313 ty::Tuple(ref tys) => {
3314 let fstr = field.as_str();
3315 if let Ok(index) = fstr.parse::<usize>() {
3316 if fstr == index.to_string() {
3317 if let Some(field_ty) = tys.get(index) {
3318 let adjustments = autoderef.adjust_steps(needs);
3319 self.apply_adjustments(base, adjustments);
3320 autoderef.finalize();
3322 self.write_field_index(expr.id, index);
3331 autoderef.unambiguous_final_ty();
3333 if let Some((did, field_ty)) = private_candidate {
3334 let struct_path = self.tcx().item_path_str(did);
3335 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3336 "field `{}` of struct `{}` is private",
3337 field, struct_path);
3338 // Also check if an accessible method exists, which is often what is meant.
3339 if self.method_exists(field, expr_t, expr.id, false) {
3340 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3344 } else if field.name == keywords::Invalid.name() {
3345 self.tcx().types.err
3346 } else if self.method_exists(field, expr_t, expr.id, true) {
3347 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3348 "attempted to take value of method `{}` on type `{}`",
3350 .help("maybe a `()` to call it is missing?")
3352 self.tcx().types.err
3354 if !expr_t.is_primitive_ty() {
3355 let mut err = self.no_such_field_err(field.span, field, expr_t);
3358 ty::Adt(def, _) if !def.is_enum() => {
3359 if let Some(suggested_field_name) =
3360 Self::suggest_field_name(def.non_enum_variant(),
3361 &field.as_str(), vec![]) {
3362 err.span_label(field.span,
3363 format!("did you mean `{}`?", suggested_field_name));
3365 err.span_label(field.span, "unknown field");
3366 let struct_variant_def = def.non_enum_variant();
3367 let field_names = self.available_field_names(struct_variant_def);
3368 if !field_names.is_empty() {
3369 err.note(&format!("available fields are: {}",
3370 self.name_series_display(field_names)));
3374 ty::Array(_, len) => {
3375 if let (Some(len), Ok(user_index)) = (
3376 len.assert_usize(self.tcx),
3377 field.as_str().parse::<u64>()
3379 let base = self.tcx.hir.node_to_pretty_string(base.id);
3380 let help = "instead of using tuple indexing, use array indexing";
3381 let suggestion = format!("{}[{}]", base, field);
3382 let applicability = if len < user_index {
3383 Applicability::MachineApplicable
3385 Applicability::MaybeIncorrect
3387 err.span_suggestion_with_applicability(
3388 expr.span, help, suggestion, applicability
3393 let base = self.tcx.hir.node_to_pretty_string(base.id);
3394 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3395 let suggestion = format!("(*{}).{}", base, field);
3396 err.span_suggestion_with_applicability(
3400 Applicability::MaybeIncorrect,
3407 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3408 "`{}` is a primitive type and therefore doesn't have fields",
3411 self.tcx().types.err
3415 // Return an hint about the closest match in field names
3416 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3418 skip: Vec<LocalInternedString>)
3420 let names = variant.fields.iter().filter_map(|field| {
3421 // ignore already set fields and private fields from non-local crates
3422 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3423 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3426 Some(&field.ident.name)
3430 find_best_match_for_name(names, field, None)
3433 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3434 variant.fields.iter().filter(|field| {
3435 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3436 field.vis.is_accessible_from(def_scope, self.tcx)
3438 .map(|field| field.ident.name)
3442 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3443 // dynamic limit, to never omit just one field
3444 let limit = if names.len() == 6 { 6 } else { 5 };
3445 let mut display = names.iter().take(limit)
3446 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3447 if names.len() > limit {
3448 display = format!("{} ... and {} others", display, names.len() - limit);
3453 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3454 -> DiagnosticBuilder {
3455 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3456 "no field `{}` on type `{}`",
3460 fn report_unknown_field(&self,
3462 variant: &'tcx ty::VariantDef,
3464 skip_fields: &[hir::Field],
3466 let mut err = self.type_error_struct_with_diag(
3468 |actual| match ty.sty {
3469 ty::Adt(adt, ..) if adt.is_enum() => {
3470 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3471 "{} `{}::{}` has no field named `{}`",
3472 kind_name, actual, variant.name, field.ident)
3475 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3476 "{} `{}` has no field named `{}`",
3477 kind_name, actual, field.ident)
3481 // prevent all specified fields from being suggested
3482 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3483 if let Some(field_name) = Self::suggest_field_name(variant,
3484 &field.ident.as_str(),
3485 skip_fields.collect()) {
3486 err.span_label(field.ident.span,
3487 format!("field does not exist - did you mean `{}`?", field_name));
3490 ty::Adt(adt, ..) => {
3492 err.span_label(field.ident.span,
3493 format!("`{}::{}` does not have this field",
3496 err.span_label(field.ident.span,
3497 format!("`{}` does not have this field", ty));
3499 let available_field_names = self.available_field_names(variant);
3500 if !available_field_names.is_empty() {
3501 err.note(&format!("available fields are: {}",
3502 self.name_series_display(available_field_names)));
3505 _ => bug!("non-ADT passed to report_unknown_field")
3511 fn check_expr_struct_fields(&self,
3513 expected: Expectation<'tcx>,
3514 expr_id: ast::NodeId,
3516 variant: &'tcx ty::VariantDef,
3517 ast_fields: &'gcx [hir::Field],
3518 check_completeness: bool) -> bool {
3522 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3523 .get(0).cloned().unwrap_or(adt_ty);
3524 // re-link the regions that EIfEO can erase.
3525 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3527 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3528 &ty::Adt(adt, substs) => {
3529 (substs, adt.adt_kind(), adt.variant_descr())
3531 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3534 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3535 (field.ident.modern(), (i, field))
3536 ).collect::<FxHashMap<_, _>>();
3538 let mut seen_fields = FxHashMap::default();
3540 let mut error_happened = false;
3542 // Typecheck each field.
3543 for field in ast_fields {
3544 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3545 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3546 seen_fields.insert(ident, field.span);
3547 self.write_field_index(field.id, i);
3549 // we don't look at stability attributes on
3550 // struct-like enums (yet...), but it's definitely not
3551 // a bug to have construct one.
3552 if adt_kind != ty::AdtKind::Enum {
3553 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3556 self.field_ty(field.span, v_field, substs)
3558 error_happened = true;
3559 if let Some(prev_span) = seen_fields.get(&ident) {
3560 let mut err = struct_span_err!(self.tcx.sess,
3563 "field `{}` specified more than once",
3566 err.span_label(field.ident.span, "used more than once");
3567 err.span_label(*prev_span, format!("first use of `{}`", ident));
3571 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3577 // Make sure to give a type to the field even if there's
3578 // an error, so we can continue typechecking
3579 self.check_expr_coercable_to_type(&field.expr, field_type);
3582 // Make sure the programmer specified correct number of fields.
3583 if kind_name == "union" {
3584 if ast_fields.len() != 1 {
3585 tcx.sess.span_err(span, "union expressions should have exactly one field");
3587 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3588 let len = remaining_fields.len();
3590 let mut displayable_field_names = remaining_fields
3592 .map(|ident| ident.as_str())
3593 .collect::<Vec<_>>();
3595 displayable_field_names.sort();
3597 let truncated_fields_error = if len <= 3 {
3600 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3603 let remaining_fields_names = displayable_field_names.iter().take(3)
3604 .map(|n| format!("`{}`", n))
3605 .collect::<Vec<_>>()
3608 struct_span_err!(tcx.sess, span, E0063,
3609 "missing field{} {}{} in initializer of `{}`",
3610 if remaining_fields.len() == 1 { "" } else { "s" },
3611 remaining_fields_names,
3612 truncated_fields_error,
3614 .span_label(span, format!("missing {}{}",
3615 remaining_fields_names,
3616 truncated_fields_error))
3622 fn check_struct_fields_on_error(&self,
3623 fields: &'gcx [hir::Field],
3624 base_expr: &'gcx Option<P<hir::Expr>>) {
3625 for field in fields {
3626 self.check_expr(&field.expr);
3628 if let Some(ref base) = *base_expr {
3629 self.check_expr(&base);
3633 pub fn check_struct_path(&self,
3635 node_id: ast::NodeId)
3636 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3637 let path_span = match *qpath {
3638 hir::QPath::Resolved(_, ref path) => path.span,
3639 hir::QPath::TypeRelative(ref qself, _) => qself.span
3641 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3642 let variant = match def {
3644 self.set_tainted_by_errors();
3647 Def::Variant(..) => {
3649 ty::Adt(adt, substs) => {
3650 Some((adt.variant_of_def(def), adt.did, substs))
3652 _ => bug!("unexpected type: {:?}", ty.sty)
3655 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3656 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3658 ty::Adt(adt, substs) if !adt.is_enum() => {
3659 Some((adt.non_enum_variant(), adt.did, substs))
3664 _ => bug!("unexpected definition: {:?}", def)
3667 if let Some((variant, did, substs)) = variant {
3668 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3669 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
3670 self.write_user_substs_from_substs(hir_id, substs, None);
3672 // Check bounds on type arguments used in the path.
3673 let bounds = self.instantiate_bounds(path_span, did, substs);
3674 let cause = traits::ObligationCause::new(path_span, self.body_id,
3675 traits::ItemObligation(did));
3676 self.add_obligations_for_parameters(cause, &bounds);
3680 struct_span_err!(self.tcx.sess, path_span, E0071,
3681 "expected struct, variant or union type, found {}",
3682 ty.sort_string(self.tcx))
3683 .span_label(path_span, "not a struct")
3689 fn check_expr_struct(&self,
3691 expected: Expectation<'tcx>,
3693 fields: &'gcx [hir::Field],
3694 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3696 // Find the relevant variant
3697 let (variant, adt_ty) =
3698 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3701 self.check_struct_fields_on_error(fields, base_expr);
3702 return self.tcx.types.err;
3705 let path_span = match *qpath {
3706 hir::QPath::Resolved(_, ref path) => path.span,
3707 hir::QPath::TypeRelative(ref qself, _) => qself.span
3710 // Prohibit struct expressions when non exhaustive flag is set.
3711 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3712 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3713 span_err!(self.tcx.sess, expr.span, E0639,
3714 "cannot create non-exhaustive {} using struct expression",
3715 adt.variant_descr());
3718 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3719 variant, fields, base_expr.is_none());
3720 if let &Some(ref base_expr) = base_expr {
3721 // If check_expr_struct_fields hit an error, do not attempt to populate
3722 // the fields with the base_expr. This could cause us to hit errors later
3723 // when certain fields are assumed to exist that in fact do not.
3724 if !error_happened {
3725 self.check_expr_has_type_or_error(base_expr, adt_ty);
3727 ty::Adt(adt, substs) if adt.is_struct() => {
3728 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3729 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3734 .fru_field_types_mut()
3735 .insert(expr.hir_id, fru_field_types);
3738 span_err!(self.tcx.sess, base_expr.span, E0436,
3739 "functional record update syntax requires a struct");
3744 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3750 /// If an expression has any sub-expressions that result in a type error,
3751 /// inspecting that expression's type with `ty.references_error()` will return
3752 /// true. Likewise, if an expression is known to diverge, inspecting its
3753 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3754 /// strict, _|_ can appear in the type of an expression that does not,
3755 /// itself, diverge: for example, fn() -> _|_.)
3756 /// Note that inspecting a type's structure *directly* may expose the fact
3757 /// that there are actually multiple representations for `Error`, so avoid
3758 /// that when err needs to be handled differently.
3759 fn check_expr_with_expectation_and_needs(&self,
3760 expr: &'gcx hir::Expr,
3761 expected: Expectation<'tcx>,
3762 needs: Needs) -> Ty<'tcx> {
3763 debug!(">> typechecking: expr={:?} expected={:?}",
3766 // Warn for expressions after diverging siblings.
3767 self.warn_if_unreachable(expr.id, expr.span, "expression");
3769 // Hide the outer diverging and has_errors flags.
3770 let old_diverges = self.diverges.get();
3771 let old_has_errors = self.has_errors.get();
3772 self.diverges.set(Diverges::Maybe);
3773 self.has_errors.set(false);
3775 let ty = self.check_expr_kind(expr, expected, needs);
3777 // Warn for non-block expressions with diverging children.
3779 hir::ExprKind::Block(..) |
3780 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3781 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3783 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3786 // Any expression that produces a value of type `!` must have diverged
3788 self.diverges.set(self.diverges.get() | Diverges::Always);
3791 // Record the type, which applies it effects.
3792 // We need to do this after the warning above, so that
3793 // we don't warn for the diverging expression itself.
3794 self.write_ty(expr.hir_id, ty);
3796 // Combine the diverging and has_error flags.
3797 self.diverges.set(self.diverges.get() | old_diverges);
3798 self.has_errors.set(self.has_errors.get() | old_has_errors);
3800 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3801 debug!("... {:?}, expected is {:?}", ty, expected);
3808 expr: &'gcx hir::Expr,
3809 expected: Expectation<'tcx>,
3813 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3822 hir::ExprKind::Box(ref subexpr) => {
3823 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3825 ty::Adt(def, _) if def.is_box()
3826 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3830 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3831 tcx.mk_box(referent_ty)
3834 hir::ExprKind::Lit(ref lit) => {
3835 self.check_lit(&lit, expected)
3837 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3838 self.check_binop(expr, op, lhs, rhs)
3840 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3841 self.check_binop_assign(expr, op, lhs, rhs)
3843 hir::ExprKind::Unary(unop, ref oprnd) => {
3844 let expected_inner = match unop {
3845 hir::UnNot | hir::UnNeg => {
3852 let needs = match unop {
3853 hir::UnDeref => needs,
3856 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3860 if !oprnd_t.references_error() {
3861 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3864 if let Some(mt) = oprnd_t.builtin_deref(true) {
3866 } else if let Some(ok) = self.try_overloaded_deref(
3867 expr.span, oprnd_t, needs) {
3868 let method = self.register_infer_ok_obligations(ok);
3869 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3870 let mutbl = match mutbl {
3871 hir::MutImmutable => AutoBorrowMutability::Immutable,
3872 hir::MutMutable => AutoBorrowMutability::Mutable {
3873 // (It shouldn't actually matter for unary ops whether
3874 // we enable two-phase borrows or not, since a unary
3875 // op has no additional operands.)
3876 allow_two_phase_borrow: AllowTwoPhase::No,
3879 self.apply_adjustments(oprnd, vec![Adjustment {
3880 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3881 target: method.sig.inputs()[0]
3884 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3885 self.write_method_call(expr.hir_id, method);
3887 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3888 "type `{}` cannot be dereferenced",
3890 oprnd_t = tcx.types.err;
3894 let result = self.check_user_unop(expr, oprnd_t, unop);
3895 // If it's builtin, we can reuse the type, this helps inference.
3896 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3901 let result = self.check_user_unop(expr, oprnd_t, unop);
3902 // If it's builtin, we can reuse the type, this helps inference.
3903 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3911 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3912 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3914 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3915 if oprnd.is_place_expr() {
3916 // Places may legitimately have unsized types.
3917 // For example, dereferences of a fat pointer and
3918 // the last field of a struct can be unsized.
3921 Expectation::rvalue_hint(self, ty)
3927 let needs = Needs::maybe_mut_place(mutbl);
3928 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3930 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3931 if tm.ty.references_error() {
3934 // Note: at this point, we cannot say what the best lifetime
3935 // is to use for resulting pointer. We want to use the
3936 // shortest lifetime possible so as to avoid spurious borrowck
3937 // errors. Moreover, the longest lifetime will depend on the
3938 // precise details of the value whose address is being taken
3939 // (and how long it is valid), which we don't know yet until type
3940 // inference is complete.
3942 // Therefore, here we simply generate a region variable. The
3943 // region inferencer will then select the ultimate value.
3944 // Finally, borrowck is charged with guaranteeing that the
3945 // value whose address was taken can actually be made to live
3946 // as long as it needs to live.
3947 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3948 tcx.mk_ref(region, tm)
3951 hir::ExprKind::Path(ref qpath) => {
3952 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3953 let ty = if def != Def::Err {
3954 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
3956 self.set_tainted_by_errors();
3960 if let ty::FnDef(..) = ty.sty {
3961 let fn_sig = ty.fn_sig(tcx);
3962 if !tcx.features().unsized_locals {
3963 // We want to remove some Sized bounds from std functions,
3964 // but don't want to expose the removal to stable Rust.
3965 // i.e. we don't want to allow
3971 // to work in stable even if the Sized bound on `drop` is relaxed.
3972 for i in 0..fn_sig.inputs().skip_binder().len() {
3973 // We just want to check sizedness, so instead of introducing
3974 // placeholder lifetimes with probing, we just replace higher lifetimes
3976 let input = self.replace_bound_vars_with_fresh_vars(
3978 infer::LateBoundRegionConversionTime::FnCall,
3979 &fn_sig.input(i)).0;
3980 self.require_type_is_sized_deferred(input, expr.span,
3981 traits::SizedArgumentType);
3984 // Here we want to prevent struct constructors from returning unsized types.
3985 // There were two cases this happened: fn pointer coercion in stable
3986 // and usual function call in presense of unsized_locals.
3987 // Also, as we just want to check sizedness, instead of introducing
3988 // placeholder lifetimes with probing, we just replace higher lifetimes
3990 let output = self.replace_bound_vars_with_fresh_vars(
3992 infer::LateBoundRegionConversionTime::FnCall,
3993 &fn_sig.output()).0;
3994 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
3997 // We always require that the type provided as the value for
3998 // a type parameter outlives the moment of instantiation.
3999 let substs = self.tables.borrow().node_substs(expr.hir_id);
4000 self.add_wf_bounds(substs, expr);
4004 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4005 for expr in outputs.iter().chain(inputs.iter()) {
4006 self.check_expr(expr);
4010 hir::ExprKind::Break(destination, ref expr_opt) => {
4011 if let Ok(target_id) = destination.target_id {
4013 if let Some(ref e) = *expr_opt {
4014 // If this is a break with a value, we need to type-check
4015 // the expression. Get an expected type from the loop context.
4016 let opt_coerce_to = {
4017 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4018 enclosing_breakables.find_breakable(target_id)
4021 .map(|coerce| coerce.expected_ty())
4024 // If the loop context is not a `loop { }`, then break with
4025 // a value is illegal, and `opt_coerce_to` will be `None`.
4026 // Just set expectation to error in that case.
4027 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4029 // Recurse without `enclosing_breakables` borrowed.
4030 e_ty = self.check_expr_with_hint(e, coerce_to);
4031 cause = self.misc(e.span);
4033 // Otherwise, this is a break *without* a value. That's
4034 // always legal, and is equivalent to `break ()`.
4035 e_ty = tcx.mk_unit();
4036 cause = self.misc(expr.span);
4039 // Now that we have type-checked `expr_opt`, borrow
4040 // the `enclosing_loops` field and let's coerce the
4041 // type of `expr_opt` into what is expected.
4042 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4043 let ctxt = enclosing_breakables.find_breakable(target_id);
4044 if let Some(ref mut coerce) = ctxt.coerce {
4045 if let Some(ref e) = *expr_opt {
4046 coerce.coerce(self, &cause, e, e_ty);
4048 assert!(e_ty.is_unit());
4049 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4052 // If `ctxt.coerce` is `None`, we can just ignore
4053 // the type of the expresison. This is because
4054 // either this was a break *without* a value, in
4055 // which case it is always a legal type (`()`), or
4056 // else an error would have been flagged by the
4057 // `loops` pass for using break with an expression
4058 // where you are not supposed to.
4059 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4062 ctxt.may_break = true;
4064 // the type of a `break` is always `!`, since it diverges
4067 // Otherwise, we failed to find the enclosing loop;
4068 // this can only happen if the `break` was not
4069 // inside a loop at all, which is caught by the
4070 // loop-checking pass.
4071 if self.tcx.sess.err_count() == 0 {
4072 self.tcx.sess.delay_span_bug(expr.span,
4073 "break was outside loop, but no error was emitted");
4076 // We still need to assign a type to the inner expression to
4077 // prevent the ICE in #43162.
4078 if let Some(ref e) = *expr_opt {
4079 self.check_expr_with_hint(e, tcx.types.err);
4081 // ... except when we try to 'break rust;'.
4082 // ICE this expression in particular (see #43162).
4083 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
4084 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4085 fatally_break_rust(self.tcx.sess);
4089 // There was an error, make typecheck fail
4094 hir::ExprKind::Continue(destination) => {
4095 if destination.target_id.is_ok() {
4098 // There was an error, make typecheck fail
4102 hir::ExprKind::Ret(ref expr_opt) => {
4103 if self.ret_coercion.is_none() {
4104 struct_span_err!(self.tcx.sess, expr.span, E0572,
4105 "return statement outside of function body").emit();
4106 } else if let Some(ref e) = *expr_opt {
4107 self.check_return_expr(e);
4109 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4110 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4111 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4115 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4116 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4118 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4121 ExpectIfCondition => {
4122 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4123 expected error elsehwere");
4126 // Only check this if not in an `if` condition, as the
4127 // mistyped comparison help is more appropriate.
4128 if !lhs.is_place_expr() {
4129 struct_span_err!(self.tcx.sess, expr.span, E0070,
4130 "invalid left-hand side expression")
4131 .span_label(expr.span, "left-hand of expression not valid")
4137 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4139 if lhs_ty.references_error() || rhs_ty.references_error() {
4145 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4146 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4147 expr.span, expected)
4149 hir::ExprKind::While(ref cond, ref body, _) => {
4150 let ctxt = BreakableCtxt {
4151 // cannot use break with a value from a while loop
4153 may_break: false, // Will get updated if/when we find a `break`.
4156 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4157 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4158 let cond_diverging = self.diverges.get();
4159 self.check_block_no_value(&body);
4161 // We may never reach the body so it diverging means nothing.
4162 self.diverges.set(cond_diverging);
4166 // No way to know whether it's diverging because
4167 // of a `break` or an outer `break` or `return`.
4168 self.diverges.set(Diverges::Maybe);
4173 hir::ExprKind::Loop(ref body, _, source) => {
4174 let coerce = match source {
4175 // you can only use break with a value from a normal `loop { }`
4176 hir::LoopSource::Loop => {
4177 let coerce_to = expected.coercion_target_type(self, body.span);
4178 Some(CoerceMany::new(coerce_to))
4181 hir::LoopSource::WhileLet |
4182 hir::LoopSource::ForLoop => {
4187 let ctxt = BreakableCtxt {
4189 may_break: false, // Will get updated if/when we find a `break`.
4192 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4193 self.check_block_no_value(&body);
4197 // No way to know whether it's diverging because
4198 // of a `break` or an outer `break` or `return`.
4199 self.diverges.set(Diverges::Maybe);
4202 // If we permit break with a value, then result type is
4203 // the LUB of the breaks (possibly ! if none); else, it
4204 // is nil. This makes sense because infinite loops
4205 // (which would have type !) are only possible iff we
4206 // permit break with a value [1].
4207 if ctxt.coerce.is_none() && !ctxt.may_break {
4209 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4211 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4213 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4214 self.check_match(expr, &discrim, arms, expected, match_src)
4216 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4217 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4219 hir::ExprKind::Block(ref body, _) => {
4220 self.check_block_with_expected(&body, expected)
4222 hir::ExprKind::Call(ref callee, ref args) => {
4223 self.check_call(expr, &callee, args, expected)
4225 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4226 self.check_method_call(expr, segment, span, args, expected, needs)
4228 hir::ExprKind::Cast(ref e, ref t) => {
4229 // Find the type of `e`. Supply hints based on the type we are casting to,
4231 let t_cast = self.to_ty_saving_user_provided_ty(t);
4232 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4233 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4234 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4236 // Eagerly check for some obvious errors.
4237 if t_expr.references_error() || t_cast.references_error() {
4240 // Defer other checks until we're done type checking.
4241 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4242 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4244 deferred_cast_checks.push(cast_check);
4247 Err(ErrorReported) => {
4253 hir::ExprKind::Type(ref e, ref t) => {
4254 let ty = self.to_ty_saving_user_provided_ty(&t);
4255 self.check_expr_eq_type(&e, ty);
4258 hir::ExprKind::Array(ref args) => {
4259 let uty = expected.to_option(self).and_then(|uty| {
4261 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4266 let element_ty = if !args.is_empty() {
4267 let coerce_to = uty.unwrap_or_else(
4268 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4269 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4270 assert_eq!(self.diverges.get(), Diverges::Maybe);
4272 let e_ty = self.check_expr_with_hint(e, coerce_to);
4273 let cause = self.misc(e.span);
4274 coerce.coerce(self, &cause, e, e_ty);
4276 coerce.complete(self)
4278 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4280 tcx.mk_array(element_ty, args.len() as u64)
4282 hir::ExprKind::Repeat(ref element, ref count) => {
4283 let count_def_id = tcx.hir.local_def_id(count.id);
4284 let param_env = ty::ParamEnv::empty();
4285 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4286 let instance = ty::Instance::resolve(
4292 let global_id = GlobalId {
4296 let count = tcx.const_eval(param_env.and(global_id));
4298 let uty = match expected {
4299 ExpectHasType(uty) => {
4301 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4308 let (element_ty, t) = match uty {
4310 self.check_expr_coercable_to_type(&element, uty);
4314 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4315 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4320 if let Ok(count) = count {
4321 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4323 // For [foo, ..n] where n > 1, `foo` must have
4325 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4326 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4330 if element_ty.references_error() {
4332 } else if let Ok(count) = count {
4333 tcx.mk_ty(ty::Array(t, count))
4338 hir::ExprKind::Tup(ref elts) => {
4339 let flds = expected.only_has_type(self).and_then(|ty| {
4340 let ty = self.resolve_type_vars_with_obligations(ty);
4342 ty::Tuple(ref flds) => Some(&flds[..]),
4347 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4348 let t = match flds {
4349 Some(ref fs) if i < fs.len() => {
4351 self.check_expr_coercable_to_type(&e, ety);
4355 self.check_expr_with_expectation(&e, NoExpectation)
4360 let tuple = tcx.mk_tup(elt_ts_iter);
4361 if tuple.references_error() {
4364 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4368 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4369 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4371 hir::ExprKind::Field(ref base, field) => {
4372 self.check_field(expr, needs, &base, field)
4374 hir::ExprKind::Index(ref base, ref idx) => {
4375 let base_t = self.check_expr_with_needs(&base, needs);
4376 let idx_t = self.check_expr(&idx);
4378 if base_t.references_error() {
4380 } else if idx_t.references_error() {
4383 let base_t = self.structurally_resolved_type(base.span, base_t);
4384 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4385 Some((index_ty, element_ty)) => {
4386 // two-phase not needed because index_ty is never mutable
4387 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4392 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4393 "cannot index into a value of type `{}`",
4395 // Try to give some advice about indexing tuples.
4396 if let ty::Tuple(..) = base_t.sty {
4397 let mut needs_note = true;
4398 // If the index is an integer, we can show the actual
4399 // fixed expression:
4400 if let hir::ExprKind::Lit(ref lit) = idx.node {
4401 if let ast::LitKind::Int(i,
4402 ast::LitIntType::Unsuffixed) = lit.node {
4403 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4404 if let Ok(snip) = snip {
4405 err.span_suggestion_with_applicability(
4407 "to access tuple elements, use",
4408 format!("{}.{}", snip, i),
4409 Applicability::MachineApplicable);
4415 err.help("to access tuple elements, use tuple indexing \
4416 syntax (e.g. `tuple.0`)");
4425 hir::ExprKind::Yield(ref value) => {
4426 match self.yield_ty {
4428 self.check_expr_coercable_to_type(&value, ty);
4431 struct_span_err!(self.tcx.sess, expr.span, E0627,
4432 "yield statement outside of generator literal").emit();
4440 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4441 // The newly resolved definition is written into `type_dependent_defs`.
4442 fn finish_resolving_struct_path(&self,
4445 node_id: ast::NodeId)
4449 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4450 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4451 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4454 hir::QPath::TypeRelative(ref qself, ref segment) => {
4455 let ty = self.to_ty(qself);
4457 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4462 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4465 // Write back the new resolution.
4466 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4467 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4474 // Resolve associated value path into a base type and associated constant or method definition.
4475 // The newly resolved definition is written into `type_dependent_defs`.
4476 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4477 qpath: &'b hir::QPath,
4478 node_id: ast::NodeId,
4480 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4482 let (ty, item_segment) = match *qpath {
4483 hir::QPath::Resolved(ref opt_qself, ref path) => {
4485 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4486 &path.segments[..]);
4488 hir::QPath::TypeRelative(ref qself, ref segment) => {
4489 (self.to_ty(qself), segment)
4492 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4493 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4494 // Return directly on cache hit. This is useful to avoid doubly reporting
4495 // errors with default match binding modes. See #44614.
4496 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4498 let item_name = item_segment.ident;
4499 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4502 let def = match error {
4503 method::MethodError::PrivateMatch(def, _) => def,
4506 if item_name.name != keywords::Invalid.name() {
4507 self.report_method_error(span, ty, item_name, None, error, None);
4513 // Write back the new resolution.
4514 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4515 (def, Some(ty), slice::from_ref(&**item_segment))
4518 pub fn check_decl_initializer(&self,
4519 local: &'gcx hir::Local,
4520 init: &'gcx hir::Expr) -> Ty<'tcx>
4522 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4523 // for #42640 (default match binding modes).
4526 let ref_bindings = local.pat.contains_explicit_ref_binding();
4528 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4529 if let Some(m) = ref_bindings {
4530 // Somewhat subtle: if we have a `ref` binding in the pattern,
4531 // we want to avoid introducing coercions for the RHS. This is
4532 // both because it helps preserve sanity and, in the case of
4533 // ref mut, for soundness (issue #23116). In particular, in
4534 // the latter case, we need to be clear that the type of the
4535 // referent for the reference that results is *equal to* the
4536 // type of the place it is referencing, and not some
4537 // supertype thereof.
4538 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4539 self.demand_eqtype(init.span, local_ty, init_ty);
4542 self.check_expr_coercable_to_type(init, local_ty)
4546 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4547 let t = self.local_ty(local.span, local.id).decl_ty;
4548 self.write_ty(local.hir_id, t);
4550 if let Some(ref init) = local.init {
4551 let init_ty = self.check_decl_initializer(local, &init);
4552 if init_ty.references_error() {
4553 self.write_ty(local.hir_id, init_ty);
4557 self.check_pat_walk(&local.pat, t,
4558 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4560 let pat_ty = self.node_ty(local.pat.hir_id);
4561 if pat_ty.references_error() {
4562 self.write_ty(local.hir_id, pat_ty);
4566 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4567 // Don't do all the complex logic below for DeclItem.
4569 hir::StmtKind::Decl(ref decl, _) => {
4570 if let hir::DeclKind::Item(_) = decl.node {
4574 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4577 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4579 // Hide the outer diverging and has_errors flags.
4580 let old_diverges = self.diverges.get();
4581 let old_has_errors = self.has_errors.get();
4582 self.diverges.set(Diverges::Maybe);
4583 self.has_errors.set(false);
4586 hir::StmtKind::Decl(ref decl, _) => {
4588 hir::DeclKind::Local(ref l) => {
4589 self.check_decl_local(&l);
4591 hir::DeclKind::Item(_) => {/* ignore for now */}
4594 hir::StmtKind::Expr(ref expr, _) => {
4595 // Check with expected type of ()
4596 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4598 hir::StmtKind::Semi(ref expr, _) => {
4599 self.check_expr(&expr);
4603 // Combine the diverging and has_error flags.
4604 self.diverges.set(self.diverges.get() | old_diverges);
4605 self.has_errors.set(self.has_errors.get() | old_has_errors);
4608 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4609 let unit = self.tcx.mk_unit();
4610 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4612 // if the block produces a `!` value, that can always be
4613 // (effectively) coerced to unit.
4615 self.demand_suptype(blk.span, unit, ty);
4619 fn check_block_with_expected(&self,
4620 blk: &'gcx hir::Block,
4621 expected: Expectation<'tcx>) -> Ty<'tcx> {
4623 let mut fcx_ps = self.ps.borrow_mut();
4624 let unsafety_state = fcx_ps.recurse(blk);
4625 replace(&mut *fcx_ps, unsafety_state)
4628 // In some cases, blocks have just one exit, but other blocks
4629 // can be targeted by multiple breaks. This can happen both
4630 // with labeled blocks as well as when we desugar
4631 // a `try { ... }` expression.
4635 // 'a: { if true { break 'a Err(()); } Ok(()) }
4637 // Here we would wind up with two coercions, one from
4638 // `Err(())` and the other from the tail expression
4639 // `Ok(())`. If the tail expression is omitted, that's a
4640 // "forced unit" -- unless the block diverges, in which
4641 // case we can ignore the tail expression (e.g., `'a: {
4642 // break 'a 22; }` would not force the type of the block
4644 let tail_expr = blk.expr.as_ref();
4645 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4646 let coerce = if blk.targeted_by_break {
4647 CoerceMany::new(coerce_to_ty)
4649 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4650 Some(e) => slice::from_ref(e),
4653 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4656 let prev_diverges = self.diverges.get();
4657 let ctxt = BreakableCtxt {
4658 coerce: Some(coerce),
4662 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4663 for s in &blk.stmts {
4667 // check the tail expression **without** holding the
4668 // `enclosing_breakables` lock below.
4669 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4671 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4672 let ctxt = enclosing_breakables.find_breakable(blk.id);
4673 let coerce = ctxt.coerce.as_mut().unwrap();
4674 if let Some(tail_expr_ty) = tail_expr_ty {
4675 let tail_expr = tail_expr.unwrap();
4676 let cause = self.cause(tail_expr.span,
4677 ObligationCauseCode::BlockTailExpression(blk.id));
4683 // Subtle: if there is no explicit tail expression,
4684 // that is typically equivalent to a tail expression
4685 // of `()` -- except if the block diverges. In that
4686 // case, there is no value supplied from the tail
4687 // expression (assuming there are no other breaks,
4688 // this implies that the type of the block will be
4691 // #41425 -- label the implicit `()` as being the
4692 // "found type" here, rather than the "expected type".
4694 // #44579 -- if the block was recovered during parsing,
4695 // the type would be nonsensical and it is not worth it
4696 // to perform the type check, so we avoid generating the
4697 // diagnostic output.
4698 if !self.diverges.get().always() && !blk.recovered {
4699 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4700 if let Some(expected_ty) = expected.only_has_type(self) {
4701 self.consider_hint_about_removing_semicolon(blk,
4711 // If we can break from the block, then the block's exit is always reachable
4712 // (... as long as the entry is reachable) - regardless of the tail of the block.
4713 self.diverges.set(prev_diverges);
4716 let mut ty = ctxt.coerce.unwrap().complete(self);
4718 if self.has_errors.get() || ty.references_error() {
4719 ty = self.tcx.types.err
4722 self.write_ty(blk.hir_id, ty);
4724 *self.ps.borrow_mut() = prev;
4728 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4729 /// suggestion can be made, `None` otherwise.
4730 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4731 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4732 // `while` before reaching it, as block tail returns are not available in them.
4733 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4734 let parent = self.tcx.hir.get(fn_id);
4736 if let Node::Item(&hir::Item {
4737 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4739 decl.clone().and_then(|decl| {
4740 // This is less than ideal, it will not suggest a return type span on any
4741 // method called `main`, regardless of whether it is actually the entry point,
4742 // but it will still present it as the reason for the expected type.
4743 Some((decl, name != Symbol::intern("main")))
4745 } else if let Node::TraitItem(&hir::TraitItem {
4746 node: hir::TraitItemKind::Method(hir::MethodSig {
4750 decl.clone().and_then(|decl| {
4753 } else if let Node::ImplItem(&hir::ImplItem {
4754 node: hir::ImplItemKind::Method(hir::MethodSig {
4758 decl.clone().and_then(|decl| {
4769 /// On implicit return expressions with mismatched types, provide the following suggestions:
4771 /// - Point out the method's return type as the reason for the expected type
4772 /// - Possible missing semicolon
4773 /// - Possible missing return type if the return type is the default, and not `fn main()`
4774 pub fn suggest_mismatched_types_on_tail(&self,
4775 err: &mut DiagnosticBuilder<'tcx>,
4776 expression: &'gcx hir::Expr,
4780 blk_id: ast::NodeId) {
4781 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4782 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4783 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4785 self.suggest_ref_or_into(err, expression, expected, found);
4788 pub fn suggest_ref_or_into(
4790 err: &mut DiagnosticBuilder<'tcx>,
4795 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4796 err.span_suggestion_with_applicability(
4800 Applicability::MachineApplicable,
4802 } else if !self.check_for_cast(err, expr, found, expected) {
4803 let methods = self.get_conversion_methods(expr.span, expected, found);
4804 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4805 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4806 .filter_map(|(receiver, method)| {
4807 let method_call = format!(".{}()", method.ident);
4808 if receiver.ends_with(&method_call) {
4809 None // do not suggest code that is already there (#53348)
4811 let method_call_list = [".to_vec()", ".to_string()"];
4812 if receiver.ends_with(".clone()")
4813 && method_call_list.contains(&method_call.as_str()) {
4814 let max_len = receiver.rfind(".").unwrap();
4815 Some(format!("{}{}", &receiver[..max_len], method_call))
4818 Some(format!("{}{}", receiver, method_call))
4822 if suggestions.peek().is_some() {
4823 err.span_suggestions_with_applicability(
4825 "try using a conversion method",
4827 Applicability::MaybeIncorrect,
4834 /// A common error is to forget to add a semicolon at the end of a block:
4838 /// bar_that_returns_u32()
4842 /// This routine checks if the return expression in a block would make sense on its own as a
4843 /// statement and the return type has been left as default or has been specified as `()`. If so,
4844 /// it suggests adding a semicolon.
4845 fn suggest_missing_semicolon(&self,
4846 err: &mut DiagnosticBuilder<'tcx>,
4847 expression: &'gcx hir::Expr,
4850 if expected.is_unit() {
4851 // `BlockTailExpression` only relevant if the tail expr would be
4852 // useful on its own.
4853 match expression.node {
4854 hir::ExprKind::Call(..) |
4855 hir::ExprKind::MethodCall(..) |
4856 hir::ExprKind::If(..) |
4857 hir::ExprKind::While(..) |
4858 hir::ExprKind::Loop(..) |
4859 hir::ExprKind::Match(..) |
4860 hir::ExprKind::Block(..) => {
4861 let sp = self.tcx.sess.source_map().next_point(cause_span);
4862 err.span_suggestion_with_applicability(
4864 "try adding a semicolon",
4866 Applicability::MachineApplicable);
4873 /// A possible error is to forget to add a return type that is needed:
4877 /// bar_that_returns_u32()
4881 /// This routine checks if the return type is left as default, the method is not part of an
4882 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4884 fn suggest_missing_return_type(&self,
4885 err: &mut DiagnosticBuilder<'tcx>,
4886 fn_decl: &hir::FnDecl,
4889 can_suggest: bool) {
4890 // Only suggest changing the return type for methods that
4891 // haven't set a return type at all (and aren't `fn main()` or an impl).
4892 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4893 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4894 err.span_suggestion_with_applicability(
4896 "try adding a return type",
4897 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4898 Applicability::MachineApplicable);
4900 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4901 err.span_label(span, "possibly return type missing here?");
4903 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4904 // `fn main()` must return `()`, do not suggest changing return type
4905 err.span_label(span, "expected `()` because of default return type");
4907 // expectation was caused by something else, not the default return
4908 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4909 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4910 // Only point to return type if the expected type is the return type, as if they
4911 // are not, the expectation must have been caused by something else.
4912 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4914 let ty = AstConv::ast_ty_to_ty(self, ty);
4915 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4916 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4917 if ty.sty == expected.sty {
4918 err.span_label(sp, format!("expected `{}` because of return type",
4926 /// A common error is to add an extra semicolon:
4929 /// fn foo() -> usize {
4934 /// This routine checks if the final statement in a block is an
4935 /// expression with an explicit semicolon whose type is compatible
4936 /// with `expected_ty`. If so, it suggests removing the semicolon.
4937 fn consider_hint_about_removing_semicolon(&self,
4938 blk: &'gcx hir::Block,
4939 expected_ty: Ty<'tcx>,
4940 err: &mut DiagnosticBuilder) {
4941 // Be helpful when the user wrote `{... expr;}` and
4942 // taking the `;` off is enough to fix the error.
4943 let last_stmt = match blk.stmts.last() {
4947 let last_expr = match last_stmt.node {
4948 hir::StmtKind::Semi(ref e, _) => e,
4951 let last_expr_ty = self.node_ty(last_expr.hir_id);
4952 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4955 let original_span = original_sp(last_stmt.span, blk.span);
4956 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4957 err.span_suggestion_with_applicability(
4959 "consider removing this semicolon",
4961 Applicability::MachineApplicable);
4964 fn def_ids_for_path_segments(&self,
4965 segments: &[hir::PathSegment],
4968 // We need to extract the type parameters supplied by the user in
4969 // the path `path`. Due to the current setup, this is a bit of a
4970 // tricky-process; the problem is that resolve only tells us the
4971 // end-point of the path resolution, and not the intermediate steps.
4972 // Luckily, we can (at least for now) deduce the intermediate steps
4973 // just from the end-point.
4975 // There are basically four cases to consider:
4977 // 1. Reference to a constructor of enum variant or struct:
4979 // struct Foo<T>(...)
4980 // enum E<T> { Foo(...) }
4982 // In these cases, the parameters are declared in the type
4985 // 2. Reference to a fn item or a free constant:
4989 // In this case, the path will again always have the form
4990 // `a::b::foo::<T>` where only the final segment should have
4991 // type parameters. However, in this case, those parameters are
4992 // declared on a value, and hence are in the `FnSpace`.
4994 // 3. Reference to a method or an associated constant:
4996 // impl<A> SomeStruct<A> {
5000 // Here we can have a path like
5001 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
5002 // may appear in two places. The penultimate segment,
5003 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
5004 // final segment, `foo::<B>` contains parameters in fn space.
5006 // 4. Reference to a local variable
5008 // Local variables can't have any type parameters.
5010 // The first step then is to categorize the segments appropriately.
5012 assert!(!segments.is_empty());
5013 let last = segments.len() - 1;
5015 let mut path_segs = vec![];
5018 // Case 1. Reference to a struct/variant constructor.
5019 Def::StructCtor(def_id, ..) |
5020 Def::VariantCtor(def_id, ..) |
5021 Def::SelfCtor(.., def_id) => {
5022 // Everything but the final segment should have no
5023 // parameters at all.
5024 let generics = self.tcx.generics_of(def_id);
5025 // Variant and struct constructors use the
5026 // generics of their parent type definition.
5027 let generics_def_id = generics.parent.unwrap_or(def_id);
5028 path_segs.push(PathSeg(generics_def_id, last));
5031 // Case 2. Reference to a top-level value.
5033 Def::Const(def_id) |
5034 Def::Static(def_id, _) => {
5035 path_segs.push(PathSeg(def_id, last));
5038 // Case 3. Reference to a method or associated const.
5039 Def::Method(def_id) |
5040 Def::AssociatedConst(def_id) => {
5041 if segments.len() >= 2 {
5042 let generics = self.tcx.generics_of(def_id);
5043 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
5045 path_segs.push(PathSeg(def_id, last));
5048 // Case 4. Local variable, no generics.
5049 Def::Local(..) | Def::Upvar(..) => {}
5051 _ => bug!("unexpected definition: {:?}", def),
5054 debug!("path_segs = {:?}", path_segs);
5059 // Instantiates the given path, which must refer to an item with the given
5060 // number of type parameters and type.
5061 pub fn instantiate_value_path(&self,
5062 segments: &[hir::PathSegment],
5063 self_ty: Option<Ty<'tcx>>,
5066 node_id: ast::NodeId)
5067 -> (Ty<'tcx>, Def) {
5069 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5076 let path_segs = self.def_ids_for_path_segments(segments, def);
5078 let mut user_self_ty = None;
5080 Def::Method(def_id) |
5081 Def::AssociatedConst(def_id) => {
5082 let container = self.tcx.associated_item(def_id).container;
5084 ty::TraitContainer(trait_did) => {
5085 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5087 ty::ImplContainer(impl_def_id) => {
5088 if segments.len() == 1 {
5089 // `<T>::assoc` will end up here, and so
5090 // can `T::assoc`. It this came from an
5091 // inherent impl, we need to record the
5092 // `T` for posterity (see `UserSelfTy` for
5094 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5095 user_self_ty = Some(UserSelfTy {
5106 // Now that we have categorized what space the parameters for each
5107 // segment belong to, let's sort out the parameters that the user
5108 // provided (if any) into their appropriate spaces. We'll also report
5109 // errors if type parameters are provided in an inappropriate place.
5111 let generic_segs = path_segs.iter().map(|PathSeg(_, index)| index)
5112 .collect::<FxHashSet<_>>();
5113 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5114 if !generic_segs.contains(&index) {
5122 Def::Local(nid) | Def::Upvar(nid, ..) => {
5123 let ty = self.local_ty(span, nid).decl_ty;
5124 let ty = self.normalize_associated_types_in(span, &ty);
5125 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
5131 // Now we have to compare the types that the user *actually*
5132 // provided against the types that were *expected*. If the user
5133 // did not provide any types, then we want to substitute inference
5134 // variables. If the user provided some types, we may still need
5135 // to add defaults. If the user provided *too many* types, that's
5138 let mut infer_args_for_err = FxHashSet::default();
5139 for &PathSeg(def_id, index) in &path_segs {
5140 let seg = &segments[index];
5141 let generics = self.tcx.generics_of(def_id);
5142 // Argument-position `impl Trait` is treated as a normal generic
5143 // parameter internally, but we don't allow users to specify the
5144 // parameter's value explicitly, so we have to do some error-
5146 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5151 false, // `is_method_call`
5153 if suppress_errors {
5154 infer_args_for_err.insert(index);
5155 self.set_tainted_by_errors(); // See issue #53251.
5159 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5160 self.tcx.generics_of(*def_id).has_self
5161 }).unwrap_or(false);
5163 let mut new_def = def;
5164 let (def_id, ty) = if let Def::SelfCtor(impl_def_id) = def {
5165 let ty = self.impl_self_ty(span, impl_def_id).ty;
5167 match ty.ty_adt_def() {
5168 Some(adt_def) if adt_def.is_struct() => {
5169 let variant = adt_def.non_enum_variant();
5170 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5171 (variant.did, self.tcx.type_of(variant.did))
5174 (impl_def_id, self.tcx.types.err)
5178 let def_id = def.def_id();
5180 // The things we are substituting into the type should not contain
5181 // escaping late-bound regions, and nor should the base type scheme.
5182 let ty = self.tcx.type_of(def_id);
5186 let substs = AstConv::create_substs_for_generic_args(
5192 // Provide the generic args, and whether types should be inferred.
5194 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5197 // If we've encountered an `impl Trait`-related error, we're just
5198 // going to infer the arguments for better error messages.
5199 if !infer_args_for_err.contains(&index) {
5200 // Check whether the user has provided generic arguments.
5201 if let Some(ref data) = segments[index].args {
5202 return (Some(data), segments[index].infer_types);
5205 return (None, segments[index].infer_types);
5210 // Provide substitutions for parameters for which (valid) arguments have been provided.
5212 match (¶m.kind, arg) {
5213 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5214 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5216 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5217 self.to_ty(ty).into()
5219 _ => unreachable!(),
5222 // Provide substitutions for parameters for which arguments are inferred.
5223 |substs, param, infer_types| {
5225 GenericParamDefKind::Lifetime => {
5226 self.re_infer(span, Some(param)).unwrap().into()
5228 GenericParamDefKind::Type { has_default, .. } => {
5229 if !infer_types && has_default {
5230 // If we have a default, then we it doesn't matter that we're not
5231 // inferring the type arguments: we provide the default where any
5233 let default = self.tcx.type_of(param.def_id);
5236 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5239 // If no type arguments were provided, we have to infer them.
5240 // This case also occurs as a result of some malformed input, e.g.
5241 // a lifetime argument being given instead of a type parameter.
5242 // Using inference instead of `Error` gives better error messages.
5243 self.var_for_def(span, param)
5249 assert!(!substs.has_escaping_bound_vars());
5250 assert!(!ty.has_escaping_bound_vars());
5252 // Write the "user substs" down first thing for later.
5253 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
5254 self.write_user_substs_from_substs(hir_id, substs, user_self_ty);
5256 // Add all the obligations that are required, substituting and
5257 // normalized appropriately.
5258 let bounds = self.instantiate_bounds(span, def_id, &substs);
5259 self.add_obligations_for_parameters(
5260 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5263 // Substitute the values for the type parameters into the type of
5264 // the referenced item.
5265 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5267 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5268 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5269 // is inherent, there is no `Self` parameter, instead, the impl needs
5270 // type parameters, which we can infer by unifying the provided `Self`
5271 // with the substituted impl type.
5272 let ty = self.tcx.type_of(impl_def_id);
5274 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5275 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5276 Ok(ok) => self.register_infer_ok_obligations(ok),
5279 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5286 self.check_rustc_args_require_const(def_id, node_id, span);
5288 debug!("instantiate_value_path: type of {:?} is {:?}",
5291 self.write_substs(hir_id, substs);
5293 (ty_substituted, new_def)
5296 fn check_rustc_args_require_const(&self,
5298 node_id: ast::NodeId,
5300 // We're only interested in functions tagged with
5301 // #[rustc_args_required_const], so ignore anything that's not.
5302 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5306 // If our calling expression is indeed the function itself, we're good!
5307 // If not, generate an error that this can only be called directly.
5308 if let Node::Expr(expr) = self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5309 if let hir::ExprKind::Call(ref callee, ..) = expr.node {
5310 if callee.id == node_id {
5316 self.tcx.sess.span_err(span, "this function can only be invoked \
5317 directly, not through a function pointer");
5320 // Resolves `typ` by a single level if `typ` is a type variable.
5321 // If no resolution is possible, then an error is reported.
5322 // Numeric inference variables may be left unresolved.
5323 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5324 let ty = self.resolve_type_vars_with_obligations(ty);
5325 if !ty.is_ty_var() {
5328 if !self.is_tainted_by_errors() {
5329 self.need_type_info_err((**self).body_id, sp, ty)
5330 .note("type must be known at this point")
5333 self.demand_suptype(sp, self.tcx.types.err, ty);
5338 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5339 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5340 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5343 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5344 index = enclosing_breakables.stack.len();
5345 enclosing_breakables.by_id.insert(id, index);
5346 enclosing_breakables.stack.push(ctxt);
5350 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5351 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5352 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5353 enclosing_breakables.stack.pop().expect("missing breakable context")
5359 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5360 generics: &ty::Generics,
5362 let own_counts = generics.own_counts();
5363 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5365 if own_counts.types == 0 {
5368 // Make a vector of booleans initially false, set to true when used.
5369 let mut types_used = vec![false; own_counts.types];
5371 for leaf_ty in ty.walk() {
5372 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5373 debug!("Found use of ty param num {}", idx);
5374 types_used[idx as usize - own_counts.lifetimes] = true;
5375 } else if let ty::Error = leaf_ty.sty {
5376 // If there is already another error, do not emit
5377 // an error for not using a type Parameter.
5378 assert!(tcx.sess.err_count() > 0);
5383 let types = generics.params.iter().filter(|param| match param.kind {
5384 ty::GenericParamDefKind::Type { .. } => true,
5387 for (&used, param) in types_used.iter().zip(types) {
5389 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5390 let span = tcx.hir.span(id);
5391 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5392 .span_label(span, "unused type parameter")
5398 fn fatally_break_rust(sess: &Session) {
5399 let handler = sess.diagnostic();
5400 handler.span_bug_no_panic(
5402 "It looks like you're trying to break rust; would you like some ICE?",
5404 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5405 handler.note_without_error(
5406 "we would appreciate a joke overview: \
5407 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5409 handler.note_without_error(&format!("rustc {} running on {}",
5410 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5411 ::session::config::host_triple(),
5415 fn potentially_plural_count(count: usize, word: &str) -> String {
5416 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })