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::*;
89 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use namespace::Namespace;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::anon_types::AnonTypeDecl;
94 use rustc::infer::type_variable::{TypeVariableOrigin};
95 use rustc::middle::region;
96 use rustc::mir::interpret::{GlobalId};
97 use rustc::ty::subst::{Kind, Subst, Substs};
98 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
99 use rustc::ty::{self, Ty, TyCtxt, Visibility, ToPredicate};
100 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
101 use rustc::ty::fold::TypeFoldable;
102 use rustc::ty::maps::Providers;
103 use rustc::ty::util::{Representability, IntTypeExt, Discr};
104 use errors::{DiagnosticBuilder, DiagnosticId};
106 use require_c_abi_if_variadic;
107 use session::{CompileIncomplete, config, Session};
110 use util::common::{ErrorReported, indenter};
111 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
113 use std::cell::{Cell, RefCell, Ref, RefMut};
114 use rustc_data_structures::sync::Lrc;
115 use std::collections::hash_map::Entry;
117 use std::fmt::Display;
118 use std::mem::replace;
120 use std::ops::{self, Deref};
121 use rustc_target::spec::abi::Abi;
124 use syntax::codemap::{original_sp, Spanned};
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};
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 use this flag for two 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 /// - To permit assignment into a local variable or other place
560 /// (including the "return slot") of type `!`. This is allowed
561 /// if **either** the type of value being assigned is `!`, which
562 /// means the current code is dead, **or** the expression's
563 /// diverging flag is true, which means that a diverging value was
564 /// wrapped (e.g., `let x: ! = foo(return)`).
566 /// To repeat the last point: an expression represents dead-code
567 /// if, after checking it, **either** its type is `!` OR the
568 /// diverges flag is set to something other than `Maybe`.
569 diverges: Cell<Diverges>,
571 /// Whether any child nodes have any type errors.
572 has_errors: Cell<bool>,
574 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
576 inh: &'a Inherited<'a, 'gcx, 'tcx>,
579 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
580 type Target = Inherited<'a, 'gcx, 'tcx>;
581 fn deref(&self) -> &Self::Target {
586 /// Helper type of a temporary returned by Inherited::build(...).
587 /// Necessary because we can't write the following bound:
588 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
589 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
590 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
594 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
595 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
596 -> InheritedBuilder<'a, 'gcx, 'tcx> {
597 let hir_id_root = if def_id.is_local() {
598 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
599 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
600 DefId::local(hir_id.owner)
606 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
612 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
613 fn enter<F, R>(&'tcx mut self, f: F) -> R
614 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
616 let def_id = self.def_id;
617 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
621 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
622 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
624 let item_id = tcx.hir.as_local_node_id(def_id);
625 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
626 let implicit_region_bound = body_id.map(|body_id| {
627 let body = tcx.hir.body(body_id);
628 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
632 tables: MaybeInProgressTables {
633 maybe_tables: infcx.in_progress_tables,
636 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
637 locals: RefCell::new(NodeMap()),
638 deferred_call_resolutions: RefCell::new(DefIdMap()),
639 deferred_cast_checks: RefCell::new(Vec::new()),
640 deferred_generator_interiors: RefCell::new(Vec::new()),
641 anon_types: RefCell::new(DefIdMap()),
642 implicit_region_bound,
647 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
648 debug!("register_predicate({:?})", obligation);
649 if obligation.has_escaping_regions() {
650 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
655 .register_predicate_obligation(self, obligation);
658 fn register_predicates<I>(&self, obligations: I)
659 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
660 for obligation in obligations {
661 self.register_predicate(obligation);
665 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
666 self.register_predicates(infer_ok.obligations);
670 fn normalize_associated_types_in<T>(&self,
672 body_id: ast::NodeId,
673 param_env: ty::ParamEnv<'tcx>,
675 where T : TypeFoldable<'tcx>
677 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
678 self.register_infer_ok_obligations(ok)
682 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
684 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
685 fn visit_item(&mut self, i: &'tcx hir::Item) {
686 check_item_type(self.tcx, i);
688 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
689 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
692 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
693 tcx.sess.track_errors(|| {
694 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
695 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
699 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
700 tcx.sess.track_errors(|| {
701 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
705 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
706 tcx.typeck_item_bodies(LOCAL_CRATE)
709 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
710 -> Result<(), CompileIncomplete>
712 debug_assert!(crate_num == LOCAL_CRATE);
713 Ok(tcx.sess.track_errors(|| {
714 for body_owner_def_id in tcx.body_owners() {
715 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
720 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
721 wfcheck::check_item_well_formed(tcx, def_id);
724 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
725 wfcheck::check_trait_item(tcx, def_id);
728 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
729 wfcheck::check_impl_item(tcx, def_id);
732 pub fn provide(providers: &mut Providers) {
733 method::provide(providers);
734 *providers = Providers {
740 check_item_well_formed,
741 check_trait_item_well_formed,
742 check_impl_item_well_formed,
747 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
749 -> Option<ty::Destructor> {
750 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
753 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
754 /// with information about it's body-id and fn-decl (if any). Otherwise,
757 /// If this function returns "some", then `typeck_tables(def_id)` will
758 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
759 /// may not succeed. In some cases where this function returns `None`
760 /// (notably closures), `typeck_tables(def_id)` would wind up
761 /// redirecting to the owning function.
762 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
764 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
766 match tcx.hir.get(id) {
767 hir::map::NodeItem(item) => {
769 hir::ItemConst(_, body) |
770 hir::ItemStatic(_, _, body) =>
772 hir::ItemFn(ref decl, .., body) =>
773 Some((body, Some(decl))),
778 hir::map::NodeTraitItem(item) => {
780 hir::TraitItemKind::Const(_, Some(body)) =>
782 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
783 Some((body, Some(&sig.decl))),
788 hir::map::NodeImplItem(item) => {
790 hir::ImplItemKind::Const(_, body) =>
792 hir::ImplItemKind::Method(ref sig, body) =>
793 Some((body, Some(&sig.decl))),
798 hir::map::NodeExpr(expr) => {
799 // FIXME(eddyb) Closures should have separate
800 // function definition IDs and expression IDs.
801 // Type-checking should not let closures get
802 // this far in a constant position.
803 // Assume that everything other than closures
804 // is a constant "initializer" expression.
806 hir::ExprClosure(..) =>
809 Some((hir::BodyId { node_id: expr.id }, None)),
816 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
819 // Closures' tables come from their outermost function,
820 // as they are part of the same "inference environment".
821 let outer_def_id = tcx.closure_base_def_id(def_id);
822 if outer_def_id != def_id {
823 return tcx.has_typeck_tables(outer_def_id);
826 let id = tcx.hir.as_local_node_id(def_id).unwrap();
827 primary_body_of(tcx, id).is_some()
830 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
833 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
836 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
838 -> &'tcx ty::TypeckTables<'tcx> {
839 // Closures' tables come from their outermost function,
840 // as they are part of the same "inference environment".
841 let outer_def_id = tcx.closure_base_def_id(def_id);
842 if outer_def_id != def_id {
843 return tcx.typeck_tables_of(outer_def_id);
846 let id = tcx.hir.as_local_node_id(def_id).unwrap();
847 let span = tcx.hir.span(id);
849 // Figure out what primary body this item has.
850 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
851 span_bug!(span, "can't type-check body of {:?}", def_id);
853 let body = tcx.hir.body(body_id);
855 let tables = Inherited::build(tcx, def_id).enter(|inh| {
856 let param_env = tcx.param_env(def_id);
857 let fcx = if let Some(decl) = fn_decl {
858 let fn_sig = tcx.fn_sig(def_id);
860 check_abi(tcx, span, fn_sig.abi());
862 // Compute the fty from point of view of inside fn.
864 tcx.liberate_late_bound_regions(def_id, &fn_sig);
866 inh.normalize_associated_types_in(body.value.span,
871 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
874 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
875 let expected_type = tcx.type_of(def_id);
876 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
877 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
879 // Gather locals in statics (because of block expressions).
880 // This is technically unnecessary because locals in static items are forbidden,
881 // but prevents type checking from blowing up before const checking can properly
883 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
885 fcx.check_expr_coercable_to_type(&body.value, expected_type);
890 // All type checking constraints were added, try to fallback unsolved variables.
891 fcx.select_obligations_where_possible(false);
892 let mut fallback_has_occurred = false;
893 for ty in &fcx.unsolved_variables() {
894 fallback_has_occurred |= fcx.fallback_if_possible(ty);
896 fcx.select_obligations_where_possible(fallback_has_occurred);
898 // Even though coercion casts provide type hints, we check casts after fallback for
899 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
902 // Closure and generater analysis may run after fallback
903 // because they don't constrain other type variables.
904 fcx.closure_analyze(body);
905 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
906 fcx.resolve_generator_interiors(def_id);
907 fcx.select_all_obligations_or_error();
909 if fn_decl.is_some() {
910 fcx.regionck_fn(id, body);
912 fcx.regionck_expr(body);
915 fcx.resolve_type_vars_in_body(body)
918 // Consistency check our TypeckTables instance can hold all ItemLocalIds
919 // it will need to hold.
920 assert_eq!(tables.local_id_root,
921 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
925 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
926 if !tcx.sess.target.target.is_abi_supported(abi) {
927 struct_span_err!(tcx.sess, span, E0570,
928 "The ABI `{}` is not supported for the current target", abi).emit()
932 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
933 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
936 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
937 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
940 // infer the variable's type
941 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
942 self.fcx.locals.borrow_mut().insert(nid, var_ty);
946 // take type that the user specified
947 self.fcx.locals.borrow_mut().insert(nid, typ);
954 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
955 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
956 NestedVisitorMap::None
959 // Add explicitly-declared locals.
960 fn visit_local(&mut self, local: &'gcx hir::Local) {
961 let o_ty = match local.ty {
963 let o_ty = self.fcx.to_ty(&ty);
965 let (c_ty, _orig_values) = self.fcx.inh.infcx.canonicalize_response(&o_ty);
966 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
967 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
973 self.assign(local.span, local.id, o_ty);
975 debug!("Local variable {:?} is assigned type {}",
977 self.fcx.ty_to_string(
978 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
979 intravisit::walk_local(self, local);
982 // Add pattern bindings.
983 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
984 if let PatKind::Binding(_, _, ref path1, _) = p.node {
985 let var_ty = self.assign(p.span, p.id, None);
987 self.fcx.require_type_is_sized(var_ty, p.span,
988 traits::VariableType(p.id));
990 debug!("Pattern binding {} is assigned to {} with type {:?}",
992 self.fcx.ty_to_string(
993 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
996 intravisit::walk_pat(self, p);
999 // Don't descend into the bodies of nested closures
1000 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1001 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1004 /// When `check_fn` is invoked on a generator (i.e., a body that
1005 /// includes yield), it returns back some information about the yield
1007 struct GeneratorTypes<'tcx> {
1008 /// Type of value that is yielded.
1009 yield_ty: ty::Ty<'tcx>,
1011 /// Types that are captured (see `GeneratorInterior` for more).
1012 interior: ty::Ty<'tcx>,
1014 /// Indicates if the generator is movable or static (immovable)
1015 movability: hir::GeneratorMovability,
1018 /// Helper used for fns and closures. Does the grungy work of checking a function
1019 /// body and returns the function context used for that purpose, since in the case of a fn item
1020 /// there is still a bit more to do.
1023 /// * inherited: other fields inherited from the enclosing fn (if any)
1024 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1025 param_env: ty::ParamEnv<'tcx>,
1026 fn_sig: ty::FnSig<'tcx>,
1027 decl: &'gcx hir::FnDecl,
1029 body: &'gcx hir::Body,
1030 can_be_generator: Option<hir::GeneratorMovability>)
1031 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1033 let mut fn_sig = fn_sig.clone();
1035 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1037 // Create the function context. This is either derived from scratch or,
1038 // in the case of function expressions, based on the outer context.
1039 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1040 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1042 let ret_ty = fn_sig.output();
1043 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1044 let ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &ret_ty);
1045 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1046 fn_sig = fcx.tcx.mk_fn_sig(
1047 fn_sig.inputs().iter().cloned(),
1054 let span = body.value.span;
1056 if body.is_generator && can_be_generator.is_some() {
1057 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1058 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1059 fcx.yield_ty = Some(yield_ty);
1062 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1064 // Add formal parameters.
1065 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1066 // Check the pattern.
1067 fcx.check_pat_walk(&arg.pat, arg_ty,
1068 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1070 // Check that argument is Sized.
1071 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1072 // for simple cases like `fn foo(x: Trait)`,
1073 // where we would error once on the parameter as a whole, and once on the binding `x`.
1074 if arg.pat.simple_name().is_none() {
1075 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1078 fcx.write_ty(arg.hir_id, arg_ty);
1081 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1082 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1084 fcx.check_return_expr(&body.value);
1086 // We insert the deferred_generator_interiors entry after visiting the body.
1087 // This ensures that all nested generators appear before the entry of this generator.
1088 // resolve_generator_interiors relies on this property.
1089 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1090 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1091 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1092 Some(GeneratorTypes {
1093 yield_ty: fcx.yield_ty.unwrap(),
1095 movability: can_be_generator.unwrap(),
1101 // Finalize the return check by taking the LUB of the return types
1102 // we saw and assigning it to the expected return type. This isn't
1103 // really expected to fail, since the coercions would have failed
1104 // earlier when trying to find a LUB.
1106 // However, the behavior around `!` is sort of complex. In the
1107 // event that the `actual_return_ty` comes back as `!`, that
1108 // indicates that the fn either does not return or "returns" only
1109 // values of type `!`. In this case, if there is an expected
1110 // return type that is *not* `!`, that should be ok. But if the
1111 // return type is being inferred, we want to "fallback" to `!`:
1113 // let x = move || panic!();
1115 // To allow for that, I am creating a type variable with diverging
1116 // fallback. This was deemed ever so slightly better than unifying
1117 // the return value with `!` because it allows for the caller to
1118 // make more assumptions about the return type (e.g., they could do
1120 // let y: Option<u32> = Some(x());
1122 // which would then cause this return type to become `u32`, not
1124 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1125 let mut actual_return_ty = coercion.complete(&fcx);
1126 if actual_return_ty.is_never() {
1127 actual_return_ty = fcx.next_diverging_ty_var(
1128 TypeVariableOrigin::DivergingFn(span));
1130 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1132 // Check that the main return type implements the termination trait.
1133 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1134 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1137 config::EntryMain => {
1138 let substs = fcx.tcx.mk_substs(iter::once(Kind::from(ret_ty)));
1139 let trait_ref = ty::TraitRef::new(term_id, substs);
1140 let return_ty_span = decl.output.span();
1141 let cause = traits::ObligationCause::new(
1142 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1144 inherited.register_predicate(
1145 traits::Obligation::new(
1146 cause, param_env, trait_ref.to_predicate()));
1148 config::EntryStart => {},
1157 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1160 let def_id = tcx.hir.local_def_id(id);
1161 let def = tcx.adt_def(def_id);
1162 def.destructor(tcx); // force the destructor to be evaluated
1163 check_representable(tcx, span, def_id);
1165 if def.repr.simd() {
1166 check_simd(tcx, span, def_id);
1169 check_transparent(tcx, span, def_id);
1170 check_packed(tcx, span, def_id);
1173 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1176 let def_id = tcx.hir.local_def_id(id);
1177 let def = tcx.adt_def(def_id);
1178 def.destructor(tcx); // force the destructor to be evaluated
1179 check_representable(tcx, span, def_id);
1181 check_packed(tcx, span, def_id);
1184 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1185 debug!("check_item_type(it.id={}, it.name={})",
1187 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1188 let _indenter = indenter();
1190 // Consts can play a role in type-checking, so they are included here.
1191 hir::ItemStatic(..) => {
1192 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1194 hir::ItemConst(..) => {
1195 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1196 if it.attrs.iter().any(|a| a.check_name("wasm_custom_section")) {
1197 let def_id = tcx.hir.local_def_id(it.id);
1198 check_const_is_u8_array(tcx, def_id, it.span);
1201 hir::ItemEnum(ref enum_definition, _) => {
1204 &enum_definition.variants,
1207 hir::ItemFn(..) => {} // entirely within check_item_body
1208 hir::ItemImpl(.., ref impl_item_refs) => {
1209 debug!("ItemImpl {} with id {}", it.name, it.id);
1210 let impl_def_id = tcx.hir.local_def_id(it.id);
1211 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1212 check_impl_items_against_trait(tcx,
1217 let trait_def_id = impl_trait_ref.def_id;
1218 check_on_unimplemented(tcx, trait_def_id, it);
1221 hir::ItemTrait(..) => {
1222 let def_id = tcx.hir.local_def_id(it.id);
1223 check_on_unimplemented(tcx, def_id, it);
1225 hir::ItemStruct(..) => {
1226 check_struct(tcx, it.id, it.span);
1228 hir::ItemUnion(..) => {
1229 check_union(tcx, it.id, it.span);
1231 hir::ItemTy(_, ref generics) => {
1232 let def_id = tcx.hir.local_def_id(it.id);
1233 let pty_ty = tcx.type_of(def_id);
1234 check_bounds_are_used(tcx, generics, pty_ty);
1236 hir::ItemForeignMod(ref m) => {
1237 check_abi(tcx, it.span, m.abi);
1239 if m.abi == Abi::RustIntrinsic {
1240 for item in &m.items {
1241 intrinsic::check_intrinsic_type(tcx, item);
1243 } else if m.abi == Abi::PlatformIntrinsic {
1244 for item in &m.items {
1245 intrinsic::check_platform_intrinsic_type(tcx, item);
1248 for item in &m.items {
1249 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1250 if !generics.types.is_empty() {
1251 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1252 "foreign items may not have type parameters");
1253 err.span_label(item.span, "can't have type parameters");
1254 // FIXME: once we start storing spans for type arguments, turn this into a
1256 err.help("use specialization instead of type parameters by replacing them \
1257 with concrete types like `u32`");
1261 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1262 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1267 _ => {/* nothing to do */ }
1271 fn check_const_is_u8_array<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1274 match tcx.type_of(def_id).sty {
1275 ty::TyArray(t, _) => {
1277 ty::TyUint(ast::UintTy::U8) => return,
1283 tcx.sess.span_err(span, "must be an array of bytes like `[u8; N]`");
1286 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1287 trait_def_id: DefId,
1289 let item_def_id = tcx.hir.local_def_id(item.id);
1290 // an error would be reported if this fails.
1291 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1294 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1295 impl_item: &hir::ImplItem,
1298 let mut err = struct_span_err!(
1299 tcx.sess, impl_item.span, E0520,
1300 "`{}` specializes an item from a parent `impl`, but \
1301 that item is not marked `default`",
1303 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1306 match tcx.span_of_impl(parent_impl) {
1308 err.span_label(span, "parent `impl` is here");
1309 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1313 err.note(&format!("parent implementation is in crate `{}`", cname));
1320 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1321 trait_def: &ty::TraitDef,
1322 trait_item: &ty::AssociatedItem,
1324 impl_item: &hir::ImplItem)
1326 let ancestors = trait_def.ancestors(tcx, impl_id);
1328 let kind = match impl_item.node {
1329 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1330 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1331 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1334 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1335 .map(|node_item| node_item.map(|parent| parent.defaultness));
1337 if let Some(parent) = parent {
1338 if tcx.impl_item_is_final(&parent) {
1339 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1345 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1348 impl_trait_ref: ty::TraitRef<'tcx>,
1349 impl_item_refs: &[hir::ImplItemRef]) {
1350 let impl_span = tcx.sess.codemap().def_span(impl_span);
1352 // If the trait reference itself is erroneous (so the compilation is going
1353 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1354 // isn't populated for such impls.
1355 if impl_trait_ref.references_error() { return; }
1357 // Locate trait definition and items
1358 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1359 let mut overridden_associated_type = None;
1361 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1363 // Check existing impl methods to see if they are both present in trait
1364 // and compatible with trait signature
1365 for impl_item in impl_items() {
1366 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1367 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1368 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1369 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1371 // Not compatible, but needed for the error message
1372 tcx.associated_items(impl_trait_ref.def_id)
1373 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1376 // Check that impl definition matches trait definition
1377 if let Some(ty_trait_item) = ty_trait_item {
1378 match impl_item.node {
1379 hir::ImplItemKind::Const(..) => {
1380 // Find associated const definition.
1381 if ty_trait_item.kind == ty::AssociatedKind::Const {
1382 compare_const_impl(tcx,
1388 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1389 "item `{}` is an associated const, \
1390 which doesn't match its trait `{}`",
1393 err.span_label(impl_item.span, "does not match trait");
1394 // We can only get the spans from local trait definition
1395 // Same for E0324 and E0325
1396 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1397 err.span_label(trait_span, "item in trait");
1402 hir::ImplItemKind::Method(..) => {
1403 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1404 if ty_trait_item.kind == ty::AssociatedKind::Method {
1405 compare_impl_method(tcx,
1412 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1413 "item `{}` is an associated method, \
1414 which doesn't match its trait `{}`",
1417 err.span_label(impl_item.span, "does not match trait");
1418 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1419 err.span_label(trait_span, "item in trait");
1424 hir::ImplItemKind::Type(_) => {
1425 if ty_trait_item.kind == ty::AssociatedKind::Type {
1426 if ty_trait_item.defaultness.has_value() {
1427 overridden_associated_type = Some(impl_item);
1430 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1431 "item `{}` is an associated type, \
1432 which doesn't match its trait `{}`",
1435 err.span_label(impl_item.span, "does not match trait");
1436 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1437 err.span_label(trait_span, "item in trait");
1444 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1448 // Check for missing items from trait
1449 let mut missing_items = Vec::new();
1450 let mut invalidated_items = Vec::new();
1451 let associated_type_overridden = overridden_associated_type.is_some();
1452 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1453 let is_implemented = trait_def.ancestors(tcx, impl_id)
1454 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1456 .map(|node_item| !node_item.node.is_from_trait())
1459 if !is_implemented && !tcx.impl_is_default(impl_id) {
1460 if !trait_item.defaultness.has_value() {
1461 missing_items.push(trait_item);
1462 } else if associated_type_overridden {
1463 invalidated_items.push(trait_item.name);
1468 if !missing_items.is_empty() {
1469 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1470 "not all trait items implemented, missing: `{}`",
1471 missing_items.iter()
1472 .map(|trait_item| trait_item.name.to_string())
1473 .collect::<Vec<_>>().join("`, `"));
1474 err.span_label(impl_span, format!("missing `{}` in implementation",
1475 missing_items.iter()
1476 .map(|trait_item| trait_item.name.to_string())
1477 .collect::<Vec<_>>().join("`, `")));
1478 for trait_item in missing_items {
1479 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1480 err.span_label(span, format!("`{}` from trait", trait_item.name));
1482 err.note_trait_signature(trait_item.name.to_string(),
1483 trait_item.signature(&tcx));
1489 if !invalidated_items.is_empty() {
1490 let invalidator = overridden_associated_type.unwrap();
1491 span_err!(tcx.sess, invalidator.span, E0399,
1492 "the following trait items need to be reimplemented \
1493 as `{}` was overridden: `{}`",
1495 invalidated_items.iter()
1496 .map(|name| name.to_string())
1497 .collect::<Vec<_>>().join("`, `"))
1501 /// Checks whether a type can be represented in memory. In particular, it
1502 /// identifies types that contain themselves without indirection through a
1503 /// pointer, which would mean their size is unbounded.
1504 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1508 let rty = tcx.type_of(item_def_id);
1510 // Check that it is possible to represent this type. This call identifies
1511 // (1) types that contain themselves and (2) types that contain a different
1512 // recursive type. It is only necessary to throw an error on those that
1513 // contain themselves. For case 2, there must be an inner type that will be
1514 // caught by case 1.
1515 match rty.is_representable(tcx, sp) {
1516 Representability::SelfRecursive(spans) => {
1517 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1519 err.span_label(span, "recursive without indirection");
1524 Representability::Representable | Representability::ContainsRecursive => (),
1529 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1530 let t = tcx.type_of(def_id);
1532 ty::TyAdt(def, substs) if def.is_struct() => {
1533 let fields = &def.non_enum_variant().fields;
1534 if fields.is_empty() {
1535 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1538 let e = fields[0].ty(tcx, substs);
1539 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1540 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1541 .span_label(sp, "SIMD elements must have the same type")
1546 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1547 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1549 span_err!(tcx.sess, sp, E0077,
1550 "SIMD vector element type should be machine type");
1559 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1560 let repr = tcx.adt_def(def_id).repr;
1562 for attr in tcx.get_attrs(def_id).iter() {
1563 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1564 if let attr::ReprPacked(pack) = r {
1565 if pack != repr.pack {
1566 struct_span_err!(tcx.sess, sp, E0634,
1567 "type has conflicting packed representation hints").emit();
1573 struct_span_err!(tcx.sess, sp, E0587,
1574 "type has conflicting packed and align representation hints").emit();
1576 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1577 struct_span_err!(tcx.sess, sp, E0588,
1578 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1583 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1585 stack: &mut Vec<DefId>) -> bool {
1586 let t = tcx.type_of(def_id);
1587 if stack.contains(&def_id) {
1588 debug!("check_packed_inner: {:?} is recursive", t);
1592 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1593 if tcx.adt_def(def.did).repr.align > 0 {
1596 // push struct def_id before checking fields
1598 for field in &def.non_enum_variant().fields {
1599 let f = field.ty(tcx, substs);
1601 ty::TyAdt(def, _) => {
1602 if check_packed_inner(tcx, def.did, stack) {
1609 // only need to pop if not early out
1617 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1618 let adt = tcx.adt_def(def_id);
1619 if !adt.repr.transparent() {
1623 // For each field, figure out if it's known to be a ZST and align(1)
1624 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1625 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1626 let param_env = tcx.param_env(field.did);
1627 let layout = tcx.layout_of(param_env.and(ty));
1628 // We are currently checking the type this field came from, so it must be local
1629 let span = tcx.hir.span_if_local(field.did).unwrap();
1630 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1631 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1635 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1636 let non_zst_count = non_zst_fields.clone().count();
1637 if non_zst_count != 1 {
1638 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1639 struct_span_err!(tcx.sess, sp, E0690,
1640 "transparent struct needs exactly one non-zero-sized field, but has {}",
1642 .span_note(field_spans, "non-zero-sized field")
1645 for &(span, zst, align1) in &field_infos {
1647 span_err!(tcx.sess, span, E0691,
1648 "zero-sized field in transparent struct has alignment larger than 1");
1653 #[allow(trivial_numeric_casts)]
1654 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1656 vs: &'tcx [hir::Variant],
1658 let def_id = tcx.hir.local_def_id(id);
1659 let def = tcx.adt_def(def_id);
1660 def.destructor(tcx); // force the destructor to be evaluated
1663 let attributes = tcx.get_attrs(def_id);
1664 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1666 tcx.sess, attr.span, E0084,
1667 "unsupported representation for zero-variant enum")
1668 .span_label(sp, "zero-variant enum")
1673 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1674 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1675 if !tcx.features().repr128 {
1676 emit_feature_err(&tcx.sess.parse_sess,
1679 GateIssue::Language,
1680 "repr with 128-bit type is unstable");
1685 if let Some(e) = v.node.disr_expr {
1686 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1690 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1691 for (discr, v) in def.discriminants(tcx).zip(vs) {
1692 // Check for duplicate discriminant values
1693 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1694 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1695 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1696 let i_span = match variant_i.node.disr_expr {
1697 Some(expr) => tcx.hir.span(expr.node_id),
1698 None => tcx.hir.span(variant_i_node_id)
1700 let span = match v.node.disr_expr {
1701 Some(expr) => tcx.hir.span(expr.node_id),
1704 struct_span_err!(tcx.sess, span, E0081,
1705 "discriminant value `{}` already exists", disr_vals[i])
1706 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1707 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1710 disr_vals.push(discr);
1713 check_representable(tcx, sp, def_id);
1716 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1717 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1719 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1720 -> ty::GenericPredicates<'tcx>
1723 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1724 let item_id = tcx.hir.ty_param_owner(node_id);
1725 let item_def_id = tcx.hir.local_def_id(item_id);
1726 let generics = tcx.generics_of(item_def_id);
1727 let index = generics.type_param_to_index[&def_id];
1728 ty::GenericPredicates {
1730 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1732 ty::Predicate::Trait(ref data) => {
1733 data.skip_binder().self_ty().is_param(index)
1737 }).cloned().collect()
1741 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1742 -> Option<ty::Region<'tcx>> {
1744 Some(def) => infer::EarlyBoundRegion(span, def.name),
1745 None => infer::MiscVariable(span)
1747 Some(self.next_region_var(v))
1750 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1751 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1754 fn ty_infer_for_def(&self,
1755 ty_param_def: &ty::TypeParameterDef,
1756 span: Span) -> Ty<'tcx> {
1757 self.type_var_for_def(span, ty_param_def)
1760 fn projected_ty_from_poly_trait_ref(&self,
1763 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1766 let (trait_ref, _) =
1767 self.replace_late_bound_regions_with_fresh_var(
1769 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1772 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1775 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1776 if ty.has_escaping_regions() {
1777 ty // FIXME: normalization and escaping regions
1779 self.normalize_associated_types_in(span, &ty)
1783 fn set_tainted_by_errors(&self) {
1784 self.infcx.set_tainted_by_errors()
1787 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1788 self.write_ty(hir_id, ty)
1792 /// Controls whether the arguments are tupled. This is used for the call
1795 /// Tupling means that all call-side arguments are packed into a tuple and
1796 /// passed as a single parameter. For example, if tupling is enabled, this
1799 /// fn f(x: (isize, isize))
1801 /// Can be called as:
1808 #[derive(Clone, Eq, PartialEq)]
1809 enum TupleArgumentsFlag {
1814 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1815 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1816 param_env: ty::ParamEnv<'tcx>,
1817 body_id: ast::NodeId)
1818 -> FnCtxt<'a, 'gcx, 'tcx> {
1822 err_count_on_creation: inh.tcx.sess.err_count(),
1825 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1826 ast::CRATE_NODE_ID)),
1827 diverges: Cell::new(Diverges::Maybe),
1828 has_errors: Cell::new(false),
1829 enclosing_breakables: RefCell::new(EnclosingBreakables {
1837 pub fn sess(&self) -> &Session {
1841 pub fn err_count_since_creation(&self) -> usize {
1842 self.tcx.sess.err_count() - self.err_count_on_creation
1845 /// Produce warning on the given node, if the current point in the
1846 /// function is unreachable, and there hasn't been another warning.
1847 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1848 if self.diverges.get() == Diverges::Always {
1849 self.diverges.set(Diverges::WarnedAlways);
1851 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1853 self.tcx().lint_node(
1854 lint::builtin::UNREACHABLE_CODE,
1856 &format!("unreachable {}", kind));
1862 code: ObligationCauseCode<'tcx>)
1863 -> ObligationCause<'tcx> {
1864 ObligationCause::new(span, self.body_id, code)
1867 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1868 self.cause(span, ObligationCauseCode::MiscObligation)
1871 /// Resolves type variables in `ty` if possible. Unlike the infcx
1872 /// version (resolve_type_vars_if_possible), this version will
1873 /// also select obligations if it seems useful, in an effort
1874 /// to get more type information.
1875 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1876 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1878 // No TyInfer()? Nothing needs doing.
1879 if !ty.has_infer_types() {
1880 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1884 // If `ty` is a type variable, see whether we already know what it is.
1885 ty = self.resolve_type_vars_if_possible(&ty);
1886 if !ty.has_infer_types() {
1887 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1891 // If not, try resolving pending obligations as much as
1892 // possible. This can help substantially when there are
1893 // indirect dependencies that don't seem worth tracking
1895 self.select_obligations_where_possible(false);
1896 ty = self.resolve_type_vars_if_possible(&ty);
1898 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1902 fn record_deferred_call_resolution(&self,
1903 closure_def_id: DefId,
1904 r: DeferredCallResolution<'gcx, 'tcx>) {
1905 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1906 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1909 fn remove_deferred_call_resolutions(&self,
1910 closure_def_id: DefId)
1911 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1913 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1914 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1917 pub fn tag(&self) -> String {
1918 let self_ptr: *const FnCtxt = self;
1919 format!("{:?}", self_ptr)
1922 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1923 match self.locals.borrow().get(&nid) {
1926 span_bug!(span, "no type for local variable {}",
1927 self.tcx.hir.node_to_string(nid));
1933 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1934 debug!("write_ty({:?}, {:?}) in fcx {}",
1935 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1936 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1938 if ty.references_error() {
1939 self.has_errors.set(true);
1940 self.set_tainted_by_errors();
1944 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
1945 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
1946 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
1949 // The NodeId and the ItemLocalId must identify the same item. We just pass
1950 // both of them for consistency checking.
1951 pub fn write_method_call(&self,
1953 method: MethodCallee<'tcx>) {
1956 .type_dependent_defs_mut()
1957 .insert(hir_id, Def::Method(method.def_id));
1958 self.write_substs(hir_id, method.substs);
1961 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1962 if !substs.is_noop() {
1963 debug!("write_substs({:?}, {:?}) in fcx {}",
1968 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1972 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1973 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1979 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1980 Entry::Vacant(entry) => { entry.insert(adj); },
1981 Entry::Occupied(mut entry) => {
1982 debug!(" - composing on top of {:?}", entry.get());
1983 match (&entry.get()[..], &adj[..]) {
1984 // Applying any adjustment on top of a NeverToAny
1985 // is a valid NeverToAny adjustment, because it can't
1987 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1989 Adjustment { kind: Adjust::Deref(_), .. },
1990 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1992 Adjustment { kind: Adjust::Deref(_), .. },
1993 .. // Any following adjustments are allowed.
1995 // A reborrow has no effect before a dereference.
1997 // FIXME: currently we never try to compose autoderefs
1998 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2000 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2001 expr, entry.get(), adj)
2003 *entry.get_mut() = adj;
2008 /// Basically whenever we are converting from a type scheme into
2009 /// the fn body space, we always want to normalize associated
2010 /// types as well. This function combines the two.
2011 fn instantiate_type_scheme<T>(&self,
2013 substs: &Substs<'tcx>,
2016 where T : TypeFoldable<'tcx>
2018 let value = value.subst(self.tcx, substs);
2019 let result = self.normalize_associated_types_in(span, &value);
2020 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2027 /// As `instantiate_type_scheme`, but for the bounds found in a
2028 /// generic type scheme.
2029 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2030 -> ty::InstantiatedPredicates<'tcx> {
2031 let bounds = self.tcx.predicates_of(def_id);
2032 let result = bounds.instantiate(self.tcx, substs);
2033 let result = self.normalize_associated_types_in(span, &result);
2034 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2041 /// Replace the anonymized types from the return value of the
2042 /// function with type variables and records the `AnonTypeMap` for
2043 /// later use during writeback. See
2044 /// `InferCtxt::instantiate_anon_types` for more details.
2045 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2050 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2052 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2057 let (value, anon_type_map) = self.register_infer_ok_obligations(
2058 self.instantiate_anon_types(
2066 let mut anon_types = self.anon_types.borrow_mut();
2067 for (ty, decl) in anon_type_map {
2068 let old_value = anon_types.insert(ty, decl);
2069 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2075 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2076 where T : TypeFoldable<'tcx>
2078 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2081 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2083 where T : TypeFoldable<'tcx>
2085 self.inh.partially_normalize_associated_types_in(span,
2091 pub fn require_type_meets(&self,
2094 code: traits::ObligationCauseCode<'tcx>,
2097 self.register_bound(
2100 traits::ObligationCause::new(span, self.body_id, code));
2103 pub fn require_type_is_sized(&self,
2106 code: traits::ObligationCauseCode<'tcx>)
2108 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2109 self.require_type_meets(ty, span, code, lang_item);
2112 pub fn register_bound(&self,
2115 cause: traits::ObligationCause<'tcx>)
2117 self.fulfillment_cx.borrow_mut()
2118 .register_bound(self, self.param_env, ty, def_id, cause);
2121 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2122 let t = AstConv::ast_ty_to_ty(self, ast_t);
2123 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2127 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2128 match self.tables.borrow().node_types().get(id) {
2130 None if self.is_tainted_by_errors() => self.tcx.types.err,
2132 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2133 bug!("no type for node {}: {} in fcx {}",
2134 node_id, self.tcx.hir.node_to_string(node_id),
2140 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2141 /// outlive the region `r`.
2142 pub fn register_wf_obligation(&self,
2145 code: traits::ObligationCauseCode<'tcx>)
2147 // WF obligations never themselves fail, so no real need to give a detailed cause:
2148 let cause = traits::ObligationCause::new(span, self.body_id, code);
2149 self.register_predicate(traits::Obligation::new(cause,
2151 ty::Predicate::WellFormed(ty)));
2154 /// Registers obligations that all types appearing in `substs` are well-formed.
2155 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2157 for ty in substs.types() {
2158 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2162 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2163 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2164 /// trait/region obligations.
2166 /// For example, if there is a function:
2169 /// fn foo<'a,T:'a>(...)
2172 /// and a reference:
2178 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2179 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2180 pub fn add_obligations_for_parameters(&self,
2181 cause: traits::ObligationCause<'tcx>,
2182 predicates: &ty::InstantiatedPredicates<'tcx>)
2184 assert!(!predicates.has_escaping_regions());
2186 debug!("add_obligations_for_parameters(predicates={:?})",
2189 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2190 self.register_predicate(obligation);
2194 // FIXME(arielb1): use this instead of field.ty everywhere
2195 // Only for fields! Returns <none> for methods>
2196 // Indifferent to privacy flags
2197 pub fn field_ty(&self,
2199 field: &'tcx ty::FieldDef,
2200 substs: &Substs<'tcx>)
2203 self.normalize_associated_types_in(span,
2204 &field.ty(self.tcx, substs))
2207 fn check_casts(&self) {
2208 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2209 for cast in deferred_cast_checks.drain(..) {
2214 fn resolve_generator_interiors(&self, def_id: DefId) {
2215 let mut generators = self.deferred_generator_interiors.borrow_mut();
2216 for (body_id, interior) in generators.drain(..) {
2217 self.select_obligations_where_possible(false);
2218 generator_interior::resolve_interior(self, def_id, body_id, interior);
2222 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2223 // Non-numerics get replaced with ! or () (depending on whether
2224 // feature(never_type) is enabled, unconstrained ints with i32,
2225 // unconstrained floats with f64.
2226 // Fallback becomes very dubious if we have encountered type-checking errors.
2227 // In that case, fallback to TyError.
2228 // The return value indicates whether fallback has occured.
2229 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2230 use rustc::ty::error::UnconstrainedNumeric::Neither;
2231 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2233 assert!(ty.is_ty_infer());
2234 let fallback = match self.type_is_unconstrained_numeric(ty) {
2235 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2236 UnconstrainedInt => self.tcx.types.i32,
2237 UnconstrainedFloat => self.tcx.types.f64,
2238 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2239 Neither => return false,
2241 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2242 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2246 fn select_all_obligations_or_error(&self) {
2247 debug!("select_all_obligations_or_error");
2248 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2249 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2253 /// Select as many obligations as we can at present.
2254 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2255 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2258 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2263 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2265 hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
2267 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2272 hir::ExprType(ref e, _) => {
2273 self.is_place_expr(e)
2276 hir::ExprUnary(hir::UnDeref, _) |
2277 hir::ExprField(..) |
2278 hir::ExprIndex(..) => {
2282 // Partially qualified paths in expressions can only legally
2283 // refer to associated items which are always rvalues.
2284 hir::ExprPath(hir::QPath::TypeRelative(..)) |
2287 hir::ExprMethodCall(..) |
2288 hir::ExprStruct(..) |
2291 hir::ExprMatch(..) |
2292 hir::ExprClosure(..) |
2293 hir::ExprBlock(..) |
2294 hir::ExprRepeat(..) |
2295 hir::ExprArray(..) |
2296 hir::ExprBreak(..) |
2297 hir::ExprAgain(..) |
2299 hir::ExprWhile(..) |
2301 hir::ExprAssign(..) |
2302 hir::ExprInlineAsm(..) |
2303 hir::ExprAssignOp(..) |
2305 hir::ExprUnary(..) |
2307 hir::ExprAddrOf(..) |
2308 hir::ExprBinary(..) |
2309 hir::ExprYield(..) |
2310 hir::ExprCast(..) => {
2316 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2317 /// returns a type of `&T`, but the actual type we assign to the
2318 /// *expression* is `T`. So this function just peels off the return
2319 /// type by one layer to yield `T`.
2320 fn make_overloaded_place_return_type(&self,
2321 method: MethodCallee<'tcx>)
2322 -> ty::TypeAndMut<'tcx>
2324 // extract method return type, which will be &T;
2325 let ret_ty = method.sig.output();
2327 // method returns &T, but the type as visible to user is T, so deref
2328 ret_ty.builtin_deref(true).unwrap()
2331 fn lookup_indexing(&self,
2333 base_expr: &'gcx hir::Expr,
2337 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2339 // FIXME(#18741) -- this is almost but not quite the same as the
2340 // autoderef that normal method probing does. They could likely be
2343 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2344 let mut result = None;
2345 while result.is_none() && autoderef.next().is_some() {
2346 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2348 autoderef.finalize();
2352 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2353 /// (and otherwise adjust) `base_expr`, looking for a type which either
2354 /// supports builtin indexing or overloaded indexing.
2355 /// This loop implements one step in that search; the autoderef loop
2356 /// is implemented by `lookup_indexing`.
2357 fn try_index_step(&self,
2359 base_expr: &hir::Expr,
2360 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2363 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2365 let adjusted_ty = autoderef.unambiguous_final_ty();
2366 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2373 for &unsize in &[false, true] {
2374 let mut self_ty = adjusted_ty;
2376 // We only unsize arrays here.
2377 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2378 self_ty = self.tcx.mk_slice(element_ty);
2384 // If some lookup succeeds, write callee into table and extract index/element
2385 // type from the method signature.
2386 // If some lookup succeeded, install method in table
2387 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2388 let method = self.try_overloaded_place_op(
2389 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2391 let result = method.map(|ok| {
2392 debug!("try_index_step: success, using overloaded indexing");
2393 let method = self.register_infer_ok_obligations(ok);
2395 let mut adjustments = autoderef.adjust_steps(needs);
2396 if let ty::TyRef(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2397 let mutbl = match r_mutbl {
2398 hir::MutImmutable => AutoBorrowMutability::Immutable,
2399 hir::MutMutable => AutoBorrowMutability::Mutable {
2400 // Indexing can be desugared to a method call,
2401 // so maybe we could use two-phase here.
2402 // See the documentation of AllowTwoPhase for why that's
2403 // not the case today.
2404 allow_two_phase_borrow: AllowTwoPhase::No,
2407 adjustments.push(Adjustment {
2408 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2409 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2416 adjustments.push(Adjustment {
2417 kind: Adjust::Unsize,
2418 target: method.sig.inputs()[0]
2421 self.apply_adjustments(base_expr, adjustments);
2423 self.write_method_call(expr.hir_id, method);
2424 (input_ty, self.make_overloaded_place_return_type(method).ty)
2426 if result.is_some() {
2434 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2435 let (tr, name) = match (op, is_mut) {
2436 (PlaceOp::Deref, false) =>
2437 (self.tcx.lang_items().deref_trait(), "deref"),
2438 (PlaceOp::Deref, true) =>
2439 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2440 (PlaceOp::Index, false) =>
2441 (self.tcx.lang_items().index_trait(), "index"),
2442 (PlaceOp::Index, true) =>
2443 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2445 (tr, Symbol::intern(name))
2448 fn try_overloaded_place_op(&self,
2451 arg_tys: &[Ty<'tcx>],
2454 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2456 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2462 // Try Mut first, if needed.
2463 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2464 let method = match (needs, mut_tr) {
2465 (Needs::MutPlace, Some(trait_did)) => {
2466 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2471 // Otherwise, fall back to the immutable version.
2472 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2473 let method = match (method, imm_tr) {
2474 (None, Some(trait_did)) => {
2475 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2477 (method, _) => method,
2483 fn check_method_argument_types(&self,
2486 method: Result<MethodCallee<'tcx>, ()>,
2487 args_no_rcvr: &'gcx [hir::Expr],
2488 tuple_arguments: TupleArgumentsFlag,
2489 expected: Expectation<'tcx>)
2491 let has_error = match method {
2493 method.substs.references_error() || method.sig.references_error()
2498 let err_inputs = self.err_args(args_no_rcvr.len());
2500 let err_inputs = match tuple_arguments {
2501 DontTupleArguments => err_inputs,
2502 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2505 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2506 false, tuple_arguments, None);
2507 return self.tcx.types.err;
2510 let method = method.unwrap();
2511 // HACK(eddyb) ignore self in the definition (see above).
2512 let expected_arg_tys = self.expected_inputs_for_expected_output(
2515 method.sig.output(),
2516 &method.sig.inputs()[1..]
2518 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2519 args_no_rcvr, method.sig.variadic, tuple_arguments,
2520 self.tcx.hir.span_if_local(method.def_id));
2524 /// Generic function that factors out common logic from function calls,
2525 /// method calls and overloaded operators.
2526 fn check_argument_types(&self,
2529 fn_inputs: &[Ty<'tcx>],
2530 mut expected_arg_tys: &[Ty<'tcx>],
2531 args: &'gcx [hir::Expr],
2533 tuple_arguments: TupleArgumentsFlag,
2534 def_span: Option<Span>) {
2537 // Grab the argument types, supplying fresh type variables
2538 // if the wrong number of arguments were supplied
2539 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2545 // All the input types from the fn signature must outlive the call
2546 // so as to validate implied bounds.
2547 for &fn_input_ty in fn_inputs {
2548 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2551 let expected_arg_count = fn_inputs.len();
2553 let param_count_error = |expected_count: usize,
2558 let mut err = tcx.sess.struct_span_err_with_code(sp,
2559 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2560 if variadic {"at least "} else {""},
2562 if expected_count == 1 {""} else {"s"},
2564 if arg_count == 1 {" was"} else {"s were"}),
2565 DiagnosticId::Error(error_code.to_owned()));
2567 if let Some(def_s) = def_span.map(|sp| tcx.sess.codemap().def_span(sp)) {
2568 err.span_label(def_s, "defined here");
2571 let sugg_span = tcx.sess.codemap().end_point(expr_sp);
2572 // remove closing `)` from the span
2573 let sugg_span = sugg_span.shrink_to_lo();
2574 err.span_suggestion(
2576 "expected the unit value `()`; create it with empty parentheses",
2577 String::from("()"));
2579 err.span_label(sp, format!("expected {}{} parameter{}",
2580 if variadic {"at least "} else {""},
2582 if expected_count == 1 {""} else {"s"}));
2587 let formal_tys = if tuple_arguments == TupleArguments {
2588 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2589 match tuple_type.sty {
2590 ty::TyTuple(arg_types) if arg_types.len() != args.len() => {
2591 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2592 expected_arg_tys = &[];
2593 self.err_args(args.len())
2595 ty::TyTuple(arg_types) => {
2596 expected_arg_tys = match expected_arg_tys.get(0) {
2597 Some(&ty) => match ty.sty {
2598 ty::TyTuple(ref tys) => &tys,
2606 span_err!(tcx.sess, sp, E0059,
2607 "cannot use call notation; the first type parameter \
2608 for the function trait is neither a tuple nor unit");
2609 expected_arg_tys = &[];
2610 self.err_args(args.len())
2613 } else if expected_arg_count == supplied_arg_count {
2615 } else if variadic {
2616 if supplied_arg_count >= expected_arg_count {
2619 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2620 expected_arg_tys = &[];
2621 self.err_args(supplied_arg_count)
2624 // is the missing argument of type `()`?
2625 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2626 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2627 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2628 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2632 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2634 expected_arg_tys = &[];
2635 self.err_args(supplied_arg_count)
2637 // If there is no expectation, expect formal_tys.
2638 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2644 debug!("check_argument_types: formal_tys={:?}",
2645 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2647 // Check the arguments.
2648 // We do this in a pretty awful way: first we typecheck any arguments
2649 // that are not closures, then we typecheck the closures. This is so
2650 // that we have more information about the types of arguments when we
2651 // typecheck the functions. This isn't really the right way to do this.
2652 for &check_closures in &[false, true] {
2653 debug!("check_closures={}", check_closures);
2655 // More awful hacks: before we check argument types, try to do
2656 // an "opportunistic" vtable resolution of any trait bounds on
2657 // the call. This helps coercions.
2659 self.select_obligations_where_possible(false);
2662 // For variadic functions, we don't have a declared type for all of
2663 // the arguments hence we only do our usual type checking with
2664 // the arguments who's types we do know.
2665 let t = if variadic {
2667 } else if tuple_arguments == TupleArguments {
2672 for (i, arg) in args.iter().take(t).enumerate() {
2673 // Warn only for the first loop (the "no closures" one).
2674 // Closure arguments themselves can't be diverging, but
2675 // a previous argument can, e.g. `foo(panic!(), || {})`.
2676 if !check_closures {
2677 self.warn_if_unreachable(arg.id, arg.span, "expression");
2680 let is_closure = match arg.node {
2681 hir::ExprClosure(..) => true,
2685 if is_closure != check_closures {
2689 debug!("checking the argument");
2690 let formal_ty = formal_tys[i];
2692 // The special-cased logic below has three functions:
2693 // 1. Provide as good of an expected type as possible.
2694 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2696 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2698 // 2. Coerce to the most detailed type that could be coerced
2699 // to, which is `expected_ty` if `rvalue_hint` returns an
2700 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2701 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2702 // We're processing function arguments so we definitely want to use
2703 // two-phase borrows.
2704 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2706 // 3. Relate the expected type and the formal one,
2707 // if the expected type was used for the coercion.
2708 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2712 // We also need to make sure we at least write the ty of the other
2713 // arguments which we skipped above.
2715 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2716 use structured_errors::{VariadicError, StructuredDiagnostic};
2717 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2720 for arg in args.iter().skip(expected_arg_count) {
2721 let arg_ty = self.check_expr(&arg);
2723 // There are a few types which get autopromoted when passed via varargs
2724 // in C but we just error out instead and require explicit casts.
2725 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2727 ty::TyFloat(ast::FloatTy::F32) => {
2728 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2730 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2731 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2733 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2734 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2736 ty::TyFnDef(..) => {
2737 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2738 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2739 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2747 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2748 (0..len).map(|_| self.tcx.types.err).collect()
2751 // AST fragment checking
2754 expected: Expectation<'tcx>)
2760 ast::LitKind::Str(..) => tcx.mk_static_str(),
2761 ast::LitKind::ByteStr(ref v) => {
2762 tcx.mk_imm_ref(tcx.types.re_static,
2763 tcx.mk_array(tcx.types.u8, v.len() as u64))
2765 ast::LitKind::Byte(_) => tcx.types.u8,
2766 ast::LitKind::Char(_) => tcx.types.char,
2767 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2768 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2769 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2770 let opt_ty = expected.to_option(self).and_then(|ty| {
2772 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2773 ty::TyChar => Some(tcx.types.u8),
2774 ty::TyRawPtr(..) => Some(tcx.types.usize),
2775 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2779 opt_ty.unwrap_or_else(
2780 || tcx.mk_int_var(self.next_int_var_id()))
2782 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2783 ast::LitKind::FloatUnsuffixed(_) => {
2784 let opt_ty = expected.to_option(self).and_then(|ty| {
2786 ty::TyFloat(_) => Some(ty),
2790 opt_ty.unwrap_or_else(
2791 || tcx.mk_float_var(self.next_float_var_id()))
2793 ast::LitKind::Bool(_) => tcx.types.bool
2797 fn check_expr_eq_type(&self,
2798 expr: &'gcx hir::Expr,
2799 expected: Ty<'tcx>) {
2800 let ty = self.check_expr_with_hint(expr, expected);
2801 self.demand_eqtype(expr.span, expected, ty);
2804 pub fn check_expr_has_type_or_error(&self,
2805 expr: &'gcx hir::Expr,
2806 expected: Ty<'tcx>) -> Ty<'tcx> {
2807 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2810 fn check_expr_meets_expectation_or_error(&self,
2811 expr: &'gcx hir::Expr,
2812 expected: Expectation<'tcx>) -> Ty<'tcx> {
2813 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2814 let mut ty = self.check_expr_with_expectation(expr, expected);
2816 // While we don't allow *arbitrary* coercions here, we *do* allow
2817 // coercions from ! to `expected`.
2819 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2820 "expression with never type wound up being adjusted");
2821 let adj_ty = self.next_diverging_ty_var(
2822 TypeVariableOrigin::AdjustmentType(expr.span));
2823 self.apply_adjustments(expr, vec![Adjustment {
2824 kind: Adjust::NeverToAny,
2830 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2831 // Add help to type error if this is an `if` condition with an assignment
2832 match (expected, &expr.node) {
2833 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2834 let msg = "try comparing for equality";
2835 if let (Ok(left), Ok(right)) = (
2836 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2837 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2839 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2851 fn check_expr_coercable_to_type(&self,
2852 expr: &'gcx hir::Expr,
2853 expected: Ty<'tcx>) -> Ty<'tcx> {
2854 let ty = self.check_expr_with_hint(expr, expected);
2855 // checks don't need two phase
2856 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2859 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2860 expected: Ty<'tcx>) -> Ty<'tcx> {
2861 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2864 fn check_expr_with_expectation(&self,
2865 expr: &'gcx hir::Expr,
2866 expected: Expectation<'tcx>) -> Ty<'tcx> {
2867 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2870 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2871 self.check_expr_with_expectation(expr, NoExpectation)
2874 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2875 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2878 // determine the `self` type, using fresh variables for all variables
2879 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2880 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2882 pub fn impl_self_ty(&self,
2883 span: Span, // (potential) receiver for this impl
2885 -> TypeAndSubsts<'tcx> {
2886 let ity = self.tcx.type_of(did);
2887 debug!("impl_self_ty: ity={:?}", ity);
2889 let substs = self.fresh_substs_for_item(span, did);
2890 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2892 TypeAndSubsts { substs: substs, ty: substd_ty }
2895 /// Unifies the output type with the expected type early, for more coercions
2896 /// and forward type information on the input expressions.
2897 fn expected_inputs_for_expected_output(&self,
2899 expected_ret: Expectation<'tcx>,
2900 formal_ret: Ty<'tcx>,
2901 formal_args: &[Ty<'tcx>])
2903 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2904 let ret_ty = match expected_ret.only_has_type(self) {
2906 None => return Vec::new()
2908 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2909 // Attempt to apply a subtyping relationship between the formal
2910 // return type (likely containing type variables if the function
2911 // is polymorphic) and the expected return type.
2912 // No argument expectations are produced if unification fails.
2913 let origin = self.misc(call_span);
2914 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
2916 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
2917 // to identity so the resulting type is not constrained.
2920 // Process any obligations locally as much as
2921 // we can. We don't care if some things turn
2922 // out unconstrained or ambiguous, as we're
2923 // just trying to get hints here.
2924 self.save_and_restore_in_snapshot_flag(|_| {
2925 let mut fulfill = TraitEngine::new(self.tcx);
2926 for obligation in ok.obligations {
2927 fulfill.register_predicate_obligation(self, obligation);
2929 fulfill.select_where_possible(self)
2930 }).map_err(|_| ())?;
2932 Err(_) => return Err(()),
2935 // Record all the argument types, with the substitutions
2936 // produced from the above subtyping unification.
2937 Ok(formal_args.iter().map(|ty| {
2938 self.resolve_type_vars_if_possible(ty)
2940 }).unwrap_or(Vec::new());
2941 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2942 formal_args, formal_ret,
2943 expect_args, expected_ret);
2947 // Checks a method call.
2948 fn check_method_call(&self,
2949 expr: &'gcx hir::Expr,
2950 segment: &hir::PathSegment,
2952 args: &'gcx [hir::Expr],
2953 expected: Expectation<'tcx>,
2954 needs: Needs) -> Ty<'tcx> {
2955 let rcvr = &args[0];
2956 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
2957 // no need to check for bot/err -- callee does that
2958 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
2960 let method = match self.lookup_method(rcvr_t,
2966 self.write_method_call(expr.hir_id, method);
2970 if segment.name != keywords::Invalid.name() {
2971 self.report_method_error(span,
2982 // Call the generic checker.
2983 self.check_method_argument_types(span,
2991 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2995 .unwrap_or_else(|| span_bug!(return_expr.span,
2996 "check_return_expr called outside fn body"));
2998 let ret_ty = ret_coercion.borrow().expected_ty();
2999 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3000 ret_coercion.borrow_mut()
3002 &self.cause(return_expr.span,
3003 ObligationCauseCode::ReturnType(return_expr.id)),
3006 self.diverges.get());
3010 // A generic function for checking the then and else in an if
3012 fn check_then_else(&self,
3013 cond_expr: &'gcx hir::Expr,
3014 then_expr: &'gcx hir::Expr,
3015 opt_else_expr: Option<&'gcx hir::Expr>,
3017 expected: Expectation<'tcx>) -> Ty<'tcx> {
3018 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3019 let cond_diverges = self.diverges.get();
3020 self.diverges.set(Diverges::Maybe);
3022 let expected = expected.adjust_for_branches(self);
3023 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3024 let then_diverges = self.diverges.get();
3025 self.diverges.set(Diverges::Maybe);
3027 // We've already taken the expected type's preferences
3028 // into account when typing the `then` branch. To figure
3029 // out the initial shot at a LUB, we thus only consider
3030 // `expected` if it represents a *hard* constraint
3031 // (`only_has_type`); otherwise, we just go with a
3032 // fresh type variable.
3033 let coerce_to_ty = expected.coercion_target_type(self, sp);
3034 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3036 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3037 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
3039 if let Some(else_expr) = opt_else_expr {
3040 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3041 let else_diverges = self.diverges.get();
3043 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
3045 // We won't diverge unless both branches do (or the condition does).
3046 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3048 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3049 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3051 // If the condition is false we can't diverge.
3052 self.diverges.set(cond_diverges);
3055 let result_ty = coerce.complete(self);
3056 if cond_ty.references_error() {
3063 // Check field access expressions
3064 fn check_field(&self,
3065 expr: &'gcx hir::Expr,
3067 base: &'gcx hir::Expr,
3068 field: &Spanned<ast::Name>) -> Ty<'tcx> {
3069 let expr_t = self.check_expr_with_needs(base, needs);
3070 let expr_t = self.structurally_resolved_type(expr.span,
3072 let mut private_candidate = None;
3073 let mut autoderef = self.autoderef(expr.span, expr_t);
3074 while let Some((base_t, _)) = autoderef.next() {
3076 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3077 debug!("struct named {:?}", base_t);
3078 let (ident, def_scope) =
3079 self.tcx.adjust(field.node, base_def.did, self.body_id);
3080 let fields = &base_def.non_enum_variant().fields;
3081 if let Some(index) = fields.iter().position(|f| f.name.to_ident() == ident) {
3082 let field = &fields[index];
3083 let field_ty = self.field_ty(expr.span, field, substs);
3084 if field.vis.is_accessible_from(def_scope, self.tcx) {
3085 let adjustments = autoderef.adjust_steps(needs);
3086 self.apply_adjustments(base, adjustments);
3087 autoderef.finalize();
3089 self.write_field_index(expr.id, index);
3090 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3093 private_candidate = Some((base_def.did, field_ty));
3096 ty::TyTuple(ref tys) => {
3097 let fstr = field.node.as_str();
3098 if let Ok(index) = fstr.parse::<usize>() {
3099 if fstr == index.to_string() {
3100 if let Some(field_ty) = tys.get(index) {
3101 let adjustments = autoderef.adjust_steps(needs);
3102 self.apply_adjustments(base, adjustments);
3103 autoderef.finalize();
3105 self.write_field_index(expr.id, index);
3114 autoderef.unambiguous_final_ty();
3116 if let Some((did, field_ty)) = private_candidate {
3117 let struct_path = self.tcx().item_path_str(did);
3118 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3119 "field `{}` of struct `{}` is private",
3120 field.node, struct_path);
3121 // Also check if an accessible method exists, which is often what is meant.
3122 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3123 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3128 } else if field.node == keywords::Invalid.name() {
3129 self.tcx().types.err
3130 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3131 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3132 "attempted to take value of method `{}` on type `{}`",
3134 .help("maybe a `()` to call it is missing?")
3136 self.tcx().types.err
3138 if !expr_t.is_primitive_ty() {
3139 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3142 ty::TyAdt(def, _) if !def.is_enum() => {
3143 if let Some(suggested_field_name) =
3144 Self::suggest_field_name(def.non_enum_variant(), field, vec![]) {
3145 err.span_label(field.span,
3146 format!("did you mean `{}`?", suggested_field_name));
3148 err.span_label(field.span, "unknown field");
3149 let struct_variant_def = def.non_enum_variant();
3150 let field_names = self.available_field_names(struct_variant_def);
3151 if !field_names.is_empty() {
3152 err.note(&format!("available fields are: {}",
3153 self.name_series_display(field_names)));
3157 ty::TyRawPtr(..) => {
3158 let base = self.tcx.hir.node_to_pretty_string(base.id);
3159 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3160 let suggestion = format!("(*{}).{}", base, field.node);
3161 err.span_suggestion(field.span, &msg, suggestion);
3167 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3168 "`{}` is a primitive type and therefore doesn't have fields",
3171 self.tcx().types.err
3175 // Return an hint about the closest match in field names
3176 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3177 field: &Spanned<ast::Name>,
3178 skip: Vec<LocalInternedString>)
3180 let name = field.node.as_str();
3181 let names = variant.fields.iter().filter_map(|field| {
3182 // ignore already set fields and private fields from non-local crates
3183 if skip.iter().any(|x| *x == field.name.as_str()) ||
3184 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3191 find_best_match_for_name(names, &name, None)
3194 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3195 let mut available = Vec::new();
3196 for field in variant.fields.iter() {
3197 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3198 if field.vis.is_accessible_from(def_scope, self.tcx) {
3199 available.push(field.name);
3205 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3206 // dynamic limit, to never omit just one field
3207 let limit = if names.len() == 6 { 6 } else { 5 };
3208 let mut display = names.iter().take(limit)
3209 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3210 if names.len() > limit {
3211 display = format!("{} ... and {} others", display, names.len() - limit);
3216 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3217 -> DiagnosticBuilder {
3218 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3219 "no field `{}` on type `{}`",
3223 fn report_unknown_field(&self,
3225 variant: &'tcx ty::VariantDef,
3227 skip_fields: &[hir::Field],
3229 let mut err = self.type_error_struct_with_diag(
3231 |actual| match ty.sty {
3232 ty::TyAdt(adt, ..) if adt.is_enum() => {
3233 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3234 "{} `{}::{}` has no field named `{}`",
3235 kind_name, actual, variant.name, field.name.node)
3238 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3239 "{} `{}` has no field named `{}`",
3240 kind_name, actual, field.name.node)
3244 // prevent all specified fields from being suggested
3245 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3246 if let Some(field_name) = Self::suggest_field_name(variant,
3248 skip_fields.collect()) {
3249 err.span_label(field.name.span,
3250 format!("field does not exist - did you mean `{}`?", field_name));
3253 ty::TyAdt(adt, ..) => {
3255 err.span_label(field.name.span,
3256 format!("`{}::{}` does not have this field",
3259 err.span_label(field.name.span,
3260 format!("`{}` does not have this field", ty));
3262 let available_field_names = self.available_field_names(variant);
3263 if !available_field_names.is_empty() {
3264 err.note(&format!("available fields are: {}",
3265 self.name_series_display(available_field_names)));
3268 _ => bug!("non-ADT passed to report_unknown_field")
3274 fn check_expr_struct_fields(&self,
3276 expected: Expectation<'tcx>,
3277 expr_id: ast::NodeId,
3279 variant: &'tcx ty::VariantDef,
3280 ast_fields: &'gcx [hir::Field],
3281 check_completeness: bool) -> bool {
3285 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3286 .get(0).cloned().unwrap_or(adt_ty);
3287 // re-link the regions that EIfEO can erase.
3288 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3290 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3291 &ty::TyAdt(adt, substs) => {
3292 (substs, adt.adt_kind(), adt.variant_descr())
3294 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3297 let mut remaining_fields = FxHashMap();
3298 for (i, field) in variant.fields.iter().enumerate() {
3299 remaining_fields.insert(field.name.to_ident(), (i, field));
3302 let mut seen_fields = FxHashMap();
3304 let mut error_happened = false;
3306 // Typecheck each field.
3307 for field in ast_fields {
3308 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3309 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3310 seen_fields.insert(ident, field.span);
3311 self.write_field_index(field.id, i);
3313 // we don't look at stability attributes on
3314 // struct-like enums (yet...), but it's definitely not
3315 // a bug to have construct one.
3316 if adt_kind != ty::AdtKind::Enum {
3317 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3320 self.field_ty(field.span, v_field, substs)
3322 error_happened = true;
3323 if let Some(prev_span) = seen_fields.get(&ident) {
3324 let mut err = struct_span_err!(self.tcx.sess,
3327 "field `{}` specified more than once",
3330 err.span_label(field.name.span, "used more than once");
3331 err.span_label(*prev_span, format!("first use of `{}`", ident));
3335 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3341 // Make sure to give a type to the field even if there's
3342 // an error, so we can continue typechecking
3343 self.check_expr_coercable_to_type(&field.expr, field_type);
3346 // Make sure the programmer specified correct number of fields.
3347 if kind_name == "union" {
3348 if ast_fields.len() != 1 {
3349 tcx.sess.span_err(span, "union expressions should have exactly one field");
3351 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3352 let len = remaining_fields.len();
3354 let mut displayable_field_names = remaining_fields
3356 .map(|ident| ident.name.as_str())
3357 .collect::<Vec<_>>();
3359 displayable_field_names.sort();
3361 let truncated_fields_error = if len <= 3 {
3364 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3367 let remaining_fields_names = displayable_field_names.iter().take(3)
3368 .map(|n| format!("`{}`", n))
3369 .collect::<Vec<_>>()
3372 struct_span_err!(tcx.sess, span, E0063,
3373 "missing field{} {}{} in initializer of `{}`",
3374 if remaining_fields.len() == 1 { "" } else { "s" },
3375 remaining_fields_names,
3376 truncated_fields_error,
3378 .span_label(span, format!("missing {}{}",
3379 remaining_fields_names,
3380 truncated_fields_error))
3386 fn check_struct_fields_on_error(&self,
3387 fields: &'gcx [hir::Field],
3388 base_expr: &'gcx Option<P<hir::Expr>>) {
3389 for field in fields {
3390 self.check_expr(&field.expr);
3394 self.check_expr(&base);
3400 pub fn check_struct_path(&self,
3402 node_id: ast::NodeId)
3403 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3404 let path_span = match *qpath {
3405 hir::QPath::Resolved(_, ref path) => path.span,
3406 hir::QPath::TypeRelative(ref qself, _) => qself.span
3408 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3409 let variant = match def {
3411 self.set_tainted_by_errors();
3414 Def::Variant(..) => {
3416 ty::TyAdt(adt, substs) => {
3417 Some((adt.variant_of_def(def), adt.did, substs))
3419 _ => bug!("unexpected type: {:?}", ty.sty)
3422 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3423 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3425 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3426 Some((adt.non_enum_variant(), adt.did, substs))
3431 _ => bug!("unexpected definition: {:?}", def)
3434 if let Some((variant, did, substs)) = variant {
3435 // Check bounds on type arguments used in the path.
3436 let bounds = self.instantiate_bounds(path_span, did, substs);
3437 let cause = traits::ObligationCause::new(path_span, self.body_id,
3438 traits::ItemObligation(did));
3439 self.add_obligations_for_parameters(cause, &bounds);
3443 struct_span_err!(self.tcx.sess, path_span, E0071,
3444 "expected struct, variant or union type, found {}",
3445 ty.sort_string(self.tcx))
3446 .span_label(path_span, "not a struct")
3452 fn check_expr_struct(&self,
3454 expected: Expectation<'tcx>,
3456 fields: &'gcx [hir::Field],
3457 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3459 // Find the relevant variant
3460 let (variant, struct_ty) =
3461 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3464 self.check_struct_fields_on_error(fields, base_expr);
3465 return self.tcx.types.err;
3468 let path_span = match *qpath {
3469 hir::QPath::Resolved(_, ref path) => path.span,
3470 hir::QPath::TypeRelative(ref qself, _) => qself.span
3473 // Prohibit struct expressions when non exhaustive flag is set.
3474 if let ty::TyAdt(adt, _) = struct_ty.sty {
3475 if !adt.did.is_local() && adt.is_non_exhaustive() {
3476 span_err!(self.tcx.sess, expr.span, E0639,
3477 "cannot create non-exhaustive {} using struct expression",
3478 adt.variant_descr());
3482 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3483 variant, fields, base_expr.is_none());
3484 if let &Some(ref base_expr) = base_expr {
3485 // If check_expr_struct_fields hit an error, do not attempt to populate
3486 // the fields with the base_expr. This could cause us to hit errors later
3487 // when certain fields are assumed to exist that in fact do not.
3488 if !error_happened {
3489 self.check_expr_has_type_or_error(base_expr, struct_ty);
3490 match struct_ty.sty {
3491 ty::TyAdt(adt, substs) if adt.is_struct() => {
3492 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3493 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3498 .fru_field_types_mut()
3499 .insert(expr.hir_id, fru_field_types);
3502 span_err!(self.tcx.sess, base_expr.span, E0436,
3503 "functional record update syntax requires a struct");
3508 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3514 /// If an expression has any sub-expressions that result in a type error,
3515 /// inspecting that expression's type with `ty.references_error()` will return
3516 /// true. Likewise, if an expression is known to diverge, inspecting its
3517 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3518 /// strict, _|_ can appear in the type of an expression that does not,
3519 /// itself, diverge: for example, fn() -> _|_.)
3520 /// Note that inspecting a type's structure *directly* may expose the fact
3521 /// that there are actually multiple representations for `TyError`, so avoid
3522 /// that when err needs to be handled differently.
3523 fn check_expr_with_expectation_and_needs(&self,
3524 expr: &'gcx hir::Expr,
3525 expected: Expectation<'tcx>,
3526 needs: Needs) -> Ty<'tcx> {
3527 debug!(">> typechecking: expr={:?} expected={:?}",
3530 // Warn for expressions after diverging siblings.
3531 self.warn_if_unreachable(expr.id, expr.span, "expression");
3533 // Hide the outer diverging and has_errors flags.
3534 let old_diverges = self.diverges.get();
3535 let old_has_errors = self.has_errors.get();
3536 self.diverges.set(Diverges::Maybe);
3537 self.has_errors.set(false);
3539 let ty = self.check_expr_kind(expr, expected, needs);
3541 // Warn for non-block expressions with diverging children.
3544 hir::ExprLoop(..) | hir::ExprWhile(..) |
3545 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3547 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3550 // Any expression that produces a value of type `!` must have diverged
3552 self.diverges.set(self.diverges.get() | Diverges::Always);
3555 // Record the type, which applies it effects.
3556 // We need to do this after the warning above, so that
3557 // we don't warn for the diverging expression itself.
3558 self.write_ty(expr.hir_id, ty);
3560 // Combine the diverging and has_error flags.
3561 self.diverges.set(self.diverges.get() | old_diverges);
3562 self.has_errors.set(self.has_errors.get() | old_has_errors);
3564 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3565 debug!("... {:?}, expected is {:?}", ty, expected);
3570 fn check_expr_kind(&self,
3571 expr: &'gcx hir::Expr,
3572 expected: Expectation<'tcx>,
3573 needs: Needs) -> Ty<'tcx> {
3577 hir::ExprBox(ref subexpr) => {
3578 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3580 ty::TyAdt(def, _) if def.is_box()
3581 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3585 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3586 tcx.mk_box(referent_ty)
3589 hir::ExprLit(ref lit) => {
3590 self.check_lit(&lit, expected)
3592 hir::ExprBinary(op, ref lhs, ref rhs) => {
3593 self.check_binop(expr, op, lhs, rhs)
3595 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3596 self.check_binop_assign(expr, op, lhs, rhs)
3598 hir::ExprUnary(unop, ref oprnd) => {
3599 let expected_inner = match unop {
3600 hir::UnNot | hir::UnNeg => {
3607 let needs = match unop {
3608 hir::UnDeref => needs,
3611 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3615 if !oprnd_t.references_error() {
3616 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3619 if let Some(mt) = oprnd_t.builtin_deref(true) {
3621 } else if let Some(ok) = self.try_overloaded_deref(
3622 expr.span, oprnd_t, needs) {
3623 let method = self.register_infer_ok_obligations(ok);
3624 if let ty::TyRef(region, _, mutbl) = method.sig.inputs()[0].sty {
3625 let mutbl = match mutbl {
3626 hir::MutImmutable => AutoBorrowMutability::Immutable,
3627 hir::MutMutable => AutoBorrowMutability::Mutable {
3628 // (It shouldn't actually matter for unary ops whether
3629 // we enable two-phase borrows or not, since a unary
3630 // op has no additional operands.)
3631 allow_two_phase_borrow: AllowTwoPhase::No,
3634 self.apply_adjustments(oprnd, vec![Adjustment {
3635 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3636 target: method.sig.inputs()[0]
3639 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3640 self.write_method_call(expr.hir_id, method);
3642 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3643 "type `{}` cannot be dereferenced",
3645 oprnd_t = tcx.types.err;
3649 let result = self.check_user_unop(expr, oprnd_t, unop);
3650 // If it's builtin, we can reuse the type, this helps inference.
3651 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3656 let result = self.check_user_unop(expr, oprnd_t, unop);
3657 // If it's builtin, we can reuse the type, this helps inference.
3658 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3666 hir::ExprAddrOf(mutbl, ref oprnd) => {
3667 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3669 ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
3670 if self.is_place_expr(&oprnd) {
3671 // Places may legitimately have unsized types.
3672 // For example, dereferences of a fat pointer and
3673 // the last field of a struct can be unsized.
3676 Expectation::rvalue_hint(self, ty)
3682 let needs = Needs::maybe_mut_place(mutbl);
3683 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3685 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3686 if tm.ty.references_error() {
3689 // Note: at this point, we cannot say what the best lifetime
3690 // is to use for resulting pointer. We want to use the
3691 // shortest lifetime possible so as to avoid spurious borrowck
3692 // errors. Moreover, the longest lifetime will depend on the
3693 // precise details of the value whose address is being taken
3694 // (and how long it is valid), which we don't know yet until type
3695 // inference is complete.
3697 // Therefore, here we simply generate a region variable. The
3698 // region inferencer will then select the ultimate value.
3699 // Finally, borrowck is charged with guaranteeing that the
3700 // value whose address was taken can actually be made to live
3701 // as long as it needs to live.
3702 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3703 tcx.mk_ref(region, tm)
3706 hir::ExprPath(ref qpath) => {
3707 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3708 expr.id, expr.span);
3709 let ty = if def != Def::Err {
3710 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3712 self.set_tainted_by_errors();
3716 // We always require that the type provided as the value for
3717 // a type parameter outlives the moment of instantiation.
3718 let substs = self.tables.borrow().node_substs(expr.hir_id);
3719 self.add_wf_bounds(substs, expr);
3723 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3724 for output in outputs {
3725 self.check_expr(output);
3727 for input in inputs {
3728 self.check_expr(input);
3732 hir::ExprBreak(destination, ref expr_opt) => {
3733 if let Some(target_id) = destination.target_id.opt_id() {
3734 let (e_ty, e_diverges, cause);
3735 if let Some(ref e) = *expr_opt {
3736 // If this is a break with a value, we need to type-check
3737 // the expression. Get an expected type from the loop context.
3738 let opt_coerce_to = {
3739 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3740 enclosing_breakables.find_breakable(target_id)
3743 .map(|coerce| coerce.expected_ty())
3746 // If the loop context is not a `loop { }`, then break with
3747 // a value is illegal, and `opt_coerce_to` will be `None`.
3748 // Just set expectation to error in that case.
3749 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3751 // Recurse without `enclosing_breakables` borrowed.
3752 e_ty = self.check_expr_with_hint(e, coerce_to);
3753 e_diverges = self.diverges.get();
3754 cause = self.misc(e.span);
3756 // Otherwise, this is a break *without* a value. That's
3757 // always legal, and is equivalent to `break ()`.
3758 e_ty = tcx.mk_nil();
3759 e_diverges = Diverges::Maybe;
3760 cause = self.misc(expr.span);
3763 // Now that we have type-checked `expr_opt`, borrow
3764 // the `enclosing_loops` field and let's coerce the
3765 // type of `expr_opt` into what is expected.
3766 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3767 let ctxt = enclosing_breakables.find_breakable(target_id);
3768 if let Some(ref mut coerce) = ctxt.coerce {
3769 if let Some(ref e) = *expr_opt {
3770 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3772 assert!(e_ty.is_nil());
3773 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3776 // If `ctxt.coerce` is `None`, we can just ignore
3777 // the type of the expresison. This is because
3778 // either this was a break *without* a value, in
3779 // which case it is always a legal type (`()`), or
3780 // else an error would have been flagged by the
3781 // `loops` pass for using break with an expression
3782 // where you are not supposed to.
3783 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3786 ctxt.may_break = true;
3788 // Otherwise, we failed to find the enclosing loop;
3789 // this can only happen if the `break` was not
3790 // inside a loop at all, which is caught by the
3791 // loop-checking pass.
3792 assert!(self.tcx.sess.err_count() > 0);
3794 // We still need to assign a type to the inner expression to
3795 // prevent the ICE in #43162.
3796 if let Some(ref e) = *expr_opt {
3797 self.check_expr_with_hint(e, tcx.types.err);
3799 // ... except when we try to 'break rust;'.
3800 // ICE this expression in particular (see #43162).
3801 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3802 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3803 fatally_break_rust(self.tcx.sess);
3809 // the type of a `break` is always `!`, since it diverges
3812 hir::ExprAgain(_) => { tcx.types.never }
3813 hir::ExprRet(ref expr_opt) => {
3814 if self.ret_coercion.is_none() {
3815 struct_span_err!(self.tcx.sess, expr.span, E0572,
3816 "return statement outside of function body").emit();
3817 } else if let Some(ref e) = *expr_opt {
3818 self.check_return_expr(e);
3820 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3821 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3822 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3826 hir::ExprAssign(ref lhs, ref rhs) => {
3827 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3829 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3832 ExpectIfCondition => {
3833 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3834 expected error elsehwere");
3837 // Only check this if not in an `if` condition, as the
3838 // mistyped comparison help is more appropriate.
3839 if !self.is_place_expr(&lhs) {
3840 struct_span_err!(self.tcx.sess, expr.span, E0070,
3841 "invalid left-hand side expression")
3842 .span_label(expr.span, "left-hand of expression not valid")
3848 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3850 if lhs_ty.references_error() || rhs_ty.references_error() {
3856 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3857 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3858 expr.span, expected)
3860 hir::ExprWhile(ref cond, ref body, _) => {
3861 let ctxt = BreakableCtxt {
3862 // cannot use break with a value from a while loop
3867 self.with_breakable_ctxt(expr.id, ctxt, || {
3868 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3869 let cond_diverging = self.diverges.get();
3870 self.check_block_no_value(&body);
3872 // We may never reach the body so it diverging means nothing.
3873 self.diverges.set(cond_diverging);
3878 hir::ExprLoop(ref body, _, source) => {
3879 let coerce = match source {
3880 // you can only use break with a value from a normal `loop { }`
3881 hir::LoopSource::Loop => {
3882 let coerce_to = expected.coercion_target_type(self, body.span);
3883 Some(CoerceMany::new(coerce_to))
3886 hir::LoopSource::WhileLet |
3887 hir::LoopSource::ForLoop => {
3892 let ctxt = BreakableCtxt {
3894 may_break: false, // will get updated if/when we find a `break`
3897 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3898 self.check_block_no_value(&body);
3902 // No way to know whether it's diverging because
3903 // of a `break` or an outer `break` or `return.
3904 self.diverges.set(Diverges::Maybe);
3907 // If we permit break with a value, then result type is
3908 // the LUB of the breaks (possibly ! if none); else, it
3909 // is nil. This makes sense because infinite loops
3910 // (which would have type !) are only possible iff we
3911 // permit break with a value [1].
3912 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3913 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3915 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3916 self.check_match(expr, &discrim, arms, expected, match_src)
3918 hir::ExprClosure(capture, ref decl, body_id, _, gen) => {
3919 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
3921 hir::ExprBlock(ref body) => {
3922 self.check_block_with_expected(&body, expected)
3924 hir::ExprCall(ref callee, ref args) => {
3925 self.check_call(expr, &callee, args, expected)
3927 hir::ExprMethodCall(ref segment, span, ref args) => {
3928 self.check_method_call(expr, segment, span, args, expected, needs)
3930 hir::ExprCast(ref e, ref t) => {
3931 // Find the type of `e`. Supply hints based on the type we are casting to,
3933 let t_cast = self.to_ty(t);
3934 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3935 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3936 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3938 // Eagerly check for some obvious errors.
3939 if t_expr.references_error() || t_cast.references_error() {
3942 // Defer other checks until we're done type checking.
3943 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3944 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
3946 deferred_cast_checks.push(cast_check);
3949 Err(ErrorReported) => {
3955 hir::ExprType(ref e, ref t) => {
3956 let typ = self.to_ty(&t);
3957 self.check_expr_eq_type(&e, typ);
3960 hir::ExprArray(ref args) => {
3961 let uty = expected.to_option(self).and_then(|uty| {
3963 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3968 let element_ty = if !args.is_empty() {
3969 let coerce_to = uty.unwrap_or_else(
3970 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3971 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3972 assert_eq!(self.diverges.get(), Diverges::Maybe);
3974 let e_ty = self.check_expr_with_hint(e, coerce_to);
3975 let cause = self.misc(e.span);
3976 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3978 coerce.complete(self)
3980 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3982 tcx.mk_array(element_ty, args.len() as u64)
3984 hir::ExprRepeat(ref element, count) => {
3985 let count_def_id = tcx.hir.body_owner_def_id(count);
3986 let param_env = ty::ParamEnv::empty();
3987 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
3988 let instance = ty::Instance::resolve(
3994 let global_id = GlobalId {
3998 let count = tcx.const_eval(param_env.and(global_id));
4000 if let Err(ref err) = count {
4001 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
4004 let uty = match expected {
4005 ExpectHasType(uty) => {
4007 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4014 let (element_ty, t) = match uty {
4016 self.check_expr_coercable_to_type(&element, uty);
4020 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4021 let element_ty = self.check_expr_has_type_or_error(&element, t);
4026 if let Ok(count) = count {
4027 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4029 // For [foo, ..n] where n > 1, `foo` must have
4031 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4032 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4036 if element_ty.references_error() {
4038 } else if let Ok(count) = count {
4039 tcx.mk_ty(ty::TyArray(t, count))
4044 hir::ExprTup(ref elts) => {
4045 let flds = expected.only_has_type(self).and_then(|ty| {
4046 let ty = self.resolve_type_vars_with_obligations(ty);
4048 ty::TyTuple(ref flds) => Some(&flds[..]),
4053 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4054 let t = match flds {
4055 Some(ref fs) if i < fs.len() => {
4057 self.check_expr_coercable_to_type(&e, ety);
4061 self.check_expr_with_expectation(&e, NoExpectation)
4066 let tuple = tcx.mk_tup(elt_ts_iter);
4067 if tuple.references_error() {
4070 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4074 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4075 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4077 hir::ExprField(ref base, ref field) => {
4078 self.check_field(expr, needs, &base, field)
4080 hir::ExprIndex(ref base, ref idx) => {
4081 let base_t = self.check_expr_with_needs(&base, needs);
4082 let idx_t = self.check_expr(&idx);
4084 if base_t.references_error() {
4086 } else if idx_t.references_error() {
4089 let base_t = self.structurally_resolved_type(expr.span, base_t);
4090 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4091 Some((index_ty, element_ty)) => {
4092 // two-phase not needed because index_ty is never mutable
4093 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4097 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4098 "cannot index into a value of type `{}`",
4100 // Try to give some advice about indexing tuples.
4101 if let ty::TyTuple(..) = base_t.sty {
4102 let mut needs_note = true;
4103 // If the index is an integer, we can show the actual
4104 // fixed expression:
4105 if let hir::ExprLit(ref lit) = idx.node {
4106 if let ast::LitKind::Int(i,
4107 ast::LitIntType::Unsuffixed) = lit.node {
4108 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4109 if let Ok(snip) = snip {
4110 err.span_suggestion(expr.span,
4111 "to access tuple elements, use",
4112 format!("{}.{}", snip, i));
4118 err.help("to access tuple elements, use tuple indexing \
4119 syntax (e.g. `tuple.0`)");
4128 hir::ExprYield(ref value) => {
4129 match self.yield_ty {
4131 self.check_expr_coercable_to_type(&value, ty);
4134 struct_span_err!(self.tcx.sess, expr.span, E0627,
4135 "yield statement outside of generator literal").emit();
4143 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4144 // The newly resolved definition is written into `type_dependent_defs`.
4145 fn finish_resolving_struct_path(&self,
4148 node_id: ast::NodeId)
4152 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4153 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4154 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4157 hir::QPath::TypeRelative(ref qself, ref segment) => {
4158 let ty = self.to_ty(qself);
4160 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4165 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4168 // Write back the new resolution.
4169 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4170 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4177 // Resolve associated value path into a base type and associated constant or method definition.
4178 // The newly resolved definition is written into `type_dependent_defs`.
4179 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4180 qpath: &'b hir::QPath,
4181 node_id: ast::NodeId,
4183 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4185 let (ty, item_segment) = match *qpath {
4186 hir::QPath::Resolved(ref opt_qself, ref path) => {
4188 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4189 &path.segments[..]);
4191 hir::QPath::TypeRelative(ref qself, ref segment) => {
4192 (self.to_ty(qself), segment)
4195 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4196 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4197 // Return directly on cache hit. This is useful to avoid doubly reporting
4198 // errors with default match binding modes. See #44614.
4199 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4201 let item_name = item_segment.name;
4202 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4205 let def = match error {
4206 method::MethodError::PrivateMatch(def, _) => def,
4209 if item_name != keywords::Invalid.name() {
4210 self.report_method_error(span, ty, item_name, None, error, None);
4216 // Write back the new resolution.
4217 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4218 (def, Some(ty), slice::from_ref(&**item_segment))
4221 pub fn check_decl_initializer(&self,
4222 local: &'gcx hir::Local,
4223 init: &'gcx hir::Expr) -> Ty<'tcx>
4225 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4226 // for #42640 (default match binding modes).
4229 let ref_bindings = local.pat.contains_explicit_ref_binding();
4231 let local_ty = self.local_ty(init.span, local.id);
4232 if let Some(m) = ref_bindings {
4233 // Somewhat subtle: if we have a `ref` binding in the pattern,
4234 // we want to avoid introducing coercions for the RHS. This is
4235 // both because it helps preserve sanity and, in the case of
4236 // ref mut, for soundness (issue #23116). In particular, in
4237 // the latter case, we need to be clear that the type of the
4238 // referent for the reference that results is *equal to* the
4239 // type of the place it is referencing, and not some
4240 // supertype thereof.
4241 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4242 self.demand_eqtype(init.span, local_ty, init_ty);
4245 self.check_expr_coercable_to_type(init, local_ty)
4249 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4250 let t = self.local_ty(local.span, local.id);
4251 self.write_ty(local.hir_id, t);
4253 if let Some(ref init) = local.init {
4254 let init_ty = self.check_decl_initializer(local, &init);
4255 if init_ty.references_error() {
4256 self.write_ty(local.hir_id, init_ty);
4260 self.check_pat_walk(&local.pat, t,
4261 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4263 let pat_ty = self.node_ty(local.pat.hir_id);
4264 if pat_ty.references_error() {
4265 self.write_ty(local.hir_id, pat_ty);
4269 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4270 // Don't do all the complex logic below for DeclItem.
4272 hir::StmtDecl(ref decl, _) => {
4274 hir::DeclLocal(_) => {}
4275 hir::DeclItem(_) => {
4280 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4283 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4285 // Hide the outer diverging and has_errors flags.
4286 let old_diverges = self.diverges.get();
4287 let old_has_errors = self.has_errors.get();
4288 self.diverges.set(Diverges::Maybe);
4289 self.has_errors.set(false);
4292 hir::StmtDecl(ref decl, _) => {
4294 hir::DeclLocal(ref l) => {
4295 self.check_decl_local(&l);
4297 hir::DeclItem(_) => {/* ignore for now */}
4300 hir::StmtExpr(ref expr, _) => {
4301 // Check with expected type of ()
4302 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4304 hir::StmtSemi(ref expr, _) => {
4305 self.check_expr(&expr);
4309 // Combine the diverging and has_error flags.
4310 self.diverges.set(self.diverges.get() | old_diverges);
4311 self.has_errors.set(self.has_errors.get() | old_has_errors);
4314 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4315 let unit = self.tcx.mk_nil();
4316 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4318 // if the block produces a `!` value, that can always be
4319 // (effectively) coerced to unit.
4321 self.demand_suptype(blk.span, unit, ty);
4325 fn check_block_with_expected(&self,
4326 blk: &'gcx hir::Block,
4327 expected: Expectation<'tcx>) -> Ty<'tcx> {
4329 let mut fcx_ps = self.ps.borrow_mut();
4330 let unsafety_state = fcx_ps.recurse(blk);
4331 replace(&mut *fcx_ps, unsafety_state)
4334 // In some cases, blocks have just one exit, but other blocks
4335 // can be targeted by multiple breaks. This cannot happen in
4336 // normal Rust syntax today, but it can happen when we desugar
4337 // a `do catch { ... }` expression.
4341 // 'a: { if true { break 'a Err(()); } Ok(()) }
4343 // Here we would wind up with two coercions, one from
4344 // `Err(())` and the other from the tail expression
4345 // `Ok(())`. If the tail expression is omitted, that's a
4346 // "forced unit" -- unless the block diverges, in which
4347 // case we can ignore the tail expression (e.g., `'a: {
4348 // break 'a 22; }` would not force the type of the block
4350 let tail_expr = blk.expr.as_ref();
4351 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4352 let coerce = if blk.targeted_by_break {
4353 CoerceMany::new(coerce_to_ty)
4355 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4356 Some(e) => slice::from_ref(e),
4359 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4362 let prev_diverges = self.diverges.get();
4363 let ctxt = BreakableCtxt {
4364 coerce: Some(coerce),
4368 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4369 for s in &blk.stmts {
4373 // check the tail expression **without** holding the
4374 // `enclosing_breakables` lock below.
4375 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4377 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4378 let ctxt = enclosing_breakables.find_breakable(blk.id);
4379 let coerce = ctxt.coerce.as_mut().unwrap();
4380 if let Some(tail_expr_ty) = tail_expr_ty {
4381 let tail_expr = tail_expr.unwrap();
4382 let cause = self.cause(tail_expr.span,
4383 ObligationCauseCode::BlockTailExpression(blk.id));
4388 self.diverges.get());
4390 // Subtle: if there is no explicit tail expression,
4391 // that is typically equivalent to a tail expression
4392 // of `()` -- except if the block diverges. In that
4393 // case, there is no value supplied from the tail
4394 // expression (assuming there are no other breaks,
4395 // this implies that the type of the block will be
4398 // #41425 -- label the implicit `()` as being the
4399 // "found type" here, rather than the "expected type".
4401 // #44579 -- if the block was recovered during parsing,
4402 // the type would be nonsensical and it is not worth it
4403 // to perform the type check, so we avoid generating the
4404 // diagnostic output.
4405 if !self.diverges.get().always() && !blk.recovered {
4406 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4407 if let Some(expected_ty) = expected.only_has_type(self) {
4408 self.consider_hint_about_removing_semicolon(blk,
4418 // If we can break from the block, then the block's exit is always reachable
4419 // (... as long as the entry is reachable) - regardless of the tail of the block.
4420 self.diverges.set(prev_diverges);
4423 let mut ty = ctxt.coerce.unwrap().complete(self);
4425 if self.has_errors.get() || ty.references_error() {
4426 ty = self.tcx.types.err
4429 self.write_ty(blk.hir_id, ty);
4431 *self.ps.borrow_mut() = prev;
4435 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4436 /// suggestion can be made, `None` otherwise.
4437 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4438 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4439 // `while` before reaching it, as block tail returns are not available in them.
4440 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4441 let parent = self.tcx.hir.get(fn_id);
4443 if let Node::NodeItem(&hir::Item {
4444 name, node: hir::ItemFn(ref decl, ..), ..
4446 decl.clone().and_then(|decl| {
4447 // This is less than ideal, it will not suggest a return type span on any
4448 // method called `main`, regardless of whether it is actually the entry point,
4449 // but it will still present it as the reason for the expected type.
4450 Some((decl, name != Symbol::intern("main")))
4452 } else if let Node::NodeTraitItem(&hir::TraitItem {
4453 node: hir::TraitItemKind::Method(hir::MethodSig {
4457 decl.clone().and_then(|decl| {
4460 } else if let Node::NodeImplItem(&hir::ImplItem {
4461 node: hir::ImplItemKind::Method(hir::MethodSig {
4465 decl.clone().and_then(|decl| {
4476 /// On implicit return expressions with mismatched types, provide the following suggestions:
4478 /// - Point out the method's return type as the reason for the expected type
4479 /// - Possible missing semicolon
4480 /// - Possible missing return type if the return type is the default, and not `fn main()`
4481 pub fn suggest_mismatched_types_on_tail(&self,
4482 err: &mut DiagnosticBuilder<'tcx>,
4483 expression: &'gcx hir::Expr,
4487 blk_id: ast::NodeId) {
4488 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4490 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4491 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4495 /// A common error is to forget to add a semicolon at the end of a block:
4499 /// bar_that_returns_u32()
4503 /// This routine checks if the return expression in a block would make sense on its own as a
4504 /// statement and the return type has been left as default or has been specified as `()`. If so,
4505 /// it suggests adding a semicolon.
4506 fn suggest_missing_semicolon(&self,
4507 err: &mut DiagnosticBuilder<'tcx>,
4508 expression: &'gcx hir::Expr,
4511 if expected.is_nil() {
4512 // `BlockTailExpression` only relevant if the tail expr would be
4513 // useful on its own.
4514 match expression.node {
4516 hir::ExprMethodCall(..) |
4518 hir::ExprWhile(..) |
4520 hir::ExprMatch(..) |
4521 hir::ExprBlock(..) => {
4522 let sp = self.tcx.sess.codemap().next_point(cause_span);
4523 err.span_suggestion(sp,
4524 "try adding a semicolon",
4533 /// A possible error is to forget to add a return type that is needed:
4537 /// bar_that_returns_u32()
4541 /// This routine checks if the return type is left as default, the method is not part of an
4542 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4544 fn suggest_missing_return_type(&self,
4545 err: &mut DiagnosticBuilder<'tcx>,
4546 fn_decl: &hir::FnDecl,
4549 can_suggest: bool) {
4550 // Only suggest changing the return type for methods that
4551 // haven't set a return type at all (and aren't `fn main()` or an impl).
4552 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4553 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4554 err.span_suggestion(span,
4555 "try adding a return type",
4557 self.resolve_type_vars_with_obligations(found)));
4559 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4560 err.span_label(span, "possibly return type missing here?");
4562 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4563 // `fn main()` must return `()`, do not suggest changing return type
4564 err.span_label(span, "expected `()` because of default return type");
4566 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4567 // Only point to return type if the expected type is the return type, as if they
4568 // are not, the expectation must have been caused by something else.
4569 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4571 let ty = AstConv::ast_ty_to_ty(self, ty);
4572 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4573 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4574 if ty.sty == expected.sty {
4575 err.span_label(sp, format!("expected `{}` because of return type",
4583 /// A common error is to add an extra semicolon:
4586 /// fn foo() -> usize {
4591 /// This routine checks if the final statement in a block is an
4592 /// expression with an explicit semicolon whose type is compatible
4593 /// with `expected_ty`. If so, it suggests removing the semicolon.
4594 fn consider_hint_about_removing_semicolon(&self,
4595 blk: &'gcx hir::Block,
4596 expected_ty: Ty<'tcx>,
4597 err: &mut DiagnosticBuilder) {
4598 // Be helpful when the user wrote `{... expr;}` and
4599 // taking the `;` off is enough to fix the error.
4600 let last_stmt = match blk.stmts.last() {
4604 let last_expr = match last_stmt.node {
4605 hir::StmtSemi(ref e, _) => e,
4608 let last_expr_ty = self.node_ty(last_expr.hir_id);
4609 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4612 let original_span = original_sp(last_stmt.span, blk.span);
4613 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4614 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4617 // Instantiates the given path, which must refer to an item with the given
4618 // number of type parameters and type.
4619 pub fn instantiate_value_path(&self,
4620 segments: &[hir::PathSegment],
4621 opt_self_ty: Option<Ty<'tcx>>,
4624 node_id: ast::NodeId)
4626 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4631 // We need to extract the type parameters supplied by the user in
4632 // the path `path`. Due to the current setup, this is a bit of a
4633 // tricky-process; the problem is that resolve only tells us the
4634 // end-point of the path resolution, and not the intermediate steps.
4635 // Luckily, we can (at least for now) deduce the intermediate steps
4636 // just from the end-point.
4638 // There are basically four cases to consider:
4640 // 1. Reference to a constructor of enum variant or struct:
4642 // struct Foo<T>(...)
4643 // enum E<T> { Foo(...) }
4645 // In these cases, the parameters are declared in the type
4648 // 2. Reference to a fn item or a free constant:
4652 // In this case, the path will again always have the form
4653 // `a::b::foo::<T>` where only the final segment should have
4654 // type parameters. However, in this case, those parameters are
4655 // declared on a value, and hence are in the `FnSpace`.
4657 // 3. Reference to a method or an associated constant:
4659 // impl<A> SomeStruct<A> {
4663 // Here we can have a path like
4664 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4665 // may appear in two places. The penultimate segment,
4666 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4667 // final segment, `foo::<B>` contains parameters in fn space.
4669 // 4. Reference to a local variable
4671 // Local variables can't have any type parameters.
4673 // The first step then is to categorize the segments appropriately.
4675 assert!(!segments.is_empty());
4677 let mut ufcs_associated = None;
4678 let mut type_segment = None;
4679 let mut fn_segment = None;
4681 // Case 1. Reference to a struct/variant constructor.
4682 Def::StructCtor(def_id, ..) |
4683 Def::VariantCtor(def_id, ..) => {
4684 // Everything but the final segment should have no
4685 // parameters at all.
4686 let mut generics = self.tcx.generics_of(def_id);
4687 if let Some(def_id) = generics.parent {
4688 // Variant and struct constructors use the
4689 // generics of their parent type definition.
4690 generics = self.tcx.generics_of(def_id);
4692 type_segment = Some((segments.last().unwrap(), generics));
4695 // Case 2. Reference to a top-level value.
4697 Def::Const(def_id) |
4698 Def::Static(def_id, _) => {
4699 fn_segment = Some((segments.last().unwrap(),
4700 self.tcx.generics_of(def_id)));
4703 // Case 3. Reference to a method or associated const.
4704 Def::Method(def_id) |
4705 Def::AssociatedConst(def_id) => {
4706 let container = self.tcx.associated_item(def_id).container;
4708 ty::TraitContainer(trait_did) => {
4709 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4711 ty::ImplContainer(_) => {}
4714 let generics = self.tcx.generics_of(def_id);
4715 if segments.len() >= 2 {
4716 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4717 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4719 // `<T>::assoc` will end up here, and so can `T::assoc`.
4720 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4721 ufcs_associated = Some((container, self_ty));
4723 fn_segment = Some((segments.last().unwrap(), generics));
4726 // Case 4. Local variable, no generics.
4727 Def::Local(..) | Def::Upvar(..) => {}
4729 _ => bug!("unexpected definition: {:?}", def),
4732 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4734 // Now that we have categorized what space the parameters for each
4735 // segment belong to, let's sort out the parameters that the user
4736 // provided (if any) into their appropriate spaces. We'll also report
4737 // errors if type parameters are provided in an inappropriate place.
4738 let poly_segments = type_segment.is_some() as usize +
4739 fn_segment.is_some() as usize;
4740 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4743 Def::Local(nid) | Def::Upvar(nid, ..) => {
4744 let ty = self.local_ty(span, nid);
4745 let ty = self.normalize_associated_types_in(span, &ty);
4746 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4752 // Now we have to compare the types that the user *actually*
4753 // provided against the types that were *expected*. If the user
4754 // did not provide any types, then we want to substitute inference
4755 // variables. If the user provided some types, we may still need
4756 // to add defaults. If the user provided *too many* types, that's
4758 let supress_mismatch = self.check_impl_trait(span, &mut fn_segment);
4759 self.check_path_parameter_count(span, &mut type_segment, false, supress_mismatch);
4760 self.check_path_parameter_count(span, &mut fn_segment, false, supress_mismatch);
4762 let (fn_start, has_self) = match (type_segment, fn_segment) {
4763 (_, Some((_, generics))) => {
4764 (generics.parent_count(), generics.has_self)
4766 (Some((_, generics)), None) => {
4767 (generics.own_count(), generics.has_self)
4769 (None, None) => (0, false)
4771 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4772 let mut i = def.index as usize;
4774 let segment = if i < fn_start {
4775 i -= has_self as usize;
4781 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4782 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4785 if let Some(lifetime) = lifetimes.get(i) {
4786 AstConv::ast_region_to_region(self, lifetime, Some(def))
4788 self.re_infer(span, Some(def)).unwrap()
4791 let mut i = def.index as usize;
4793 let segment = if i < fn_start {
4794 // Handle Self first, so we can adjust the index to match the AST.
4795 if has_self && i == 0 {
4796 return opt_self_ty.unwrap_or_else(|| {
4797 self.type_var_for_def(span, def)
4800 i -= has_self as usize;
4806 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4807 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4810 // Skip over the lifetimes in the same segment.
4811 if let Some((_, generics)) = segment {
4812 i -= generics.regions.len();
4815 if let Some(ast_ty) = types.get(i) {
4816 // A provided type parameter.
4818 } else if !infer_types && def.has_default {
4819 // No type parameter provided, but a default exists.
4820 let default = self.tcx.type_of(def.def_id);
4823 default.subst_spanned(self.tcx, substs, Some(span))
4826 // No type parameters were provided, we can infer all.
4827 // This can also be reached in some error cases:
4828 // We prefer to use inference variables instead of
4829 // TyError to let type inference recover somewhat.
4830 self.type_var_for_def(span, def)
4834 // The things we are substituting into the type should not contain
4835 // escaping late-bound regions, and nor should the base type scheme.
4836 let ty = self.tcx.type_of(def.def_id());
4837 assert!(!substs.has_escaping_regions());
4838 assert!(!ty.has_escaping_regions());
4840 // Add all the obligations that are required, substituting and
4841 // normalized appropriately.
4842 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4843 self.add_obligations_for_parameters(
4844 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4847 // Substitute the values for the type parameters into the type of
4848 // the referenced item.
4849 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4851 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4852 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4853 // is inherent, there is no `Self` parameter, instead, the impl needs
4854 // type parameters, which we can infer by unifying the provided `Self`
4855 // with the substituted impl type.
4856 let ty = self.tcx.type_of(impl_def_id);
4858 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4859 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4860 Ok(ok) => self.register_infer_ok_obligations(ok),
4863 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4870 self.check_rustc_args_require_const(def.def_id(), node_id, span);
4872 debug!("instantiate_value_path: type of {:?} is {:?}",
4875 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4879 fn check_rustc_args_require_const(&self,
4881 node_id: ast::NodeId,
4883 // We're only interested in functions tagged with
4884 // #[rustc_args_required_const], so ignore anything that's not.
4885 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
4889 // If our calling expression is indeed the function itself, we're good!
4890 // If not, generate an error that this can only be called directly.
4891 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
4892 Node::NodeExpr(expr) => {
4894 hir::ExprCall(ref callee, ..) => {
4895 if callee.id == node_id {
4905 self.tcx.sess.span_err(span, "this function can only be invoked \
4906 directly, not through a function pointer");
4909 /// Report errors if the provided parameters are too few or too many.
4910 fn check_path_parameter_count(&self,
4912 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4913 is_method_call: bool,
4914 supress_mismatch_error: bool) {
4915 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4916 (&[][..], &[][..], true, &[][..]),
4917 |(s, _)| s.parameters.as_ref().map_or(
4918 (&[][..], &[][..], s.infer_types, &[][..]),
4919 |p| (&p.lifetimes[..], &p.types[..],
4920 s.infer_types, &p.bindings[..])));
4921 let infer_lifetimes = lifetimes.len() == 0;
4923 let count_lifetime_params = |n| {
4924 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4926 let count_type_params = |n| {
4927 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4930 // Check provided type parameters.
4931 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4932 if generics.parent.is_none() {
4933 &generics.types[generics.has_self as usize..]
4938 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4939 if types.len() > type_defs.len() {
4940 let span = types[type_defs.len()].span;
4941 let expected_text = count_type_params(type_defs.len());
4942 let actual_text = count_type_params(types.len());
4943 struct_span_err!(self.tcx.sess, span, E0087,
4944 "too many type parameters provided: \
4945 expected at most {}, found {}",
4946 expected_text, actual_text)
4947 .span_label(span, format!("expected {}", expected_text))
4950 // To prevent derived errors to accumulate due to extra
4951 // type parameters, we force instantiate_value_path to
4952 // use inference variables instead of the provided types.
4954 } else if types.len() < required_len && !infer_types && !supress_mismatch_error {
4955 let expected_text = count_type_params(required_len);
4956 let actual_text = count_type_params(types.len());
4957 struct_span_err!(self.tcx.sess, span, E0089,
4958 "too few type parameters provided: \
4959 expected {}, found {}",
4960 expected_text, actual_text)
4961 .span_label(span, format!("expected {}", expected_text))
4965 if !bindings.is_empty() {
4966 AstConv::prohibit_projection(self, bindings[0].span);
4969 // Check provided lifetime parameters.
4970 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4971 let required_len = lifetime_defs.len();
4973 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4974 let has_late_bound_lifetime_defs =
4975 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4976 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4977 // Report this as a lint only if no error was reported previously.
4978 let primary_msg = "cannot specify lifetime arguments explicitly \
4979 if late bound lifetime parameters are present";
4980 let note_msg = "the late bound lifetime parameter is introduced here";
4981 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4982 lifetimes.len() < required_len && !infer_lifetimes) {
4983 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4984 err.span_note(span_late, note_msg);
4988 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4989 multispan.push_span_label(span_late, note_msg.to_string());
4990 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4991 lifetimes[0].id, multispan, primary_msg);
4996 if lifetimes.len() > lifetime_defs.len() {
4997 let span = lifetimes[lifetime_defs.len()].span;
4998 let expected_text = count_lifetime_params(lifetime_defs.len());
4999 let actual_text = count_lifetime_params(lifetimes.len());
5000 struct_span_err!(self.tcx.sess, span, E0088,
5001 "too many lifetime parameters provided: \
5002 expected at most {}, found {}",
5003 expected_text, actual_text)
5004 .span_label(span, format!("expected {}", expected_text))
5006 } else if lifetimes.len() < required_len && !infer_lifetimes {
5007 let expected_text = count_lifetime_params(lifetime_defs.len());
5008 let actual_text = count_lifetime_params(lifetimes.len());
5009 struct_span_err!(self.tcx.sess, span, E0090,
5010 "too few lifetime parameters provided: \
5011 expected {}, found {}",
5012 expected_text, actual_text)
5013 .span_label(span, format!("expected {}", expected_text))
5018 /// Report error if there is an explicit type parameter when using `impl Trait`.
5019 fn check_impl_trait(&self,
5021 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>)
5023 use hir::SyntheticTyParamKind::*;
5025 let segment = segment.map(|(path_segment, generics)| {
5026 let explicit = !path_segment.infer_types;
5027 let impl_trait = generics.types.iter()
5029 match ty_param.synthetic {
5030 Some(ImplTrait) => true,
5035 if explicit && impl_trait {
5036 let mut err = struct_span_err! {
5040 "cannot provide explicit type parameters when `impl Trait` is \
5041 used in argument position."
5050 segment.unwrap_or(false)
5053 // Resolves `typ` by a single level if `typ` is a type variable.
5054 // If no resolution is possible, then an error is reported.
5055 // Numeric inference variables may be left unresolved.
5056 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5057 let ty = self.resolve_type_vars_with_obligations(ty);
5058 if !ty.is_ty_var() {
5061 if !self.is_tainted_by_errors() {
5062 self.need_type_info((**self).body_id, sp, ty);
5064 self.demand_suptype(sp, self.tcx.types.err, ty);
5069 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5070 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5071 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5074 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5075 index = enclosing_breakables.stack.len();
5076 enclosing_breakables.by_id.insert(id, index);
5077 enclosing_breakables.stack.push(ctxt);
5081 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5082 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5083 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5084 enclosing_breakables.stack.pop().expect("missing breakable context")
5090 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5091 generics: &hir::Generics,
5093 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5094 generics.ty_params().count(), ty);
5096 // make a vector of booleans initially false, set to true when used
5097 if generics.ty_params().next().is_none() { return; }
5098 let mut tps_used = vec![false; generics.ty_params().count()];
5100 let lifetime_count = generics.lifetimes().count();
5102 for leaf_ty in ty.walk() {
5103 if let ty::TyParam(ty::ParamTy {idx, ..}) = leaf_ty.sty {
5104 debug!("Found use of ty param num {}", idx);
5105 tps_used[idx as usize - lifetime_count] = true;
5106 } else if let ty::TyError = leaf_ty.sty {
5107 // If there already another error, do not emit an error for not using a type Parameter
5108 assert!(tcx.sess.err_count() > 0);
5113 for (&used, param) in tps_used.iter().zip(generics.ty_params()) {
5115 struct_span_err!(tcx.sess, param.span, E0091,
5116 "type parameter `{}` is unused",
5118 .span_label(param.span, "unused type parameter")
5124 fn fatally_break_rust(sess: &Session) {
5125 let handler = sess.diagnostic();
5126 handler.span_bug_no_panic(
5128 "It looks like you're trying to break rust; would you like some ICE?",
5130 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5131 handler.note_without_error(
5132 "we would appreciate a joke overview: \
5133 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5135 handler.note_without_error(&format!("rustc {} running on {}",
5136 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5137 ::session::config::host_triple(),