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::anon_types::AnonTypeDecl;
95 use rustc::infer::type_variable::{TypeVariableOrigin};
96 use rustc::middle::region;
97 use rustc::mir::interpret::{GlobalId};
98 use rustc::ty::subst::{UnpackedKind, Subst, Substs};
99 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
100 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
101 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
102 use rustc::ty::fold::TypeFoldable;
103 use rustc::ty::query::Providers;
104 use rustc::ty::util::{Representability, IntTypeExt, Discr};
105 use errors::{DiagnosticBuilder, DiagnosticId};
107 use require_c_abi_if_variadic;
108 use session::{CompileIncomplete, config, Session};
111 use util::common::{ErrorReported, indenter};
112 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
114 use std::cell::{Cell, RefCell, Ref, RefMut};
115 use rustc_data_structures::sync::Lrc;
116 use std::collections::hash_map::Entry;
118 use std::fmt::Display;
120 use std::mem::replace;
121 use std::ops::{self, Deref};
122 use rustc_target::spec::abi::Abi;
125 use syntax::codemap::original_sp;
126 use syntax::feature_gate::{GateIssue, emit_feature_err};
128 use syntax::symbol::{Symbol, LocalInternedString, keywords};
129 use syntax::util::lev_distance::find_best_match_for_name;
130 use syntax_pos::{self, BytePos, Span, MultiSpan};
132 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
133 use rustc::hir::itemlikevisit::ItemLikeVisitor;
134 use rustc::hir::map::Node;
135 use rustc::hir::{self, PatKind, Item_};
136 use rustc::middle::lang_items;
152 mod generator_interior;
156 /// A wrapper for InferCtxt's `in_progress_tables` field.
157 #[derive(Copy, Clone)]
158 struct MaybeInProgressTables<'a, 'tcx: 'a> {
159 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
162 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
163 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
164 match self.maybe_tables {
165 Some(tables) => tables.borrow(),
167 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
172 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
173 match self.maybe_tables {
174 Some(tables) => tables.borrow_mut(),
176 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
183 /// closures defined within the function. For example:
186 /// bar(move|| { ... })
189 /// Here, the function `foo()` and the closure passed to
190 /// `bar()` will each have their own `FnCtxt`, but they will
191 /// share the inherited fields.
192 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
193 infcx: InferCtxt<'a, 'gcx, 'tcx>,
195 tables: MaybeInProgressTables<'a, 'tcx>,
197 locals: RefCell<NodeMap<Ty<'tcx>>>,
199 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
201 // When we process a call like `c()` where `c` is a closure type,
202 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
203 // `FnOnce` closure. In that case, we defer full resolution of the
204 // call until upvar inference can kick in and make the
205 // decision. We keep these deferred resolutions grouped by the
206 // def-id of the closure, so that once we decide, we can easily go
207 // back and process them.
208 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
210 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
212 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
214 // Anonymized types found in explicit return types and their
215 // associated fresh inference variable. Writeback resolves these
216 // variables to get the concrete type, which can be used to
217 // deanonymize TyAnon, after typeck is done with all functions.
218 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
220 /// Each type parameter has an implicit region bound that
221 /// indicates it must outlive at least the function body (the user
222 /// may specify stronger requirements). This field indicates the
223 /// region of the callee. If it is `None`, then the parameter
224 /// environment is for an item or something where the "callee" is
226 implicit_region_bound: Option<ty::Region<'tcx>>,
228 body_id: Option<hir::BodyId>,
231 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
232 type Target = InferCtxt<'a, 'gcx, 'tcx>;
233 fn deref(&self) -> &Self::Target {
238 /// When type-checking an expression, we propagate downward
239 /// whatever type hint we are able in the form of an `Expectation`.
240 #[derive(Copy, Clone, Debug)]
241 pub enum Expectation<'tcx> {
242 /// We know nothing about what type this expression should have.
245 /// This expression is an `if` condition, it must resolve to `bool`.
248 /// This expression should have the type given (or some subtype)
249 ExpectHasType(Ty<'tcx>),
251 /// This expression will be cast to the `Ty`
252 ExpectCastableToType(Ty<'tcx>),
254 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
255 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
256 ExpectRvalueLikeUnsized(Ty<'tcx>),
259 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
260 // Disregard "castable to" expectations because they
261 // can lead us astray. Consider for example `if cond
262 // {22} else {c} as u8` -- if we propagate the
263 // "castable to u8" constraint to 22, it will pick the
264 // type 22u8, which is overly constrained (c might not
265 // be a u8). In effect, the problem is that the
266 // "castable to" expectation is not the tightest thing
267 // we can say, so we want to drop it in this case.
268 // The tightest thing we can say is "must unify with
269 // else branch". Note that in the case of a "has type"
270 // constraint, this limitation does not hold.
272 // If the expected type is just a type variable, then don't use
273 // an expected type. Otherwise, we might write parts of the type
274 // when checking the 'then' block which are incompatible with the
276 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
278 ExpectHasType(ety) => {
279 let ety = fcx.shallow_resolve(ety);
280 if !ety.is_ty_var() {
286 ExpectRvalueLikeUnsized(ety) => {
287 ExpectRvalueLikeUnsized(ety)
293 /// Provide an expectation for an rvalue expression given an *optional*
294 /// hint, which is not required for type safety (the resulting type might
295 /// be checked higher up, as is the case with `&expr` and `box expr`), but
296 /// is useful in determining the concrete type.
298 /// The primary use case is where the expected type is a fat pointer,
299 /// like `&[isize]`. For example, consider the following statement:
301 /// let x: &[isize] = &[1, 2, 3];
303 /// In this case, the expected type for the `&[1, 2, 3]` expression is
304 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
305 /// expectation `ExpectHasType([isize])`, that would be too strong --
306 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
307 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
308 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
309 /// which still is useful, because it informs integer literals and the like.
310 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
311 /// for examples of where this comes up,.
312 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
313 match fcx.tcx.struct_tail(ty).sty {
314 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
315 ExpectRvalueLikeUnsized(ty)
317 _ => ExpectHasType(ty)
321 // Resolves `expected` by a single level if it is a variable. If
322 // there is no expected type or resolution is not possible (e.g.,
323 // no constraints yet present), just returns `None`.
324 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
326 NoExpectation => NoExpectation,
327 ExpectIfCondition => ExpectIfCondition,
328 ExpectCastableToType(t) => {
329 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
331 ExpectHasType(t) => {
332 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
334 ExpectRvalueLikeUnsized(t) => {
335 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
340 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
341 match self.resolve(fcx) {
342 NoExpectation => None,
343 ExpectIfCondition => Some(fcx.tcx.types.bool),
344 ExpectCastableToType(ty) |
346 ExpectRvalueLikeUnsized(ty) => Some(ty),
350 /// It sometimes happens that we want to turn an expectation into
351 /// a **hard constraint** (i.e., something that must be satisfied
352 /// for the program to type-check). `only_has_type` will return
353 /// such a constraint, if it exists.
354 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
355 match self.resolve(fcx) {
356 ExpectHasType(ty) => Some(ty),
357 ExpectIfCondition => Some(fcx.tcx.types.bool),
358 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
362 /// Like `only_has_type`, but instead of returning `None` if no
363 /// hard constraint exists, creates a fresh type variable.
364 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
365 self.only_has_type(fcx)
366 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
370 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
377 fn maybe_mut_place(m: hir::Mutability) -> Self {
379 hir::MutMutable => Needs::MutPlace,
380 hir::MutImmutable => Needs::None,
385 #[derive(Copy, Clone)]
386 pub struct UnsafetyState {
387 pub def: ast::NodeId,
388 pub unsafety: hir::Unsafety,
389 pub unsafe_push_count: u32,
394 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
395 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
398 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
399 match self.unsafety {
400 // If this unsafe, then if the outer function was already marked as
401 // unsafe we shouldn't attribute the unsafe'ness to the block. This
402 // way the block can be warned about instead of ignoring this
403 // extraneous block (functions are never warned about).
404 hir::Unsafety::Unsafe if self.from_fn => *self,
407 let (unsafety, def, count) = match blk.rules {
408 hir::PushUnsafeBlock(..) =>
409 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
410 hir::PopUnsafeBlock(..) =>
411 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
412 hir::UnsafeBlock(..) =>
413 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
415 (unsafety, self.def, self.unsafe_push_count),
419 unsafe_push_count: count,
426 #[derive(Debug, Copy, Clone)]
432 /// Tracks whether executing a node may exit normally (versus
433 /// return/break/panic, which "diverge", leaving dead code in their
434 /// wake). Tracked semi-automatically (through type variables marked
435 /// as diverging), with some manual adjustments for control-flow
436 /// primitives (approximating a CFG).
437 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
439 /// Potentially unknown, some cases converge,
440 /// others require a CFG to determine them.
443 /// Definitely known to diverge and therefore
444 /// not reach the next sibling or its parent.
447 /// Same as `Always` but with a reachability
448 /// warning already emitted
452 // Convenience impls for combinig `Diverges`.
454 impl ops::BitAnd for Diverges {
456 fn bitand(self, other: Self) -> Self {
457 cmp::min(self, other)
461 impl ops::BitOr for Diverges {
463 fn bitor(self, other: Self) -> Self {
464 cmp::max(self, other)
468 impl ops::BitAndAssign for Diverges {
469 fn bitand_assign(&mut self, other: Self) {
470 *self = *self & other;
474 impl ops::BitOrAssign for Diverges {
475 fn bitor_assign(&mut self, other: Self) {
476 *self = *self | other;
481 fn always(self) -> bool {
482 self >= Diverges::Always
486 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
489 // this is `null` for loops where break with a value is illegal,
490 // such as `while`, `for`, and `while let`
491 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
494 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
495 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
496 by_id: NodeMap<usize>,
499 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
500 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
501 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
502 bug!("could not find enclosing breakable with id {}", target_id);
508 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
509 body_id: ast::NodeId,
511 /// The parameter environment used for proving trait obligations
512 /// in this function. This can change when we descend into
513 /// closures (as they bring new things into scope), hence it is
514 /// not part of `Inherited` (as of the time of this writing,
515 /// closures do not yet change the environment, but they will
517 param_env: ty::ParamEnv<'tcx>,
519 // Number of errors that had been reported when we started
520 // checking this function. On exit, if we find that *more* errors
521 // have been reported, we will skip regionck and other work that
522 // expects the types within the function to be consistent.
523 err_count_on_creation: usize,
525 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
527 yield_ty: Option<Ty<'tcx>>,
529 ps: RefCell<UnsafetyState>,
531 /// Whether the last checked node generates a divergence (e.g.,
532 /// `return` will set this to Always). In general, when entering
533 /// an expression or other node in the tree, the initial value
534 /// indicates whether prior parts of the containing expression may
535 /// have diverged. It is then typically set to `Maybe` (and the
536 /// old value remembered) for processing the subparts of the
537 /// current expression. As each subpart is processed, they may set
538 /// the flag to `Always` etc. Finally, at the end, we take the
539 /// result and "union" it with the original value, so that when we
540 /// return the flag indicates if any subpart of the the parent
541 /// expression (up to and including this part) has diverged. So,
542 /// if you read it after evaluating a subexpression `X`, the value
543 /// you get indicates whether any subexpression that was
544 /// evaluating up to and including `X` diverged.
546 /// We currently use this flag only for diagnostic purposes:
548 /// - To warn about unreachable code: if, after processing a
549 /// sub-expression but before we have applied the effects of the
550 /// current node, we see that the flag is set to `Always`, we
551 /// can issue a warning. This corresponds to something like
552 /// `foo(return)`; we warn on the `foo()` expression. (We then
553 /// update the flag to `WarnedAlways` to suppress duplicate
554 /// reports.) Similarly, if we traverse to a fresh statement (or
555 /// tail expression) from a `Always` setting, we will issue a
556 /// warning. This corresponds to something like `{return;
557 /// foo();}` or `{return; 22}`, where we would warn on the
560 /// An expression represents dead-code if, after checking it,
561 /// the diverges flag is set to something other than `Maybe`.
562 diverges: Cell<Diverges>,
564 /// Whether any child nodes have any type errors.
565 has_errors: Cell<bool>,
567 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
569 inh: &'a Inherited<'a, 'gcx, 'tcx>,
572 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
573 type Target = Inherited<'a, 'gcx, 'tcx>;
574 fn deref(&self) -> &Self::Target {
579 /// Helper type of a temporary returned by Inherited::build(...).
580 /// Necessary because we can't write the following bound:
581 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
582 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
583 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
587 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
588 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
589 -> InheritedBuilder<'a, 'gcx, 'tcx> {
590 let hir_id_root = if def_id.is_local() {
591 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
592 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
593 DefId::local(hir_id.owner)
599 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
605 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
606 fn enter<F, R>(&'tcx mut self, f: F) -> R
607 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
609 let def_id = self.def_id;
610 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
614 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
615 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
617 let item_id = tcx.hir.as_local_node_id(def_id);
618 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
619 let implicit_region_bound = body_id.map(|body_id| {
620 let body = tcx.hir.body(body_id);
621 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
625 tables: MaybeInProgressTables {
626 maybe_tables: infcx.in_progress_tables,
629 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
630 locals: RefCell::new(NodeMap()),
631 deferred_call_resolutions: RefCell::new(DefIdMap()),
632 deferred_cast_checks: RefCell::new(Vec::new()),
633 deferred_generator_interiors: RefCell::new(Vec::new()),
634 anon_types: RefCell::new(DefIdMap()),
635 implicit_region_bound,
640 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
641 debug!("register_predicate({:?})", obligation);
642 if obligation.has_escaping_regions() {
643 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
648 .register_predicate_obligation(self, obligation);
651 fn register_predicates<I>(&self, obligations: I)
652 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
653 for obligation in obligations {
654 self.register_predicate(obligation);
658 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
659 self.register_predicates(infer_ok.obligations);
663 fn normalize_associated_types_in<T>(&self,
665 body_id: ast::NodeId,
666 param_env: ty::ParamEnv<'tcx>,
668 where T : TypeFoldable<'tcx>
670 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
671 self.register_infer_ok_obligations(ok)
675 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
677 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
678 fn visit_item(&mut self, i: &'tcx hir::Item) {
679 check_item_type(self.tcx, i);
681 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
682 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
685 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
686 tcx.sess.track_errors(|| {
687 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
688 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
692 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
693 tcx.sess.track_errors(|| {
694 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
698 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
699 tcx.typeck_item_bodies(LOCAL_CRATE)
702 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
703 -> Result<(), CompileIncomplete>
705 debug_assert!(crate_num == LOCAL_CRATE);
706 Ok(tcx.sess.track_errors(|| {
707 tcx.par_body_owners(|body_owner_def_id| {
708 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
713 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
714 wfcheck::check_item_well_formed(tcx, def_id);
717 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
718 wfcheck::check_trait_item(tcx, def_id);
721 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
722 wfcheck::check_impl_item(tcx, def_id);
725 pub fn provide(providers: &mut Providers) {
726 method::provide(providers);
727 *providers = Providers {
733 check_item_well_formed,
734 check_trait_item_well_formed,
735 check_impl_item_well_formed,
740 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
742 -> Option<ty::Destructor> {
743 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
746 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
747 /// with information about it's body-id and fn-decl (if any). Otherwise,
750 /// If this function returns "some", then `typeck_tables(def_id)` will
751 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
752 /// may not succeed. In some cases where this function returns `None`
753 /// (notably closures), `typeck_tables(def_id)` would wind up
754 /// redirecting to the owning function.
755 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
757 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
759 match tcx.hir.get(id) {
760 hir::map::NodeItem(item) => {
762 hir::ItemConst(_, body) |
763 hir::ItemStatic(_, _, body) =>
765 hir::ItemFn(ref decl, .., body) =>
766 Some((body, Some(decl))),
771 hir::map::NodeTraitItem(item) => {
773 hir::TraitItemKind::Const(_, Some(body)) =>
775 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
776 Some((body, Some(&sig.decl))),
781 hir::map::NodeImplItem(item) => {
783 hir::ImplItemKind::Const(_, body) =>
785 hir::ImplItemKind::Method(ref sig, body) =>
786 Some((body, Some(&sig.decl))),
791 hir::map::NodeAnonConst(constant) => Some((constant.body, None)),
796 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
799 // Closures' tables come from their outermost function,
800 // as they are part of the same "inference environment".
801 let outer_def_id = tcx.closure_base_def_id(def_id);
802 if outer_def_id != def_id {
803 return tcx.has_typeck_tables(outer_def_id);
806 let id = tcx.hir.as_local_node_id(def_id).unwrap();
807 primary_body_of(tcx, id).is_some()
810 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
813 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
816 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
818 -> &'tcx ty::TypeckTables<'tcx> {
819 // Closures' tables come from their outermost function,
820 // as they are part of the same "inference environment".
821 let outer_def_id = tcx.closure_base_def_id(def_id);
822 if outer_def_id != def_id {
823 return tcx.typeck_tables_of(outer_def_id);
826 let id = tcx.hir.as_local_node_id(def_id).unwrap();
827 let span = tcx.hir.span(id);
829 // Figure out what primary body this item has.
830 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
831 span_bug!(span, "can't type-check body of {:?}", def_id);
833 let body = tcx.hir.body(body_id);
835 let tables = Inherited::build(tcx, def_id).enter(|inh| {
836 let param_env = tcx.param_env(def_id);
837 let fcx = if let Some(decl) = fn_decl {
838 let fn_sig = tcx.fn_sig(def_id);
840 check_abi(tcx, span, fn_sig.abi());
842 // Compute the fty from point of view of inside fn.
844 tcx.liberate_late_bound_regions(def_id, &fn_sig);
846 inh.normalize_associated_types_in(body.value.span,
851 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
854 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
855 let expected_type = tcx.type_of(def_id);
856 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
857 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
859 // Gather locals in statics (because of block expressions).
860 // This is technically unnecessary because locals in static items are forbidden,
861 // but prevents type checking from blowing up before const checking can properly
863 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
865 fcx.check_expr_coercable_to_type(&body.value, expected_type);
870 // All type checking constraints were added, try to fallback unsolved variables.
871 fcx.select_obligations_where_possible(false);
872 let mut fallback_has_occurred = false;
873 for ty in &fcx.unsolved_variables() {
874 fallback_has_occurred |= fcx.fallback_if_possible(ty);
876 fcx.select_obligations_where_possible(fallback_has_occurred);
878 // Even though coercion casts provide type hints, we check casts after fallback for
879 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
882 // Closure and generater analysis may run after fallback
883 // because they don't constrain other type variables.
884 fcx.closure_analyze(body);
885 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
886 fcx.resolve_generator_interiors(def_id);
887 fcx.select_all_obligations_or_error();
889 if fn_decl.is_some() {
890 fcx.regionck_fn(id, body);
892 fcx.regionck_expr(body);
895 fcx.resolve_type_vars_in_body(body)
898 // Consistency check our TypeckTables instance can hold all ItemLocalIds
899 // it will need to hold.
900 assert_eq!(tables.local_id_root,
901 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
905 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
906 if !tcx.sess.target.target.is_abi_supported(abi) {
907 struct_span_err!(tcx.sess, span, E0570,
908 "The ABI `{}` is not supported for the current target", abi).emit()
912 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
913 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
916 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
917 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
920 // infer the variable's type
921 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
922 self.fcx.locals.borrow_mut().insert(nid, var_ty);
926 // take type that the user specified
927 self.fcx.locals.borrow_mut().insert(nid, typ);
934 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
935 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
936 NestedVisitorMap::None
939 // Add explicitly-declared locals.
940 fn visit_local(&mut self, local: &'gcx hir::Local) {
941 let o_ty = match local.ty {
943 let o_ty = self.fcx.to_ty(&ty);
945 let (c_ty, _orig_values) = self.fcx.inh.infcx.canonicalize_response(&o_ty);
946 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
947 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
953 self.assign(local.span, local.id, o_ty);
955 debug!("Local variable {:?} is assigned type {}",
957 self.fcx.ty_to_string(
958 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
959 intravisit::walk_local(self, local);
962 // Add pattern bindings.
963 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
964 if let PatKind::Binding(_, _, ident, _) = p.node {
965 let var_ty = self.assign(p.span, p.id, None);
967 self.fcx.require_type_is_sized(var_ty, p.span,
968 traits::VariableType(p.id));
970 debug!("Pattern binding {} is assigned to {} with type {:?}",
972 self.fcx.ty_to_string(
973 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
976 intravisit::walk_pat(self, p);
979 // Don't descend into the bodies of nested closures
980 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
981 _: hir::BodyId, _: Span, _: ast::NodeId) { }
984 /// When `check_fn` is invoked on a generator (i.e., a body that
985 /// includes yield), it returns back some information about the yield
987 struct GeneratorTypes<'tcx> {
988 /// Type of value that is yielded.
989 yield_ty: ty::Ty<'tcx>,
991 /// Types that are captured (see `GeneratorInterior` for more).
992 interior: ty::Ty<'tcx>,
994 /// Indicates if the generator is movable or static (immovable)
995 movability: hir::GeneratorMovability,
998 /// Helper used for fns and closures. Does the grungy work of checking a function
999 /// body and returns the function context used for that purpose, since in the case of a fn item
1000 /// there is still a bit more to do.
1003 /// * inherited: other fields inherited from the enclosing fn (if any)
1004 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1005 param_env: ty::ParamEnv<'tcx>,
1006 fn_sig: ty::FnSig<'tcx>,
1007 decl: &'gcx hir::FnDecl,
1009 body: &'gcx hir::Body,
1010 can_be_generator: Option<hir::GeneratorMovability>)
1011 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1013 let mut fn_sig = fn_sig.clone();
1015 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1017 // Create the function context. This is either derived from scratch or,
1018 // in the case of closures, based on the outer context.
1019 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1020 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1022 let declared_ret_ty = fn_sig.output();
1023 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1024 let revealed_ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &declared_ret_ty);
1025 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1026 fn_sig = fcx.tcx.mk_fn_sig(
1027 fn_sig.inputs().iter().cloned(),
1034 let span = body.value.span;
1036 if body.is_generator && can_be_generator.is_some() {
1037 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1038 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1039 fcx.yield_ty = Some(yield_ty);
1042 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1044 // Add formal parameters.
1045 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1046 // Check the pattern.
1047 fcx.check_pat_walk(&arg.pat, arg_ty,
1048 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1050 // Check that argument is Sized.
1051 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1052 // for simple cases like `fn foo(x: Trait)`,
1053 // where we would error once on the parameter as a whole, and once on the binding `x`.
1054 if arg.pat.simple_ident().is_none() {
1055 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1058 fcx.write_ty(arg.hir_id, arg_ty);
1061 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1062 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1064 fcx.check_return_expr(&body.value);
1066 // We insert the deferred_generator_interiors entry after visiting the body.
1067 // This ensures that all nested generators appear before the entry of this generator.
1068 // resolve_generator_interiors relies on this property.
1069 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1070 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1071 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1072 Some(GeneratorTypes {
1073 yield_ty: fcx.yield_ty.unwrap(),
1075 movability: can_be_generator.unwrap(),
1081 // Finalize the return check by taking the LUB of the return types
1082 // we saw and assigning it to the expected return type. This isn't
1083 // really expected to fail, since the coercions would have failed
1084 // earlier when trying to find a LUB.
1086 // However, the behavior around `!` is sort of complex. In the
1087 // event that the `actual_return_ty` comes back as `!`, that
1088 // indicates that the fn either does not return or "returns" only
1089 // values of type `!`. In this case, if there is an expected
1090 // return type that is *not* `!`, that should be ok. But if the
1091 // return type is being inferred, we want to "fallback" to `!`:
1093 // let x = move || panic!();
1095 // To allow for that, I am creating a type variable with diverging
1096 // fallback. This was deemed ever so slightly better than unifying
1097 // the return value with `!` because it allows for the caller to
1098 // make more assumptions about the return type (e.g., they could do
1100 // let y: Option<u32> = Some(x());
1102 // which would then cause this return type to become `u32`, not
1104 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1105 let mut actual_return_ty = coercion.complete(&fcx);
1106 if actual_return_ty.is_never() {
1107 actual_return_ty = fcx.next_diverging_ty_var(
1108 TypeVariableOrigin::DivergingFn(span));
1110 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1112 // Check that the main return type implements the termination trait.
1113 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1114 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1117 config::EntryMain => {
1118 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1119 let trait_ref = ty::TraitRef::new(term_id, substs);
1120 let return_ty_span = decl.output.span();
1121 let cause = traits::ObligationCause::new(
1122 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1124 inherited.register_predicate(
1125 traits::Obligation::new(
1126 cause, param_env, trait_ref.to_predicate()));
1128 config::EntryStart => {},
1134 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1135 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1136 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1137 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1138 if declared_ret_ty.sty != ty::TyNever {
1139 fcx.tcx.sess.span_err(
1141 "return type should be `!`",
1145 let inputs = fn_sig.inputs();
1146 let span = fcx.tcx.hir.span(fn_id);
1147 if inputs.len() == 1 {
1148 let arg_is_panic_info = match inputs[0].sty {
1149 ty::TyRef(region, ty, mutbl) => match ty.sty {
1150 ty::TyAdt(ref adt, _) => {
1151 adt.did == panic_info_did &&
1152 mutbl == hir::Mutability::MutImmutable &&
1153 *region != RegionKind::ReStatic
1160 if !arg_is_panic_info {
1161 fcx.tcx.sess.span_err(
1162 decl.inputs[0].span,
1163 "argument should be `&PanicInfo`",
1167 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1168 if let Item_::ItemFn(_, _, ref generics, _) = item.node {
1169 if !generics.params.is_empty() {
1170 fcx.tcx.sess.span_err(
1172 "`#[panic_implementation]` function should have no type \
1179 fcx.tcx.sess.span_err(span, "function should have one argument");
1182 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1191 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1194 let def_id = tcx.hir.local_def_id(id);
1195 let def = tcx.adt_def(def_id);
1196 def.destructor(tcx); // force the destructor to be evaluated
1197 check_representable(tcx, span, def_id);
1199 if def.repr.simd() {
1200 check_simd(tcx, span, def_id);
1203 check_transparent(tcx, span, def_id);
1204 check_packed(tcx, span, def_id);
1207 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1210 let def_id = tcx.hir.local_def_id(id);
1211 let def = tcx.adt_def(def_id);
1212 def.destructor(tcx); // force the destructor to be evaluated
1213 check_representable(tcx, span, def_id);
1215 check_packed(tcx, span, def_id);
1218 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1219 debug!("check_item_type(it.id={}, it.name={})",
1221 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1222 let _indenter = indenter();
1224 // Consts can play a role in type-checking, so they are included here.
1225 hir::ItemStatic(..) => {
1226 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1228 hir::ItemConst(..) => {
1229 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1230 if it.attrs.iter().any(|a| a.check_name("wasm_custom_section")) {
1231 let def_id = tcx.hir.local_def_id(it.id);
1232 check_const_is_u8_array(tcx, def_id, it.span);
1235 hir::ItemEnum(ref enum_definition, _) => {
1238 &enum_definition.variants,
1241 hir::ItemFn(..) => {} // entirely within check_item_body
1242 hir::ItemImpl(.., ref impl_item_refs) => {
1243 debug!("ItemImpl {} with id {}", it.name, it.id);
1244 let impl_def_id = tcx.hir.local_def_id(it.id);
1245 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1246 check_impl_items_against_trait(tcx,
1251 let trait_def_id = impl_trait_ref.def_id;
1252 check_on_unimplemented(tcx, trait_def_id, it);
1255 hir::ItemTrait(..) => {
1256 let def_id = tcx.hir.local_def_id(it.id);
1257 check_on_unimplemented(tcx, def_id, it);
1259 hir::ItemStruct(..) => {
1260 check_struct(tcx, it.id, it.span);
1262 hir::ItemUnion(..) => {
1263 check_union(tcx, it.id, it.span);
1265 hir::ItemTy(..) => {
1266 let def_id = tcx.hir.local_def_id(it.id);
1267 let pty_ty = tcx.type_of(def_id);
1268 let generics = tcx.generics_of(def_id);
1269 check_bounds_are_used(tcx, &generics, pty_ty);
1271 hir::ItemForeignMod(ref m) => {
1272 check_abi(tcx, it.span, m.abi);
1274 if m.abi == Abi::RustIntrinsic {
1275 for item in &m.items {
1276 intrinsic::check_intrinsic_type(tcx, item);
1278 } else if m.abi == Abi::PlatformIntrinsic {
1279 for item in &m.items {
1280 intrinsic::check_platform_intrinsic_type(tcx, item);
1283 for item in &m.items {
1284 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1285 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1286 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1287 "foreign items may not have type parameters");
1288 err.span_label(item.span, "can't have type parameters");
1289 // FIXME: once we start storing spans for type arguments, turn this into a
1291 err.help("use specialization instead of type parameters by replacing them \
1292 with concrete types like `u32`");
1296 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1297 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1302 _ => {/* nothing to do */ }
1306 fn check_const_is_u8_array<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1309 match tcx.type_of(def_id).sty {
1310 ty::TyArray(t, _) => {
1312 ty::TyUint(ast::UintTy::U8) => return,
1318 tcx.sess.span_err(span, "must be an array of bytes like `[u8; N]`");
1321 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1322 trait_def_id: DefId,
1324 let item_def_id = tcx.hir.local_def_id(item.id);
1325 // an error would be reported if this fails.
1326 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1329 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1330 impl_item: &hir::ImplItem,
1333 let mut err = struct_span_err!(
1334 tcx.sess, impl_item.span, E0520,
1335 "`{}` specializes an item from a parent `impl`, but \
1336 that item is not marked `default`",
1338 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1341 match tcx.span_of_impl(parent_impl) {
1343 err.span_label(span, "parent `impl` is here");
1344 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1348 err.note(&format!("parent implementation is in crate `{}`", cname));
1355 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1356 trait_def: &ty::TraitDef,
1357 trait_item: &ty::AssociatedItem,
1359 impl_item: &hir::ImplItem)
1361 let ancestors = trait_def.ancestors(tcx, impl_id);
1363 let kind = match impl_item.node {
1364 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1365 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1366 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1369 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).skip(1).next()
1370 .map(|node_item| node_item.map(|parent| parent.defaultness));
1372 if let Some(parent) = parent {
1373 if tcx.impl_item_is_final(&parent) {
1374 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1380 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1383 impl_trait_ref: ty::TraitRef<'tcx>,
1384 impl_item_refs: &[hir::ImplItemRef]) {
1385 let impl_span = tcx.sess.codemap().def_span(impl_span);
1387 // If the trait reference itself is erroneous (so the compilation is going
1388 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1389 // isn't populated for such impls.
1390 if impl_trait_ref.references_error() { return; }
1392 // Locate trait definition and items
1393 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1394 let mut overridden_associated_type = None;
1396 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1398 // Check existing impl methods to see if they are both present in trait
1399 // and compatible with trait signature
1400 for impl_item in impl_items() {
1401 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1402 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1403 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1404 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1406 // Not compatible, but needed for the error message
1407 tcx.associated_items(impl_trait_ref.def_id)
1408 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1411 // Check that impl definition matches trait definition
1412 if let Some(ty_trait_item) = ty_trait_item {
1413 match impl_item.node {
1414 hir::ImplItemKind::Const(..) => {
1415 // Find associated const definition.
1416 if ty_trait_item.kind == ty::AssociatedKind::Const {
1417 compare_const_impl(tcx,
1423 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1424 "item `{}` is an associated const, \
1425 which doesn't match its trait `{}`",
1428 err.span_label(impl_item.span, "does not match trait");
1429 // We can only get the spans from local trait definition
1430 // Same for E0324 and E0325
1431 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1432 err.span_label(trait_span, "item in trait");
1437 hir::ImplItemKind::Method(..) => {
1438 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1439 if ty_trait_item.kind == ty::AssociatedKind::Method {
1440 compare_impl_method(tcx,
1447 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1448 "item `{}` is an associated method, \
1449 which doesn't match its trait `{}`",
1452 err.span_label(impl_item.span, "does not match trait");
1453 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1454 err.span_label(trait_span, "item in trait");
1459 hir::ImplItemKind::Type(_) => {
1460 if ty_trait_item.kind == ty::AssociatedKind::Type {
1461 if ty_trait_item.defaultness.has_value() {
1462 overridden_associated_type = Some(impl_item);
1465 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1466 "item `{}` is an associated type, \
1467 which doesn't match its trait `{}`",
1470 err.span_label(impl_item.span, "does not match trait");
1471 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1472 err.span_label(trait_span, "item in trait");
1479 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1483 // Check for missing items from trait
1484 let mut missing_items = Vec::new();
1485 let mut invalidated_items = Vec::new();
1486 let associated_type_overridden = overridden_associated_type.is_some();
1487 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1488 let is_implemented = trait_def.ancestors(tcx, impl_id)
1489 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1491 .map(|node_item| !node_item.node.is_from_trait())
1494 if !is_implemented && !tcx.impl_is_default(impl_id) {
1495 if !trait_item.defaultness.has_value() {
1496 missing_items.push(trait_item);
1497 } else if associated_type_overridden {
1498 invalidated_items.push(trait_item.ident);
1503 if !missing_items.is_empty() {
1504 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1505 "not all trait items implemented, missing: `{}`",
1506 missing_items.iter()
1507 .map(|trait_item| trait_item.ident.to_string())
1508 .collect::<Vec<_>>().join("`, `"));
1509 err.span_label(impl_span, format!("missing `{}` in implementation",
1510 missing_items.iter()
1511 .map(|trait_item| trait_item.ident.to_string())
1512 .collect::<Vec<_>>().join("`, `")));
1513 for trait_item in missing_items {
1514 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1515 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1517 err.note_trait_signature(trait_item.ident.to_string(),
1518 trait_item.signature(&tcx));
1524 if !invalidated_items.is_empty() {
1525 let invalidator = overridden_associated_type.unwrap();
1526 span_err!(tcx.sess, invalidator.span, E0399,
1527 "the following trait items need to be reimplemented \
1528 as `{}` was overridden: `{}`",
1530 invalidated_items.iter()
1531 .map(|name| name.to_string())
1532 .collect::<Vec<_>>().join("`, `"))
1536 /// Checks whether a type can be represented in memory. In particular, it
1537 /// identifies types that contain themselves without indirection through a
1538 /// pointer, which would mean their size is unbounded.
1539 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1543 let rty = tcx.type_of(item_def_id);
1545 // Check that it is possible to represent this type. This call identifies
1546 // (1) types that contain themselves and (2) types that contain a different
1547 // recursive type. It is only necessary to throw an error on those that
1548 // contain themselves. For case 2, there must be an inner type that will be
1549 // caught by case 1.
1550 match rty.is_representable(tcx, sp) {
1551 Representability::SelfRecursive(spans) => {
1552 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1554 err.span_label(span, "recursive without indirection");
1559 Representability::Representable | Representability::ContainsRecursive => (),
1564 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1565 let t = tcx.type_of(def_id);
1567 ty::TyAdt(def, substs) if def.is_struct() => {
1568 let fields = &def.non_enum_variant().fields;
1569 if fields.is_empty() {
1570 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1573 let e = fields[0].ty(tcx, substs);
1574 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1575 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1576 .span_label(sp, "SIMD elements must have the same type")
1581 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1582 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1584 span_err!(tcx.sess, sp, E0077,
1585 "SIMD vector element type should be machine type");
1594 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1595 let repr = tcx.adt_def(def_id).repr;
1597 for attr in tcx.get_attrs(def_id).iter() {
1598 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1599 if let attr::ReprPacked(pack) = r {
1600 if pack != repr.pack {
1601 struct_span_err!(tcx.sess, sp, E0634,
1602 "type has conflicting packed representation hints").emit();
1608 struct_span_err!(tcx.sess, sp, E0587,
1609 "type has conflicting packed and align representation hints").emit();
1611 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1612 struct_span_err!(tcx.sess, sp, E0588,
1613 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1618 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1620 stack: &mut Vec<DefId>) -> bool {
1621 let t = tcx.type_of(def_id);
1622 if stack.contains(&def_id) {
1623 debug!("check_packed_inner: {:?} is recursive", t);
1627 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1628 if tcx.adt_def(def.did).repr.align > 0 {
1631 // push struct def_id before checking fields
1633 for field in &def.non_enum_variant().fields {
1634 let f = field.ty(tcx, substs);
1636 ty::TyAdt(def, _) => {
1637 if check_packed_inner(tcx, def.did, stack) {
1644 // only need to pop if not early out
1652 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1653 let adt = tcx.adt_def(def_id);
1654 if !adt.repr.transparent() {
1658 // For each field, figure out if it's known to be a ZST and align(1)
1659 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1660 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1661 let param_env = tcx.param_env(field.did);
1662 let layout = tcx.layout_of(param_env.and(ty));
1663 // We are currently checking the type this field came from, so it must be local
1664 let span = tcx.hir.span_if_local(field.did).unwrap();
1665 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1666 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1670 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1671 let non_zst_count = non_zst_fields.clone().count();
1672 if non_zst_count != 1 {
1673 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1674 struct_span_err!(tcx.sess, sp, E0690,
1675 "transparent struct needs exactly one non-zero-sized field, but has {}",
1677 .span_note(field_spans, "non-zero-sized field")
1680 for &(span, zst, align1) in &field_infos {
1682 span_err!(tcx.sess, span, E0691,
1683 "zero-sized field in transparent struct has alignment larger than 1");
1688 #[allow(trivial_numeric_casts)]
1689 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1691 vs: &'tcx [hir::Variant],
1693 let def_id = tcx.hir.local_def_id(id);
1694 let def = tcx.adt_def(def_id);
1695 def.destructor(tcx); // force the destructor to be evaluated
1698 let attributes = tcx.get_attrs(def_id);
1699 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1701 tcx.sess, attr.span, E0084,
1702 "unsupported representation for zero-variant enum")
1703 .span_label(sp, "zero-variant enum")
1708 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1709 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1710 if !tcx.features().repr128 {
1711 emit_feature_err(&tcx.sess.parse_sess,
1714 GateIssue::Language,
1715 "repr with 128-bit type is unstable");
1720 if let Some(ref e) = v.node.disr_expr {
1721 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1725 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1726 for (discr, v) in def.discriminants(tcx).zip(vs) {
1727 // Check for duplicate discriminant values
1728 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1729 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1730 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1731 let i_span = match variant_i.node.disr_expr {
1732 Some(ref expr) => tcx.hir.span(expr.id),
1733 None => tcx.hir.span(variant_i_node_id)
1735 let span = match v.node.disr_expr {
1736 Some(ref expr) => tcx.hir.span(expr.id),
1739 struct_span_err!(tcx.sess, span, E0081,
1740 "discriminant value `{}` already exists", disr_vals[i])
1741 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1742 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1745 disr_vals.push(discr);
1748 check_representable(tcx, sp, def_id);
1751 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1752 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1754 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1755 -> ty::GenericPredicates<'tcx>
1758 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1759 let item_id = tcx.hir.ty_param_owner(node_id);
1760 let item_def_id = tcx.hir.local_def_id(item_id);
1761 let generics = tcx.generics_of(item_def_id);
1762 let index = generics.param_def_id_to_index[&def_id];
1763 ty::GenericPredicates {
1765 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1767 ty::Predicate::Trait(ref data) => {
1768 data.skip_binder().self_ty().is_param(index)
1772 }).cloned().collect()
1776 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1777 -> Option<ty::Region<'tcx>> {
1779 Some(def) => infer::EarlyBoundRegion(span, def.name),
1780 None => infer::MiscVariable(span)
1782 Some(self.next_region_var(v))
1785 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1786 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1789 fn ty_infer_for_def(&self,
1790 ty_param_def: &ty::GenericParamDef,
1791 span: Span) -> Ty<'tcx> {
1792 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1798 fn projected_ty_from_poly_trait_ref(&self,
1801 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1804 let (trait_ref, _) =
1805 self.replace_late_bound_regions_with_fresh_var(
1807 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1810 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1813 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1814 if ty.has_escaping_regions() {
1815 ty // FIXME: normalization and escaping regions
1817 self.normalize_associated_types_in(span, &ty)
1821 fn set_tainted_by_errors(&self) {
1822 self.infcx.set_tainted_by_errors()
1825 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1826 self.write_ty(hir_id, ty)
1830 /// Controls whether the arguments are tupled. This is used for the call
1833 /// Tupling means that all call-side arguments are packed into a tuple and
1834 /// passed as a single parameter. For example, if tupling is enabled, this
1837 /// fn f(x: (isize, isize))
1839 /// Can be called as:
1846 #[derive(Clone, Eq, PartialEq)]
1847 enum TupleArgumentsFlag {
1852 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1853 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1854 param_env: ty::ParamEnv<'tcx>,
1855 body_id: ast::NodeId)
1856 -> FnCtxt<'a, 'gcx, 'tcx> {
1860 err_count_on_creation: inh.tcx.sess.err_count(),
1863 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1864 ast::CRATE_NODE_ID)),
1865 diverges: Cell::new(Diverges::Maybe),
1866 has_errors: Cell::new(false),
1867 enclosing_breakables: RefCell::new(EnclosingBreakables {
1875 pub fn sess(&self) -> &Session {
1879 pub fn err_count_since_creation(&self) -> usize {
1880 self.tcx.sess.err_count() - self.err_count_on_creation
1883 /// Produce warning on the given node, if the current point in the
1884 /// function is unreachable, and there hasn't been another warning.
1885 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1886 if self.diverges.get() == Diverges::Always {
1887 self.diverges.set(Diverges::WarnedAlways);
1889 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1891 self.tcx().lint_node(
1892 lint::builtin::UNREACHABLE_CODE,
1894 &format!("unreachable {}", kind));
1900 code: ObligationCauseCode<'tcx>)
1901 -> ObligationCause<'tcx> {
1902 ObligationCause::new(span, self.body_id, code)
1905 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1906 self.cause(span, ObligationCauseCode::MiscObligation)
1909 /// Resolves type variables in `ty` if possible. Unlike the infcx
1910 /// version (resolve_type_vars_if_possible), this version will
1911 /// also select obligations if it seems useful, in an effort
1912 /// to get more type information.
1913 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1914 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1916 // No TyInfer()? Nothing needs doing.
1917 if !ty.has_infer_types() {
1918 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1922 // If `ty` is a type variable, see whether we already know what it is.
1923 ty = self.resolve_type_vars_if_possible(&ty);
1924 if !ty.has_infer_types() {
1925 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1929 // If not, try resolving pending obligations as much as
1930 // possible. This can help substantially when there are
1931 // indirect dependencies that don't seem worth tracking
1933 self.select_obligations_where_possible(false);
1934 ty = self.resolve_type_vars_if_possible(&ty);
1936 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1940 fn record_deferred_call_resolution(&self,
1941 closure_def_id: DefId,
1942 r: DeferredCallResolution<'gcx, 'tcx>) {
1943 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1944 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1947 fn remove_deferred_call_resolutions(&self,
1948 closure_def_id: DefId)
1949 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1951 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1952 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1955 pub fn tag(&self) -> String {
1956 let self_ptr: *const FnCtxt = self;
1957 format!("{:?}", self_ptr)
1960 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1961 match self.locals.borrow().get(&nid) {
1964 span_bug!(span, "no type for local variable {}",
1965 self.tcx.hir.node_to_string(nid));
1971 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1972 debug!("write_ty({:?}, {:?}) in fcx {}",
1973 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1974 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1976 if ty.references_error() {
1977 self.has_errors.set(true);
1978 self.set_tainted_by_errors();
1982 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
1983 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
1984 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
1987 // The NodeId and the ItemLocalId must identify the same item. We just pass
1988 // both of them for consistency checking.
1989 pub fn write_method_call(&self,
1991 method: MethodCallee<'tcx>) {
1994 .type_dependent_defs_mut()
1995 .insert(hir_id, Def::Method(method.def_id));
1996 self.write_substs(hir_id, method.substs);
1999 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2000 if !substs.is_noop() {
2001 debug!("write_substs({:?}, {:?}) in fcx {}",
2006 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2010 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2011 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2017 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2018 Entry::Vacant(entry) => { entry.insert(adj); },
2019 Entry::Occupied(mut entry) => {
2020 debug!(" - composing on top of {:?}", entry.get());
2021 match (&entry.get()[..], &adj[..]) {
2022 // Applying any adjustment on top of a NeverToAny
2023 // is a valid NeverToAny adjustment, because it can't
2025 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2027 Adjustment { kind: Adjust::Deref(_), .. },
2028 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2030 Adjustment { kind: Adjust::Deref(_), .. },
2031 .. // Any following adjustments are allowed.
2033 // A reborrow has no effect before a dereference.
2035 // FIXME: currently we never try to compose autoderefs
2036 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2038 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2039 expr, entry.get(), adj)
2041 *entry.get_mut() = adj;
2046 /// Basically whenever we are converting from a type scheme into
2047 /// the fn body space, we always want to normalize associated
2048 /// types as well. This function combines the two.
2049 fn instantiate_type_scheme<T>(&self,
2051 substs: &Substs<'tcx>,
2054 where T : TypeFoldable<'tcx>
2056 let value = value.subst(self.tcx, substs);
2057 let result = self.normalize_associated_types_in(span, &value);
2058 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2065 /// As `instantiate_type_scheme`, but for the bounds found in a
2066 /// generic type scheme.
2067 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2068 -> ty::InstantiatedPredicates<'tcx> {
2069 let bounds = self.tcx.predicates_of(def_id);
2070 let result = bounds.instantiate(self.tcx, substs);
2071 let result = self.normalize_associated_types_in(span, &result);
2072 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2079 /// Replace the anonymized types from the return value of the
2080 /// function with type variables and records the `AnonTypeMap` for
2081 /// later use during writeback. See
2082 /// `InferCtxt::instantiate_anon_types` for more details.
2083 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2088 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2090 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2095 let (value, anon_type_map) = self.register_infer_ok_obligations(
2096 self.instantiate_anon_types(
2104 let mut anon_types = self.anon_types.borrow_mut();
2105 for (ty, decl) in anon_type_map {
2106 let old_value = anon_types.insert(ty, decl);
2107 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2113 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2114 where T : TypeFoldable<'tcx>
2116 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2119 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2121 where T : TypeFoldable<'tcx>
2123 self.inh.partially_normalize_associated_types_in(span,
2129 pub fn require_type_meets(&self,
2132 code: traits::ObligationCauseCode<'tcx>,
2135 self.register_bound(
2138 traits::ObligationCause::new(span, self.body_id, code));
2141 pub fn require_type_is_sized(&self,
2144 code: traits::ObligationCauseCode<'tcx>)
2146 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2147 self.require_type_meets(ty, span, code, lang_item);
2150 pub fn register_bound(&self,
2153 cause: traits::ObligationCause<'tcx>)
2155 self.fulfillment_cx.borrow_mut()
2156 .register_bound(self, self.param_env, ty, def_id, cause);
2159 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2160 let t = AstConv::ast_ty_to_ty(self, ast_t);
2161 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2165 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2166 match self.tables.borrow().node_types().get(id) {
2168 None if self.is_tainted_by_errors() => self.tcx.types.err,
2170 let node_id = self.tcx.hir.hir_to_node_id(id);
2171 bug!("no type for node {}: {} in fcx {}",
2172 node_id, self.tcx.hir.node_to_string(node_id),
2178 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2179 /// outlive the region `r`.
2180 pub fn register_wf_obligation(&self,
2183 code: traits::ObligationCauseCode<'tcx>)
2185 // WF obligations never themselves fail, so no real need to give a detailed cause:
2186 let cause = traits::ObligationCause::new(span, self.body_id, code);
2187 self.register_predicate(traits::Obligation::new(cause,
2189 ty::Predicate::WellFormed(ty)));
2192 /// Registers obligations that all types appearing in `substs` are well-formed.
2193 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2195 for ty in substs.types() {
2196 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2200 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2201 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2202 /// trait/region obligations.
2204 /// For example, if there is a function:
2207 /// fn foo<'a,T:'a>(...)
2210 /// and a reference:
2216 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2217 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2218 pub fn add_obligations_for_parameters(&self,
2219 cause: traits::ObligationCause<'tcx>,
2220 predicates: &ty::InstantiatedPredicates<'tcx>)
2222 assert!(!predicates.has_escaping_regions());
2224 debug!("add_obligations_for_parameters(predicates={:?})",
2227 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2228 self.register_predicate(obligation);
2232 // FIXME(arielb1): use this instead of field.ty everywhere
2233 // Only for fields! Returns <none> for methods>
2234 // Indifferent to privacy flags
2235 pub fn field_ty(&self,
2237 field: &'tcx ty::FieldDef,
2238 substs: &Substs<'tcx>)
2241 self.normalize_associated_types_in(span,
2242 &field.ty(self.tcx, substs))
2245 fn check_casts(&self) {
2246 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2247 for cast in deferred_cast_checks.drain(..) {
2252 fn resolve_generator_interiors(&self, def_id: DefId) {
2253 let mut generators = self.deferred_generator_interiors.borrow_mut();
2254 for (body_id, interior) in generators.drain(..) {
2255 self.select_obligations_where_possible(false);
2256 generator_interior::resolve_interior(self, def_id, body_id, interior);
2260 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2261 // Non-numerics get replaced with ! or () (depending on whether
2262 // feature(never_type) is enabled, unconstrained ints with i32,
2263 // unconstrained floats with f64.
2264 // Fallback becomes very dubious if we have encountered type-checking errors.
2265 // In that case, fallback to TyError.
2266 // The return value indicates whether fallback has occured.
2267 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2268 use rustc::ty::error::UnconstrainedNumeric::Neither;
2269 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2271 assert!(ty.is_ty_infer());
2272 let fallback = match self.type_is_unconstrained_numeric(ty) {
2273 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2274 UnconstrainedInt => self.tcx.types.i32,
2275 UnconstrainedFloat => self.tcx.types.f64,
2276 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2277 Neither => return false,
2279 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2280 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2284 fn select_all_obligations_or_error(&self) {
2285 debug!("select_all_obligations_or_error");
2286 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2287 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2291 /// Select as many obligations as we can at present.
2292 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2293 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2296 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2301 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2303 hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
2305 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2310 hir::ExprType(ref e, _) => {
2311 self.is_place_expr(e)
2314 hir::ExprUnary(hir::UnDeref, _) |
2315 hir::ExprField(..) |
2316 hir::ExprIndex(..) => {
2320 // Partially qualified paths in expressions can only legally
2321 // refer to associated items which are always rvalues.
2322 hir::ExprPath(hir::QPath::TypeRelative(..)) |
2325 hir::ExprMethodCall(..) |
2326 hir::ExprStruct(..) |
2329 hir::ExprMatch(..) |
2330 hir::ExprClosure(..) |
2331 hir::ExprBlock(..) |
2332 hir::ExprRepeat(..) |
2333 hir::ExprArray(..) |
2334 hir::ExprBreak(..) |
2335 hir::ExprContinue(..) |
2337 hir::ExprWhile(..) |
2339 hir::ExprAssign(..) |
2340 hir::ExprInlineAsm(..) |
2341 hir::ExprAssignOp(..) |
2343 hir::ExprUnary(..) |
2345 hir::ExprAddrOf(..) |
2346 hir::ExprBinary(..) |
2347 hir::ExprYield(..) |
2348 hir::ExprCast(..) => {
2354 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2355 /// returns a type of `&T`, but the actual type we assign to the
2356 /// *expression* is `T`. So this function just peels off the return
2357 /// type by one layer to yield `T`.
2358 fn make_overloaded_place_return_type(&self,
2359 method: MethodCallee<'tcx>)
2360 -> ty::TypeAndMut<'tcx>
2362 // extract method return type, which will be &T;
2363 let ret_ty = method.sig.output();
2365 // method returns &T, but the type as visible to user is T, so deref
2366 ret_ty.builtin_deref(true).unwrap()
2369 fn lookup_indexing(&self,
2371 base_expr: &'gcx hir::Expr,
2375 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2377 // FIXME(#18741) -- this is almost but not quite the same as the
2378 // autoderef that normal method probing does. They could likely be
2381 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2382 let mut result = None;
2383 while result.is_none() && autoderef.next().is_some() {
2384 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2386 autoderef.finalize();
2390 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2391 /// (and otherwise adjust) `base_expr`, looking for a type which either
2392 /// supports builtin indexing or overloaded indexing.
2393 /// This loop implements one step in that search; the autoderef loop
2394 /// is implemented by `lookup_indexing`.
2395 fn try_index_step(&self,
2397 base_expr: &hir::Expr,
2398 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2401 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2403 let adjusted_ty = autoderef.unambiguous_final_ty();
2404 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2411 for &unsize in &[false, true] {
2412 let mut self_ty = adjusted_ty;
2414 // We only unsize arrays here.
2415 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2416 self_ty = self.tcx.mk_slice(element_ty);
2422 // If some lookup succeeds, write callee into table and extract index/element
2423 // type from the method signature.
2424 // If some lookup succeeded, install method in table
2425 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2426 let method = self.try_overloaded_place_op(
2427 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2429 let result = method.map(|ok| {
2430 debug!("try_index_step: success, using overloaded indexing");
2431 let method = self.register_infer_ok_obligations(ok);
2433 let mut adjustments = autoderef.adjust_steps(needs);
2434 if let ty::TyRef(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2435 let mutbl = match r_mutbl {
2436 hir::MutImmutable => AutoBorrowMutability::Immutable,
2437 hir::MutMutable => AutoBorrowMutability::Mutable {
2438 // Indexing can be desugared to a method call,
2439 // so maybe we could use two-phase here.
2440 // See the documentation of AllowTwoPhase for why that's
2441 // not the case today.
2442 allow_two_phase_borrow: AllowTwoPhase::No,
2445 adjustments.push(Adjustment {
2446 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2447 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2454 adjustments.push(Adjustment {
2455 kind: Adjust::Unsize,
2456 target: method.sig.inputs()[0]
2459 self.apply_adjustments(base_expr, adjustments);
2461 self.write_method_call(expr.hir_id, method);
2462 (input_ty, self.make_overloaded_place_return_type(method).ty)
2464 if result.is_some() {
2472 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2473 let (tr, name) = match (op, is_mut) {
2474 (PlaceOp::Deref, false) =>
2475 (self.tcx.lang_items().deref_trait(), "deref"),
2476 (PlaceOp::Deref, true) =>
2477 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2478 (PlaceOp::Index, false) =>
2479 (self.tcx.lang_items().index_trait(), "index"),
2480 (PlaceOp::Index, true) =>
2481 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2483 (tr, ast::Ident::from_str(name))
2486 fn try_overloaded_place_op(&self,
2489 arg_tys: &[Ty<'tcx>],
2492 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2494 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2500 // Try Mut first, if needed.
2501 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2502 let method = match (needs, mut_tr) {
2503 (Needs::MutPlace, Some(trait_did)) => {
2504 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2509 // Otherwise, fall back to the immutable version.
2510 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2511 let method = match (method, imm_tr) {
2512 (None, Some(trait_did)) => {
2513 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2515 (method, _) => method,
2521 fn check_method_argument_types(&self,
2524 method: Result<MethodCallee<'tcx>, ()>,
2525 args_no_rcvr: &'gcx [hir::Expr],
2526 tuple_arguments: TupleArgumentsFlag,
2527 expected: Expectation<'tcx>)
2529 let has_error = match method {
2531 method.substs.references_error() || method.sig.references_error()
2536 let err_inputs = self.err_args(args_no_rcvr.len());
2538 let err_inputs = match tuple_arguments {
2539 DontTupleArguments => err_inputs,
2540 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2543 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2544 false, tuple_arguments, None);
2545 return self.tcx.types.err;
2548 let method = method.unwrap();
2549 // HACK(eddyb) ignore self in the definition (see above).
2550 let expected_arg_tys = self.expected_inputs_for_expected_output(
2553 method.sig.output(),
2554 &method.sig.inputs()[1..]
2556 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2557 args_no_rcvr, method.sig.variadic, tuple_arguments,
2558 self.tcx.hir.span_if_local(method.def_id));
2562 /// Generic function that factors out common logic from function calls,
2563 /// method calls and overloaded operators.
2564 fn check_argument_types(&self,
2567 fn_inputs: &[Ty<'tcx>],
2568 mut expected_arg_tys: &[Ty<'tcx>],
2569 args: &'gcx [hir::Expr],
2571 tuple_arguments: TupleArgumentsFlag,
2572 def_span: Option<Span>) {
2575 // Grab the argument types, supplying fresh type variables
2576 // if the wrong number of arguments were supplied
2577 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2583 // All the input types from the fn signature must outlive the call
2584 // so as to validate implied bounds.
2585 for &fn_input_ty in fn_inputs {
2586 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2589 let expected_arg_count = fn_inputs.len();
2591 let param_count_error = |expected_count: usize,
2596 let mut err = tcx.sess.struct_span_err_with_code(sp,
2597 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2598 if variadic {"at least "} else {""},
2600 if expected_count == 1 {""} else {"s"},
2602 if arg_count == 1 {" was"} else {"s were"}),
2603 DiagnosticId::Error(error_code.to_owned()));
2605 if let Some(def_s) = def_span.map(|sp| tcx.sess.codemap().def_span(sp)) {
2606 err.span_label(def_s, "defined here");
2609 let sugg_span = tcx.sess.codemap().end_point(expr_sp);
2610 // remove closing `)` from the span
2611 let sugg_span = sugg_span.shrink_to_lo();
2612 err.span_suggestion(
2614 "expected the unit value `()`; create it with empty parentheses",
2615 String::from("()"));
2617 err.span_label(sp, format!("expected {}{} parameter{}",
2618 if variadic {"at least "} else {""},
2620 if expected_count == 1 {""} else {"s"}));
2625 let formal_tys = if tuple_arguments == TupleArguments {
2626 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2627 match tuple_type.sty {
2628 ty::TyTuple(arg_types) if arg_types.len() != args.len() => {
2629 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2630 expected_arg_tys = &[];
2631 self.err_args(args.len())
2633 ty::TyTuple(arg_types) => {
2634 expected_arg_tys = match expected_arg_tys.get(0) {
2635 Some(&ty) => match ty.sty {
2636 ty::TyTuple(ref tys) => &tys,
2644 span_err!(tcx.sess, sp, E0059,
2645 "cannot use call notation; the first type parameter \
2646 for the function trait is neither a tuple nor unit");
2647 expected_arg_tys = &[];
2648 self.err_args(args.len())
2651 } else if expected_arg_count == supplied_arg_count {
2653 } else if variadic {
2654 if supplied_arg_count >= expected_arg_count {
2657 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2658 expected_arg_tys = &[];
2659 self.err_args(supplied_arg_count)
2662 // is the missing argument of type `()`?
2663 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2664 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2665 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2666 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2670 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2672 expected_arg_tys = &[];
2673 self.err_args(supplied_arg_count)
2675 // If there is no expectation, expect formal_tys.
2676 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2682 debug!("check_argument_types: formal_tys={:?}",
2683 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2685 // Check the arguments.
2686 // We do this in a pretty awful way: first we typecheck any arguments
2687 // that are not closures, then we typecheck the closures. This is so
2688 // that we have more information about the types of arguments when we
2689 // typecheck the functions. This isn't really the right way to do this.
2690 for &check_closures in &[false, true] {
2691 debug!("check_closures={}", check_closures);
2693 // More awful hacks: before we check argument types, try to do
2694 // an "opportunistic" vtable resolution of any trait bounds on
2695 // the call. This helps coercions.
2697 self.select_obligations_where_possible(false);
2700 // For variadic functions, we don't have a declared type for all of
2701 // the arguments hence we only do our usual type checking with
2702 // the arguments who's types we do know.
2703 let t = if variadic {
2705 } else if tuple_arguments == TupleArguments {
2710 for (i, arg) in args.iter().take(t).enumerate() {
2711 // Warn only for the first loop (the "no closures" one).
2712 // Closure arguments themselves can't be diverging, but
2713 // a previous argument can, e.g. `foo(panic!(), || {})`.
2714 if !check_closures {
2715 self.warn_if_unreachable(arg.id, arg.span, "expression");
2718 let is_closure = match arg.node {
2719 hir::ExprClosure(..) => true,
2723 if is_closure != check_closures {
2727 debug!("checking the argument");
2728 let formal_ty = formal_tys[i];
2730 // The special-cased logic below has three functions:
2731 // 1. Provide as good of an expected type as possible.
2732 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2734 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2736 // 2. Coerce to the most detailed type that could be coerced
2737 // to, which is `expected_ty` if `rvalue_hint` returns an
2738 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2739 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2740 // We're processing function arguments so we definitely want to use
2741 // two-phase borrows.
2742 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2744 // 3. Relate the expected type and the formal one,
2745 // if the expected type was used for the coercion.
2746 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2750 // We also need to make sure we at least write the ty of the other
2751 // arguments which we skipped above.
2753 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2754 use structured_errors::{VariadicError, StructuredDiagnostic};
2755 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2758 for arg in args.iter().skip(expected_arg_count) {
2759 let arg_ty = self.check_expr(&arg);
2761 // There are a few types which get autopromoted when passed via varargs
2762 // in C but we just error out instead and require explicit casts.
2763 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2765 ty::TyFloat(ast::FloatTy::F32) => {
2766 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2768 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2769 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2771 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2772 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2774 ty::TyFnDef(..) => {
2775 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2776 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2777 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2785 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2786 (0..len).map(|_| self.tcx.types.err).collect()
2789 // AST fragment checking
2792 expected: Expectation<'tcx>)
2798 ast::LitKind::Str(..) => tcx.mk_static_str(),
2799 ast::LitKind::ByteStr(ref v) => {
2800 tcx.mk_imm_ref(tcx.types.re_static,
2801 tcx.mk_array(tcx.types.u8, v.len() as u64))
2803 ast::LitKind::Byte(_) => tcx.types.u8,
2804 ast::LitKind::Char(_) => tcx.types.char,
2805 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2806 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2807 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2808 let opt_ty = expected.to_option(self).and_then(|ty| {
2810 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2811 ty::TyChar => Some(tcx.types.u8),
2812 ty::TyRawPtr(..) => Some(tcx.types.usize),
2813 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2817 opt_ty.unwrap_or_else(
2818 || tcx.mk_int_var(self.next_int_var_id()))
2820 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2821 ast::LitKind::FloatUnsuffixed(_) => {
2822 let opt_ty = expected.to_option(self).and_then(|ty| {
2824 ty::TyFloat(_) => Some(ty),
2828 opt_ty.unwrap_or_else(
2829 || tcx.mk_float_var(self.next_float_var_id()))
2831 ast::LitKind::Bool(_) => tcx.types.bool
2835 fn check_expr_eq_type(&self,
2836 expr: &'gcx hir::Expr,
2837 expected: Ty<'tcx>) {
2838 let ty = self.check_expr_with_hint(expr, expected);
2839 self.demand_eqtype(expr.span, expected, ty);
2842 pub fn check_expr_has_type_or_error(&self,
2843 expr: &'gcx hir::Expr,
2844 expected: Ty<'tcx>) -> Ty<'tcx> {
2845 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2848 fn check_expr_meets_expectation_or_error(&self,
2849 expr: &'gcx hir::Expr,
2850 expected: Expectation<'tcx>) -> Ty<'tcx> {
2851 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2852 let mut ty = self.check_expr_with_expectation(expr, expected);
2854 // While we don't allow *arbitrary* coercions here, we *do* allow
2855 // coercions from ! to `expected`.
2857 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2858 "expression with never type wound up being adjusted");
2859 let adj_ty = self.next_diverging_ty_var(
2860 TypeVariableOrigin::AdjustmentType(expr.span));
2861 self.apply_adjustments(expr, vec![Adjustment {
2862 kind: Adjust::NeverToAny,
2868 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2869 // Add help to type error if this is an `if` condition with an assignment
2870 match (expected, &expr.node) {
2871 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2872 let msg = "try comparing for equality";
2873 if let (Ok(left), Ok(right)) = (
2874 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2875 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2877 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2889 fn check_expr_coercable_to_type(&self,
2890 expr: &'gcx hir::Expr,
2891 expected: Ty<'tcx>) -> Ty<'tcx> {
2892 let ty = self.check_expr_with_hint(expr, expected);
2893 // checks don't need two phase
2894 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2897 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2898 expected: Ty<'tcx>) -> Ty<'tcx> {
2899 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2902 fn check_expr_with_expectation(&self,
2903 expr: &'gcx hir::Expr,
2904 expected: Expectation<'tcx>) -> Ty<'tcx> {
2905 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2908 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2909 self.check_expr_with_expectation(expr, NoExpectation)
2912 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2913 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2916 // determine the `self` type, using fresh variables for all variables
2917 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2918 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2920 pub fn impl_self_ty(&self,
2921 span: Span, // (potential) receiver for this impl
2923 -> TypeAndSubsts<'tcx> {
2924 let ity = self.tcx.type_of(did);
2925 debug!("impl_self_ty: ity={:?}", ity);
2927 let substs = self.fresh_substs_for_item(span, did);
2928 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2930 TypeAndSubsts { substs: substs, ty: substd_ty }
2933 /// Unifies the output type with the expected type early, for more coercions
2934 /// and forward type information on the input expressions.
2935 fn expected_inputs_for_expected_output(&self,
2937 expected_ret: Expectation<'tcx>,
2938 formal_ret: Ty<'tcx>,
2939 formal_args: &[Ty<'tcx>])
2941 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2942 let ret_ty = match expected_ret.only_has_type(self) {
2944 None => return Vec::new()
2946 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2947 // Attempt to apply a subtyping relationship between the formal
2948 // return type (likely containing type variables if the function
2949 // is polymorphic) and the expected return type.
2950 // No argument expectations are produced if unification fails.
2951 let origin = self.misc(call_span);
2952 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
2954 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
2955 // to identity so the resulting type is not constrained.
2958 // Process any obligations locally as much as
2959 // we can. We don't care if some things turn
2960 // out unconstrained or ambiguous, as we're
2961 // just trying to get hints here.
2962 self.save_and_restore_in_snapshot_flag(|_| {
2963 let mut fulfill = TraitEngine::new(self.tcx);
2964 for obligation in ok.obligations {
2965 fulfill.register_predicate_obligation(self, obligation);
2967 fulfill.select_where_possible(self)
2968 }).map_err(|_| ())?;
2970 Err(_) => return Err(()),
2973 // Record all the argument types, with the substitutions
2974 // produced from the above subtyping unification.
2975 Ok(formal_args.iter().map(|ty| {
2976 self.resolve_type_vars_if_possible(ty)
2978 }).unwrap_or(Vec::new());
2979 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2980 formal_args, formal_ret,
2981 expect_args, expected_ret);
2985 // Checks a method call.
2986 fn check_method_call(&self,
2987 expr: &'gcx hir::Expr,
2988 segment: &hir::PathSegment,
2990 args: &'gcx [hir::Expr],
2991 expected: Expectation<'tcx>,
2992 needs: Needs) -> Ty<'tcx> {
2993 let rcvr = &args[0];
2994 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
2995 // no need to check for bot/err -- callee does that
2996 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
2998 let method = match self.lookup_method(rcvr_t,
3004 self.write_method_call(expr.hir_id, method);
3008 if segment.ident.name != keywords::Invalid.name() {
3009 self.report_method_error(span,
3020 // Call the generic checker.
3021 self.check_method_argument_types(span,
3029 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3033 .unwrap_or_else(|| span_bug!(return_expr.span,
3034 "check_return_expr called outside fn body"));
3036 let ret_ty = ret_coercion.borrow().expected_ty();
3037 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3038 ret_coercion.borrow_mut()
3040 &self.cause(return_expr.span,
3041 ObligationCauseCode::ReturnType(return_expr.id)),
3047 // A generic function for checking the then and else in an if
3049 fn check_then_else(&self,
3050 cond_expr: &'gcx hir::Expr,
3051 then_expr: &'gcx hir::Expr,
3052 opt_else_expr: Option<&'gcx hir::Expr>,
3054 expected: Expectation<'tcx>) -> Ty<'tcx> {
3055 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3056 let cond_diverges = self.diverges.get();
3057 self.diverges.set(Diverges::Maybe);
3059 let expected = expected.adjust_for_branches(self);
3060 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3061 let then_diverges = self.diverges.get();
3062 self.diverges.set(Diverges::Maybe);
3064 // We've already taken the expected type's preferences
3065 // into account when typing the `then` branch. To figure
3066 // out the initial shot at a LUB, we thus only consider
3067 // `expected` if it represents a *hard* constraint
3068 // (`only_has_type`); otherwise, we just go with a
3069 // fresh type variable.
3070 let coerce_to_ty = expected.coercion_target_type(self, sp);
3071 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3073 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3074 coerce.coerce(self, &if_cause, then_expr, then_ty);
3076 if let Some(else_expr) = opt_else_expr {
3077 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3078 let else_diverges = self.diverges.get();
3080 coerce.coerce(self, &if_cause, else_expr, else_ty);
3082 // We won't diverge unless both branches do (or the condition does).
3083 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3085 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3086 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3088 // If the condition is false we can't diverge.
3089 self.diverges.set(cond_diverges);
3092 let result_ty = coerce.complete(self);
3093 if cond_ty.references_error() {
3100 // Check field access expressions
3101 fn check_field(&self,
3102 expr: &'gcx hir::Expr,
3104 base: &'gcx hir::Expr,
3105 field: ast::Ident) -> Ty<'tcx> {
3106 let expr_t = self.check_expr_with_needs(base, needs);
3107 let expr_t = self.structurally_resolved_type(base.span,
3109 let mut private_candidate = None;
3110 let mut autoderef = self.autoderef(expr.span, expr_t);
3111 while let Some((base_t, _)) = autoderef.next() {
3113 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3114 debug!("struct named {:?}", base_t);
3115 let (ident, def_scope) =
3116 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3117 let fields = &base_def.non_enum_variant().fields;
3118 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3119 let field = &fields[index];
3120 let field_ty = self.field_ty(expr.span, field, substs);
3121 // Save the index of all fields regardless of their visibility in case
3122 // of error recovery.
3123 self.write_field_index(expr.id, index);
3124 if field.vis.is_accessible_from(def_scope, self.tcx) {
3125 let adjustments = autoderef.adjust_steps(needs);
3126 self.apply_adjustments(base, adjustments);
3127 autoderef.finalize();
3129 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3132 private_candidate = Some((base_def.did, field_ty));
3135 ty::TyTuple(ref tys) => {
3136 let fstr = field.as_str();
3137 if let Ok(index) = fstr.parse::<usize>() {
3138 if fstr == index.to_string() {
3139 if let Some(field_ty) = tys.get(index) {
3140 let adjustments = autoderef.adjust_steps(needs);
3141 self.apply_adjustments(base, adjustments);
3142 autoderef.finalize();
3144 self.write_field_index(expr.id, index);
3153 autoderef.unambiguous_final_ty();
3155 if let Some((did, field_ty)) = private_candidate {
3156 let struct_path = self.tcx().item_path_str(did);
3157 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3158 "field `{}` of struct `{}` is private",
3159 field, struct_path);
3160 // Also check if an accessible method exists, which is often what is meant.
3161 if self.method_exists(field, expr_t, expr.id, false) {
3162 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3166 } else if field.name == keywords::Invalid.name() {
3167 self.tcx().types.err
3168 } else if self.method_exists(field, expr_t, expr.id, true) {
3169 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3170 "attempted to take value of method `{}` on type `{}`",
3172 .help("maybe a `()` to call it is missing?")
3174 self.tcx().types.err
3176 if !expr_t.is_primitive_ty() {
3177 let mut err = self.no_such_field_err(field.span, field, expr_t);
3180 ty::TyAdt(def, _) if !def.is_enum() => {
3181 if let Some(suggested_field_name) =
3182 Self::suggest_field_name(def.non_enum_variant(),
3183 &field.as_str(), vec![]) {
3184 err.span_label(field.span,
3185 format!("did you mean `{}`?", suggested_field_name));
3187 err.span_label(field.span, "unknown field");
3188 let struct_variant_def = def.non_enum_variant();
3189 let field_names = self.available_field_names(struct_variant_def);
3190 if !field_names.is_empty() {
3191 err.note(&format!("available fields are: {}",
3192 self.name_series_display(field_names)));
3196 ty::TyRawPtr(..) => {
3197 let base = self.tcx.hir.node_to_pretty_string(base.id);
3198 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3199 let suggestion = format!("(*{}).{}", base, field);
3200 err.span_suggestion(field.span, &msg, suggestion);
3206 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3207 "`{}` is a primitive type and therefore doesn't have fields",
3210 self.tcx().types.err
3214 // Return an hint about the closest match in field names
3215 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3217 skip: Vec<LocalInternedString>)
3219 let names = variant.fields.iter().filter_map(|field| {
3220 // ignore already set fields and private fields from non-local crates
3221 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3222 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3225 Some(&field.ident.name)
3229 find_best_match_for_name(names, field, None)
3232 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3233 let mut available = Vec::new();
3234 for field in variant.fields.iter() {
3235 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3236 if field.vis.is_accessible_from(def_scope, self.tcx) {
3237 available.push(field.ident.name);
3243 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3244 // dynamic limit, to never omit just one field
3245 let limit = if names.len() == 6 { 6 } else { 5 };
3246 let mut display = names.iter().take(limit)
3247 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3248 if names.len() > limit {
3249 display = format!("{} ... and {} others", display, names.len() - limit);
3254 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3255 -> DiagnosticBuilder {
3256 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3257 "no field `{}` on type `{}`",
3261 fn report_unknown_field(&self,
3263 variant: &'tcx ty::VariantDef,
3265 skip_fields: &[hir::Field],
3267 let mut err = self.type_error_struct_with_diag(
3269 |actual| match ty.sty {
3270 ty::TyAdt(adt, ..) if adt.is_enum() => {
3271 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3272 "{} `{}::{}` has no field named `{}`",
3273 kind_name, actual, variant.name, field.ident)
3276 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3277 "{} `{}` has no field named `{}`",
3278 kind_name, actual, field.ident)
3282 // prevent all specified fields from being suggested
3283 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3284 if let Some(field_name) = Self::suggest_field_name(variant,
3285 &field.ident.as_str(),
3286 skip_fields.collect()) {
3287 err.span_label(field.ident.span,
3288 format!("field does not exist - did you mean `{}`?", field_name));
3291 ty::TyAdt(adt, ..) => {
3293 err.span_label(field.ident.span,
3294 format!("`{}::{}` does not have this field",
3297 err.span_label(field.ident.span,
3298 format!("`{}` does not have this field", ty));
3300 let available_field_names = self.available_field_names(variant);
3301 if !available_field_names.is_empty() {
3302 err.note(&format!("available fields are: {}",
3303 self.name_series_display(available_field_names)));
3306 _ => bug!("non-ADT passed to report_unknown_field")
3312 fn check_expr_struct_fields(&self,
3314 expected: Expectation<'tcx>,
3315 expr_id: ast::NodeId,
3317 variant: &'tcx ty::VariantDef,
3318 ast_fields: &'gcx [hir::Field],
3319 check_completeness: bool) -> bool {
3323 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3324 .get(0).cloned().unwrap_or(adt_ty);
3325 // re-link the regions that EIfEO can erase.
3326 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3328 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3329 &ty::TyAdt(adt, substs) => {
3330 (substs, adt.adt_kind(), adt.variant_descr())
3332 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3335 let mut remaining_fields = FxHashMap();
3336 for (i, field) in variant.fields.iter().enumerate() {
3337 remaining_fields.insert(field.ident.modern(), (i, field));
3340 let mut seen_fields = FxHashMap();
3342 let mut error_happened = false;
3344 // Typecheck each field.
3345 for field in ast_fields {
3346 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3347 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3348 seen_fields.insert(ident, field.span);
3349 self.write_field_index(field.id, i);
3351 // we don't look at stability attributes on
3352 // struct-like enums (yet...), but it's definitely not
3353 // a bug to have construct one.
3354 if adt_kind != ty::AdtKind::Enum {
3355 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3358 self.field_ty(field.span, v_field, substs)
3360 error_happened = true;
3361 if let Some(prev_span) = seen_fields.get(&ident) {
3362 let mut err = struct_span_err!(self.tcx.sess,
3365 "field `{}` specified more than once",
3368 err.span_label(field.ident.span, "used more than once");
3369 err.span_label(*prev_span, format!("first use of `{}`", ident));
3373 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3379 // Make sure to give a type to the field even if there's
3380 // an error, so we can continue typechecking
3381 self.check_expr_coercable_to_type(&field.expr, field_type);
3384 // Make sure the programmer specified correct number of fields.
3385 if kind_name == "union" {
3386 if ast_fields.len() != 1 {
3387 tcx.sess.span_err(span, "union expressions should have exactly one field");
3389 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3390 let len = remaining_fields.len();
3392 let mut displayable_field_names = remaining_fields
3394 .map(|ident| ident.as_str())
3395 .collect::<Vec<_>>();
3397 displayable_field_names.sort();
3399 let truncated_fields_error = if len <= 3 {
3402 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3405 let remaining_fields_names = displayable_field_names.iter().take(3)
3406 .map(|n| format!("`{}`", n))
3407 .collect::<Vec<_>>()
3410 struct_span_err!(tcx.sess, span, E0063,
3411 "missing field{} {}{} in initializer of `{}`",
3412 if remaining_fields.len() == 1 { "" } else { "s" },
3413 remaining_fields_names,
3414 truncated_fields_error,
3416 .span_label(span, format!("missing {}{}",
3417 remaining_fields_names,
3418 truncated_fields_error))
3424 fn check_struct_fields_on_error(&self,
3425 fields: &'gcx [hir::Field],
3426 base_expr: &'gcx Option<P<hir::Expr>>) {
3427 for field in fields {
3428 self.check_expr(&field.expr);
3432 self.check_expr(&base);
3438 pub fn check_struct_path(&self,
3440 node_id: ast::NodeId)
3441 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3442 let path_span = match *qpath {
3443 hir::QPath::Resolved(_, ref path) => path.span,
3444 hir::QPath::TypeRelative(ref qself, _) => qself.span
3446 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3447 let variant = match def {
3449 self.set_tainted_by_errors();
3452 Def::Variant(..) => {
3454 ty::TyAdt(adt, substs) => {
3455 Some((adt.variant_of_def(def), adt.did, substs))
3457 _ => bug!("unexpected type: {:?}", ty.sty)
3460 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3461 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3463 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3464 Some((adt.non_enum_variant(), adt.did, substs))
3469 _ => bug!("unexpected definition: {:?}", def)
3472 if let Some((variant, did, substs)) = variant {
3473 // Check bounds on type arguments used in the path.
3474 let bounds = self.instantiate_bounds(path_span, did, substs);
3475 let cause = traits::ObligationCause::new(path_span, self.body_id,
3476 traits::ItemObligation(did));
3477 self.add_obligations_for_parameters(cause, &bounds);
3481 struct_span_err!(self.tcx.sess, path_span, E0071,
3482 "expected struct, variant or union type, found {}",
3483 ty.sort_string(self.tcx))
3484 .span_label(path_span, "not a struct")
3490 fn check_expr_struct(&self,
3492 expected: Expectation<'tcx>,
3494 fields: &'gcx [hir::Field],
3495 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3497 // Find the relevant variant
3498 let (variant, struct_ty) =
3499 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3502 self.check_struct_fields_on_error(fields, base_expr);
3503 return self.tcx.types.err;
3506 let path_span = match *qpath {
3507 hir::QPath::Resolved(_, ref path) => path.span,
3508 hir::QPath::TypeRelative(ref qself, _) => qself.span
3511 // Prohibit struct expressions when non exhaustive flag is set.
3512 if let ty::TyAdt(adt, _) = struct_ty.sty {
3513 if !adt.did.is_local() && adt.is_non_exhaustive() {
3514 span_err!(self.tcx.sess, expr.span, E0639,
3515 "cannot create non-exhaustive {} using struct expression",
3516 adt.variant_descr());
3520 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3521 variant, fields, base_expr.is_none());
3522 if let &Some(ref base_expr) = base_expr {
3523 // If check_expr_struct_fields hit an error, do not attempt to populate
3524 // the fields with the base_expr. This could cause us to hit errors later
3525 // when certain fields are assumed to exist that in fact do not.
3526 if !error_happened {
3527 self.check_expr_has_type_or_error(base_expr, struct_ty);
3528 match struct_ty.sty {
3529 ty::TyAdt(adt, substs) if adt.is_struct() => {
3530 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3531 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3536 .fru_field_types_mut()
3537 .insert(expr.hir_id, fru_field_types);
3540 span_err!(self.tcx.sess, base_expr.span, E0436,
3541 "functional record update syntax requires a struct");
3546 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3552 /// If an expression has any sub-expressions that result in a type error,
3553 /// inspecting that expression's type with `ty.references_error()` will return
3554 /// true. Likewise, if an expression is known to diverge, inspecting its
3555 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3556 /// strict, _|_ can appear in the type of an expression that does not,
3557 /// itself, diverge: for example, fn() -> _|_.)
3558 /// Note that inspecting a type's structure *directly* may expose the fact
3559 /// that there are actually multiple representations for `TyError`, so avoid
3560 /// that when err needs to be handled differently.
3561 fn check_expr_with_expectation_and_needs(&self,
3562 expr: &'gcx hir::Expr,
3563 expected: Expectation<'tcx>,
3564 needs: Needs) -> Ty<'tcx> {
3565 debug!(">> typechecking: expr={:?} expected={:?}",
3568 // Warn for expressions after diverging siblings.
3569 self.warn_if_unreachable(expr.id, expr.span, "expression");
3571 // Hide the outer diverging and has_errors flags.
3572 let old_diverges = self.diverges.get();
3573 let old_has_errors = self.has_errors.get();
3574 self.diverges.set(Diverges::Maybe);
3575 self.has_errors.set(false);
3577 let ty = self.check_expr_kind(expr, expected, needs);
3579 // Warn for non-block expressions with diverging children.
3581 hir::ExprBlock(..) |
3582 hir::ExprLoop(..) | hir::ExprWhile(..) |
3583 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3585 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3588 // Any expression that produces a value of type `!` must have diverged
3590 self.diverges.set(self.diverges.get() | Diverges::Always);
3593 // Record the type, which applies it effects.
3594 // We need to do this after the warning above, so that
3595 // we don't warn for the diverging expression itself.
3596 self.write_ty(expr.hir_id, ty);
3598 // Combine the diverging and has_error flags.
3599 self.diverges.set(self.diverges.get() | old_diverges);
3600 self.has_errors.set(self.has_errors.get() | old_has_errors);
3602 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3603 debug!("... {:?}, expected is {:?}", ty, expected);
3608 fn check_expr_kind(&self,
3609 expr: &'gcx hir::Expr,
3610 expected: Expectation<'tcx>,
3611 needs: Needs) -> Ty<'tcx> {
3615 hir::ExprBox(ref subexpr) => {
3616 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3618 ty::TyAdt(def, _) if def.is_box()
3619 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3623 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3624 tcx.mk_box(referent_ty)
3627 hir::ExprLit(ref lit) => {
3628 self.check_lit(&lit, expected)
3630 hir::ExprBinary(op, ref lhs, ref rhs) => {
3631 self.check_binop(expr, op, lhs, rhs)
3633 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3634 self.check_binop_assign(expr, op, lhs, rhs)
3636 hir::ExprUnary(unop, ref oprnd) => {
3637 let expected_inner = match unop {
3638 hir::UnNot | hir::UnNeg => {
3645 let needs = match unop {
3646 hir::UnDeref => needs,
3649 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3653 if !oprnd_t.references_error() {
3654 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3657 if let Some(mt) = oprnd_t.builtin_deref(true) {
3659 } else if let Some(ok) = self.try_overloaded_deref(
3660 expr.span, oprnd_t, needs) {
3661 let method = self.register_infer_ok_obligations(ok);
3662 if let ty::TyRef(region, _, mutbl) = method.sig.inputs()[0].sty {
3663 let mutbl = match mutbl {
3664 hir::MutImmutable => AutoBorrowMutability::Immutable,
3665 hir::MutMutable => AutoBorrowMutability::Mutable {
3666 // (It shouldn't actually matter for unary ops whether
3667 // we enable two-phase borrows or not, since a unary
3668 // op has no additional operands.)
3669 allow_two_phase_borrow: AllowTwoPhase::No,
3672 self.apply_adjustments(oprnd, vec![Adjustment {
3673 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3674 target: method.sig.inputs()[0]
3677 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3678 self.write_method_call(expr.hir_id, method);
3680 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3681 "type `{}` cannot be dereferenced",
3683 oprnd_t = tcx.types.err;
3687 let result = self.check_user_unop(expr, oprnd_t, unop);
3688 // If it's builtin, we can reuse the type, this helps inference.
3689 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3694 let result = self.check_user_unop(expr, oprnd_t, unop);
3695 // If it's builtin, we can reuse the type, this helps inference.
3696 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3704 hir::ExprAddrOf(mutbl, ref oprnd) => {
3705 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3707 ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
3708 if self.is_place_expr(&oprnd) {
3709 // Places may legitimately have unsized types.
3710 // For example, dereferences of a fat pointer and
3711 // the last field of a struct can be unsized.
3714 Expectation::rvalue_hint(self, ty)
3720 let needs = Needs::maybe_mut_place(mutbl);
3721 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3723 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3724 if tm.ty.references_error() {
3727 // Note: at this point, we cannot say what the best lifetime
3728 // is to use for resulting pointer. We want to use the
3729 // shortest lifetime possible so as to avoid spurious borrowck
3730 // errors. Moreover, the longest lifetime will depend on the
3731 // precise details of the value whose address is being taken
3732 // (and how long it is valid), which we don't know yet until type
3733 // inference is complete.
3735 // Therefore, here we simply generate a region variable. The
3736 // region inferencer will then select the ultimate value.
3737 // Finally, borrowck is charged with guaranteeing that the
3738 // value whose address was taken can actually be made to live
3739 // as long as it needs to live.
3740 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3741 tcx.mk_ref(region, tm)
3744 hir::ExprPath(ref qpath) => {
3745 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3746 let ty = if def != Def::Err {
3747 self.instantiate_value_path(segs, opt_ty, def, expr.span, id)
3749 self.set_tainted_by_errors();
3753 // We always require that the type provided as the value for
3754 // a type parameter outlives the moment of instantiation.
3755 let substs = self.tables.borrow().node_substs(expr.hir_id);
3756 self.add_wf_bounds(substs, expr);
3760 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3761 for output in outputs {
3762 self.check_expr(output);
3764 for input in inputs {
3765 self.check_expr(input);
3769 hir::ExprBreak(destination, ref expr_opt) => {
3770 if let Ok(target_id) = destination.target_id {
3772 if let Some(ref e) = *expr_opt {
3773 // If this is a break with a value, we need to type-check
3774 // the expression. Get an expected type from the loop context.
3775 let opt_coerce_to = {
3776 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3777 enclosing_breakables.find_breakable(target_id)
3780 .map(|coerce| coerce.expected_ty())
3783 // If the loop context is not a `loop { }`, then break with
3784 // a value is illegal, and `opt_coerce_to` will be `None`.
3785 // Just set expectation to error in that case.
3786 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3788 // Recurse without `enclosing_breakables` borrowed.
3789 e_ty = self.check_expr_with_hint(e, coerce_to);
3790 cause = self.misc(e.span);
3792 // Otherwise, this is a break *without* a value. That's
3793 // always legal, and is equivalent to `break ()`.
3794 e_ty = tcx.mk_nil();
3795 cause = self.misc(expr.span);
3798 // Now that we have type-checked `expr_opt`, borrow
3799 // the `enclosing_loops` field and let's coerce the
3800 // type of `expr_opt` into what is expected.
3801 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3802 let ctxt = enclosing_breakables.find_breakable(target_id);
3803 if let Some(ref mut coerce) = ctxt.coerce {
3804 if let Some(ref e) = *expr_opt {
3805 coerce.coerce(self, &cause, e, e_ty);
3807 assert!(e_ty.is_nil());
3808 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3811 // If `ctxt.coerce` is `None`, we can just ignore
3812 // the type of the expresison. This is because
3813 // either this was a break *without* a value, in
3814 // which case it is always a legal type (`()`), or
3815 // else an error would have been flagged by the
3816 // `loops` pass for using break with an expression
3817 // where you are not supposed to.
3818 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3821 ctxt.may_break = true;
3823 // the type of a `break` is always `!`, since it diverges
3826 // Otherwise, we failed to find the enclosing loop;
3827 // this can only happen if the `break` was not
3828 // inside a loop at all, which is caught by the
3829 // loop-checking pass.
3830 if self.tcx.sess.err_count() == 0 {
3831 self.tcx.sess.delay_span_bug(expr.span,
3832 "break was outside loop, but no error was emitted");
3835 // We still need to assign a type to the inner expression to
3836 // prevent the ICE in #43162.
3837 if let Some(ref e) = *expr_opt {
3838 self.check_expr_with_hint(e, tcx.types.err);
3840 // ... except when we try to 'break rust;'.
3841 // ICE this expression in particular (see #43162).
3842 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3843 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3844 fatally_break_rust(self.tcx.sess);
3848 // There was an error, make typecheck fail
3853 hir::ExprContinue(destination) => {
3854 if let Ok(_) = destination.target_id {
3857 // There was an error, make typecheck fail
3861 hir::ExprRet(ref expr_opt) => {
3862 if self.ret_coercion.is_none() {
3863 struct_span_err!(self.tcx.sess, expr.span, E0572,
3864 "return statement outside of function body").emit();
3865 } else if let Some(ref e) = *expr_opt {
3866 self.check_return_expr(e);
3868 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3869 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3870 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3874 hir::ExprAssign(ref lhs, ref rhs) => {
3875 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3877 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3880 ExpectIfCondition => {
3881 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3882 expected error elsehwere");
3885 // Only check this if not in an `if` condition, as the
3886 // mistyped comparison help is more appropriate.
3887 if !self.is_place_expr(&lhs) {
3888 struct_span_err!(self.tcx.sess, expr.span, E0070,
3889 "invalid left-hand side expression")
3890 .span_label(expr.span, "left-hand of expression not valid")
3896 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3898 if lhs_ty.references_error() || rhs_ty.references_error() {
3904 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3905 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3906 expr.span, expected)
3908 hir::ExprWhile(ref cond, ref body, _) => {
3909 let ctxt = BreakableCtxt {
3910 // cannot use break with a value from a while loop
3912 may_break: false, // Will get updated if/when we find a `break`.
3915 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3916 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3917 let cond_diverging = self.diverges.get();
3918 self.check_block_no_value(&body);
3920 // We may never reach the body so it diverging means nothing.
3921 self.diverges.set(cond_diverging);
3925 // No way to know whether it's diverging because
3926 // of a `break` or an outer `break` or `return`.
3927 self.diverges.set(Diverges::Maybe);
3932 hir::ExprLoop(ref body, _, source) => {
3933 let coerce = match source {
3934 // you can only use break with a value from a normal `loop { }`
3935 hir::LoopSource::Loop => {
3936 let coerce_to = expected.coercion_target_type(self, body.span);
3937 Some(CoerceMany::new(coerce_to))
3940 hir::LoopSource::WhileLet |
3941 hir::LoopSource::ForLoop => {
3946 let ctxt = BreakableCtxt {
3948 may_break: false, // Will get updated if/when we find a `break`.
3951 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3952 self.check_block_no_value(&body);
3956 // No way to know whether it's diverging because
3957 // of a `break` or an outer `break` or `return`.
3958 self.diverges.set(Diverges::Maybe);
3961 // If we permit break with a value, then result type is
3962 // the LUB of the breaks (possibly ! if none); else, it
3963 // is nil. This makes sense because infinite loops
3964 // (which would have type !) are only possible iff we
3965 // permit break with a value [1].
3966 if ctxt.coerce.is_none() && !ctxt.may_break {
3968 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
3970 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3972 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3973 self.check_match(expr, &discrim, arms, expected, match_src)
3975 hir::ExprClosure(capture, ref decl, body_id, _, gen) => {
3976 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
3978 hir::ExprBlock(ref body, _) => {
3979 self.check_block_with_expected(&body, expected)
3981 hir::ExprCall(ref callee, ref args) => {
3982 self.check_call(expr, &callee, args, expected)
3984 hir::ExprMethodCall(ref segment, span, ref args) => {
3985 self.check_method_call(expr, segment, span, args, expected, needs)
3987 hir::ExprCast(ref e, ref t) => {
3988 // Find the type of `e`. Supply hints based on the type we are casting to,
3990 let t_cast = self.to_ty(t);
3991 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3992 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3993 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3995 // Eagerly check for some obvious errors.
3996 if t_expr.references_error() || t_cast.references_error() {
3999 // Defer other checks until we're done type checking.
4000 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4001 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4003 deferred_cast_checks.push(cast_check);
4006 Err(ErrorReported) => {
4012 hir::ExprType(ref e, ref t) => {
4013 let ty = self.to_ty(&t);
4014 self.check_expr_eq_type(&e, ty);
4017 hir::ExprArray(ref args) => {
4018 let uty = expected.to_option(self).and_then(|uty| {
4020 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4025 let element_ty = if !args.is_empty() {
4026 let coerce_to = uty.unwrap_or_else(
4027 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4028 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4029 assert_eq!(self.diverges.get(), Diverges::Maybe);
4031 let e_ty = self.check_expr_with_hint(e, coerce_to);
4032 let cause = self.misc(e.span);
4033 coerce.coerce(self, &cause, e, e_ty);
4035 coerce.complete(self)
4037 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4039 tcx.mk_array(element_ty, args.len() as u64)
4041 hir::ExprRepeat(ref element, ref count) => {
4042 let count_def_id = tcx.hir.local_def_id(count.id);
4043 let param_env = ty::ParamEnv::empty();
4044 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4045 let instance = ty::Instance::resolve(
4051 let global_id = GlobalId {
4055 let count = tcx.const_eval(param_env.and(global_id));
4057 if let Err(ref err) = count {
4058 err.report_as_error(
4059 tcx.at(tcx.def_span(count_def_id)),
4060 "could not evaluate repeat length",
4064 let uty = match expected {
4065 ExpectHasType(uty) => {
4067 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4074 let (element_ty, t) = match uty {
4076 self.check_expr_coercable_to_type(&element, uty);
4080 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4081 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4086 if let Ok(count) = count {
4087 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4089 // For [foo, ..n] where n > 1, `foo` must have
4091 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4092 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4096 if element_ty.references_error() {
4098 } else if let Ok(count) = count {
4099 tcx.mk_ty(ty::TyArray(t, count))
4104 hir::ExprTup(ref elts) => {
4105 let flds = expected.only_has_type(self).and_then(|ty| {
4106 let ty = self.resolve_type_vars_with_obligations(ty);
4108 ty::TyTuple(ref flds) => Some(&flds[..]),
4113 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4114 let t = match flds {
4115 Some(ref fs) if i < fs.len() => {
4117 self.check_expr_coercable_to_type(&e, ety);
4121 self.check_expr_with_expectation(&e, NoExpectation)
4126 let tuple = tcx.mk_tup(elt_ts_iter);
4127 if tuple.references_error() {
4130 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4134 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4135 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4137 hir::ExprField(ref base, field) => {
4138 self.check_field(expr, needs, &base, field)
4140 hir::ExprIndex(ref base, ref idx) => {
4141 let base_t = self.check_expr_with_needs(&base, needs);
4142 let idx_t = self.check_expr(&idx);
4144 if base_t.references_error() {
4146 } else if idx_t.references_error() {
4149 let base_t = self.structurally_resolved_type(base.span, base_t);
4150 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4151 Some((index_ty, element_ty)) => {
4152 // two-phase not needed because index_ty is never mutable
4153 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4158 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4159 "cannot index into a value of type `{}`",
4161 // Try to give some advice about indexing tuples.
4162 if let ty::TyTuple(..) = base_t.sty {
4163 let mut needs_note = true;
4164 // If the index is an integer, we can show the actual
4165 // fixed expression:
4166 if let hir::ExprLit(ref lit) = idx.node {
4167 if let ast::LitKind::Int(i,
4168 ast::LitIntType::Unsuffixed) = lit.node {
4169 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4170 if let Ok(snip) = snip {
4171 err.span_suggestion(expr.span,
4172 "to access tuple elements, use",
4173 format!("{}.{}", snip, i));
4179 err.help("to access tuple elements, use tuple indexing \
4180 syntax (e.g. `tuple.0`)");
4189 hir::ExprYield(ref value) => {
4190 match self.yield_ty {
4192 self.check_expr_coercable_to_type(&value, ty);
4195 struct_span_err!(self.tcx.sess, expr.span, E0627,
4196 "yield statement outside of generator literal").emit();
4204 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4205 // The newly resolved definition is written into `type_dependent_defs`.
4206 fn finish_resolving_struct_path(&self,
4209 node_id: ast::NodeId)
4213 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4214 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4215 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4218 hir::QPath::TypeRelative(ref qself, ref segment) => {
4219 let ty = self.to_ty(qself);
4221 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4226 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4229 // Write back the new resolution.
4230 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4231 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4238 // Resolve associated value path into a base type and associated constant or method definition.
4239 // The newly resolved definition is written into `type_dependent_defs`.
4240 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4241 qpath: &'b hir::QPath,
4242 node_id: ast::NodeId,
4244 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4246 let (ty, item_segment) = match *qpath {
4247 hir::QPath::Resolved(ref opt_qself, ref path) => {
4249 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4250 &path.segments[..]);
4252 hir::QPath::TypeRelative(ref qself, ref segment) => {
4253 (self.to_ty(qself), segment)
4256 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4257 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4258 // Return directly on cache hit. This is useful to avoid doubly reporting
4259 // errors with default match binding modes. See #44614.
4260 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4262 let item_name = item_segment.ident;
4263 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4266 let def = match error {
4267 method::MethodError::PrivateMatch(def, _) => def,
4270 if item_name.name != keywords::Invalid.name() {
4271 self.report_method_error(span, ty, item_name, None, error, None);
4277 // Write back the new resolution.
4278 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4279 (def, Some(ty), slice::from_ref(&**item_segment))
4282 pub fn check_decl_initializer(&self,
4283 local: &'gcx hir::Local,
4284 init: &'gcx hir::Expr) -> Ty<'tcx>
4286 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4287 // for #42640 (default match binding modes).
4290 let ref_bindings = local.pat.contains_explicit_ref_binding();
4292 let local_ty = self.local_ty(init.span, local.id);
4293 if let Some(m) = ref_bindings {
4294 // Somewhat subtle: if we have a `ref` binding in the pattern,
4295 // we want to avoid introducing coercions for the RHS. This is
4296 // both because it helps preserve sanity and, in the case of
4297 // ref mut, for soundness (issue #23116). In particular, in
4298 // the latter case, we need to be clear that the type of the
4299 // referent for the reference that results is *equal to* the
4300 // type of the place it is referencing, and not some
4301 // supertype thereof.
4302 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4303 self.demand_eqtype(init.span, local_ty, init_ty);
4306 self.check_expr_coercable_to_type(init, local_ty)
4310 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4311 let t = self.local_ty(local.span, local.id);
4312 self.write_ty(local.hir_id, t);
4314 if let Some(ref init) = local.init {
4315 let init_ty = self.check_decl_initializer(local, &init);
4316 if init_ty.references_error() {
4317 self.write_ty(local.hir_id, init_ty);
4321 self.check_pat_walk(&local.pat, t,
4322 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4324 let pat_ty = self.node_ty(local.pat.hir_id);
4325 if pat_ty.references_error() {
4326 self.write_ty(local.hir_id, pat_ty);
4330 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4331 // Don't do all the complex logic below for DeclItem.
4333 hir::StmtDecl(ref decl, _) => {
4335 hir::DeclLocal(_) => {}
4336 hir::DeclItem(_) => {
4341 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4344 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4346 // Hide the outer diverging and has_errors flags.
4347 let old_diverges = self.diverges.get();
4348 let old_has_errors = self.has_errors.get();
4349 self.diverges.set(Diverges::Maybe);
4350 self.has_errors.set(false);
4353 hir::StmtDecl(ref decl, _) => {
4355 hir::DeclLocal(ref l) => {
4356 self.check_decl_local(&l);
4358 hir::DeclItem(_) => {/* ignore for now */}
4361 hir::StmtExpr(ref expr, _) => {
4362 // Check with expected type of ()
4363 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4365 hir::StmtSemi(ref expr, _) => {
4366 self.check_expr(&expr);
4370 // Combine the diverging and has_error flags.
4371 self.diverges.set(self.diverges.get() | old_diverges);
4372 self.has_errors.set(self.has_errors.get() | old_has_errors);
4375 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4376 let unit = self.tcx.mk_nil();
4377 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4379 // if the block produces a `!` value, that can always be
4380 // (effectively) coerced to unit.
4382 self.demand_suptype(blk.span, unit, ty);
4386 fn check_block_with_expected(&self,
4387 blk: &'gcx hir::Block,
4388 expected: Expectation<'tcx>) -> Ty<'tcx> {
4390 let mut fcx_ps = self.ps.borrow_mut();
4391 let unsafety_state = fcx_ps.recurse(blk);
4392 replace(&mut *fcx_ps, unsafety_state)
4395 // In some cases, blocks have just one exit, but other blocks
4396 // can be targeted by multiple breaks. This can happen both
4397 // with labeled blocks as well as when we desugar
4398 // a `do catch { ... }` expression.
4402 // 'a: { if true { break 'a Err(()); } Ok(()) }
4404 // Here we would wind up with two coercions, one from
4405 // `Err(())` and the other from the tail expression
4406 // `Ok(())`. If the tail expression is omitted, that's a
4407 // "forced unit" -- unless the block diverges, in which
4408 // case we can ignore the tail expression (e.g., `'a: {
4409 // break 'a 22; }` would not force the type of the block
4411 let tail_expr = blk.expr.as_ref();
4412 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4413 let coerce = if blk.targeted_by_break {
4414 CoerceMany::new(coerce_to_ty)
4416 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4417 Some(e) => slice::from_ref(e),
4420 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4423 let prev_diverges = self.diverges.get();
4424 let ctxt = BreakableCtxt {
4425 coerce: Some(coerce),
4429 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4430 for s in &blk.stmts {
4434 // check the tail expression **without** holding the
4435 // `enclosing_breakables` lock below.
4436 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4438 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4439 let ctxt = enclosing_breakables.find_breakable(blk.id);
4440 let coerce = ctxt.coerce.as_mut().unwrap();
4441 if let Some(tail_expr_ty) = tail_expr_ty {
4442 let tail_expr = tail_expr.unwrap();
4443 let cause = self.cause(tail_expr.span,
4444 ObligationCauseCode::BlockTailExpression(blk.id));
4450 // Subtle: if there is no explicit tail expression,
4451 // that is typically equivalent to a tail expression
4452 // of `()` -- except if the block diverges. In that
4453 // case, there is no value supplied from the tail
4454 // expression (assuming there are no other breaks,
4455 // this implies that the type of the block will be
4458 // #41425 -- label the implicit `()` as being the
4459 // "found type" here, rather than the "expected type".
4461 // #44579 -- if the block was recovered during parsing,
4462 // the type would be nonsensical and it is not worth it
4463 // to perform the type check, so we avoid generating the
4464 // diagnostic output.
4465 if !self.diverges.get().always() && !blk.recovered {
4466 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4467 if let Some(expected_ty) = expected.only_has_type(self) {
4468 self.consider_hint_about_removing_semicolon(blk,
4478 // If we can break from the block, then the block's exit is always reachable
4479 // (... as long as the entry is reachable) - regardless of the tail of the block.
4480 self.diverges.set(prev_diverges);
4483 let mut ty = ctxt.coerce.unwrap().complete(self);
4485 if self.has_errors.get() || ty.references_error() {
4486 ty = self.tcx.types.err
4489 self.write_ty(blk.hir_id, ty);
4491 *self.ps.borrow_mut() = prev;
4495 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4496 /// suggestion can be made, `None` otherwise.
4497 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4498 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4499 // `while` before reaching it, as block tail returns are not available in them.
4500 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4501 let parent = self.tcx.hir.get(fn_id);
4503 if let Node::NodeItem(&hir::Item {
4504 name, node: hir::ItemFn(ref decl, ..), ..
4506 decl.clone().and_then(|decl| {
4507 // This is less than ideal, it will not suggest a return type span on any
4508 // method called `main`, regardless of whether it is actually the entry point,
4509 // but it will still present it as the reason for the expected type.
4510 Some((decl, name != Symbol::intern("main")))
4512 } else if let Node::NodeTraitItem(&hir::TraitItem {
4513 node: hir::TraitItemKind::Method(hir::MethodSig {
4517 decl.clone().and_then(|decl| {
4520 } else if let Node::NodeImplItem(&hir::ImplItem {
4521 node: hir::ImplItemKind::Method(hir::MethodSig {
4525 decl.clone().and_then(|decl| {
4536 /// On implicit return expressions with mismatched types, provide the following suggestions:
4538 /// - Point out the method's return type as the reason for the expected type
4539 /// - Possible missing semicolon
4540 /// - Possible missing return type if the return type is the default, and not `fn main()`
4541 pub fn suggest_mismatched_types_on_tail(&self,
4542 err: &mut DiagnosticBuilder<'tcx>,
4543 expression: &'gcx hir::Expr,
4547 blk_id: ast::NodeId) {
4548 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4549 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4550 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4552 self.suggest_ref_or_into(err, expression, expected, found);
4555 pub fn suggest_ref_or_into(
4557 err: &mut DiagnosticBuilder<'tcx>,
4562 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4563 err.span_suggestion(sp, msg, suggestion);
4564 } else if !self.check_for_cast(err, expr, found, expected) {
4565 let methods = self.get_conversion_methods(expr.span, expected, found);
4566 if let Ok(expr_text) = self.sess().codemap().span_to_snippet(expr.span) {
4567 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4568 .map(|(receiver, method)| format!("{}.{}()", receiver, method.ident))
4569 .collect::<Vec<_>>();
4570 if !suggestions.is_empty() {
4571 err.span_suggestions(expr.span, "try using a conversion method", suggestions);
4577 /// A common error is to forget to add a semicolon at the end of a block:
4581 /// bar_that_returns_u32()
4585 /// This routine checks if the return expression in a block would make sense on its own as a
4586 /// statement and the return type has been left as default or has been specified as `()`. If so,
4587 /// it suggests adding a semicolon.
4588 fn suggest_missing_semicolon(&self,
4589 err: &mut DiagnosticBuilder<'tcx>,
4590 expression: &'gcx hir::Expr,
4593 if expected.is_nil() {
4594 // `BlockTailExpression` only relevant if the tail expr would be
4595 // useful on its own.
4596 match expression.node {
4598 hir::ExprMethodCall(..) |
4600 hir::ExprWhile(..) |
4602 hir::ExprMatch(..) |
4603 hir::ExprBlock(..) => {
4604 let sp = self.tcx.sess.codemap().next_point(cause_span);
4605 err.span_suggestion(sp,
4606 "try adding a semicolon",
4615 /// A possible error is to forget to add a return type that is needed:
4619 /// bar_that_returns_u32()
4623 /// This routine checks if the return type is left as default, the method is not part of an
4624 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4626 fn suggest_missing_return_type(&self,
4627 err: &mut DiagnosticBuilder<'tcx>,
4628 fn_decl: &hir::FnDecl,
4631 can_suggest: bool) {
4632 // Only suggest changing the return type for methods that
4633 // haven't set a return type at all (and aren't `fn main()` or an impl).
4634 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_nil()) {
4635 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4636 err.span_suggestion(span,
4637 "try adding a return type",
4639 self.resolve_type_vars_with_obligations(found)));
4641 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4642 err.span_label(span, "possibly return type missing here?");
4644 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4645 // `fn main()` must return `()`, do not suggest changing return type
4646 err.span_label(span, "expected `()` because of default return type");
4648 // expectation was caused by something else, not the default return
4649 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4650 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4651 // Only point to return type if the expected type is the return type, as if they
4652 // are not, the expectation must have been caused by something else.
4653 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4655 let ty = AstConv::ast_ty_to_ty(self, ty);
4656 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4657 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4658 if ty.sty == expected.sty {
4659 err.span_label(sp, format!("expected `{}` because of return type",
4667 /// A common error is to add an extra semicolon:
4670 /// fn foo() -> usize {
4675 /// This routine checks if the final statement in a block is an
4676 /// expression with an explicit semicolon whose type is compatible
4677 /// with `expected_ty`. If so, it suggests removing the semicolon.
4678 fn consider_hint_about_removing_semicolon(&self,
4679 blk: &'gcx hir::Block,
4680 expected_ty: Ty<'tcx>,
4681 err: &mut DiagnosticBuilder) {
4682 // Be helpful when the user wrote `{... expr;}` and
4683 // taking the `;` off is enough to fix the error.
4684 let last_stmt = match blk.stmts.last() {
4688 let last_expr = match last_stmt.node {
4689 hir::StmtSemi(ref e, _) => e,
4692 let last_expr_ty = self.node_ty(last_expr.hir_id);
4693 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4696 let original_span = original_sp(last_stmt.span, blk.span);
4697 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4698 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4701 // Instantiates the given path, which must refer to an item with the given
4702 // number of type parameters and type.
4703 pub fn instantiate_value_path(&self,
4704 segments: &[hir::PathSegment],
4705 opt_self_ty: Option<Ty<'tcx>>,
4708 node_id: ast::NodeId)
4710 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4715 // We need to extract the type parameters supplied by the user in
4716 // the path `path`. Due to the current setup, this is a bit of a
4717 // tricky-process; the problem is that resolve only tells us the
4718 // end-point of the path resolution, and not the intermediate steps.
4719 // Luckily, we can (at least for now) deduce the intermediate steps
4720 // just from the end-point.
4722 // There are basically four cases to consider:
4724 // 1. Reference to a constructor of enum variant or struct:
4726 // struct Foo<T>(...)
4727 // enum E<T> { Foo(...) }
4729 // In these cases, the parameters are declared in the type
4732 // 2. Reference to a fn item or a free constant:
4736 // In this case, the path will again always have the form
4737 // `a::b::foo::<T>` where only the final segment should have
4738 // type parameters. However, in this case, those parameters are
4739 // declared on a value, and hence are in the `FnSpace`.
4741 // 3. Reference to a method or an associated constant:
4743 // impl<A> SomeStruct<A> {
4747 // Here we can have a path like
4748 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4749 // may appear in two places. The penultimate segment,
4750 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4751 // final segment, `foo::<B>` contains parameters in fn space.
4753 // 4. Reference to a local variable
4755 // Local variables can't have any type parameters.
4757 // The first step then is to categorize the segments appropriately.
4759 assert!(!segments.is_empty());
4761 let mut ufcs_associated = None;
4762 let mut type_segment = None;
4763 let mut fn_segment = None;
4765 // Case 1. Reference to a struct/variant constructor.
4766 Def::StructCtor(def_id, ..) |
4767 Def::VariantCtor(def_id, ..) => {
4768 // Everything but the final segment should have no
4769 // parameters at all.
4770 let mut generics = self.tcx.generics_of(def_id);
4771 if let Some(def_id) = generics.parent {
4772 // Variant and struct constructors use the
4773 // generics of their parent type definition.
4774 generics = self.tcx.generics_of(def_id);
4776 type_segment = Some((segments.last().unwrap(), generics));
4779 // Case 2. Reference to a top-level value.
4781 Def::Const(def_id) |
4782 Def::Static(def_id, _) => {
4783 fn_segment = Some((segments.last().unwrap(), self.tcx.generics_of(def_id)));
4786 // Case 3. Reference to a method or associated const.
4787 Def::Method(def_id) |
4788 Def::AssociatedConst(def_id) => {
4789 let container = self.tcx.associated_item(def_id).container;
4791 ty::TraitContainer(trait_did) => {
4792 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4794 ty::ImplContainer(_) => {}
4797 let generics = self.tcx.generics_of(def_id);
4798 if segments.len() >= 2 {
4799 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4800 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4802 // `<T>::assoc` will end up here, and so can `T::assoc`.
4803 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4804 ufcs_associated = Some((container, self_ty));
4806 fn_segment = Some((segments.last().unwrap(), generics));
4809 // Case 4. Local variable, no generics.
4810 Def::Local(..) | Def::Upvar(..) => {}
4812 _ => bug!("unexpected definition: {:?}", def),
4815 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4817 // Now that we have categorized what space the parameters for each
4818 // segment belong to, let's sort out the parameters that the user
4819 // provided (if any) into their appropriate spaces. We'll also report
4820 // errors if type parameters are provided in an inappropriate place.
4821 let poly_segments = type_segment.is_some() as usize +
4822 fn_segment.is_some() as usize;
4823 AstConv::prohibit_generics(self, &segments[..segments.len() - poly_segments]);
4826 Def::Local(nid) | Def::Upvar(nid, ..) => {
4827 let ty = self.local_ty(span, nid);
4828 let ty = self.normalize_associated_types_in(span, &ty);
4829 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4835 // Now we have to compare the types that the user *actually*
4836 // provided against the types that were *expected*. If the user
4837 // did not provide any types, then we want to substitute inference
4838 // variables. If the user provided some types, we may still need
4839 // to add defaults. If the user provided *too many* types, that's
4841 let supress_mismatch = self.check_impl_trait(span, fn_segment);
4842 self.check_generic_arg_count(span, &mut type_segment, false, supress_mismatch);
4843 self.check_generic_arg_count(span, &mut fn_segment, false, supress_mismatch);
4845 let (fn_start, has_self) = match (type_segment, fn_segment) {
4846 (_, Some((_, generics))) => {
4847 (generics.parent_count, generics.has_self)
4849 (Some((_, generics)), None) => {
4850 (generics.params.len(), generics.has_self)
4852 (None, None) => (0, false)
4854 // FIXME(varkor): Separating out the parameters is messy.
4855 let mut lifetimes_type_seg = vec![];
4856 let mut types_type_seg = vec![];
4857 let mut infer_types_type_seg = true;
4858 if let Some((seg, _)) = type_segment {
4859 if let Some(ref data) = seg.args {
4860 for arg in &data.args {
4862 GenericArg::Lifetime(lt) => lifetimes_type_seg.push(lt),
4863 GenericArg::Type(ty) => types_type_seg.push(ty),
4867 infer_types_type_seg = seg.infer_types;
4870 let mut lifetimes_fn_seg = vec![];
4871 let mut types_fn_seg = vec![];
4872 let mut infer_types_fn_seg = true;
4873 if let Some((seg, _)) = fn_segment {
4874 if let Some(ref data) = seg.args {
4875 for arg in &data.args {
4877 GenericArg::Lifetime(lt) => lifetimes_fn_seg.push(lt),
4878 GenericArg::Type(ty) => types_fn_seg.push(ty),
4882 infer_types_fn_seg = seg.infer_types;
4885 let substs = Substs::for_item(self.tcx, def.def_id(), |param, substs| {
4886 let mut i = param.index as usize;
4888 let (segment, lifetimes, types, infer_types) = if i < fn_start {
4889 if let GenericParamDefKind::Type { .. } = param.kind {
4890 // Handle Self first, so we can adjust the index to match the AST.
4891 if has_self && i == 0 {
4892 return opt_self_ty.map(|ty| ty.into()).unwrap_or_else(|| {
4893 self.var_for_def(span, param)
4897 i -= has_self as usize;
4898 (type_segment, &lifetimes_type_seg, &types_type_seg, infer_types_type_seg)
4901 (fn_segment, &lifetimes_fn_seg, &types_fn_seg, infer_types_fn_seg)
4905 GenericParamDefKind::Lifetime => {
4906 if let Some(lifetime) = lifetimes.get(i) {
4907 AstConv::ast_region_to_region(self, lifetime, Some(param)).into()
4909 self.re_infer(span, Some(param)).unwrap().into()
4912 GenericParamDefKind::Type { .. } => {
4913 // Skip over the lifetimes in the same segment.
4914 if let Some((_, generics)) = segment {
4915 i -= generics.own_counts().lifetimes;
4918 let has_default = match param.kind {
4919 GenericParamDefKind::Type { has_default, .. } => has_default,
4923 if let Some(ast_ty) = types.get(i) {
4924 // A provided type parameter.
4925 self.to_ty(ast_ty).into()
4926 } else if !infer_types && has_default {
4927 // No type parameter provided, but a default exists.
4928 let default = self.tcx.type_of(param.def_id);
4931 default.subst_spanned(self.tcx, substs, Some(span))
4934 // No type parameters were provided, we can infer all.
4935 // This can also be reached in some error cases:
4936 // We prefer to use inference variables instead of
4937 // TyError to let type inference recover somewhat.
4938 self.var_for_def(span, param)
4944 // The things we are substituting into the type should not contain
4945 // escaping late-bound regions, and nor should the base type scheme.
4946 let ty = self.tcx.type_of(def.def_id());
4947 assert!(!substs.has_escaping_regions());
4948 assert!(!ty.has_escaping_regions());
4950 // Add all the obligations that are required, substituting and
4951 // normalized appropriately.
4952 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4953 self.add_obligations_for_parameters(
4954 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4957 // Substitute the values for the type parameters into the type of
4958 // the referenced item.
4959 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4961 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4962 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4963 // is inherent, there is no `Self` parameter, instead, the impl needs
4964 // type parameters, which we can infer by unifying the provided `Self`
4965 // with the substituted impl type.
4966 let ty = self.tcx.type_of(impl_def_id);
4968 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4969 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4970 Ok(ok) => self.register_infer_ok_obligations(ok),
4973 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4980 self.check_rustc_args_require_const(def.def_id(), node_id, span);
4982 debug!("instantiate_value_path: type of {:?} is {:?}",
4985 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4989 fn check_rustc_args_require_const(&self,
4991 node_id: ast::NodeId,
4993 // We're only interested in functions tagged with
4994 // #[rustc_args_required_const], so ignore anything that's not.
4995 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
4999 // If our calling expression is indeed the function itself, we're good!
5000 // If not, generate an error that this can only be called directly.
5001 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5002 Node::NodeExpr(expr) => {
5004 hir::ExprCall(ref callee, ..) => {
5005 if callee.id == node_id {
5015 self.tcx.sess.span_err(span, "this function can only be invoked \
5016 directly, not through a function pointer");
5019 /// Report errors if the provided parameters are too few or too many.
5020 fn check_generic_arg_count(&self,
5022 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
5023 is_method_call: bool,
5024 supress_mismatch_error: bool) {
5025 let (lifetimes, types, infer_types, bindings) = segment.map_or(
5026 (vec![], vec![], true, &[][..]),
5028 s.args.as_ref().map_or(
5029 (vec![], vec![], s.infer_types, &[][..]),
5031 let (mut lifetimes, mut types) = (vec![], vec![]);
5032 data.args.iter().for_each(|arg| match arg {
5033 GenericArg::Lifetime(lt) => lifetimes.push(lt),
5034 GenericArg::Type(ty) => types.push(ty),
5036 (lifetimes, types, s.infer_types, &data.bindings[..])
5041 // Check provided parameters.
5042 let ((ty_required, ty_accepted), lt_accepted) =
5043 segment.map_or(((0, 0), 0), |(_, generics)| {
5049 let mut lt_accepted = 0;
5050 let mut ty_params = ParamRange { required: 0, accepted: 0 };
5051 for param in &generics.params {
5053 GenericParamDefKind::Lifetime => lt_accepted += 1,
5054 GenericParamDefKind::Type { has_default, .. } => {
5055 ty_params.accepted += 1;
5057 ty_params.required += 1;
5062 if generics.parent.is_none() && generics.has_self {
5063 ty_params.required -= 1;
5064 ty_params.accepted -= 1;
5067 ((ty_params.required, ty_params.accepted), lt_accepted)
5070 let count_type_params = |n| {
5071 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
5073 let expected_text = count_type_params(ty_accepted);
5074 let actual_text = count_type_params(types.len());
5075 if let Some((mut err, span)) = if types.len() > ty_accepted {
5076 // To prevent derived errors to accumulate due to extra
5077 // type parameters, we force instantiate_value_path to
5078 // use inference variables instead of the provided types.
5080 let span = types[ty_accepted].span;
5081 Some((struct_span_err!(self.tcx.sess, span, E0087,
5082 "too many type parameters provided: \
5083 expected at most {}, found {}",
5084 expected_text, actual_text), span))
5085 } else if types.len() < ty_required && !infer_types && !supress_mismatch_error {
5086 Some((struct_span_err!(self.tcx.sess, span, E0089,
5087 "too few type parameters provided: \
5088 expected {}, found {}",
5089 expected_text, actual_text), span))
5093 err.span_label(span, format!("expected {}", expected_text)).emit();
5096 if !bindings.is_empty() {
5097 AstConv::prohibit_projection(self, bindings[0].span);
5100 let infer_lifetimes = lifetimes.len() == 0;
5101 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
5102 let has_late_bound_lifetime_defs =
5103 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
5104 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
5105 // Report this as a lint only if no error was reported previously.
5106 let primary_msg = "cannot specify lifetime arguments explicitly \
5107 if late bound lifetime parameters are present";
5108 let note_msg = "the late bound lifetime parameter is introduced here";
5109 if !is_method_call && (lifetimes.len() > lt_accepted ||
5110 lifetimes.len() < lt_accepted && !infer_lifetimes) {
5111 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
5112 err.span_note(span_late, note_msg);
5116 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
5117 multispan.push_span_label(span_late, note_msg.to_string());
5118 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
5119 lifetimes[0].id, multispan, primary_msg);
5124 let count_lifetime_params = |n| {
5125 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
5127 let expected_text = count_lifetime_params(lt_accepted);
5128 let actual_text = count_lifetime_params(lifetimes.len());
5129 if let Some((mut err, span)) = if lifetimes.len() > lt_accepted {
5130 let span = lifetimes[lt_accepted].span;
5131 Some((struct_span_err!(self.tcx.sess, span, E0088,
5132 "too many lifetime parameters provided: \
5133 expected at most {}, found {}",
5134 expected_text, actual_text), span))
5135 } else if lifetimes.len() < lt_accepted && !infer_lifetimes {
5136 Some((struct_span_err!(self.tcx.sess, span, E0090,
5137 "too few lifetime parameters provided: \
5138 expected {}, found {}",
5139 expected_text, actual_text), span))
5143 err.span_label(span, format!("expected {}", expected_text)).emit();
5147 /// Report error if there is an explicit type parameter when using `impl Trait`.
5148 fn check_impl_trait(&self,
5150 segment: Option<(&hir::PathSegment, &ty::Generics)>)
5152 let segment = segment.map(|(path_segment, generics)| {
5153 let explicit = !path_segment.infer_types;
5154 let impl_trait = generics.params.iter().any(|param| match param.kind {
5155 ty::GenericParamDefKind::Type {
5156 synthetic: Some(hir::SyntheticTyParamKind::ImplTrait), ..
5161 if explicit && impl_trait {
5162 let mut err = struct_span_err! {
5166 "cannot provide explicit type parameters when `impl Trait` is \
5167 used in argument position."
5176 segment.unwrap_or(false)
5179 // Resolves `typ` by a single level if `typ` is a type variable.
5180 // If no resolution is possible, then an error is reported.
5181 // Numeric inference variables may be left unresolved.
5182 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5183 let ty = self.resolve_type_vars_with_obligations(ty);
5184 if !ty.is_ty_var() {
5187 if !self.is_tainted_by_errors() {
5188 self.need_type_info_err((**self).body_id, sp, ty)
5189 .note("type must be known at this point")
5192 self.demand_suptype(sp, self.tcx.types.err, ty);
5197 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5198 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5199 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5202 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5203 index = enclosing_breakables.stack.len();
5204 enclosing_breakables.by_id.insert(id, index);
5205 enclosing_breakables.stack.push(ctxt);
5209 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5210 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5211 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5212 enclosing_breakables.stack.pop().expect("missing breakable context")
5218 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5219 generics: &ty::Generics,
5221 let own_counts = generics.own_counts();
5222 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5224 if own_counts.types == 0 {
5227 // Make a vector of booleans initially false, set to true when used.
5228 let mut types_used = vec![false; own_counts.types];
5230 for leaf_ty in ty.walk() {
5231 if let ty::TyParam(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5232 debug!("Found use of ty param num {}", idx);
5233 types_used[idx as usize - own_counts.lifetimes] = true;
5234 } else if let ty::TyError = leaf_ty.sty {
5235 // If there is already another error, do not emit
5236 // an error for not using a type Parameter.
5237 assert!(tcx.sess.err_count() > 0);
5242 let types = generics.params.iter().filter(|param| match param.kind {
5243 ty::GenericParamDefKind::Type { .. } => true,
5246 for (&used, param) in types_used.iter().zip(types) {
5248 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5249 let span = tcx.hir.span(id);
5250 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5251 .span_label(span, "unused type parameter")
5257 fn fatally_break_rust(sess: &Session) {
5258 let handler = sess.diagnostic();
5259 handler.span_bug_no_panic(
5261 "It looks like you're trying to break rust; would you like some ICE?",
5263 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5264 handler.note_without_error(
5265 "we would appreciate a joke overview: \
5266 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5268 handler.note_without_error(&format!("rustc {} running on {}",
5269 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5270 ::session::config::host_triple(),