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;
119 use std::mem::replace;
120 use std::ops::{self, Deref};
121 use rustc_target::spec::abi::Abi;
124 use syntax::codemap::original_sp;
125 use syntax::feature_gate::{GateIssue, emit_feature_err};
127 use syntax::symbol::{Symbol, LocalInternedString, keywords};
128 use syntax::util::lev_distance::find_best_match_for_name;
129 use syntax_pos::{self, BytePos, Span, MultiSpan};
131 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
132 use rustc::hir::itemlikevisit::ItemLikeVisitor;
133 use rustc::hir::map::Node;
134 use rustc::hir::{self, PatKind, Item_};
135 use rustc::middle::lang_items;
151 mod generator_interior;
155 /// A wrapper for InferCtxt's `in_progress_tables` field.
156 #[derive(Copy, Clone)]
157 struct MaybeInProgressTables<'a, 'tcx: 'a> {
158 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
161 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
162 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
163 match self.maybe_tables {
164 Some(tables) => tables.borrow(),
166 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
171 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
172 match self.maybe_tables {
173 Some(tables) => tables.borrow_mut(),
175 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
182 /// closures defined within the function. For example:
185 /// bar(move|| { ... })
188 /// Here, the function `foo()` and the closure passed to
189 /// `bar()` will each have their own `FnCtxt`, but they will
190 /// share the inherited fields.
191 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
192 infcx: InferCtxt<'a, 'gcx, 'tcx>,
194 tables: MaybeInProgressTables<'a, 'tcx>,
196 locals: RefCell<NodeMap<Ty<'tcx>>>,
198 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
200 // When we process a call like `c()` where `c` is a closure type,
201 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
202 // `FnOnce` closure. In that case, we defer full resolution of the
203 // call until upvar inference can kick in and make the
204 // decision. We keep these deferred resolutions grouped by the
205 // def-id of the closure, so that once we decide, we can easily go
206 // back and process them.
207 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
209 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
211 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
213 // Anonymized types found in explicit return types and their
214 // associated fresh inference variable. Writeback resolves these
215 // variables to get the concrete type, which can be used to
216 // deanonymize TyAnon, after typeck is done with all functions.
217 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
219 /// Each type parameter has an implicit region bound that
220 /// indicates it must outlive at least the function body (the user
221 /// may specify stronger requirements). This field indicates the
222 /// region of the callee. If it is `None`, then the parameter
223 /// environment is for an item or something where the "callee" is
225 implicit_region_bound: Option<ty::Region<'tcx>>,
227 body_id: Option<hir::BodyId>,
230 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
231 type Target = InferCtxt<'a, 'gcx, 'tcx>;
232 fn deref(&self) -> &Self::Target {
237 /// When type-checking an expression, we propagate downward
238 /// whatever type hint we are able in the form of an `Expectation`.
239 #[derive(Copy, Clone, Debug)]
240 pub enum Expectation<'tcx> {
241 /// We know nothing about what type this expression should have.
244 /// This expression is an `if` condition, it must resolve to `bool`.
247 /// This expression should have the type given (or some subtype)
248 ExpectHasType(Ty<'tcx>),
250 /// This expression will be cast to the `Ty`
251 ExpectCastableToType(Ty<'tcx>),
253 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
254 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
255 ExpectRvalueLikeUnsized(Ty<'tcx>),
258 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
259 // Disregard "castable to" expectations because they
260 // can lead us astray. Consider for example `if cond
261 // {22} else {c} as u8` -- if we propagate the
262 // "castable to u8" constraint to 22, it will pick the
263 // type 22u8, which is overly constrained (c might not
264 // be a u8). In effect, the problem is that the
265 // "castable to" expectation is not the tightest thing
266 // we can say, so we want to drop it in this case.
267 // The tightest thing we can say is "must unify with
268 // else branch". Note that in the case of a "has type"
269 // constraint, this limitation does not hold.
271 // If the expected type is just a type variable, then don't use
272 // an expected type. Otherwise, we might write parts of the type
273 // when checking the 'then' block which are incompatible with the
275 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
277 ExpectHasType(ety) => {
278 let ety = fcx.shallow_resolve(ety);
279 if !ety.is_ty_var() {
285 ExpectRvalueLikeUnsized(ety) => {
286 ExpectRvalueLikeUnsized(ety)
292 /// Provide an expectation for an rvalue expression given an *optional*
293 /// hint, which is not required for type safety (the resulting type might
294 /// be checked higher up, as is the case with `&expr` and `box expr`), but
295 /// is useful in determining the concrete type.
297 /// The primary use case is where the expected type is a fat pointer,
298 /// like `&[isize]`. For example, consider the following statement:
300 /// let x: &[isize] = &[1, 2, 3];
302 /// In this case, the expected type for the `&[1, 2, 3]` expression is
303 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
304 /// expectation `ExpectHasType([isize])`, that would be too strong --
305 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
306 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
307 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
308 /// which still is useful, because it informs integer literals and the like.
309 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
310 /// for examples of where this comes up,.
311 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
312 match fcx.tcx.struct_tail(ty).sty {
313 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
314 ExpectRvalueLikeUnsized(ty)
316 _ => ExpectHasType(ty)
320 // Resolves `expected` by a single level if it is a variable. If
321 // there is no expected type or resolution is not possible (e.g.,
322 // no constraints yet present), just returns `None`.
323 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
325 NoExpectation => NoExpectation,
326 ExpectIfCondition => ExpectIfCondition,
327 ExpectCastableToType(t) => {
328 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
330 ExpectHasType(t) => {
331 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
333 ExpectRvalueLikeUnsized(t) => {
334 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
339 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
340 match self.resolve(fcx) {
341 NoExpectation => None,
342 ExpectIfCondition => Some(fcx.tcx.types.bool),
343 ExpectCastableToType(ty) |
345 ExpectRvalueLikeUnsized(ty) => Some(ty),
349 /// It sometimes happens that we want to turn an expectation into
350 /// a **hard constraint** (i.e., something that must be satisfied
351 /// for the program to type-check). `only_has_type` will return
352 /// such a constraint, if it exists.
353 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
354 match self.resolve(fcx) {
355 ExpectHasType(ty) => Some(ty),
356 ExpectIfCondition => Some(fcx.tcx.types.bool),
357 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
361 /// Like `only_has_type`, but instead of returning `None` if no
362 /// hard constraint exists, creates a fresh type variable.
363 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
364 self.only_has_type(fcx)
365 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
369 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
376 fn maybe_mut_place(m: hir::Mutability) -> Self {
378 hir::MutMutable => Needs::MutPlace,
379 hir::MutImmutable => Needs::None,
384 #[derive(Copy, Clone)]
385 pub struct UnsafetyState {
386 pub def: ast::NodeId,
387 pub unsafety: hir::Unsafety,
388 pub unsafe_push_count: u32,
393 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
394 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
397 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
398 match self.unsafety {
399 // If this unsafe, then if the outer function was already marked as
400 // unsafe we shouldn't attribute the unsafe'ness to the block. This
401 // way the block can be warned about instead of ignoring this
402 // extraneous block (functions are never warned about).
403 hir::Unsafety::Unsafe if self.from_fn => *self,
406 let (unsafety, def, count) = match blk.rules {
407 hir::PushUnsafeBlock(..) =>
408 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
409 hir::PopUnsafeBlock(..) =>
410 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
411 hir::UnsafeBlock(..) =>
412 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
414 (unsafety, self.def, self.unsafe_push_count),
418 unsafe_push_count: count,
425 #[derive(Debug, Copy, Clone)]
431 /// Tracks whether executing a node may exit normally (versus
432 /// return/break/panic, which "diverge", leaving dead code in their
433 /// wake). Tracked semi-automatically (through type variables marked
434 /// as diverging), with some manual adjustments for control-flow
435 /// primitives (approximating a CFG).
436 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
438 /// Potentially unknown, some cases converge,
439 /// others require a CFG to determine them.
442 /// Definitely known to diverge and therefore
443 /// not reach the next sibling or its parent.
446 /// Same as `Always` but with a reachability
447 /// warning already emitted
451 // Convenience impls for combinig `Diverges`.
453 impl ops::BitAnd for Diverges {
455 fn bitand(self, other: Self) -> Self {
456 cmp::min(self, other)
460 impl ops::BitOr for Diverges {
462 fn bitor(self, other: Self) -> Self {
463 cmp::max(self, other)
467 impl ops::BitAndAssign for Diverges {
468 fn bitand_assign(&mut self, other: Self) {
469 *self = *self & other;
473 impl ops::BitOrAssign for Diverges {
474 fn bitor_assign(&mut self, other: Self) {
475 *self = *self | other;
480 fn always(self) -> bool {
481 self >= Diverges::Always
485 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
488 // this is `null` for loops where break with a value is illegal,
489 // such as `while`, `for`, and `while let`
490 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
493 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
494 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
495 by_id: NodeMap<usize>,
498 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
499 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
500 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
501 bug!("could not find enclosing breakable with id {}", target_id);
507 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
508 body_id: ast::NodeId,
510 /// The parameter environment used for proving trait obligations
511 /// in this function. This can change when we descend into
512 /// closures (as they bring new things into scope), hence it is
513 /// not part of `Inherited` (as of the time of this writing,
514 /// closures do not yet change the environment, but they will
516 param_env: ty::ParamEnv<'tcx>,
518 // Number of errors that had been reported when we started
519 // checking this function. On exit, if we find that *more* errors
520 // have been reported, we will skip regionck and other work that
521 // expects the types within the function to be consistent.
522 err_count_on_creation: usize,
524 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
526 yield_ty: Option<Ty<'tcx>>,
528 ps: RefCell<UnsafetyState>,
530 /// Whether the last checked node generates a divergence (e.g.,
531 /// `return` will set this to Always). In general, when entering
532 /// an expression or other node in the tree, the initial value
533 /// indicates whether prior parts of the containing expression may
534 /// have diverged. It is then typically set to `Maybe` (and the
535 /// old value remembered) for processing the subparts of the
536 /// current expression. As each subpart is processed, they may set
537 /// the flag to `Always` etc. Finally, at the end, we take the
538 /// result and "union" it with the original value, so that when we
539 /// return the flag indicates if any subpart of the the parent
540 /// expression (up to and including this part) has diverged. So,
541 /// if you read it after evaluating a subexpression `X`, the value
542 /// you get indicates whether any subexpression that was
543 /// evaluating up to and including `X` diverged.
545 /// We currently use this flag only for diagnostic purposes:
547 /// - To warn about unreachable code: if, after processing a
548 /// sub-expression but before we have applied the effects of the
549 /// current node, we see that the flag is set to `Always`, we
550 /// can issue a warning. This corresponds to something like
551 /// `foo(return)`; we warn on the `foo()` expression. (We then
552 /// update the flag to `WarnedAlways` to suppress duplicate
553 /// reports.) Similarly, if we traverse to a fresh statement (or
554 /// tail expression) from a `Always` setting, we will issue a
555 /// warning. This corresponds to something like `{return;
556 /// foo();}` or `{return; 22}`, where we would warn on the
559 /// An expression represents dead-code if, after checking it,
560 /// the diverges flag is set to something other than `Maybe`.
561 diverges: Cell<Diverges>,
563 /// Whether any child nodes have any type errors.
564 has_errors: Cell<bool>,
566 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
568 inh: &'a Inherited<'a, 'gcx, 'tcx>,
571 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
572 type Target = Inherited<'a, 'gcx, 'tcx>;
573 fn deref(&self) -> &Self::Target {
578 /// Helper type of a temporary returned by Inherited::build(...).
579 /// Necessary because we can't write the following bound:
580 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
581 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
582 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
586 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
587 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
588 -> InheritedBuilder<'a, 'gcx, 'tcx> {
589 let hir_id_root = if def_id.is_local() {
590 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
591 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
592 DefId::local(hir_id.owner)
598 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
604 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
605 fn enter<F, R>(&'tcx mut self, f: F) -> R
606 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
608 let def_id = self.def_id;
609 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
613 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
614 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
616 let item_id = tcx.hir.as_local_node_id(def_id);
617 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
618 let implicit_region_bound = body_id.map(|body_id| {
619 let body = tcx.hir.body(body_id);
620 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
624 tables: MaybeInProgressTables {
625 maybe_tables: infcx.in_progress_tables,
628 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
629 locals: RefCell::new(NodeMap()),
630 deferred_call_resolutions: RefCell::new(DefIdMap()),
631 deferred_cast_checks: RefCell::new(Vec::new()),
632 deferred_generator_interiors: RefCell::new(Vec::new()),
633 anon_types: RefCell::new(DefIdMap()),
634 implicit_region_bound,
639 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
640 debug!("register_predicate({:?})", obligation);
641 if obligation.has_escaping_regions() {
642 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
647 .register_predicate_obligation(self, obligation);
650 fn register_predicates<I>(&self, obligations: I)
651 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
652 for obligation in obligations {
653 self.register_predicate(obligation);
657 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
658 self.register_predicates(infer_ok.obligations);
662 fn normalize_associated_types_in<T>(&self,
664 body_id: ast::NodeId,
665 param_env: ty::ParamEnv<'tcx>,
667 where T : TypeFoldable<'tcx>
669 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
670 self.register_infer_ok_obligations(ok)
674 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
676 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
677 fn visit_item(&mut self, i: &'tcx hir::Item) {
678 check_item_type(self.tcx, i);
680 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
681 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
684 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
685 tcx.sess.track_errors(|| {
686 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
687 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
691 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
692 tcx.sess.track_errors(|| {
693 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
697 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
698 tcx.typeck_item_bodies(LOCAL_CRATE)
701 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
702 -> Result<(), CompileIncomplete>
704 debug_assert!(crate_num == LOCAL_CRATE);
705 Ok(tcx.sess.track_errors(|| {
706 tcx.par_body_owners(|body_owner_def_id| {
707 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
712 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
713 wfcheck::check_item_well_formed(tcx, def_id);
716 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
717 wfcheck::check_trait_item(tcx, def_id);
720 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
721 wfcheck::check_impl_item(tcx, def_id);
724 pub fn provide(providers: &mut Providers) {
725 method::provide(providers);
726 *providers = Providers {
732 check_item_well_formed,
733 check_trait_item_well_formed,
734 check_impl_item_well_formed,
739 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
741 -> Option<ty::Destructor> {
742 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
745 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
746 /// with information about it's body-id and fn-decl (if any). Otherwise,
749 /// If this function returns "some", then `typeck_tables(def_id)` will
750 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
751 /// may not succeed. In some cases where this function returns `None`
752 /// (notably closures), `typeck_tables(def_id)` would wind up
753 /// redirecting to the owning function.
754 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
756 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
758 match tcx.hir.get(id) {
759 hir::map::NodeItem(item) => {
761 hir::ItemConst(_, body) |
762 hir::ItemStatic(_, _, body) =>
764 hir::ItemFn(ref decl, .., body) =>
765 Some((body, Some(decl))),
770 hir::map::NodeTraitItem(item) => {
772 hir::TraitItemKind::Const(_, Some(body)) =>
774 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
775 Some((body, Some(&sig.decl))),
780 hir::map::NodeImplItem(item) => {
782 hir::ImplItemKind::Const(_, body) =>
784 hir::ImplItemKind::Method(ref sig, body) =>
785 Some((body, Some(&sig.decl))),
790 hir::map::NodeAnonConst(constant) => Some((constant.body, None)),
795 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
798 // Closures' tables come from their outermost function,
799 // as they are part of the same "inference environment".
800 let outer_def_id = tcx.closure_base_def_id(def_id);
801 if outer_def_id != def_id {
802 return tcx.has_typeck_tables(outer_def_id);
805 let id = tcx.hir.as_local_node_id(def_id).unwrap();
806 primary_body_of(tcx, id).is_some()
809 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
812 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
815 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
817 -> &'tcx ty::TypeckTables<'tcx> {
818 // Closures' tables come from their outermost function,
819 // as they are part of the same "inference environment".
820 let outer_def_id = tcx.closure_base_def_id(def_id);
821 if outer_def_id != def_id {
822 return tcx.typeck_tables_of(outer_def_id);
825 let id = tcx.hir.as_local_node_id(def_id).unwrap();
826 let span = tcx.hir.span(id);
828 // Figure out what primary body this item has.
829 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
830 span_bug!(span, "can't type-check body of {:?}", def_id);
832 let body = tcx.hir.body(body_id);
834 let tables = Inherited::build(tcx, def_id).enter(|inh| {
835 let param_env = tcx.param_env(def_id);
836 let fcx = if let Some(decl) = fn_decl {
837 let fn_sig = tcx.fn_sig(def_id);
839 check_abi(tcx, span, fn_sig.abi());
841 // Compute the fty from point of view of inside fn.
843 tcx.liberate_late_bound_regions(def_id, &fn_sig);
845 inh.normalize_associated_types_in(body.value.span,
850 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
853 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
854 let expected_type = tcx.type_of(def_id);
855 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
856 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
858 // Gather locals in statics (because of block expressions).
859 // This is technically unnecessary because locals in static items are forbidden,
860 // but prevents type checking from blowing up before const checking can properly
862 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
864 fcx.check_expr_coercable_to_type(&body.value, expected_type);
869 // All type checking constraints were added, try to fallback unsolved variables.
870 fcx.select_obligations_where_possible(false);
871 let mut fallback_has_occurred = false;
872 for ty in &fcx.unsolved_variables() {
873 fallback_has_occurred |= fcx.fallback_if_possible(ty);
875 fcx.select_obligations_where_possible(fallback_has_occurred);
877 // Even though coercion casts provide type hints, we check casts after fallback for
878 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
881 // Closure and generater analysis may run after fallback
882 // because they don't constrain other type variables.
883 fcx.closure_analyze(body);
884 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
885 fcx.resolve_generator_interiors(def_id);
886 fcx.select_all_obligations_or_error();
888 if fn_decl.is_some() {
889 fcx.regionck_fn(id, body);
891 fcx.regionck_expr(body);
894 fcx.resolve_type_vars_in_body(body)
897 // Consistency check our TypeckTables instance can hold all ItemLocalIds
898 // it will need to hold.
899 assert_eq!(tables.local_id_root,
900 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
904 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
905 if !tcx.sess.target.target.is_abi_supported(abi) {
906 struct_span_err!(tcx.sess, span, E0570,
907 "The ABI `{}` is not supported for the current target", abi).emit()
911 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
912 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
915 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
916 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
919 // infer the variable's type
920 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
921 self.fcx.locals.borrow_mut().insert(nid, var_ty);
925 // take type that the user specified
926 self.fcx.locals.borrow_mut().insert(nid, typ);
933 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
934 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
935 NestedVisitorMap::None
938 // Add explicitly-declared locals.
939 fn visit_local(&mut self, local: &'gcx hir::Local) {
940 let o_ty = match local.ty {
942 let o_ty = self.fcx.to_ty(&ty);
944 let (c_ty, _orig_values) = self.fcx.inh.infcx.canonicalize_response(&o_ty);
945 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
946 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
952 self.assign(local.span, local.id, o_ty);
954 debug!("Local variable {:?} is assigned type {}",
956 self.fcx.ty_to_string(
957 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
958 intravisit::walk_local(self, local);
961 // Add pattern bindings.
962 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
963 if let PatKind::Binding(_, _, ident, _) = p.node {
964 let var_ty = self.assign(p.span, p.id, None);
966 self.fcx.require_type_is_sized(var_ty, p.span,
967 traits::VariableType(p.id));
969 debug!("Pattern binding {} is assigned to {} with type {:?}",
971 self.fcx.ty_to_string(
972 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
975 intravisit::walk_pat(self, p);
978 // Don't descend into the bodies of nested closures
979 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
980 _: hir::BodyId, _: Span, _: ast::NodeId) { }
983 /// When `check_fn` is invoked on a generator (i.e., a body that
984 /// includes yield), it returns back some information about the yield
986 struct GeneratorTypes<'tcx> {
987 /// Type of value that is yielded.
988 yield_ty: ty::Ty<'tcx>,
990 /// Types that are captured (see `GeneratorInterior` for more).
991 interior: ty::Ty<'tcx>,
993 /// Indicates if the generator is movable or static (immovable)
994 movability: hir::GeneratorMovability,
997 /// Helper used for fns and closures. Does the grungy work of checking a function
998 /// body and returns the function context used for that purpose, since in the case of a fn item
999 /// there is still a bit more to do.
1002 /// * inherited: other fields inherited from the enclosing fn (if any)
1003 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1004 param_env: ty::ParamEnv<'tcx>,
1005 fn_sig: ty::FnSig<'tcx>,
1006 decl: &'gcx hir::FnDecl,
1008 body: &'gcx hir::Body,
1009 can_be_generator: Option<hir::GeneratorMovability>)
1010 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1012 let mut fn_sig = fn_sig.clone();
1014 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1016 // Create the function context. This is either derived from scratch or,
1017 // in the case of closures, based on the outer context.
1018 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1019 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1021 let declared_ret_ty = fn_sig.output();
1022 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1023 let revealed_ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &declared_ret_ty);
1024 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1025 fn_sig = fcx.tcx.mk_fn_sig(
1026 fn_sig.inputs().iter().cloned(),
1033 let span = body.value.span;
1035 if body.is_generator && can_be_generator.is_some() {
1036 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1037 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1038 fcx.yield_ty = Some(yield_ty);
1041 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1043 // Add formal parameters.
1044 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1045 // Check the pattern.
1046 fcx.check_pat_walk(&arg.pat, arg_ty,
1047 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1049 // Check that argument is Sized.
1050 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1051 // for simple cases like `fn foo(x: Trait)`,
1052 // where we would error once on the parameter as a whole, and once on the binding `x`.
1053 if arg.pat.simple_ident().is_none() {
1054 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1057 fcx.write_ty(arg.hir_id, arg_ty);
1060 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1061 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1063 fcx.check_return_expr(&body.value);
1065 // We insert the deferred_generator_interiors entry after visiting the body.
1066 // This ensures that all nested generators appear before the entry of this generator.
1067 // resolve_generator_interiors relies on this property.
1068 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1069 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1070 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1071 Some(GeneratorTypes {
1072 yield_ty: fcx.yield_ty.unwrap(),
1074 movability: can_be_generator.unwrap(),
1080 // Finalize the return check by taking the LUB of the return types
1081 // we saw and assigning it to the expected return type. This isn't
1082 // really expected to fail, since the coercions would have failed
1083 // earlier when trying to find a LUB.
1085 // However, the behavior around `!` is sort of complex. In the
1086 // event that the `actual_return_ty` comes back as `!`, that
1087 // indicates that the fn either does not return or "returns" only
1088 // values of type `!`. In this case, if there is an expected
1089 // return type that is *not* `!`, that should be ok. But if the
1090 // return type is being inferred, we want to "fallback" to `!`:
1092 // let x = move || panic!();
1094 // To allow for that, I am creating a type variable with diverging
1095 // fallback. This was deemed ever so slightly better than unifying
1096 // the return value with `!` because it allows for the caller to
1097 // make more assumptions about the return type (e.g., they could do
1099 // let y: Option<u32> = Some(x());
1101 // which would then cause this return type to become `u32`, not
1103 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1104 let mut actual_return_ty = coercion.complete(&fcx);
1105 if actual_return_ty.is_never() {
1106 actual_return_ty = fcx.next_diverging_ty_var(
1107 TypeVariableOrigin::DivergingFn(span));
1109 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1111 // Check that the main return type implements the termination trait.
1112 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1113 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1116 config::EntryMain => {
1117 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1118 let trait_ref = ty::TraitRef::new(term_id, substs);
1119 let return_ty_span = decl.output.span();
1120 let cause = traits::ObligationCause::new(
1121 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1123 inherited.register_predicate(
1124 traits::Obligation::new(
1125 cause, param_env, trait_ref.to_predicate()));
1127 config::EntryStart => {},
1133 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1134 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1135 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1136 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1137 if declared_ret_ty.sty != ty::TyNever {
1138 fcx.tcx.sess.span_err(
1140 "return type should be `!`",
1144 let inputs = fn_sig.inputs();
1145 let span = fcx.tcx.hir.span(fn_id);
1146 if inputs.len() == 1 {
1147 let arg_is_panic_info = match inputs[0].sty {
1148 ty::TyRef(region, ty, mutbl) => match ty.sty {
1149 ty::TyAdt(ref adt, _) => {
1150 adt.did == panic_info_did &&
1151 mutbl == hir::Mutability::MutImmutable &&
1152 *region != RegionKind::ReStatic
1159 if !arg_is_panic_info {
1160 fcx.tcx.sess.span_err(
1161 decl.inputs[0].span,
1162 "argument should be `&PanicInfo`",
1166 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1167 if let Item_::ItemFn(_, _, ref generics, _) = item.node {
1168 if !generics.params.is_empty() {
1169 fcx.tcx.sess.span_err(
1171 "`#[panic_implementation]` function should have no type \
1178 fcx.tcx.sess.span_err(span, "function should have one argument");
1181 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1190 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1193 let def_id = tcx.hir.local_def_id(id);
1194 let def = tcx.adt_def(def_id);
1195 def.destructor(tcx); // force the destructor to be evaluated
1196 check_representable(tcx, span, def_id);
1198 if def.repr.simd() {
1199 check_simd(tcx, span, def_id);
1202 check_transparent(tcx, span, def_id);
1203 check_packed(tcx, span, def_id);
1206 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1209 let def_id = tcx.hir.local_def_id(id);
1210 let def = tcx.adt_def(def_id);
1211 def.destructor(tcx); // force the destructor to be evaluated
1212 check_representable(tcx, span, def_id);
1214 check_packed(tcx, span, def_id);
1217 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1218 debug!("check_item_type(it.id={}, it.name={})",
1220 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1221 let _indenter = indenter();
1223 // Consts can play a role in type-checking, so they are included here.
1224 hir::ItemStatic(..) => {
1225 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1227 hir::ItemConst(..) => {
1228 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1229 if it.attrs.iter().any(|a| a.check_name("wasm_custom_section")) {
1230 let def_id = tcx.hir.local_def_id(it.id);
1231 check_const_is_u8_array(tcx, def_id, it.span);
1234 hir::ItemEnum(ref enum_definition, _) => {
1237 &enum_definition.variants,
1240 hir::ItemFn(..) => {} // entirely within check_item_body
1241 hir::ItemImpl(.., ref impl_item_refs) => {
1242 debug!("ItemImpl {} with id {}", it.name, it.id);
1243 let impl_def_id = tcx.hir.local_def_id(it.id);
1244 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1245 check_impl_items_against_trait(tcx,
1250 let trait_def_id = impl_trait_ref.def_id;
1251 check_on_unimplemented(tcx, trait_def_id, it);
1254 hir::ItemTrait(..) => {
1255 let def_id = tcx.hir.local_def_id(it.id);
1256 check_on_unimplemented(tcx, def_id, it);
1258 hir::ItemStruct(..) => {
1259 check_struct(tcx, it.id, it.span);
1261 hir::ItemUnion(..) => {
1262 check_union(tcx, it.id, it.span);
1264 hir::ItemTy(..) => {
1265 let def_id = tcx.hir.local_def_id(it.id);
1266 let pty_ty = tcx.type_of(def_id);
1267 let generics = tcx.generics_of(def_id);
1268 check_bounds_are_used(tcx, &generics, pty_ty);
1270 hir::ItemForeignMod(ref m) => {
1271 check_abi(tcx, it.span, m.abi);
1273 if m.abi == Abi::RustIntrinsic {
1274 for item in &m.items {
1275 intrinsic::check_intrinsic_type(tcx, item);
1277 } else if m.abi == Abi::PlatformIntrinsic {
1278 for item in &m.items {
1279 intrinsic::check_platform_intrinsic_type(tcx, item);
1282 for item in &m.items {
1283 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1284 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1285 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1286 "foreign items may not have type parameters");
1287 err.span_label(item.span, "can't have type parameters");
1288 // FIXME: once we start storing spans for type arguments, turn this into a
1290 err.help("use specialization instead of type parameters by replacing them \
1291 with concrete types like `u32`");
1295 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1296 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1301 _ => {/* nothing to do */ }
1305 fn check_const_is_u8_array<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1308 match tcx.type_of(def_id).sty {
1309 ty::TyArray(t, _) => {
1311 ty::TyUint(ast::UintTy::U8) => return,
1317 tcx.sess.span_err(span, "must be an array of bytes like `[u8; N]`");
1320 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1321 trait_def_id: DefId,
1323 let item_def_id = tcx.hir.local_def_id(item.id);
1324 // an error would be reported if this fails.
1325 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1328 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1329 impl_item: &hir::ImplItem,
1332 let mut err = struct_span_err!(
1333 tcx.sess, impl_item.span, E0520,
1334 "`{}` specializes an item from a parent `impl`, but \
1335 that item is not marked `default`",
1337 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1340 match tcx.span_of_impl(parent_impl) {
1342 err.span_label(span, "parent `impl` is here");
1343 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1347 err.note(&format!("parent implementation is in crate `{}`", cname));
1354 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1355 trait_def: &ty::TraitDef,
1356 trait_item: &ty::AssociatedItem,
1358 impl_item: &hir::ImplItem)
1360 let ancestors = trait_def.ancestors(tcx, impl_id);
1362 let kind = match impl_item.node {
1363 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1364 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1365 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1368 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).skip(1).next()
1369 .map(|node_item| node_item.map(|parent| parent.defaultness));
1371 if let Some(parent) = parent {
1372 if tcx.impl_item_is_final(&parent) {
1373 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1379 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1382 impl_trait_ref: ty::TraitRef<'tcx>,
1383 impl_item_refs: &[hir::ImplItemRef]) {
1384 let impl_span = tcx.sess.codemap().def_span(impl_span);
1386 // If the trait reference itself is erroneous (so the compilation is going
1387 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1388 // isn't populated for such impls.
1389 if impl_trait_ref.references_error() { return; }
1391 // Locate trait definition and items
1392 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1393 let mut overridden_associated_type = None;
1395 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1397 // Check existing impl methods to see if they are both present in trait
1398 // and compatible with trait signature
1399 for impl_item in impl_items() {
1400 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1401 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1402 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1403 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1405 // Not compatible, but needed for the error message
1406 tcx.associated_items(impl_trait_ref.def_id)
1407 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1410 // Check that impl definition matches trait definition
1411 if let Some(ty_trait_item) = ty_trait_item {
1412 match impl_item.node {
1413 hir::ImplItemKind::Const(..) => {
1414 // Find associated const definition.
1415 if ty_trait_item.kind == ty::AssociatedKind::Const {
1416 compare_const_impl(tcx,
1422 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1423 "item `{}` is an associated const, \
1424 which doesn't match its trait `{}`",
1427 err.span_label(impl_item.span, "does not match trait");
1428 // We can only get the spans from local trait definition
1429 // Same for E0324 and E0325
1430 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1431 err.span_label(trait_span, "item in trait");
1436 hir::ImplItemKind::Method(..) => {
1437 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1438 if ty_trait_item.kind == ty::AssociatedKind::Method {
1439 compare_impl_method(tcx,
1446 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1447 "item `{}` is an associated method, \
1448 which doesn't match its trait `{}`",
1451 err.span_label(impl_item.span, "does not match trait");
1452 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1453 err.span_label(trait_span, "item in trait");
1458 hir::ImplItemKind::Type(_) => {
1459 if ty_trait_item.kind == ty::AssociatedKind::Type {
1460 if ty_trait_item.defaultness.has_value() {
1461 overridden_associated_type = Some(impl_item);
1464 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1465 "item `{}` is an associated type, \
1466 which doesn't match its trait `{}`",
1469 err.span_label(impl_item.span, "does not match trait");
1470 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1471 err.span_label(trait_span, "item in trait");
1478 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1482 // Check for missing items from trait
1483 let mut missing_items = Vec::new();
1484 let mut invalidated_items = Vec::new();
1485 let associated_type_overridden = overridden_associated_type.is_some();
1486 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1487 let is_implemented = trait_def.ancestors(tcx, impl_id)
1488 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1490 .map(|node_item| !node_item.node.is_from_trait())
1493 if !is_implemented && !tcx.impl_is_default(impl_id) {
1494 if !trait_item.defaultness.has_value() {
1495 missing_items.push(trait_item);
1496 } else if associated_type_overridden {
1497 invalidated_items.push(trait_item.ident);
1502 if !missing_items.is_empty() {
1503 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1504 "not all trait items implemented, missing: `{}`",
1505 missing_items.iter()
1506 .map(|trait_item| trait_item.ident.to_string())
1507 .collect::<Vec<_>>().join("`, `"));
1508 err.span_label(impl_span, format!("missing `{}` in implementation",
1509 missing_items.iter()
1510 .map(|trait_item| trait_item.ident.to_string())
1511 .collect::<Vec<_>>().join("`, `")));
1512 for trait_item in missing_items {
1513 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1514 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1516 err.note_trait_signature(trait_item.ident.to_string(),
1517 trait_item.signature(&tcx));
1523 if !invalidated_items.is_empty() {
1524 let invalidator = overridden_associated_type.unwrap();
1525 span_err!(tcx.sess, invalidator.span, E0399,
1526 "the following trait items need to be reimplemented \
1527 as `{}` was overridden: `{}`",
1529 invalidated_items.iter()
1530 .map(|name| name.to_string())
1531 .collect::<Vec<_>>().join("`, `"))
1535 /// Checks whether a type can be represented in memory. In particular, it
1536 /// identifies types that contain themselves without indirection through a
1537 /// pointer, which would mean their size is unbounded.
1538 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1542 let rty = tcx.type_of(item_def_id);
1544 // Check that it is possible to represent this type. This call identifies
1545 // (1) types that contain themselves and (2) types that contain a different
1546 // recursive type. It is only necessary to throw an error on those that
1547 // contain themselves. For case 2, there must be an inner type that will be
1548 // caught by case 1.
1549 match rty.is_representable(tcx, sp) {
1550 Representability::SelfRecursive(spans) => {
1551 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1553 err.span_label(span, "recursive without indirection");
1558 Representability::Representable | Representability::ContainsRecursive => (),
1563 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1564 let t = tcx.type_of(def_id);
1566 ty::TyAdt(def, substs) if def.is_struct() => {
1567 let fields = &def.non_enum_variant().fields;
1568 if fields.is_empty() {
1569 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1572 let e = fields[0].ty(tcx, substs);
1573 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1574 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1575 .span_label(sp, "SIMD elements must have the same type")
1580 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1581 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1583 span_err!(tcx.sess, sp, E0077,
1584 "SIMD vector element type should be machine type");
1593 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1594 let repr = tcx.adt_def(def_id).repr;
1596 for attr in tcx.get_attrs(def_id).iter() {
1597 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1598 if let attr::ReprPacked(pack) = r {
1599 if pack != repr.pack {
1600 struct_span_err!(tcx.sess, sp, E0634,
1601 "type has conflicting packed representation hints").emit();
1607 struct_span_err!(tcx.sess, sp, E0587,
1608 "type has conflicting packed and align representation hints").emit();
1610 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1611 struct_span_err!(tcx.sess, sp, E0588,
1612 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1617 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1619 stack: &mut Vec<DefId>) -> bool {
1620 let t = tcx.type_of(def_id);
1621 if stack.contains(&def_id) {
1622 debug!("check_packed_inner: {:?} is recursive", t);
1626 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1627 if tcx.adt_def(def.did).repr.align > 0 {
1630 // push struct def_id before checking fields
1632 for field in &def.non_enum_variant().fields {
1633 let f = field.ty(tcx, substs);
1635 ty::TyAdt(def, _) => {
1636 if check_packed_inner(tcx, def.did, stack) {
1643 // only need to pop if not early out
1651 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1652 let adt = tcx.adt_def(def_id);
1653 if !adt.repr.transparent() {
1657 // For each field, figure out if it's known to be a ZST and align(1)
1658 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1659 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1660 let param_env = tcx.param_env(field.did);
1661 let layout = tcx.layout_of(param_env.and(ty));
1662 // We are currently checking the type this field came from, so it must be local
1663 let span = tcx.hir.span_if_local(field.did).unwrap();
1664 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1665 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1669 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1670 let non_zst_count = non_zst_fields.clone().count();
1671 if non_zst_count != 1 {
1672 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1673 struct_span_err!(tcx.sess, sp, E0690,
1674 "transparent struct needs exactly one non-zero-sized field, but has {}",
1676 .span_note(field_spans, "non-zero-sized field")
1679 for &(span, zst, align1) in &field_infos {
1681 span_err!(tcx.sess, span, E0691,
1682 "zero-sized field in transparent struct has alignment larger than 1");
1687 #[allow(trivial_numeric_casts)]
1688 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1690 vs: &'tcx [hir::Variant],
1692 let def_id = tcx.hir.local_def_id(id);
1693 let def = tcx.adt_def(def_id);
1694 def.destructor(tcx); // force the destructor to be evaluated
1697 let attributes = tcx.get_attrs(def_id);
1698 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1700 tcx.sess, attr.span, E0084,
1701 "unsupported representation for zero-variant enum")
1702 .span_label(sp, "zero-variant enum")
1707 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1708 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1709 if !tcx.features().repr128 {
1710 emit_feature_err(&tcx.sess.parse_sess,
1713 GateIssue::Language,
1714 "repr with 128-bit type is unstable");
1719 if let Some(ref e) = v.node.disr_expr {
1720 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1724 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1725 for (discr, v) in def.discriminants(tcx).zip(vs) {
1726 // Check for duplicate discriminant values
1727 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1728 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1729 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1730 let i_span = match variant_i.node.disr_expr {
1731 Some(ref expr) => tcx.hir.span(expr.id),
1732 None => tcx.hir.span(variant_i_node_id)
1734 let span = match v.node.disr_expr {
1735 Some(ref expr) => tcx.hir.span(expr.id),
1738 struct_span_err!(tcx.sess, span, E0081,
1739 "discriminant value `{}` already exists", disr_vals[i])
1740 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1741 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1744 disr_vals.push(discr);
1747 check_representable(tcx, sp, def_id);
1750 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1751 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1753 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1754 -> ty::GenericPredicates<'tcx>
1757 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1758 let item_id = tcx.hir.ty_param_owner(node_id);
1759 let item_def_id = tcx.hir.local_def_id(item_id);
1760 let generics = tcx.generics_of(item_def_id);
1761 let index = generics.param_def_id_to_index[&def_id];
1762 ty::GenericPredicates {
1764 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1766 ty::Predicate::Trait(ref data) => {
1767 data.skip_binder().self_ty().is_param(index)
1771 }).cloned().collect()
1775 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1776 -> Option<ty::Region<'tcx>> {
1778 Some(def) => infer::EarlyBoundRegion(span, def.name),
1779 None => infer::MiscVariable(span)
1781 Some(self.next_region_var(v))
1784 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1785 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1788 fn ty_infer_for_def(&self,
1789 ty_param_def: &ty::GenericParamDef,
1790 span: Span) -> Ty<'tcx> {
1791 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1797 fn projected_ty_from_poly_trait_ref(&self,
1800 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1803 let (trait_ref, _) =
1804 self.replace_late_bound_regions_with_fresh_var(
1806 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1809 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1812 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1813 if ty.has_escaping_regions() {
1814 ty // FIXME: normalization and escaping regions
1816 self.normalize_associated_types_in(span, &ty)
1820 fn set_tainted_by_errors(&self) {
1821 self.infcx.set_tainted_by_errors()
1824 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1825 self.write_ty(hir_id, ty)
1829 /// Controls whether the arguments are tupled. This is used for the call
1832 /// Tupling means that all call-side arguments are packed into a tuple and
1833 /// passed as a single parameter. For example, if tupling is enabled, this
1836 /// fn f(x: (isize, isize))
1838 /// Can be called as:
1845 #[derive(Clone, Eq, PartialEq)]
1846 enum TupleArgumentsFlag {
1851 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1852 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1853 param_env: ty::ParamEnv<'tcx>,
1854 body_id: ast::NodeId)
1855 -> FnCtxt<'a, 'gcx, 'tcx> {
1859 err_count_on_creation: inh.tcx.sess.err_count(),
1862 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1863 ast::CRATE_NODE_ID)),
1864 diverges: Cell::new(Diverges::Maybe),
1865 has_errors: Cell::new(false),
1866 enclosing_breakables: RefCell::new(EnclosingBreakables {
1874 pub fn sess(&self) -> &Session {
1878 pub fn err_count_since_creation(&self) -> usize {
1879 self.tcx.sess.err_count() - self.err_count_on_creation
1882 /// Produce warning on the given node, if the current point in the
1883 /// function is unreachable, and there hasn't been another warning.
1884 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1885 if self.diverges.get() == Diverges::Always {
1886 self.diverges.set(Diverges::WarnedAlways);
1888 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1890 self.tcx().lint_node(
1891 lint::builtin::UNREACHABLE_CODE,
1893 &format!("unreachable {}", kind));
1899 code: ObligationCauseCode<'tcx>)
1900 -> ObligationCause<'tcx> {
1901 ObligationCause::new(span, self.body_id, code)
1904 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1905 self.cause(span, ObligationCauseCode::MiscObligation)
1908 /// Resolves type variables in `ty` if possible. Unlike the infcx
1909 /// version (resolve_type_vars_if_possible), this version will
1910 /// also select obligations if it seems useful, in an effort
1911 /// to get more type information.
1912 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1913 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1915 // No TyInfer()? Nothing needs doing.
1916 if !ty.has_infer_types() {
1917 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1921 // If `ty` is a type variable, see whether we already know what it is.
1922 ty = self.resolve_type_vars_if_possible(&ty);
1923 if !ty.has_infer_types() {
1924 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1928 // If not, try resolving pending obligations as much as
1929 // possible. This can help substantially when there are
1930 // indirect dependencies that don't seem worth tracking
1932 self.select_obligations_where_possible(false);
1933 ty = self.resolve_type_vars_if_possible(&ty);
1935 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1939 fn record_deferred_call_resolution(&self,
1940 closure_def_id: DefId,
1941 r: DeferredCallResolution<'gcx, 'tcx>) {
1942 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1943 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1946 fn remove_deferred_call_resolutions(&self,
1947 closure_def_id: DefId)
1948 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1950 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1951 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1954 pub fn tag(&self) -> String {
1955 let self_ptr: *const FnCtxt = self;
1956 format!("{:?}", self_ptr)
1959 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1960 match self.locals.borrow().get(&nid) {
1963 span_bug!(span, "no type for local variable {}",
1964 self.tcx.hir.node_to_string(nid));
1970 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1971 debug!("write_ty({:?}, {:?}) in fcx {}",
1972 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1973 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1975 if ty.references_error() {
1976 self.has_errors.set(true);
1977 self.set_tainted_by_errors();
1981 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
1982 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
1983 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
1986 // The NodeId and the ItemLocalId must identify the same item. We just pass
1987 // both of them for consistency checking.
1988 pub fn write_method_call(&self,
1990 method: MethodCallee<'tcx>) {
1993 .type_dependent_defs_mut()
1994 .insert(hir_id, Def::Method(method.def_id));
1995 self.write_substs(hir_id, method.substs);
1998 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1999 if !substs.is_noop() {
2000 debug!("write_substs({:?}, {:?}) in fcx {}",
2005 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2009 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2010 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2016 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2017 Entry::Vacant(entry) => { entry.insert(adj); },
2018 Entry::Occupied(mut entry) => {
2019 debug!(" - composing on top of {:?}", entry.get());
2020 match (&entry.get()[..], &adj[..]) {
2021 // Applying any adjustment on top of a NeverToAny
2022 // is a valid NeverToAny adjustment, because it can't
2024 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2026 Adjustment { kind: Adjust::Deref(_), .. },
2027 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2029 Adjustment { kind: Adjust::Deref(_), .. },
2030 .. // Any following adjustments are allowed.
2032 // A reborrow has no effect before a dereference.
2034 // FIXME: currently we never try to compose autoderefs
2035 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2037 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2038 expr, entry.get(), adj)
2040 *entry.get_mut() = adj;
2045 /// Basically whenever we are converting from a type scheme into
2046 /// the fn body space, we always want to normalize associated
2047 /// types as well. This function combines the two.
2048 fn instantiate_type_scheme<T>(&self,
2050 substs: &Substs<'tcx>,
2053 where T : TypeFoldable<'tcx>
2055 let value = value.subst(self.tcx, substs);
2056 let result = self.normalize_associated_types_in(span, &value);
2057 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2064 /// As `instantiate_type_scheme`, but for the bounds found in a
2065 /// generic type scheme.
2066 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2067 -> ty::InstantiatedPredicates<'tcx> {
2068 let bounds = self.tcx.predicates_of(def_id);
2069 let result = bounds.instantiate(self.tcx, substs);
2070 let result = self.normalize_associated_types_in(span, &result);
2071 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2078 /// Replace the anonymized types from the return value of the
2079 /// function with type variables and records the `AnonTypeMap` for
2080 /// later use during writeback. See
2081 /// `InferCtxt::instantiate_anon_types` for more details.
2082 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2087 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2089 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2094 let (value, anon_type_map) = self.register_infer_ok_obligations(
2095 self.instantiate_anon_types(
2103 let mut anon_types = self.anon_types.borrow_mut();
2104 for (ty, decl) in anon_type_map {
2105 let old_value = anon_types.insert(ty, decl);
2106 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2112 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2113 where T : TypeFoldable<'tcx>
2115 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2118 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2120 where T : TypeFoldable<'tcx>
2122 self.inh.partially_normalize_associated_types_in(span,
2128 pub fn require_type_meets(&self,
2131 code: traits::ObligationCauseCode<'tcx>,
2134 self.register_bound(
2137 traits::ObligationCause::new(span, self.body_id, code));
2140 pub fn require_type_is_sized(&self,
2143 code: traits::ObligationCauseCode<'tcx>)
2145 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2146 self.require_type_meets(ty, span, code, lang_item);
2149 pub fn register_bound(&self,
2152 cause: traits::ObligationCause<'tcx>)
2154 self.fulfillment_cx.borrow_mut()
2155 .register_bound(self, self.param_env, ty, def_id, cause);
2158 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2159 let t = AstConv::ast_ty_to_ty(self, ast_t);
2160 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2164 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2165 match self.tables.borrow().node_types().get(id) {
2167 None if self.is_tainted_by_errors() => self.tcx.types.err,
2169 let node_id = self.tcx.hir.hir_to_node_id(id);
2170 bug!("no type for node {}: {} in fcx {}",
2171 node_id, self.tcx.hir.node_to_string(node_id),
2177 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2178 /// outlive the region `r`.
2179 pub fn register_wf_obligation(&self,
2182 code: traits::ObligationCauseCode<'tcx>)
2184 // WF obligations never themselves fail, so no real need to give a detailed cause:
2185 let cause = traits::ObligationCause::new(span, self.body_id, code);
2186 self.register_predicate(traits::Obligation::new(cause,
2188 ty::Predicate::WellFormed(ty)));
2191 /// Registers obligations that all types appearing in `substs` are well-formed.
2192 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2194 for ty in substs.types() {
2195 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2199 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2200 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2201 /// trait/region obligations.
2203 /// For example, if there is a function:
2206 /// fn foo<'a,T:'a>(...)
2209 /// and a reference:
2215 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2216 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2217 pub fn add_obligations_for_parameters(&self,
2218 cause: traits::ObligationCause<'tcx>,
2219 predicates: &ty::InstantiatedPredicates<'tcx>)
2221 assert!(!predicates.has_escaping_regions());
2223 debug!("add_obligations_for_parameters(predicates={:?})",
2226 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2227 self.register_predicate(obligation);
2231 // FIXME(arielb1): use this instead of field.ty everywhere
2232 // Only for fields! Returns <none> for methods>
2233 // Indifferent to privacy flags
2234 pub fn field_ty(&self,
2236 field: &'tcx ty::FieldDef,
2237 substs: &Substs<'tcx>)
2240 self.normalize_associated_types_in(span,
2241 &field.ty(self.tcx, substs))
2244 fn check_casts(&self) {
2245 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2246 for cast in deferred_cast_checks.drain(..) {
2251 fn resolve_generator_interiors(&self, def_id: DefId) {
2252 let mut generators = self.deferred_generator_interiors.borrow_mut();
2253 for (body_id, interior) in generators.drain(..) {
2254 self.select_obligations_where_possible(false);
2255 generator_interior::resolve_interior(self, def_id, body_id, interior);
2259 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2260 // Non-numerics get replaced with ! or () (depending on whether
2261 // feature(never_type) is enabled, unconstrained ints with i32,
2262 // unconstrained floats with f64.
2263 // Fallback becomes very dubious if we have encountered type-checking errors.
2264 // In that case, fallback to TyError.
2265 // The return value indicates whether fallback has occured.
2266 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2267 use rustc::ty::error::UnconstrainedNumeric::Neither;
2268 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2270 assert!(ty.is_ty_infer());
2271 let fallback = match self.type_is_unconstrained_numeric(ty) {
2272 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2273 UnconstrainedInt => self.tcx.types.i32,
2274 UnconstrainedFloat => self.tcx.types.f64,
2275 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2276 Neither => return false,
2278 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2279 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2283 fn select_all_obligations_or_error(&self) {
2284 debug!("select_all_obligations_or_error");
2285 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2286 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2290 /// Select as many obligations as we can at present.
2291 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2292 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2295 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2300 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2302 hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
2304 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2309 hir::ExprType(ref e, _) => {
2310 self.is_place_expr(e)
2313 hir::ExprUnary(hir::UnDeref, _) |
2314 hir::ExprField(..) |
2315 hir::ExprIndex(..) => {
2319 // Partially qualified paths in expressions can only legally
2320 // refer to associated items which are always rvalues.
2321 hir::ExprPath(hir::QPath::TypeRelative(..)) |
2324 hir::ExprMethodCall(..) |
2325 hir::ExprStruct(..) |
2328 hir::ExprMatch(..) |
2329 hir::ExprClosure(..) |
2330 hir::ExprBlock(..) |
2331 hir::ExprRepeat(..) |
2332 hir::ExprArray(..) |
2333 hir::ExprBreak(..) |
2334 hir::ExprContinue(..) |
2336 hir::ExprWhile(..) |
2338 hir::ExprAssign(..) |
2339 hir::ExprInlineAsm(..) |
2340 hir::ExprAssignOp(..) |
2342 hir::ExprUnary(..) |
2344 hir::ExprAddrOf(..) |
2345 hir::ExprBinary(..) |
2346 hir::ExprYield(..) |
2347 hir::ExprCast(..) => {
2353 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2354 /// returns a type of `&T`, but the actual type we assign to the
2355 /// *expression* is `T`. So this function just peels off the return
2356 /// type by one layer to yield `T`.
2357 fn make_overloaded_place_return_type(&self,
2358 method: MethodCallee<'tcx>)
2359 -> ty::TypeAndMut<'tcx>
2361 // extract method return type, which will be &T;
2362 let ret_ty = method.sig.output();
2364 // method returns &T, but the type as visible to user is T, so deref
2365 ret_ty.builtin_deref(true).unwrap()
2368 fn lookup_indexing(&self,
2370 base_expr: &'gcx hir::Expr,
2374 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2376 // FIXME(#18741) -- this is almost but not quite the same as the
2377 // autoderef that normal method probing does. They could likely be
2380 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2381 let mut result = None;
2382 while result.is_none() && autoderef.next().is_some() {
2383 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2385 autoderef.finalize();
2389 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2390 /// (and otherwise adjust) `base_expr`, looking for a type which either
2391 /// supports builtin indexing or overloaded indexing.
2392 /// This loop implements one step in that search; the autoderef loop
2393 /// is implemented by `lookup_indexing`.
2394 fn try_index_step(&self,
2396 base_expr: &hir::Expr,
2397 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2400 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2402 let adjusted_ty = autoderef.unambiguous_final_ty();
2403 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2410 for &unsize in &[false, true] {
2411 let mut self_ty = adjusted_ty;
2413 // We only unsize arrays here.
2414 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2415 self_ty = self.tcx.mk_slice(element_ty);
2421 // If some lookup succeeds, write callee into table and extract index/element
2422 // type from the method signature.
2423 // If some lookup succeeded, install method in table
2424 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2425 let method = self.try_overloaded_place_op(
2426 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2428 let result = method.map(|ok| {
2429 debug!("try_index_step: success, using overloaded indexing");
2430 let method = self.register_infer_ok_obligations(ok);
2432 let mut adjustments = autoderef.adjust_steps(needs);
2433 if let ty::TyRef(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2434 let mutbl = match r_mutbl {
2435 hir::MutImmutable => AutoBorrowMutability::Immutable,
2436 hir::MutMutable => AutoBorrowMutability::Mutable {
2437 // Indexing can be desugared to a method call,
2438 // so maybe we could use two-phase here.
2439 // See the documentation of AllowTwoPhase for why that's
2440 // not the case today.
2441 allow_two_phase_borrow: AllowTwoPhase::No,
2444 adjustments.push(Adjustment {
2445 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2446 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2453 adjustments.push(Adjustment {
2454 kind: Adjust::Unsize,
2455 target: method.sig.inputs()[0]
2458 self.apply_adjustments(base_expr, adjustments);
2460 self.write_method_call(expr.hir_id, method);
2461 (input_ty, self.make_overloaded_place_return_type(method).ty)
2463 if result.is_some() {
2471 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2472 let (tr, name) = match (op, is_mut) {
2473 (PlaceOp::Deref, false) =>
2474 (self.tcx.lang_items().deref_trait(), "deref"),
2475 (PlaceOp::Deref, true) =>
2476 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2477 (PlaceOp::Index, false) =>
2478 (self.tcx.lang_items().index_trait(), "index"),
2479 (PlaceOp::Index, true) =>
2480 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2482 (tr, ast::Ident::from_str(name))
2485 fn try_overloaded_place_op(&self,
2488 arg_tys: &[Ty<'tcx>],
2491 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2493 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2499 // Try Mut first, if needed.
2500 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2501 let method = match (needs, mut_tr) {
2502 (Needs::MutPlace, Some(trait_did)) => {
2503 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2508 // Otherwise, fall back to the immutable version.
2509 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2510 let method = match (method, imm_tr) {
2511 (None, Some(trait_did)) => {
2512 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2514 (method, _) => method,
2520 fn check_method_argument_types(&self,
2523 method: Result<MethodCallee<'tcx>, ()>,
2524 args_no_rcvr: &'gcx [hir::Expr],
2525 tuple_arguments: TupleArgumentsFlag,
2526 expected: Expectation<'tcx>)
2528 let has_error = match method {
2530 method.substs.references_error() || method.sig.references_error()
2535 let err_inputs = self.err_args(args_no_rcvr.len());
2537 let err_inputs = match tuple_arguments {
2538 DontTupleArguments => err_inputs,
2539 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2542 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2543 false, tuple_arguments, None);
2544 return self.tcx.types.err;
2547 let method = method.unwrap();
2548 // HACK(eddyb) ignore self in the definition (see above).
2549 let expected_arg_tys = self.expected_inputs_for_expected_output(
2552 method.sig.output(),
2553 &method.sig.inputs()[1..]
2555 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2556 args_no_rcvr, method.sig.variadic, tuple_arguments,
2557 self.tcx.hir.span_if_local(method.def_id));
2561 /// Generic function that factors out common logic from function calls,
2562 /// method calls and overloaded operators.
2563 fn check_argument_types(&self,
2566 fn_inputs: &[Ty<'tcx>],
2567 mut expected_arg_tys: &[Ty<'tcx>],
2568 args: &'gcx [hir::Expr],
2570 tuple_arguments: TupleArgumentsFlag,
2571 def_span: Option<Span>) {
2574 // Grab the argument types, supplying fresh type variables
2575 // if the wrong number of arguments were supplied
2576 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2582 // All the input types from the fn signature must outlive the call
2583 // so as to validate implied bounds.
2584 for &fn_input_ty in fn_inputs {
2585 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2588 let expected_arg_count = fn_inputs.len();
2590 let param_count_error = |expected_count: usize,
2595 let mut err = tcx.sess.struct_span_err_with_code(sp,
2596 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2597 if variadic {"at least "} else {""},
2599 if expected_count == 1 {""} else {"s"},
2601 if arg_count == 1 {" was"} else {"s were"}),
2602 DiagnosticId::Error(error_code.to_owned()));
2604 if let Some(def_s) = def_span.map(|sp| tcx.sess.codemap().def_span(sp)) {
2605 err.span_label(def_s, "defined here");
2608 let sugg_span = tcx.sess.codemap().end_point(expr_sp);
2609 // remove closing `)` from the span
2610 let sugg_span = sugg_span.shrink_to_lo();
2611 err.span_suggestion(
2613 "expected the unit value `()`; create it with empty parentheses",
2614 String::from("()"));
2616 err.span_label(sp, format!("expected {}{} parameter{}",
2617 if variadic {"at least "} else {""},
2619 if expected_count == 1 {""} else {"s"}));
2624 let formal_tys = if tuple_arguments == TupleArguments {
2625 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2626 match tuple_type.sty {
2627 ty::TyTuple(arg_types) if arg_types.len() != args.len() => {
2628 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2629 expected_arg_tys = &[];
2630 self.err_args(args.len())
2632 ty::TyTuple(arg_types) => {
2633 expected_arg_tys = match expected_arg_tys.get(0) {
2634 Some(&ty) => match ty.sty {
2635 ty::TyTuple(ref tys) => &tys,
2643 span_err!(tcx.sess, sp, E0059,
2644 "cannot use call notation; the first type parameter \
2645 for the function trait is neither a tuple nor unit");
2646 expected_arg_tys = &[];
2647 self.err_args(args.len())
2650 } else if expected_arg_count == supplied_arg_count {
2652 } else if variadic {
2653 if supplied_arg_count >= expected_arg_count {
2656 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2657 expected_arg_tys = &[];
2658 self.err_args(supplied_arg_count)
2661 // is the missing argument of type `()`?
2662 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2663 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2664 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2665 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2669 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2671 expected_arg_tys = &[];
2672 self.err_args(supplied_arg_count)
2674 // If there is no expectation, expect formal_tys.
2675 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2681 debug!("check_argument_types: formal_tys={:?}",
2682 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2684 // Check the arguments.
2685 // We do this in a pretty awful way: first we typecheck any arguments
2686 // that are not closures, then we typecheck the closures. This is so
2687 // that we have more information about the types of arguments when we
2688 // typecheck the functions. This isn't really the right way to do this.
2689 for &check_closures in &[false, true] {
2690 debug!("check_closures={}", check_closures);
2692 // More awful hacks: before we check argument types, try to do
2693 // an "opportunistic" vtable resolution of any trait bounds on
2694 // the call. This helps coercions.
2696 self.select_obligations_where_possible(false);
2699 // For variadic functions, we don't have a declared type for all of
2700 // the arguments hence we only do our usual type checking with
2701 // the arguments who's types we do know.
2702 let t = if variadic {
2704 } else if tuple_arguments == TupleArguments {
2709 for (i, arg) in args.iter().take(t).enumerate() {
2710 // Warn only for the first loop (the "no closures" one).
2711 // Closure arguments themselves can't be diverging, but
2712 // a previous argument can, e.g. `foo(panic!(), || {})`.
2713 if !check_closures {
2714 self.warn_if_unreachable(arg.id, arg.span, "expression");
2717 let is_closure = match arg.node {
2718 hir::ExprClosure(..) => true,
2722 if is_closure != check_closures {
2726 debug!("checking the argument");
2727 let formal_ty = formal_tys[i];
2729 // The special-cased logic below has three functions:
2730 // 1. Provide as good of an expected type as possible.
2731 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2733 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2735 // 2. Coerce to the most detailed type that could be coerced
2736 // to, which is `expected_ty` if `rvalue_hint` returns an
2737 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2738 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2739 // We're processing function arguments so we definitely want to use
2740 // two-phase borrows.
2741 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2743 // 3. Relate the expected type and the formal one,
2744 // if the expected type was used for the coercion.
2745 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2749 // We also need to make sure we at least write the ty of the other
2750 // arguments which we skipped above.
2752 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2753 use structured_errors::{VariadicError, StructuredDiagnostic};
2754 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2757 for arg in args.iter().skip(expected_arg_count) {
2758 let arg_ty = self.check_expr(&arg);
2760 // There are a few types which get autopromoted when passed via varargs
2761 // in C but we just error out instead and require explicit casts.
2762 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2764 ty::TyFloat(ast::FloatTy::F32) => {
2765 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2767 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2768 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2770 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2771 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2773 ty::TyFnDef(..) => {
2774 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2775 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2776 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2784 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2785 (0..len).map(|_| self.tcx.types.err).collect()
2788 // AST fragment checking
2791 expected: Expectation<'tcx>)
2797 ast::LitKind::Str(..) => tcx.mk_static_str(),
2798 ast::LitKind::ByteStr(ref v) => {
2799 tcx.mk_imm_ref(tcx.types.re_static,
2800 tcx.mk_array(tcx.types.u8, v.len() as u64))
2802 ast::LitKind::Byte(_) => tcx.types.u8,
2803 ast::LitKind::Char(_) => tcx.types.char,
2804 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2805 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2806 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2807 let opt_ty = expected.to_option(self).and_then(|ty| {
2809 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2810 ty::TyChar => Some(tcx.types.u8),
2811 ty::TyRawPtr(..) => Some(tcx.types.usize),
2812 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2816 opt_ty.unwrap_or_else(
2817 || tcx.mk_int_var(self.next_int_var_id()))
2819 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2820 ast::LitKind::FloatUnsuffixed(_) => {
2821 let opt_ty = expected.to_option(self).and_then(|ty| {
2823 ty::TyFloat(_) => Some(ty),
2827 opt_ty.unwrap_or_else(
2828 || tcx.mk_float_var(self.next_float_var_id()))
2830 ast::LitKind::Bool(_) => tcx.types.bool
2834 fn check_expr_eq_type(&self,
2835 expr: &'gcx hir::Expr,
2836 expected: Ty<'tcx>) {
2837 let ty = self.check_expr_with_hint(expr, expected);
2838 self.demand_eqtype(expr.span, expected, ty);
2841 pub fn check_expr_has_type_or_error(&self,
2842 expr: &'gcx hir::Expr,
2843 expected: Ty<'tcx>) -> Ty<'tcx> {
2844 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2847 fn check_expr_meets_expectation_or_error(&self,
2848 expr: &'gcx hir::Expr,
2849 expected: Expectation<'tcx>) -> Ty<'tcx> {
2850 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2851 let mut ty = self.check_expr_with_expectation(expr, expected);
2853 // While we don't allow *arbitrary* coercions here, we *do* allow
2854 // coercions from ! to `expected`.
2856 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2857 "expression with never type wound up being adjusted");
2858 let adj_ty = self.next_diverging_ty_var(
2859 TypeVariableOrigin::AdjustmentType(expr.span));
2860 self.apply_adjustments(expr, vec![Adjustment {
2861 kind: Adjust::NeverToAny,
2867 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2868 // Add help to type error if this is an `if` condition with an assignment
2869 match (expected, &expr.node) {
2870 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2871 let msg = "try comparing for equality";
2872 if let (Ok(left), Ok(right)) = (
2873 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2874 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2876 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2888 fn check_expr_coercable_to_type(&self,
2889 expr: &'gcx hir::Expr,
2890 expected: Ty<'tcx>) -> Ty<'tcx> {
2891 let ty = self.check_expr_with_hint(expr, expected);
2892 // checks don't need two phase
2893 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2896 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2897 expected: Ty<'tcx>) -> Ty<'tcx> {
2898 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2901 fn check_expr_with_expectation(&self,
2902 expr: &'gcx hir::Expr,
2903 expected: Expectation<'tcx>) -> Ty<'tcx> {
2904 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2907 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2908 self.check_expr_with_expectation(expr, NoExpectation)
2911 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2912 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2915 // determine the `self` type, using fresh variables for all variables
2916 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2917 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2919 pub fn impl_self_ty(&self,
2920 span: Span, // (potential) receiver for this impl
2922 -> TypeAndSubsts<'tcx> {
2923 let ity = self.tcx.type_of(did);
2924 debug!("impl_self_ty: ity={:?}", ity);
2926 let substs = self.fresh_substs_for_item(span, did);
2927 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2929 TypeAndSubsts { substs: substs, ty: substd_ty }
2932 /// Unifies the output type with the expected type early, for more coercions
2933 /// and forward type information on the input expressions.
2934 fn expected_inputs_for_expected_output(&self,
2936 expected_ret: Expectation<'tcx>,
2937 formal_ret: Ty<'tcx>,
2938 formal_args: &[Ty<'tcx>])
2940 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2941 let ret_ty = match expected_ret.only_has_type(self) {
2943 None => return Vec::new()
2945 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2946 // Attempt to apply a subtyping relationship between the formal
2947 // return type (likely containing type variables if the function
2948 // is polymorphic) and the expected return type.
2949 // No argument expectations are produced if unification fails.
2950 let origin = self.misc(call_span);
2951 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
2953 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
2954 // to identity so the resulting type is not constrained.
2957 // Process any obligations locally as much as
2958 // we can. We don't care if some things turn
2959 // out unconstrained or ambiguous, as we're
2960 // just trying to get hints here.
2961 self.save_and_restore_in_snapshot_flag(|_| {
2962 let mut fulfill = TraitEngine::new(self.tcx);
2963 for obligation in ok.obligations {
2964 fulfill.register_predicate_obligation(self, obligation);
2966 fulfill.select_where_possible(self)
2967 }).map_err(|_| ())?;
2969 Err(_) => return Err(()),
2972 // Record all the argument types, with the substitutions
2973 // produced from the above subtyping unification.
2974 Ok(formal_args.iter().map(|ty| {
2975 self.resolve_type_vars_if_possible(ty)
2977 }).unwrap_or(Vec::new());
2978 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2979 formal_args, formal_ret,
2980 expect_args, expected_ret);
2984 // Checks a method call.
2985 fn check_method_call(&self,
2986 expr: &'gcx hir::Expr,
2987 segment: &hir::PathSegment,
2989 args: &'gcx [hir::Expr],
2990 expected: Expectation<'tcx>,
2991 needs: Needs) -> Ty<'tcx> {
2992 let rcvr = &args[0];
2993 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
2994 // no need to check for bot/err -- callee does that
2995 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
2997 let method = match self.lookup_method(rcvr_t,
3003 self.write_method_call(expr.hir_id, method);
3007 if segment.ident.name != keywords::Invalid.name() {
3008 self.report_method_error(span,
3019 // Call the generic checker.
3020 self.check_method_argument_types(span,
3028 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3032 .unwrap_or_else(|| span_bug!(return_expr.span,
3033 "check_return_expr called outside fn body"));
3035 let ret_ty = ret_coercion.borrow().expected_ty();
3036 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3037 ret_coercion.borrow_mut()
3039 &self.cause(return_expr.span,
3040 ObligationCauseCode::ReturnType(return_expr.id)),
3046 // A generic function for checking the then and else in an if
3048 fn check_then_else(&self,
3049 cond_expr: &'gcx hir::Expr,
3050 then_expr: &'gcx hir::Expr,
3051 opt_else_expr: Option<&'gcx hir::Expr>,
3053 expected: Expectation<'tcx>) -> Ty<'tcx> {
3054 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3055 let cond_diverges = self.diverges.get();
3056 self.diverges.set(Diverges::Maybe);
3058 let expected = expected.adjust_for_branches(self);
3059 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3060 let then_diverges = self.diverges.get();
3061 self.diverges.set(Diverges::Maybe);
3063 // We've already taken the expected type's preferences
3064 // into account when typing the `then` branch. To figure
3065 // out the initial shot at a LUB, we thus only consider
3066 // `expected` if it represents a *hard* constraint
3067 // (`only_has_type`); otherwise, we just go with a
3068 // fresh type variable.
3069 let coerce_to_ty = expected.coercion_target_type(self, sp);
3070 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3072 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3073 coerce.coerce(self, &if_cause, then_expr, then_ty);
3075 if let Some(else_expr) = opt_else_expr {
3076 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3077 let else_diverges = self.diverges.get();
3079 coerce.coerce(self, &if_cause, else_expr, else_ty);
3081 // We won't diverge unless both branches do (or the condition does).
3082 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3084 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3085 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3087 // If the condition is false we can't diverge.
3088 self.diverges.set(cond_diverges);
3091 let result_ty = coerce.complete(self);
3092 if cond_ty.references_error() {
3099 // Check field access expressions
3100 fn check_field(&self,
3101 expr: &'gcx hir::Expr,
3103 base: &'gcx hir::Expr,
3104 field: ast::Ident) -> Ty<'tcx> {
3105 let expr_t = self.check_expr_with_needs(base, needs);
3106 let expr_t = self.structurally_resolved_type(base.span,
3108 let mut private_candidate = None;
3109 let mut autoderef = self.autoderef(expr.span, expr_t);
3110 while let Some((base_t, _)) = autoderef.next() {
3112 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3113 debug!("struct named {:?}", base_t);
3114 let (ident, def_scope) =
3115 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3116 let fields = &base_def.non_enum_variant().fields;
3117 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3118 let field = &fields[index];
3119 let field_ty = self.field_ty(expr.span, field, substs);
3120 // Save the index of all fields regardless of their visibility in case
3121 // of error recovery.
3122 self.write_field_index(expr.id, index);
3123 if field.vis.is_accessible_from(def_scope, self.tcx) {
3124 let adjustments = autoderef.adjust_steps(needs);
3125 self.apply_adjustments(base, adjustments);
3126 autoderef.finalize();
3128 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3131 private_candidate = Some((base_def.did, field_ty));
3134 ty::TyTuple(ref tys) => {
3135 let fstr = field.as_str();
3136 if let Ok(index) = fstr.parse::<usize>() {
3137 if fstr == index.to_string() {
3138 if let Some(field_ty) = tys.get(index) {
3139 let adjustments = autoderef.adjust_steps(needs);
3140 self.apply_adjustments(base, adjustments);
3141 autoderef.finalize();
3143 self.write_field_index(expr.id, index);
3152 autoderef.unambiguous_final_ty();
3154 if let Some((did, field_ty)) = private_candidate {
3155 let struct_path = self.tcx().item_path_str(did);
3156 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3157 "field `{}` of struct `{}` is private",
3158 field, struct_path);
3159 // Also check if an accessible method exists, which is often what is meant.
3160 if self.method_exists(field, expr_t, expr.id, false) {
3161 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3165 } else if field.name == keywords::Invalid.name() {
3166 self.tcx().types.err
3167 } else if self.method_exists(field, expr_t, expr.id, true) {
3168 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3169 "attempted to take value of method `{}` on type `{}`",
3171 .help("maybe a `()` to call it is missing?")
3173 self.tcx().types.err
3175 if !expr_t.is_primitive_ty() {
3176 let mut err = self.no_such_field_err(field.span, field, expr_t);
3179 ty::TyAdt(def, _) if !def.is_enum() => {
3180 if let Some(suggested_field_name) =
3181 Self::suggest_field_name(def.non_enum_variant(),
3182 &field.as_str(), vec![]) {
3183 err.span_label(field.span,
3184 format!("did you mean `{}`?", suggested_field_name));
3186 err.span_label(field.span, "unknown field");
3187 let struct_variant_def = def.non_enum_variant();
3188 let field_names = self.available_field_names(struct_variant_def);
3189 if !field_names.is_empty() {
3190 err.note(&format!("available fields are: {}",
3191 self.name_series_display(field_names)));
3195 ty::TyRawPtr(..) => {
3196 let base = self.tcx.hir.node_to_pretty_string(base.id);
3197 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3198 let suggestion = format!("(*{}).{}", base, field);
3199 err.span_suggestion(field.span, &msg, suggestion);
3205 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3206 "`{}` is a primitive type and therefore doesn't have fields",
3209 self.tcx().types.err
3213 // Return an hint about the closest match in field names
3214 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3216 skip: Vec<LocalInternedString>)
3218 let names = variant.fields.iter().filter_map(|field| {
3219 // ignore already set fields and private fields from non-local crates
3220 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3221 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3224 Some(&field.ident.name)
3228 find_best_match_for_name(names, field, None)
3231 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3232 let mut available = Vec::new();
3233 for field in variant.fields.iter() {
3234 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3235 if field.vis.is_accessible_from(def_scope, self.tcx) {
3236 available.push(field.ident.name);
3242 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3243 // dynamic limit, to never omit just one field
3244 let limit = if names.len() == 6 { 6 } else { 5 };
3245 let mut display = names.iter().take(limit)
3246 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3247 if names.len() > limit {
3248 display = format!("{} ... and {} others", display, names.len() - limit);
3253 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3254 -> DiagnosticBuilder {
3255 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3256 "no field `{}` on type `{}`",
3260 fn report_unknown_field(&self,
3262 variant: &'tcx ty::VariantDef,
3264 skip_fields: &[hir::Field],
3266 let mut err = self.type_error_struct_with_diag(
3268 |actual| match ty.sty {
3269 ty::TyAdt(adt, ..) if adt.is_enum() => {
3270 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3271 "{} `{}::{}` has no field named `{}`",
3272 kind_name, actual, variant.name, field.ident)
3275 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3276 "{} `{}` has no field named `{}`",
3277 kind_name, actual, field.ident)
3281 // prevent all specified fields from being suggested
3282 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3283 if let Some(field_name) = Self::suggest_field_name(variant,
3284 &field.ident.as_str(),
3285 skip_fields.collect()) {
3286 err.span_label(field.ident.span,
3287 format!("field does not exist - did you mean `{}`?", field_name));
3290 ty::TyAdt(adt, ..) => {
3292 err.span_label(field.ident.span,
3293 format!("`{}::{}` does not have this field",
3296 err.span_label(field.ident.span,
3297 format!("`{}` does not have this field", ty));
3299 let available_field_names = self.available_field_names(variant);
3300 if !available_field_names.is_empty() {
3301 err.note(&format!("available fields are: {}",
3302 self.name_series_display(available_field_names)));
3305 _ => bug!("non-ADT passed to report_unknown_field")
3311 fn check_expr_struct_fields(&self,
3313 expected: Expectation<'tcx>,
3314 expr_id: ast::NodeId,
3316 variant: &'tcx ty::VariantDef,
3317 ast_fields: &'gcx [hir::Field],
3318 check_completeness: bool) -> bool {
3322 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3323 .get(0).cloned().unwrap_or(adt_ty);
3324 // re-link the regions that EIfEO can erase.
3325 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3327 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3328 &ty::TyAdt(adt, substs) => {
3329 (substs, adt.adt_kind(), adt.variant_descr())
3331 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3334 let mut remaining_fields = FxHashMap();
3335 for (i, field) in variant.fields.iter().enumerate() {
3336 remaining_fields.insert(field.ident.modern(), (i, field));
3339 let mut seen_fields = FxHashMap();
3341 let mut error_happened = false;
3343 // Typecheck each field.
3344 for field in ast_fields {
3345 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3346 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3347 seen_fields.insert(ident, field.span);
3348 self.write_field_index(field.id, i);
3350 // we don't look at stability attributes on
3351 // struct-like enums (yet...), but it's definitely not
3352 // a bug to have construct one.
3353 if adt_kind != ty::AdtKind::Enum {
3354 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3357 self.field_ty(field.span, v_field, substs)
3359 error_happened = true;
3360 if let Some(prev_span) = seen_fields.get(&ident) {
3361 let mut err = struct_span_err!(self.tcx.sess,
3364 "field `{}` specified more than once",
3367 err.span_label(field.ident.span, "used more than once");
3368 err.span_label(*prev_span, format!("first use of `{}`", ident));
3372 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3378 // Make sure to give a type to the field even if there's
3379 // an error, so we can continue typechecking
3380 self.check_expr_coercable_to_type(&field.expr, field_type);
3383 // Make sure the programmer specified correct number of fields.
3384 if kind_name == "union" {
3385 if ast_fields.len() != 1 {
3386 tcx.sess.span_err(span, "union expressions should have exactly one field");
3388 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3389 let len = remaining_fields.len();
3391 let mut displayable_field_names = remaining_fields
3393 .map(|ident| ident.as_str())
3394 .collect::<Vec<_>>();
3396 displayable_field_names.sort();
3398 let truncated_fields_error = if len <= 3 {
3401 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3404 let remaining_fields_names = displayable_field_names.iter().take(3)
3405 .map(|n| format!("`{}`", n))
3406 .collect::<Vec<_>>()
3409 struct_span_err!(tcx.sess, span, E0063,
3410 "missing field{} {}{} in initializer of `{}`",
3411 if remaining_fields.len() == 1 { "" } else { "s" },
3412 remaining_fields_names,
3413 truncated_fields_error,
3415 .span_label(span, format!("missing {}{}",
3416 remaining_fields_names,
3417 truncated_fields_error))
3423 fn check_struct_fields_on_error(&self,
3424 fields: &'gcx [hir::Field],
3425 base_expr: &'gcx Option<P<hir::Expr>>) {
3426 for field in fields {
3427 self.check_expr(&field.expr);
3431 self.check_expr(&base);
3437 pub fn check_struct_path(&self,
3439 node_id: ast::NodeId)
3440 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3441 let path_span = match *qpath {
3442 hir::QPath::Resolved(_, ref path) => path.span,
3443 hir::QPath::TypeRelative(ref qself, _) => qself.span
3445 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3446 let variant = match def {
3448 self.set_tainted_by_errors();
3451 Def::Variant(..) => {
3453 ty::TyAdt(adt, substs) => {
3454 Some((adt.variant_of_def(def), adt.did, substs))
3456 _ => bug!("unexpected type: {:?}", ty.sty)
3459 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3460 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3462 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3463 Some((adt.non_enum_variant(), adt.did, substs))
3468 _ => bug!("unexpected definition: {:?}", def)
3471 if let Some((variant, did, substs)) = variant {
3472 // Check bounds on type arguments used in the path.
3473 let bounds = self.instantiate_bounds(path_span, did, substs);
3474 let cause = traits::ObligationCause::new(path_span, self.body_id,
3475 traits::ItemObligation(did));
3476 self.add_obligations_for_parameters(cause, &bounds);
3480 struct_span_err!(self.tcx.sess, path_span, E0071,
3481 "expected struct, variant or union type, found {}",
3482 ty.sort_string(self.tcx))
3483 .span_label(path_span, "not a struct")
3489 fn check_expr_struct(&self,
3491 expected: Expectation<'tcx>,
3493 fields: &'gcx [hir::Field],
3494 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3496 // Find the relevant variant
3497 let (variant, struct_ty) =
3498 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3501 self.check_struct_fields_on_error(fields, base_expr);
3502 return self.tcx.types.err;
3505 let path_span = match *qpath {
3506 hir::QPath::Resolved(_, ref path) => path.span,
3507 hir::QPath::TypeRelative(ref qself, _) => qself.span
3510 // Prohibit struct expressions when non exhaustive flag is set.
3511 if let ty::TyAdt(adt, _) = struct_ty.sty {
3512 if !adt.did.is_local() && adt.is_non_exhaustive() {
3513 span_err!(self.tcx.sess, expr.span, E0639,
3514 "cannot create non-exhaustive {} using struct expression",
3515 adt.variant_descr());
3519 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3520 variant, fields, base_expr.is_none());
3521 if let &Some(ref base_expr) = base_expr {
3522 // If check_expr_struct_fields hit an error, do not attempt to populate
3523 // the fields with the base_expr. This could cause us to hit errors later
3524 // when certain fields are assumed to exist that in fact do not.
3525 if !error_happened {
3526 self.check_expr_has_type_or_error(base_expr, struct_ty);
3527 match struct_ty.sty {
3528 ty::TyAdt(adt, substs) if adt.is_struct() => {
3529 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3530 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3535 .fru_field_types_mut()
3536 .insert(expr.hir_id, fru_field_types);
3539 span_err!(self.tcx.sess, base_expr.span, E0436,
3540 "functional record update syntax requires a struct");
3545 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3551 /// If an expression has any sub-expressions that result in a type error,
3552 /// inspecting that expression's type with `ty.references_error()` will return
3553 /// true. Likewise, if an expression is known to diverge, inspecting its
3554 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3555 /// strict, _|_ can appear in the type of an expression that does not,
3556 /// itself, diverge: for example, fn() -> _|_.)
3557 /// Note that inspecting a type's structure *directly* may expose the fact
3558 /// that there are actually multiple representations for `TyError`, so avoid
3559 /// that when err needs to be handled differently.
3560 fn check_expr_with_expectation_and_needs(&self,
3561 expr: &'gcx hir::Expr,
3562 expected: Expectation<'tcx>,
3563 needs: Needs) -> Ty<'tcx> {
3564 debug!(">> typechecking: expr={:?} expected={:?}",
3567 // Warn for expressions after diverging siblings.
3568 self.warn_if_unreachable(expr.id, expr.span, "expression");
3570 // Hide the outer diverging and has_errors flags.
3571 let old_diverges = self.diverges.get();
3572 let old_has_errors = self.has_errors.get();
3573 self.diverges.set(Diverges::Maybe);
3574 self.has_errors.set(false);
3576 let ty = self.check_expr_kind(expr, expected, needs);
3578 // Warn for non-block expressions with diverging children.
3580 hir::ExprBlock(..) |
3581 hir::ExprLoop(..) | hir::ExprWhile(..) |
3582 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3584 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3587 // Any expression that produces a value of type `!` must have diverged
3589 self.diverges.set(self.diverges.get() | Diverges::Always);
3592 // Record the type, which applies it effects.
3593 // We need to do this after the warning above, so that
3594 // we don't warn for the diverging expression itself.
3595 self.write_ty(expr.hir_id, ty);
3597 // Combine the diverging and has_error flags.
3598 self.diverges.set(self.diverges.get() | old_diverges);
3599 self.has_errors.set(self.has_errors.get() | old_has_errors);
3601 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3602 debug!("... {:?}, expected is {:?}", ty, expected);
3607 fn check_expr_kind(&self,
3608 expr: &'gcx hir::Expr,
3609 expected: Expectation<'tcx>,
3610 needs: Needs) -> Ty<'tcx> {
3614 hir::ExprBox(ref subexpr) => {
3615 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3617 ty::TyAdt(def, _) if def.is_box()
3618 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3622 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3623 tcx.mk_box(referent_ty)
3626 hir::ExprLit(ref lit) => {
3627 self.check_lit(&lit, expected)
3629 hir::ExprBinary(op, ref lhs, ref rhs) => {
3630 self.check_binop(expr, op, lhs, rhs)
3632 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3633 self.check_binop_assign(expr, op, lhs, rhs)
3635 hir::ExprUnary(unop, ref oprnd) => {
3636 let expected_inner = match unop {
3637 hir::UnNot | hir::UnNeg => {
3644 let needs = match unop {
3645 hir::UnDeref => needs,
3648 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3652 if !oprnd_t.references_error() {
3653 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3656 if let Some(mt) = oprnd_t.builtin_deref(true) {
3658 } else if let Some(ok) = self.try_overloaded_deref(
3659 expr.span, oprnd_t, needs) {
3660 let method = self.register_infer_ok_obligations(ok);
3661 if let ty::TyRef(region, _, mutbl) = method.sig.inputs()[0].sty {
3662 let mutbl = match mutbl {
3663 hir::MutImmutable => AutoBorrowMutability::Immutable,
3664 hir::MutMutable => AutoBorrowMutability::Mutable {
3665 // (It shouldn't actually matter for unary ops whether
3666 // we enable two-phase borrows or not, since a unary
3667 // op has no additional operands.)
3668 allow_two_phase_borrow: AllowTwoPhase::No,
3671 self.apply_adjustments(oprnd, vec![Adjustment {
3672 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3673 target: method.sig.inputs()[0]
3676 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3677 self.write_method_call(expr.hir_id, method);
3679 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3680 "type `{}` cannot be dereferenced",
3682 oprnd_t = tcx.types.err;
3686 let result = self.check_user_unop(expr, oprnd_t, unop);
3687 // If it's builtin, we can reuse the type, this helps inference.
3688 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3693 let result = self.check_user_unop(expr, oprnd_t, unop);
3694 // If it's builtin, we can reuse the type, this helps inference.
3695 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3703 hir::ExprAddrOf(mutbl, ref oprnd) => {
3704 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3706 ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
3707 if self.is_place_expr(&oprnd) {
3708 // Places may legitimately have unsized types.
3709 // For example, dereferences of a fat pointer and
3710 // the last field of a struct can be unsized.
3713 Expectation::rvalue_hint(self, ty)
3719 let needs = Needs::maybe_mut_place(mutbl);
3720 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3722 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3723 if tm.ty.references_error() {
3726 // Note: at this point, we cannot say what the best lifetime
3727 // is to use for resulting pointer. We want to use the
3728 // shortest lifetime possible so as to avoid spurious borrowck
3729 // errors. Moreover, the longest lifetime will depend on the
3730 // precise details of the value whose address is being taken
3731 // (and how long it is valid), which we don't know yet until type
3732 // inference is complete.
3734 // Therefore, here we simply generate a region variable. The
3735 // region inferencer will then select the ultimate value.
3736 // Finally, borrowck is charged with guaranteeing that the
3737 // value whose address was taken can actually be made to live
3738 // as long as it needs to live.
3739 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3740 tcx.mk_ref(region, tm)
3743 hir::ExprPath(ref qpath) => {
3744 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3745 let ty = if def != Def::Err {
3746 self.instantiate_value_path(segs, opt_ty, def, expr.span, id)
3748 self.set_tainted_by_errors();
3752 // We always require that the type provided as the value for
3753 // a type parameter outlives the moment of instantiation.
3754 let substs = self.tables.borrow().node_substs(expr.hir_id);
3755 self.add_wf_bounds(substs, expr);
3759 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3760 for output in outputs {
3761 self.check_expr(output);
3763 for input in inputs {
3764 self.check_expr(input);
3768 hir::ExprBreak(destination, ref expr_opt) => {
3769 if let Ok(target_id) = destination.target_id {
3771 if let Some(ref e) = *expr_opt {
3772 // If this is a break with a value, we need to type-check
3773 // the expression. Get an expected type from the loop context.
3774 let opt_coerce_to = {
3775 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3776 enclosing_breakables.find_breakable(target_id)
3779 .map(|coerce| coerce.expected_ty())
3782 // If the loop context is not a `loop { }`, then break with
3783 // a value is illegal, and `opt_coerce_to` will be `None`.
3784 // Just set expectation to error in that case.
3785 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3787 // Recurse without `enclosing_breakables` borrowed.
3788 e_ty = self.check_expr_with_hint(e, coerce_to);
3789 cause = self.misc(e.span);
3791 // Otherwise, this is a break *without* a value. That's
3792 // always legal, and is equivalent to `break ()`.
3793 e_ty = tcx.mk_nil();
3794 cause = self.misc(expr.span);
3797 // Now that we have type-checked `expr_opt`, borrow
3798 // the `enclosing_loops` field and let's coerce the
3799 // type of `expr_opt` into what is expected.
3800 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3801 let ctxt = enclosing_breakables.find_breakable(target_id);
3802 if let Some(ref mut coerce) = ctxt.coerce {
3803 if let Some(ref e) = *expr_opt {
3804 coerce.coerce(self, &cause, e, e_ty);
3806 assert!(e_ty.is_nil());
3807 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3810 // If `ctxt.coerce` is `None`, we can just ignore
3811 // the type of the expresison. This is because
3812 // either this was a break *without* a value, in
3813 // which case it is always a legal type (`()`), or
3814 // else an error would have been flagged by the
3815 // `loops` pass for using break with an expression
3816 // where you are not supposed to.
3817 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3820 ctxt.may_break = true;
3822 // the type of a `break` is always `!`, since it diverges
3825 // Otherwise, we failed to find the enclosing loop;
3826 // this can only happen if the `break` was not
3827 // inside a loop at all, which is caught by the
3828 // loop-checking pass.
3829 assert!(self.tcx.sess.err_count() > 0);
3831 // We still need to assign a type to the inner expression to
3832 // prevent the ICE in #43162.
3833 if let Some(ref e) = *expr_opt {
3834 self.check_expr_with_hint(e, tcx.types.err);
3836 // ... except when we try to 'break rust;'.
3837 // ICE this expression in particular (see #43162).
3838 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3839 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3840 fatally_break_rust(self.tcx.sess);
3844 // There was an error, make typecheck fail
3849 hir::ExprContinue(destination) => {
3850 if let Ok(_) = destination.target_id {
3853 // There was an error, make typecheck fail
3857 hir::ExprRet(ref expr_opt) => {
3858 if self.ret_coercion.is_none() {
3859 struct_span_err!(self.tcx.sess, expr.span, E0572,
3860 "return statement outside of function body").emit();
3861 } else if let Some(ref e) = *expr_opt {
3862 self.check_return_expr(e);
3864 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3865 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3866 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3870 hir::ExprAssign(ref lhs, ref rhs) => {
3871 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3873 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3876 ExpectIfCondition => {
3877 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3878 expected error elsehwere");
3881 // Only check this if not in an `if` condition, as the
3882 // mistyped comparison help is more appropriate.
3883 if !self.is_place_expr(&lhs) {
3884 struct_span_err!(self.tcx.sess, expr.span, E0070,
3885 "invalid left-hand side expression")
3886 .span_label(expr.span, "left-hand of expression not valid")
3892 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3894 if lhs_ty.references_error() || rhs_ty.references_error() {
3900 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3901 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3902 expr.span, expected)
3904 hir::ExprWhile(ref cond, ref body, _) => {
3905 let ctxt = BreakableCtxt {
3906 // cannot use break with a value from a while loop
3908 may_break: false, // Will get updated if/when we find a `break`.
3911 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3912 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3913 let cond_diverging = self.diverges.get();
3914 self.check_block_no_value(&body);
3916 // We may never reach the body so it diverging means nothing.
3917 self.diverges.set(cond_diverging);
3921 // No way to know whether it's diverging because
3922 // of a `break` or an outer `break` or `return`.
3923 self.diverges.set(Diverges::Maybe);
3928 hir::ExprLoop(ref body, _, source) => {
3929 let coerce = match source {
3930 // you can only use break with a value from a normal `loop { }`
3931 hir::LoopSource::Loop => {
3932 let coerce_to = expected.coercion_target_type(self, body.span);
3933 Some(CoerceMany::new(coerce_to))
3936 hir::LoopSource::WhileLet |
3937 hir::LoopSource::ForLoop => {
3942 let ctxt = BreakableCtxt {
3944 may_break: false, // Will get updated if/when we find a `break`.
3947 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3948 self.check_block_no_value(&body);
3952 // No way to know whether it's diverging because
3953 // of a `break` or an outer `break` or `return`.
3954 self.diverges.set(Diverges::Maybe);
3957 // If we permit break with a value, then result type is
3958 // the LUB of the breaks (possibly ! if none); else, it
3959 // is nil. This makes sense because infinite loops
3960 // (which would have type !) are only possible iff we
3961 // permit break with a value [1].
3962 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3963 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3965 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3966 self.check_match(expr, &discrim, arms, expected, match_src)
3968 hir::ExprClosure(capture, ref decl, body_id, _, gen) => {
3969 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
3971 hir::ExprBlock(ref body, _) => {
3972 self.check_block_with_expected(&body, expected)
3974 hir::ExprCall(ref callee, ref args) => {
3975 self.check_call(expr, &callee, args, expected)
3977 hir::ExprMethodCall(ref segment, span, ref args) => {
3978 self.check_method_call(expr, segment, span, args, expected, needs)
3980 hir::ExprCast(ref e, ref t) => {
3981 // Find the type of `e`. Supply hints based on the type we are casting to,
3983 let t_cast = self.to_ty(t);
3984 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3985 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3986 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3988 // Eagerly check for some obvious errors.
3989 if t_expr.references_error() || t_cast.references_error() {
3992 // Defer other checks until we're done type checking.
3993 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3994 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
3996 deferred_cast_checks.push(cast_check);
3999 Err(ErrorReported) => {
4005 hir::ExprType(ref e, ref t) => {
4006 let ty = self.to_ty(&t);
4007 self.check_expr_eq_type(&e, ty);
4010 hir::ExprArray(ref args) => {
4011 let uty = expected.to_option(self).and_then(|uty| {
4013 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4018 let element_ty = if !args.is_empty() {
4019 let coerce_to = uty.unwrap_or_else(
4020 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4021 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4022 assert_eq!(self.diverges.get(), Diverges::Maybe);
4024 let e_ty = self.check_expr_with_hint(e, coerce_to);
4025 let cause = self.misc(e.span);
4026 coerce.coerce(self, &cause, e, e_ty);
4028 coerce.complete(self)
4030 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4032 tcx.mk_array(element_ty, args.len() as u64)
4034 hir::ExprRepeat(ref element, ref count) => {
4035 let count_def_id = tcx.hir.local_def_id(count.id);
4036 let param_env = ty::ParamEnv::empty();
4037 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4038 let instance = ty::Instance::resolve(
4044 let global_id = GlobalId {
4048 let count = tcx.const_eval(param_env.and(global_id));
4050 if let Err(ref err) = count {
4051 err.report_as_error(
4052 tcx.at(tcx.def_span(count_def_id)),
4053 "could not evaluate repeat length",
4057 let uty = match expected {
4058 ExpectHasType(uty) => {
4060 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4067 let (element_ty, t) = match uty {
4069 self.check_expr_coercable_to_type(&element, uty);
4073 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4074 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4079 if let Ok(count) = count {
4080 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4082 // For [foo, ..n] where n > 1, `foo` must have
4084 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4085 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4089 if element_ty.references_error() {
4091 } else if let Ok(count) = count {
4092 tcx.mk_ty(ty::TyArray(t, count))
4097 hir::ExprTup(ref elts) => {
4098 let flds = expected.only_has_type(self).and_then(|ty| {
4099 let ty = self.resolve_type_vars_with_obligations(ty);
4101 ty::TyTuple(ref flds) => Some(&flds[..]),
4106 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4107 let t = match flds {
4108 Some(ref fs) if i < fs.len() => {
4110 self.check_expr_coercable_to_type(&e, ety);
4114 self.check_expr_with_expectation(&e, NoExpectation)
4119 let tuple = tcx.mk_tup(elt_ts_iter);
4120 if tuple.references_error() {
4123 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4127 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4128 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4130 hir::ExprField(ref base, field) => {
4131 self.check_field(expr, needs, &base, field)
4133 hir::ExprIndex(ref base, ref idx) => {
4134 let base_t = self.check_expr_with_needs(&base, needs);
4135 let idx_t = self.check_expr(&idx);
4137 if base_t.references_error() {
4139 } else if idx_t.references_error() {
4142 let base_t = self.structurally_resolved_type(base.span, base_t);
4143 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4144 Some((index_ty, element_ty)) => {
4145 // two-phase not needed because index_ty is never mutable
4146 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4151 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4152 "cannot index into a value of type `{}`",
4154 // Try to give some advice about indexing tuples.
4155 if let ty::TyTuple(..) = base_t.sty {
4156 let mut needs_note = true;
4157 // If the index is an integer, we can show the actual
4158 // fixed expression:
4159 if let hir::ExprLit(ref lit) = idx.node {
4160 if let ast::LitKind::Int(i,
4161 ast::LitIntType::Unsuffixed) = lit.node {
4162 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4163 if let Ok(snip) = snip {
4164 err.span_suggestion(expr.span,
4165 "to access tuple elements, use",
4166 format!("{}.{}", snip, i));
4172 err.help("to access tuple elements, use tuple indexing \
4173 syntax (e.g. `tuple.0`)");
4182 hir::ExprYield(ref value) => {
4183 match self.yield_ty {
4185 self.check_expr_coercable_to_type(&value, ty);
4188 struct_span_err!(self.tcx.sess, expr.span, E0627,
4189 "yield statement outside of generator literal").emit();
4197 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4198 // The newly resolved definition is written into `type_dependent_defs`.
4199 fn finish_resolving_struct_path(&self,
4202 node_id: ast::NodeId)
4206 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4207 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4208 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4211 hir::QPath::TypeRelative(ref qself, ref segment) => {
4212 let ty = self.to_ty(qself);
4214 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4219 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4222 // Write back the new resolution.
4223 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4224 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4231 // Resolve associated value path into a base type and associated constant or method definition.
4232 // The newly resolved definition is written into `type_dependent_defs`.
4233 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4234 qpath: &'b hir::QPath,
4235 node_id: ast::NodeId,
4237 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4239 let (ty, item_segment) = match *qpath {
4240 hir::QPath::Resolved(ref opt_qself, ref path) => {
4242 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4243 &path.segments[..]);
4245 hir::QPath::TypeRelative(ref qself, ref segment) => {
4246 (self.to_ty(qself), segment)
4249 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4250 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4251 // Return directly on cache hit. This is useful to avoid doubly reporting
4252 // errors with default match binding modes. See #44614.
4253 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4255 let item_name = item_segment.ident;
4256 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4259 let def = match error {
4260 method::MethodError::PrivateMatch(def, _) => def,
4263 if item_name.name != keywords::Invalid.name() {
4264 self.report_method_error(span, ty, item_name, None, error, None);
4270 // Write back the new resolution.
4271 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4272 (def, Some(ty), slice::from_ref(&**item_segment))
4275 pub fn check_decl_initializer(&self,
4276 local: &'gcx hir::Local,
4277 init: &'gcx hir::Expr) -> Ty<'tcx>
4279 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4280 // for #42640 (default match binding modes).
4283 let ref_bindings = local.pat.contains_explicit_ref_binding();
4285 let local_ty = self.local_ty(init.span, local.id);
4286 if let Some(m) = ref_bindings {
4287 // Somewhat subtle: if we have a `ref` binding in the pattern,
4288 // we want to avoid introducing coercions for the RHS. This is
4289 // both because it helps preserve sanity and, in the case of
4290 // ref mut, for soundness (issue #23116). In particular, in
4291 // the latter case, we need to be clear that the type of the
4292 // referent for the reference that results is *equal to* the
4293 // type of the place it is referencing, and not some
4294 // supertype thereof.
4295 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4296 self.demand_eqtype(init.span, local_ty, init_ty);
4299 self.check_expr_coercable_to_type(init, local_ty)
4303 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4304 let t = self.local_ty(local.span, local.id);
4305 self.write_ty(local.hir_id, t);
4307 if let Some(ref init) = local.init {
4308 let init_ty = self.check_decl_initializer(local, &init);
4309 if init_ty.references_error() {
4310 self.write_ty(local.hir_id, init_ty);
4314 self.check_pat_walk(&local.pat, t,
4315 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4317 let pat_ty = self.node_ty(local.pat.hir_id);
4318 if pat_ty.references_error() {
4319 self.write_ty(local.hir_id, pat_ty);
4323 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4324 // Don't do all the complex logic below for DeclItem.
4326 hir::StmtDecl(ref decl, _) => {
4328 hir::DeclLocal(_) => {}
4329 hir::DeclItem(_) => {
4334 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4337 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4339 // Hide the outer diverging and has_errors flags.
4340 let old_diverges = self.diverges.get();
4341 let old_has_errors = self.has_errors.get();
4342 self.diverges.set(Diverges::Maybe);
4343 self.has_errors.set(false);
4346 hir::StmtDecl(ref decl, _) => {
4348 hir::DeclLocal(ref l) => {
4349 self.check_decl_local(&l);
4351 hir::DeclItem(_) => {/* ignore for now */}
4354 hir::StmtExpr(ref expr, _) => {
4355 // Check with expected type of ()
4356 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4358 hir::StmtSemi(ref expr, _) => {
4359 self.check_expr(&expr);
4363 // Combine the diverging and has_error flags.
4364 self.diverges.set(self.diverges.get() | old_diverges);
4365 self.has_errors.set(self.has_errors.get() | old_has_errors);
4368 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4369 let unit = self.tcx.mk_nil();
4370 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4372 // if the block produces a `!` value, that can always be
4373 // (effectively) coerced to unit.
4375 self.demand_suptype(blk.span, unit, ty);
4379 fn check_block_with_expected(&self,
4380 blk: &'gcx hir::Block,
4381 expected: Expectation<'tcx>) -> Ty<'tcx> {
4383 let mut fcx_ps = self.ps.borrow_mut();
4384 let unsafety_state = fcx_ps.recurse(blk);
4385 replace(&mut *fcx_ps, unsafety_state)
4388 // In some cases, blocks have just one exit, but other blocks
4389 // can be targeted by multiple breaks. This can happen both
4390 // with labeled blocks as well as when we desugar
4391 // a `do catch { ... }` expression.
4395 // 'a: { if true { break 'a Err(()); } Ok(()) }
4397 // Here we would wind up with two coercions, one from
4398 // `Err(())` and the other from the tail expression
4399 // `Ok(())`. If the tail expression is omitted, that's a
4400 // "forced unit" -- unless the block diverges, in which
4401 // case we can ignore the tail expression (e.g., `'a: {
4402 // break 'a 22; }` would not force the type of the block
4404 let tail_expr = blk.expr.as_ref();
4405 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4406 let coerce = if blk.targeted_by_break {
4407 CoerceMany::new(coerce_to_ty)
4409 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4410 Some(e) => slice::from_ref(e),
4413 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4416 let prev_diverges = self.diverges.get();
4417 let ctxt = BreakableCtxt {
4418 coerce: Some(coerce),
4422 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4423 for s in &blk.stmts {
4427 // check the tail expression **without** holding the
4428 // `enclosing_breakables` lock below.
4429 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4431 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4432 let ctxt = enclosing_breakables.find_breakable(blk.id);
4433 let coerce = ctxt.coerce.as_mut().unwrap();
4434 if let Some(tail_expr_ty) = tail_expr_ty {
4435 let tail_expr = tail_expr.unwrap();
4436 let cause = self.cause(tail_expr.span,
4437 ObligationCauseCode::BlockTailExpression(blk.id));
4443 // Subtle: if there is no explicit tail expression,
4444 // that is typically equivalent to a tail expression
4445 // of `()` -- except if the block diverges. In that
4446 // case, there is no value supplied from the tail
4447 // expression (assuming there are no other breaks,
4448 // this implies that the type of the block will be
4451 // #41425 -- label the implicit `()` as being the
4452 // "found type" here, rather than the "expected type".
4454 // #44579 -- if the block was recovered during parsing,
4455 // the type would be nonsensical and it is not worth it
4456 // to perform the type check, so we avoid generating the
4457 // diagnostic output.
4458 if !self.diverges.get().always() && !blk.recovered {
4459 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4460 if let Some(expected_ty) = expected.only_has_type(self) {
4461 self.consider_hint_about_removing_semicolon(blk,
4471 // If we can break from the block, then the block's exit is always reachable
4472 // (... as long as the entry is reachable) - regardless of the tail of the block.
4473 self.diverges.set(prev_diverges);
4476 let mut ty = ctxt.coerce.unwrap().complete(self);
4478 if self.has_errors.get() || ty.references_error() {
4479 ty = self.tcx.types.err
4482 self.write_ty(blk.hir_id, ty);
4484 *self.ps.borrow_mut() = prev;
4488 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4489 /// suggestion can be made, `None` otherwise.
4490 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4491 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4492 // `while` before reaching it, as block tail returns are not available in them.
4493 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4494 let parent = self.tcx.hir.get(fn_id);
4496 if let Node::NodeItem(&hir::Item {
4497 name, node: hir::ItemFn(ref decl, ..), ..
4499 decl.clone().and_then(|decl| {
4500 // This is less than ideal, it will not suggest a return type span on any
4501 // method called `main`, regardless of whether it is actually the entry point,
4502 // but it will still present it as the reason for the expected type.
4503 Some((decl, name != Symbol::intern("main")))
4505 } else if let Node::NodeTraitItem(&hir::TraitItem {
4506 node: hir::TraitItemKind::Method(hir::MethodSig {
4510 decl.clone().and_then(|decl| {
4513 } else if let Node::NodeImplItem(&hir::ImplItem {
4514 node: hir::ImplItemKind::Method(hir::MethodSig {
4518 decl.clone().and_then(|decl| {
4529 /// On implicit return expressions with mismatched types, provide the following suggestions:
4531 /// - Point out the method's return type as the reason for the expected type
4532 /// - Possible missing semicolon
4533 /// - Possible missing return type if the return type is the default, and not `fn main()`
4534 pub fn suggest_mismatched_types_on_tail(&self,
4535 err: &mut DiagnosticBuilder<'tcx>,
4536 expression: &'gcx hir::Expr,
4540 blk_id: ast::NodeId) {
4541 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4543 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4544 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4548 /// A common error is to forget to add a semicolon at the end of a block:
4552 /// bar_that_returns_u32()
4556 /// This routine checks if the return expression in a block would make sense on its own as a
4557 /// statement and the return type has been left as default or has been specified as `()`. If so,
4558 /// it suggests adding a semicolon.
4559 fn suggest_missing_semicolon(&self,
4560 err: &mut DiagnosticBuilder<'tcx>,
4561 expression: &'gcx hir::Expr,
4564 if expected.is_nil() {
4565 // `BlockTailExpression` only relevant if the tail expr would be
4566 // useful on its own.
4567 match expression.node {
4569 hir::ExprMethodCall(..) |
4571 hir::ExprWhile(..) |
4573 hir::ExprMatch(..) |
4574 hir::ExprBlock(..) => {
4575 let sp = self.tcx.sess.codemap().next_point(cause_span);
4576 err.span_suggestion(sp,
4577 "try adding a semicolon",
4586 /// A possible error is to forget to add a return type that is needed:
4590 /// bar_that_returns_u32()
4594 /// This routine checks if the return type is left as default, the method is not part of an
4595 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4597 fn suggest_missing_return_type(&self,
4598 err: &mut DiagnosticBuilder<'tcx>,
4599 fn_decl: &hir::FnDecl,
4602 can_suggest: bool) {
4603 // Only suggest changing the return type for methods that
4604 // haven't set a return type at all (and aren't `fn main()` or an impl).
4605 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4606 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4607 err.span_suggestion(span,
4608 "try adding a return type",
4610 self.resolve_type_vars_with_obligations(found)));
4612 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4613 err.span_label(span, "possibly return type missing here?");
4615 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4616 // `fn main()` must return `()`, do not suggest changing return type
4617 err.span_label(span, "expected `()` because of default return type");
4619 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4620 // Only point to return type if the expected type is the return type, as if they
4621 // are not, the expectation must have been caused by something else.
4622 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4624 let ty = AstConv::ast_ty_to_ty(self, ty);
4625 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4626 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4627 if ty.sty == expected.sty {
4628 err.span_label(sp, format!("expected `{}` because of return type",
4636 /// A common error is to add an extra semicolon:
4639 /// fn foo() -> usize {
4644 /// This routine checks if the final statement in a block is an
4645 /// expression with an explicit semicolon whose type is compatible
4646 /// with `expected_ty`. If so, it suggests removing the semicolon.
4647 fn consider_hint_about_removing_semicolon(&self,
4648 blk: &'gcx hir::Block,
4649 expected_ty: Ty<'tcx>,
4650 err: &mut DiagnosticBuilder) {
4651 // Be helpful when the user wrote `{... expr;}` and
4652 // taking the `;` off is enough to fix the error.
4653 let last_stmt = match blk.stmts.last() {
4657 let last_expr = match last_stmt.node {
4658 hir::StmtSemi(ref e, _) => e,
4661 let last_expr_ty = self.node_ty(last_expr.hir_id);
4662 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4665 let original_span = original_sp(last_stmt.span, blk.span);
4666 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4667 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4670 // Instantiates the given path, which must refer to an item with the given
4671 // number of type parameters and type.
4672 pub fn instantiate_value_path(&self,
4673 segments: &[hir::PathSegment],
4674 opt_self_ty: Option<Ty<'tcx>>,
4677 node_id: ast::NodeId)
4679 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4684 // We need to extract the type parameters supplied by the user in
4685 // the path `path`. Due to the current setup, this is a bit of a
4686 // tricky-process; the problem is that resolve only tells us the
4687 // end-point of the path resolution, and not the intermediate steps.
4688 // Luckily, we can (at least for now) deduce the intermediate steps
4689 // just from the end-point.
4691 // There are basically four cases to consider:
4693 // 1. Reference to a constructor of enum variant or struct:
4695 // struct Foo<T>(...)
4696 // enum E<T> { Foo(...) }
4698 // In these cases, the parameters are declared in the type
4701 // 2. Reference to a fn item or a free constant:
4705 // In this case, the path will again always have the form
4706 // `a::b::foo::<T>` where only the final segment should have
4707 // type parameters. However, in this case, those parameters are
4708 // declared on a value, and hence are in the `FnSpace`.
4710 // 3. Reference to a method or an associated constant:
4712 // impl<A> SomeStruct<A> {
4716 // Here we can have a path like
4717 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4718 // may appear in two places. The penultimate segment,
4719 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4720 // final segment, `foo::<B>` contains parameters in fn space.
4722 // 4. Reference to a local variable
4724 // Local variables can't have any type parameters.
4726 // The first step then is to categorize the segments appropriately.
4728 assert!(!segments.is_empty());
4730 let mut ufcs_associated = None;
4731 let mut type_segment = None;
4732 let mut fn_segment = None;
4734 // Case 1. Reference to a struct/variant constructor.
4735 Def::StructCtor(def_id, ..) |
4736 Def::VariantCtor(def_id, ..) => {
4737 // Everything but the final segment should have no
4738 // parameters at all.
4739 let mut generics = self.tcx.generics_of(def_id);
4740 if let Some(def_id) = generics.parent {
4741 // Variant and struct constructors use the
4742 // generics of their parent type definition.
4743 generics = self.tcx.generics_of(def_id);
4745 type_segment = Some((segments.last().unwrap(), generics));
4748 // Case 2. Reference to a top-level value.
4750 Def::Const(def_id) |
4751 Def::Static(def_id, _) => {
4752 fn_segment = Some((segments.last().unwrap(), self.tcx.generics_of(def_id)));
4755 // Case 3. Reference to a method or associated const.
4756 Def::Method(def_id) |
4757 Def::AssociatedConst(def_id) => {
4758 let container = self.tcx.associated_item(def_id).container;
4760 ty::TraitContainer(trait_did) => {
4761 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4763 ty::ImplContainer(_) => {}
4766 let generics = self.tcx.generics_of(def_id);
4767 if segments.len() >= 2 {
4768 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4769 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4771 // `<T>::assoc` will end up here, and so can `T::assoc`.
4772 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4773 ufcs_associated = Some((container, self_ty));
4775 fn_segment = Some((segments.last().unwrap(), generics));
4778 // Case 4. Local variable, no generics.
4779 Def::Local(..) | Def::Upvar(..) => {}
4781 _ => bug!("unexpected definition: {:?}", def),
4784 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4786 // Now that we have categorized what space the parameters for each
4787 // segment belong to, let's sort out the parameters that the user
4788 // provided (if any) into their appropriate spaces. We'll also report
4789 // errors if type parameters are provided in an inappropriate place.
4790 let poly_segments = type_segment.is_some() as usize +
4791 fn_segment.is_some() as usize;
4792 AstConv::prohibit_generics(self, &segments[..segments.len() - poly_segments]);
4795 Def::Local(nid) | Def::Upvar(nid, ..) => {
4796 let ty = self.local_ty(span, nid);
4797 let ty = self.normalize_associated_types_in(span, &ty);
4798 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4804 // Now we have to compare the types that the user *actually*
4805 // provided against the types that were *expected*. If the user
4806 // did not provide any types, then we want to substitute inference
4807 // variables. If the user provided some types, we may still need
4808 // to add defaults. If the user provided *too many* types, that's
4810 let supress_mismatch = self.check_impl_trait(span, fn_segment);
4811 self.check_generic_arg_count(span, &mut type_segment, false, supress_mismatch);
4812 self.check_generic_arg_count(span, &mut fn_segment, false, supress_mismatch);
4814 let (fn_start, has_self) = match (type_segment, fn_segment) {
4815 (_, Some((_, generics))) => {
4816 (generics.parent_count, generics.has_self)
4818 (Some((_, generics)), None) => {
4819 (generics.params.len(), generics.has_self)
4821 (None, None) => (0, false)
4823 // FIXME(varkor): Separating out the parameters is messy.
4824 let mut lifetimes_type_seg = vec![];
4825 let mut types_type_seg = vec![];
4826 let mut infer_types_type_seg = true;
4827 if let Some((seg, _)) = type_segment {
4828 if let Some(ref data) = seg.args {
4829 for arg in &data.args {
4831 GenericArg::Lifetime(lt) => lifetimes_type_seg.push(lt),
4832 GenericArg::Type(ty) => types_type_seg.push(ty),
4836 infer_types_type_seg = seg.infer_types;
4839 let mut lifetimes_fn_seg = vec![];
4840 let mut types_fn_seg = vec![];
4841 let mut infer_types_fn_seg = true;
4842 if let Some((seg, _)) = fn_segment {
4843 if let Some(ref data) = seg.args {
4844 for arg in &data.args {
4846 GenericArg::Lifetime(lt) => lifetimes_fn_seg.push(lt),
4847 GenericArg::Type(ty) => types_fn_seg.push(ty),
4851 infer_types_fn_seg = seg.infer_types;
4854 let substs = Substs::for_item(self.tcx, def.def_id(), |param, substs| {
4855 let mut i = param.index as usize;
4857 let (segment, lifetimes, types, infer_types) = if i < fn_start {
4858 if let GenericParamDefKind::Type { .. } = param.kind {
4859 // Handle Self first, so we can adjust the index to match the AST.
4860 if has_self && i == 0 {
4861 return opt_self_ty.map(|ty| ty.into()).unwrap_or_else(|| {
4862 self.var_for_def(span, param)
4866 i -= has_self as usize;
4867 (type_segment, &lifetimes_type_seg, &types_type_seg, infer_types_type_seg)
4870 (fn_segment, &lifetimes_fn_seg, &types_fn_seg, infer_types_fn_seg)
4874 GenericParamDefKind::Lifetime => {
4875 if let Some(lifetime) = lifetimes.get(i) {
4876 AstConv::ast_region_to_region(self, lifetime, Some(param)).into()
4878 self.re_infer(span, Some(param)).unwrap().into()
4881 GenericParamDefKind::Type { .. } => {
4882 // Skip over the lifetimes in the same segment.
4883 if let Some((_, generics)) = segment {
4884 i -= generics.own_counts().lifetimes;
4887 let has_default = match param.kind {
4888 GenericParamDefKind::Type { has_default, .. } => has_default,
4892 if let Some(ast_ty) = types.get(i) {
4893 // A provided type parameter.
4894 self.to_ty(ast_ty).into()
4895 } else if !infer_types && has_default {
4896 // No type parameter provided, but a default exists.
4897 let default = self.tcx.type_of(param.def_id);
4900 default.subst_spanned(self.tcx, substs, Some(span))
4903 // No type parameters were provided, we can infer all.
4904 // This can also be reached in some error cases:
4905 // We prefer to use inference variables instead of
4906 // TyError to let type inference recover somewhat.
4907 self.var_for_def(span, param)
4913 // The things we are substituting into the type should not contain
4914 // escaping late-bound regions, and nor should the base type scheme.
4915 let ty = self.tcx.type_of(def.def_id());
4916 assert!(!substs.has_escaping_regions());
4917 assert!(!ty.has_escaping_regions());
4919 // Add all the obligations that are required, substituting and
4920 // normalized appropriately.
4921 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4922 self.add_obligations_for_parameters(
4923 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4926 // Substitute the values for the type parameters into the type of
4927 // the referenced item.
4928 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4930 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4931 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4932 // is inherent, there is no `Self` parameter, instead, the impl needs
4933 // type parameters, which we can infer by unifying the provided `Self`
4934 // with the substituted impl type.
4935 let ty = self.tcx.type_of(impl_def_id);
4937 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4938 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4939 Ok(ok) => self.register_infer_ok_obligations(ok),
4942 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4949 self.check_rustc_args_require_const(def.def_id(), node_id, span);
4951 debug!("instantiate_value_path: type of {:?} is {:?}",
4954 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4958 fn check_rustc_args_require_const(&self,
4960 node_id: ast::NodeId,
4962 // We're only interested in functions tagged with
4963 // #[rustc_args_required_const], so ignore anything that's not.
4964 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
4968 // If our calling expression is indeed the function itself, we're good!
4969 // If not, generate an error that this can only be called directly.
4970 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
4971 Node::NodeExpr(expr) => {
4973 hir::ExprCall(ref callee, ..) => {
4974 if callee.id == node_id {
4984 self.tcx.sess.span_err(span, "this function can only be invoked \
4985 directly, not through a function pointer");
4988 /// Report errors if the provided parameters are too few or too many.
4989 fn check_generic_arg_count(&self,
4991 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4992 is_method_call: bool,
4993 supress_mismatch_error: bool) {
4994 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4995 (vec![], vec![], true, &[][..]),
4997 s.args.as_ref().map_or(
4998 (vec![], vec![], s.infer_types, &[][..]),
5000 let (mut lifetimes, mut types) = (vec![], vec![]);
5001 data.args.iter().for_each(|arg| match arg {
5002 GenericArg::Lifetime(lt) => lifetimes.push(lt),
5003 GenericArg::Type(ty) => types.push(ty),
5005 (lifetimes, types, s.infer_types, &data.bindings[..])
5010 // Check provided parameters.
5011 let ((ty_required, ty_accepted), lt_accepted) =
5012 segment.map_or(((0, 0), 0), |(_, generics)| {
5018 let mut lt_accepted = 0;
5019 let mut ty_params = ParamRange { required: 0, accepted: 0 };
5020 for param in &generics.params {
5022 GenericParamDefKind::Lifetime => lt_accepted += 1,
5023 GenericParamDefKind::Type { has_default, .. } => {
5024 ty_params.accepted += 1;
5026 ty_params.required += 1;
5031 if generics.parent.is_none() && generics.has_self {
5032 ty_params.required -= 1;
5033 ty_params.accepted -= 1;
5036 ((ty_params.required, ty_params.accepted), lt_accepted)
5039 let count_type_params = |n| {
5040 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
5042 let expected_text = count_type_params(ty_accepted);
5043 let actual_text = count_type_params(types.len());
5044 if let Some((mut err, span)) = if types.len() > ty_accepted {
5045 // To prevent derived errors to accumulate due to extra
5046 // type parameters, we force instantiate_value_path to
5047 // use inference variables instead of the provided types.
5049 let span = types[ty_accepted].span;
5050 Some((struct_span_err!(self.tcx.sess, span, E0087,
5051 "too many type parameters provided: \
5052 expected at most {}, found {}",
5053 expected_text, actual_text), span))
5054 } else if types.len() < ty_required && !infer_types && !supress_mismatch_error {
5055 Some((struct_span_err!(self.tcx.sess, span, E0089,
5056 "too few type parameters provided: \
5057 expected {}, found {}",
5058 expected_text, actual_text), span))
5062 err.span_label(span, format!("expected {}", expected_text)).emit();
5065 if !bindings.is_empty() {
5066 AstConv::prohibit_projection(self, bindings[0].span);
5069 let infer_lifetimes = lifetimes.len() == 0;
5070 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
5071 let has_late_bound_lifetime_defs =
5072 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
5073 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
5074 // Report this as a lint only if no error was reported previously.
5075 let primary_msg = "cannot specify lifetime arguments explicitly \
5076 if late bound lifetime parameters are present";
5077 let note_msg = "the late bound lifetime parameter is introduced here";
5078 if !is_method_call && (lifetimes.len() > lt_accepted ||
5079 lifetimes.len() < lt_accepted && !infer_lifetimes) {
5080 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
5081 err.span_note(span_late, note_msg);
5085 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
5086 multispan.push_span_label(span_late, note_msg.to_string());
5087 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
5088 lifetimes[0].id, multispan, primary_msg);
5093 let count_lifetime_params = |n| {
5094 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
5096 let expected_text = count_lifetime_params(lt_accepted);
5097 let actual_text = count_lifetime_params(lifetimes.len());
5098 if let Some((mut err, span)) = if lifetimes.len() > lt_accepted {
5099 let span = lifetimes[lt_accepted].span;
5100 Some((struct_span_err!(self.tcx.sess, span, E0088,
5101 "too many lifetime parameters provided: \
5102 expected at most {}, found {}",
5103 expected_text, actual_text), span))
5104 } else if lifetimes.len() < lt_accepted && !infer_lifetimes {
5105 Some((struct_span_err!(self.tcx.sess, span, E0090,
5106 "too few lifetime parameters provided: \
5107 expected {}, found {}",
5108 expected_text, actual_text), span))
5112 err.span_label(span, format!("expected {}", expected_text)).emit();
5116 /// Report error if there is an explicit type parameter when using `impl Trait`.
5117 fn check_impl_trait(&self,
5119 segment: Option<(&hir::PathSegment, &ty::Generics)>)
5121 let segment = segment.map(|(path_segment, generics)| {
5122 let explicit = !path_segment.infer_types;
5123 let impl_trait = generics.params.iter().any(|param| match param.kind {
5124 ty::GenericParamDefKind::Type {
5125 synthetic: Some(hir::SyntheticTyParamKind::ImplTrait), ..
5130 if explicit && impl_trait {
5131 let mut err = struct_span_err! {
5135 "cannot provide explicit type parameters when `impl Trait` is \
5136 used in argument position."
5145 segment.unwrap_or(false)
5148 // Resolves `typ` by a single level if `typ` is a type variable.
5149 // If no resolution is possible, then an error is reported.
5150 // Numeric inference variables may be left unresolved.
5151 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5152 let ty = self.resolve_type_vars_with_obligations(ty);
5153 if !ty.is_ty_var() {
5156 if !self.is_tainted_by_errors() {
5157 self.need_type_info_err((**self).body_id, sp, ty)
5158 .note("type must be known at this point")
5161 self.demand_suptype(sp, self.tcx.types.err, ty);
5166 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5167 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5168 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5171 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5172 index = enclosing_breakables.stack.len();
5173 enclosing_breakables.by_id.insert(id, index);
5174 enclosing_breakables.stack.push(ctxt);
5178 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5179 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5180 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5181 enclosing_breakables.stack.pop().expect("missing breakable context")
5187 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5188 generics: &ty::Generics,
5190 let own_counts = generics.own_counts();
5191 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5193 if own_counts.types == 0 {
5196 // Make a vector of booleans initially false, set to true when used.
5197 let mut types_used = vec![false; own_counts.types];
5199 for leaf_ty in ty.walk() {
5200 if let ty::TyParam(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5201 debug!("Found use of ty param num {}", idx);
5202 types_used[idx as usize - own_counts.lifetimes] = true;
5203 } else if let ty::TyError = leaf_ty.sty {
5204 // If there is already another error, do not emit
5205 // an error for not using a type Parameter.
5206 assert!(tcx.sess.err_count() > 0);
5211 let types = generics.params.iter().filter(|param| match param.kind {
5212 ty::GenericParamDefKind::Type { .. } => true,
5215 for (&used, param) in types_used.iter().zip(types) {
5217 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5218 let span = tcx.hir.span(id);
5219 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5220 .span_label(span, "unused type parameter")
5226 fn fatally_break_rust(sess: &Session) {
5227 let handler = sess.diagnostic();
5228 handler.span_bug_no_panic(
5230 "It looks like you're trying to break rust; would you like some ICE?",
5232 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5233 handler.note_without_error(
5234 "we would appreciate a joke overview: \
5235 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5237 handler.note_without_error(&format!("rustc {} running on {}",
5238 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5239 ::session::config::host_triple(),