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::*;
88 use hir::def::{Def, CtorKind};
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::ty::subst::{Kind, Subst, Substs};
97 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
98 use rustc::ty::{self, Ty, TyCtxt, Visibility, ToPredicate};
99 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
100 use rustc::ty::fold::TypeFoldable;
101 use rustc::ty::maps::Providers;
102 use rustc::ty::util::{Representability, IntTypeExt};
103 use errors::{DiagnosticBuilder, DiagnosticId};
105 use require_c_abi_if_variadic;
106 use session::{CompileIncomplete, config, Session};
109 use util::common::{ErrorReported, indenter};
110 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
112 use std::cell::{Cell, RefCell, Ref, RefMut};
113 use rustc_data_structures::sync::Lrc;
114 use std::collections::hash_map::Entry;
116 use std::fmt::Display;
117 use std::mem::replace;
119 use std::ops::{self, Deref};
120 use syntax::abi::Abi;
123 use syntax::codemap::{self, original_sp, Spanned};
124 use syntax::feature_gate::{GateIssue, emit_feature_err};
126 use syntax::symbol::{Symbol, InternedString, keywords};
127 use syntax::util::lev_distance::find_best_match_for_name;
128 use syntax_pos::{self, BytePos, Span, MultiSpan};
130 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
131 use rustc::hir::itemlikevisit::ItemLikeVisitor;
132 use rustc::hir::map::Node;
133 use rustc::hir::{self, PatKind};
134 use rustc::middle::lang_items;
135 use rustc_const_math::ConstInt;
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<traits::FulfillmentContext<'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::GeneratorInterior<'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(ty::UniverseIndex::ROOT,
366 TypeVariableOrigin::MiscVariable(span)))
370 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
377 fn maybe_mut_place(m: hir::Mutability) -> Self {
379 hir::MutMutable => Needs::MutPlace,
380 hir::MutImmutable => Needs::None,
385 #[derive(Copy, Clone)]
386 pub struct UnsafetyState {
387 pub def: ast::NodeId,
388 pub unsafety: hir::Unsafety,
389 pub unsafe_push_count: u32,
394 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
395 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
398 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
399 match self.unsafety {
400 // If this unsafe, then if the outer function was already marked as
401 // unsafe we shouldn't attribute the unsafe'ness to the block. This
402 // way the block can be warned about instead of ignoring this
403 // extraneous block (functions are never warned about).
404 hir::Unsafety::Unsafe if self.from_fn => *self,
407 let (unsafety, def, count) = match blk.rules {
408 hir::PushUnsafeBlock(..) =>
409 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
410 hir::PopUnsafeBlock(..) =>
411 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
412 hir::UnsafeBlock(..) =>
413 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
415 (unsafety, self.def, self.unsafe_push_count),
419 unsafe_push_count: count,
426 #[derive(Debug, Copy, Clone)]
432 /// Tracks whether executing a node may exit normally (versus
433 /// return/break/panic, which "diverge", leaving dead code in their
434 /// wake). Tracked semi-automatically (through type variables marked
435 /// as diverging), with some manual adjustments for control-flow
436 /// primitives (approximating a CFG).
437 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
439 /// Potentially unknown, some cases converge,
440 /// others require a CFG to determine them.
443 /// Definitely known to diverge and therefore
444 /// not reach the next sibling or its parent.
447 /// Same as `Always` but with a reachability
448 /// warning already emitted
452 // Convenience impls for combinig `Diverges`.
454 impl ops::BitAnd for Diverges {
456 fn bitand(self, other: Self) -> Self {
457 cmp::min(self, other)
461 impl ops::BitOr for Diverges {
463 fn bitor(self, other: Self) -> Self {
464 cmp::max(self, other)
468 impl ops::BitAndAssign for Diverges {
469 fn bitand_assign(&mut self, other: Self) {
470 *self = *self & other;
474 impl ops::BitOrAssign for Diverges {
475 fn bitor_assign(&mut self, other: Self) {
476 *self = *self | other;
481 fn always(self) -> bool {
482 self >= Diverges::Always
486 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
489 // this is `null` for loops where break with a value is illegal,
490 // such as `while`, `for`, and `while let`
491 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
494 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
495 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
496 by_id: NodeMap<usize>,
499 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
500 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
501 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
502 bug!("could not find enclosing breakable with id {}", target_id);
508 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
509 body_id: ast::NodeId,
511 /// The parameter environment used for proving trait obligations
512 /// in this function. This can change when we descend into
513 /// closures (as they bring new things into scope), hence it is
514 /// not part of `Inherited` (as of the time of this writing,
515 /// closures do not yet change the environment, but they will
517 param_env: ty::ParamEnv<'tcx>,
519 // Number of errors that had been reported when we started
520 // checking this function. On exit, if we find that *more* errors
521 // have been reported, we will skip regionck and other work that
522 // expects the types within the function to be consistent.
523 err_count_on_creation: usize,
525 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
527 yield_ty: Option<Ty<'tcx>>,
529 ps: RefCell<UnsafetyState>,
531 /// Whether the last checked node generates a divergence (e.g.,
532 /// `return` will set this to Always). In general, when entering
533 /// an expression or other node in the tree, the initial value
534 /// indicates whether prior parts of the containing expression may
535 /// have diverged. It is then typically set to `Maybe` (and the
536 /// old value remembered) for processing the subparts of the
537 /// current expression. As each subpart is processed, they may set
538 /// the flag to `Always` etc. Finally, at the end, we take the
539 /// result and "union" it with the original value, so that when we
540 /// return the flag indicates if any subpart of the the parent
541 /// expression (up to and including this part) has diverged. So,
542 /// if you read it after evaluating a subexpression `X`, the value
543 /// you get indicates whether any subexpression that was
544 /// evaluating up to and including `X` diverged.
546 /// We use this flag for two purposes:
548 /// - To warn about unreachable code: if, after processing a
549 /// sub-expression but before we have applied the effects of the
550 /// current node, we see that the flag is set to `Always`, we
551 /// can issue a warning. This corresponds to something like
552 /// `foo(return)`; we warn on the `foo()` expression. (We then
553 /// update the flag to `WarnedAlways` to suppress duplicate
554 /// reports.) Similarly, if we traverse to a fresh statement (or
555 /// tail expression) from a `Always` setting, we will issue a
556 /// warning. This corresponds to something like `{return;
557 /// foo();}` or `{return; 22}`, where we would warn on the
560 /// - To permit assignment into a local variable or other place
561 /// (including the "return slot") of type `!`. This is allowed
562 /// if **either** the type of value being assigned is `!`, which
563 /// means the current code is dead, **or** the expression's
564 /// diverging flag is true, which means that a diverging value was
565 /// wrapped (e.g., `let x: ! = foo(return)`).
567 /// To repeat the last point: an expression represents dead-code
568 /// if, after checking it, **either** its type is `!` OR the
569 /// diverges flag is set to something other than `Maybe`.
570 diverges: Cell<Diverges>,
572 /// Whether any child nodes have any type errors.
573 has_errors: Cell<bool>,
575 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
577 inh: &'a Inherited<'a, 'gcx, 'tcx>,
580 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
581 type Target = Inherited<'a, 'gcx, 'tcx>;
582 fn deref(&self) -> &Self::Target {
587 /// Helper type of a temporary returned by Inherited::build(...).
588 /// Necessary because we can't write the following bound:
589 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
590 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
591 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
595 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
596 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
597 -> InheritedBuilder<'a, 'gcx, 'tcx> {
598 let hir_id_root = if def_id.is_local() {
599 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
600 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
601 DefId::local(hir_id.owner)
607 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
613 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
614 fn enter<F, R>(&'tcx mut self, f: F) -> R
615 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
617 let def_id = self.def_id;
618 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
622 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
623 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
625 let item_id = tcx.hir.as_local_node_id(def_id);
626 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
627 let implicit_region_bound = body_id.map(|body_id| {
628 let body = tcx.hir.body(body_id);
629 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
633 tables: MaybeInProgressTables {
634 maybe_tables: infcx.in_progress_tables,
637 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
638 locals: RefCell::new(NodeMap()),
639 deferred_call_resolutions: RefCell::new(DefIdMap()),
640 deferred_cast_checks: RefCell::new(Vec::new()),
641 deferred_generator_interiors: RefCell::new(Vec::new()),
642 anon_types: RefCell::new(DefIdMap()),
643 implicit_region_bound,
648 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
649 debug!("register_predicate({:?})", obligation);
650 if obligation.has_escaping_regions() {
651 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
656 .register_predicate_obligation(self, obligation);
659 fn register_predicates<I>(&self, obligations: I)
660 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
661 for obligation in obligations {
662 self.register_predicate(obligation);
666 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
667 self.register_predicates(infer_ok.obligations);
671 fn normalize_associated_types_in<T>(&self,
673 body_id: ast::NodeId,
674 param_env: ty::ParamEnv<'tcx>,
676 where T : TypeFoldable<'tcx>
678 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
679 self.register_infer_ok_obligations(ok)
683 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
685 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
686 fn visit_item(&mut self, i: &'tcx hir::Item) {
687 check_item_type(self.tcx, i);
689 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
690 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
693 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
694 tcx.sess.track_errors(|| {
695 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
696 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
700 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
701 tcx.sess.track_errors(|| {
702 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
706 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
707 tcx.typeck_item_bodies(LOCAL_CRATE)
710 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
711 -> Result<(), CompileIncomplete>
713 debug_assert!(crate_num == LOCAL_CRATE);
714 Ok(tcx.sess.track_errors(|| {
715 for body_owner_def_id in tcx.body_owners() {
716 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
721 pub fn provide(providers: &mut Providers) {
722 *providers = Providers {
732 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
734 -> Option<ty::Destructor> {
735 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
738 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
739 /// with information about it's body-id and fn-decl (if any). Otherwise,
742 /// If this function returns "some", then `typeck_tables(def_id)` will
743 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
744 /// may not succeed. In some cases where this function returns `None`
745 /// (notably closures), `typeck_tables(def_id)` would wind up
746 /// redirecting to the owning function.
747 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
749 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
751 match tcx.hir.get(id) {
752 hir::map::NodeItem(item) => {
754 hir::ItemConst(_, body) |
755 hir::ItemStatic(_, _, body) =>
757 hir::ItemFn(ref decl, .., body) =>
758 Some((body, Some(decl))),
763 hir::map::NodeTraitItem(item) => {
765 hir::TraitItemKind::Const(_, Some(body)) =>
767 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
768 Some((body, Some(&sig.decl))),
773 hir::map::NodeImplItem(item) => {
775 hir::ImplItemKind::Const(_, body) =>
777 hir::ImplItemKind::Method(ref sig, body) =>
778 Some((body, Some(&sig.decl))),
783 hir::map::NodeExpr(expr) => {
784 // FIXME(eddyb) Closures should have separate
785 // function definition IDs and expression IDs.
786 // Type-checking should not let closures get
787 // this far in a constant position.
788 // Assume that everything other than closures
789 // is a constant "initializer" expression.
791 hir::ExprClosure(..) =>
794 Some((hir::BodyId { node_id: expr.id }, None)),
801 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
804 // Closures' tables come from their outermost function,
805 // as they are part of the same "inference environment".
806 let outer_def_id = tcx.closure_base_def_id(def_id);
807 if outer_def_id != def_id {
808 return tcx.has_typeck_tables(outer_def_id);
811 let id = tcx.hir.as_local_node_id(def_id).unwrap();
812 primary_body_of(tcx, id).is_some()
815 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
818 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
821 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
823 -> &'tcx ty::TypeckTables<'tcx> {
824 // Closures' tables come from their outermost function,
825 // as they are part of the same "inference environment".
826 let outer_def_id = tcx.closure_base_def_id(def_id);
827 if outer_def_id != def_id {
828 return tcx.typeck_tables_of(outer_def_id);
831 let id = tcx.hir.as_local_node_id(def_id).unwrap();
832 let span = tcx.hir.span(id);
834 // Figure out what primary body this item has.
835 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
836 span_bug!(span, "can't type-check body of {:?}", def_id);
838 let body = tcx.hir.body(body_id);
840 let tables = Inherited::build(tcx, def_id).enter(|inh| {
841 let param_env = tcx.param_env(def_id);
842 let fcx = if let Some(decl) = fn_decl {
843 let fn_sig = tcx.fn_sig(def_id);
845 check_abi(tcx, span, fn_sig.abi());
847 // Compute the fty from point of view of inside fn.
849 tcx.liberate_late_bound_regions(def_id, &fn_sig);
851 inh.normalize_associated_types_in(body.value.span,
856 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
859 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
860 let expected_type = tcx.type_of(def_id);
861 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
862 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
864 // Gather locals in statics (because of block expressions).
865 // This is technically unnecessary because locals in static items are forbidden,
866 // but prevents type checking from blowing up before const checking can properly
868 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
870 fcx.check_expr_coercable_to_type(&body.value, expected_type);
875 // All type checking constraints were added, try to fallback unsolved variables.
876 fcx.select_obligations_where_possible();
877 for ty in &fcx.unsolved_variables() {
878 fcx.fallback_if_possible(ty);
880 fcx.select_obligations_where_possible();
882 // Even though coercion casts provide type hints, we check casts after fallback for
883 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
886 // Closure and generater analysis may run after fallback
887 // because they don't constrain other type variables.
888 fcx.closure_analyze(body);
889 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
890 fcx.resolve_generator_interiors(def_id);
891 fcx.select_all_obligations_or_error();
893 if fn_decl.is_some() {
894 fcx.regionck_fn(id, body);
896 fcx.regionck_expr(body);
899 fcx.resolve_type_vars_in_body(body)
902 // Consistency check our TypeckTables instance can hold all ItemLocalIds
903 // it will need to hold.
904 assert_eq!(tables.local_id_root,
905 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
909 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
910 if !tcx.sess.target.target.is_abi_supported(abi) {
911 struct_span_err!(tcx.sess, span, E0570,
912 "The ABI `{}` is not supported for the current target", abi).emit()
916 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
917 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
920 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
921 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
924 // infer the variable's type
925 let var_ty = self.fcx.next_ty_var(ty::UniverseIndex::ROOT,
926 TypeVariableOrigin::TypeInference(span));
927 self.fcx.locals.borrow_mut().insert(nid, var_ty);
931 // take type that the user specified
932 self.fcx.locals.borrow_mut().insert(nid, typ);
939 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
940 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
941 NestedVisitorMap::None
944 // Add explicitly-declared locals.
945 fn visit_local(&mut self, local: &'gcx hir::Local) {
946 let o_ty = match local.ty {
947 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
950 self.assign(local.span, local.id, o_ty);
951 debug!("Local variable {:?} is assigned type {}",
953 self.fcx.ty_to_string(
954 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
955 intravisit::walk_local(self, local);
958 // Add pattern bindings.
959 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
960 if let PatKind::Binding(_, _, ref path1, _) = p.node {
961 let var_ty = self.assign(p.span, p.id, None);
963 self.fcx.require_type_is_sized(var_ty, p.span,
964 traits::VariableType(p.id));
966 debug!("Pattern binding {} is assigned to {} with type {:?}",
968 self.fcx.ty_to_string(
969 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
972 intravisit::walk_pat(self, p);
975 // Don't descend into the bodies of nested closures
976 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
977 _: hir::BodyId, _: Span, _: ast::NodeId) { }
980 /// When `check_fn` is invoked on a generator (i.e., a body that
981 /// includes yield), it returns back some information about the yield
983 struct GeneratorTypes<'tcx> {
984 /// Type of value that is yielded.
985 yield_ty: ty::Ty<'tcx>,
987 /// Types that are captured (see `GeneratorInterior` for more).
988 interior: ty::GeneratorInterior<'tcx>
991 /// Helper used for fns and closures. Does the grungy work of checking a function
992 /// body and returns the function context used for that purpose, since in the case of a fn item
993 /// there is still a bit more to do.
996 /// * inherited: other fields inherited from the enclosing fn (if any)
997 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
998 param_env: ty::ParamEnv<'tcx>,
999 fn_sig: ty::FnSig<'tcx>,
1000 decl: &'gcx hir::FnDecl,
1002 body: &'gcx hir::Body,
1003 can_be_generator: Option<hir::GeneratorMovability>)
1004 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1006 let mut fn_sig = fn_sig.clone();
1008 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1010 // Create the function context. This is either derived from scratch or,
1011 // in the case of function expressions, based on the outer context.
1012 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1013 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1015 let ret_ty = fn_sig.output();
1016 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1017 let ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &ret_ty);
1018 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1019 fn_sig = fcx.tcx.mk_fn_sig(
1020 fn_sig.inputs().iter().cloned(),
1027 let span = body.value.span;
1029 if body.is_generator && can_be_generator.is_some() {
1030 let yield_ty = fcx.next_ty_var(ty::UniverseIndex::ROOT,
1031 TypeVariableOrigin::TypeInference(span));
1032 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1033 fcx.yield_ty = Some(yield_ty);
1036 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1038 // Add formal parameters.
1039 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1040 // Check the pattern.
1041 fcx.check_pat_walk(&arg.pat, arg_ty,
1042 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1044 // Check that argument is Sized.
1045 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1046 // for simple cases like `fn foo(x: Trait)`,
1047 // where we would error once on the parameter as a whole, and once on the binding `x`.
1048 if arg.pat.simple_name().is_none() {
1049 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1052 fcx.write_ty(arg.hir_id, arg_ty);
1055 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1056 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1058 fcx.check_return_expr(&body.value);
1060 // We insert the deferred_generator_interiors entry after visiting the body.
1061 // This ensures that all nested generators appear before the entry of this generator.
1062 // resolve_generator_interiors relies on this property.
1063 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1064 let witness = fcx.next_ty_var(ty::UniverseIndex::ROOT,
1065 TypeVariableOrigin::MiscVariable(span));
1066 let interior = ty::GeneratorInterior {
1068 movable: can_be_generator.unwrap() == hir::GeneratorMovability::Movable,
1070 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1071 Some(GeneratorTypes { yield_ty: fcx.yield_ty.unwrap(), interior: interior })
1076 // Finalize the return check by taking the LUB of the return types
1077 // we saw and assigning it to the expected return type. This isn't
1078 // really expected to fail, since the coercions would have failed
1079 // earlier when trying to find a LUB.
1081 // However, the behavior around `!` is sort of complex. In the
1082 // event that the `actual_return_ty` comes back as `!`, that
1083 // indicates that the fn either does not return or "returns" only
1084 // values of type `!`. In this case, if there is an expected
1085 // return type that is *not* `!`, that should be ok. But if the
1086 // return type is being inferred, we want to "fallback" to `!`:
1088 // let x = move || panic!();
1090 // To allow for that, I am creating a type variable with diverging
1091 // fallback. This was deemed ever so slightly better than unifying
1092 // the return value with `!` because it allows for the caller to
1093 // make more assumptions about the return type (e.g., they could do
1095 // let y: Option<u32> = Some(x());
1097 // which would then cause this return type to become `u32`, not
1099 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1100 let mut actual_return_ty = coercion.complete(&fcx);
1101 if actual_return_ty.is_never() {
1102 actual_return_ty = fcx.next_diverging_ty_var(
1103 ty::UniverseIndex::ROOT,
1104 TypeVariableOrigin::DivergingFn(span));
1106 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1108 if fcx.tcx.features().termination_trait {
1109 // If the termination trait language item is activated, check that the main return type
1110 // implements the termination trait.
1111 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1112 if let Some((id, _)) = *fcx.tcx.sess.entry_fn.borrow() {
1114 match fcx.sess().entry_type.get() {
1115 Some(config::EntryMain) => {
1116 let substs = fcx.tcx.mk_substs(iter::once(Kind::from(ret_ty)));
1117 let trait_ref = ty::TraitRef::new(term_id, substs);
1118 let cause = traits::ObligationCause::new(
1119 span, fn_id, ObligationCauseCode::MainFunctionType);
1121 inherited.register_predicate(
1122 traits::Obligation::new(
1123 cause, param_env, trait_ref.to_predicate()));
1135 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1138 let def_id = tcx.hir.local_def_id(id);
1139 let def = tcx.adt_def(def_id);
1140 def.destructor(tcx); // force the destructor to be evaluated
1141 check_representable(tcx, span, def_id);
1143 if def.repr.simd() {
1144 check_simd(tcx, span, def_id);
1147 check_transparent(tcx, span, def_id);
1148 check_packed(tcx, span, def_id);
1151 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1154 let def_id = tcx.hir.local_def_id(id);
1155 let def = tcx.adt_def(def_id);
1156 def.destructor(tcx); // force the destructor to be evaluated
1157 check_representable(tcx, span, def_id);
1159 check_packed(tcx, span, def_id);
1162 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1163 debug!("check_item_type(it.id={}, it.name={})",
1165 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1166 let _indenter = indenter();
1168 // Consts can play a role in type-checking, so they are included here.
1169 hir::ItemStatic(..) |
1170 hir::ItemConst(..) => {
1171 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1173 hir::ItemEnum(ref enum_definition, _) => {
1176 &enum_definition.variants,
1179 hir::ItemFn(..) => {} // entirely within check_item_body
1180 hir::ItemImpl(.., ref impl_item_refs) => {
1181 debug!("ItemImpl {} with id {}", it.name, it.id);
1182 let impl_def_id = tcx.hir.local_def_id(it.id);
1183 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1184 check_impl_items_against_trait(tcx,
1189 let trait_def_id = impl_trait_ref.def_id;
1190 check_on_unimplemented(tcx, trait_def_id, it);
1193 hir::ItemTrait(..) => {
1194 let def_id = tcx.hir.local_def_id(it.id);
1195 check_on_unimplemented(tcx, def_id, it);
1197 hir::ItemStruct(..) => {
1198 check_struct(tcx, it.id, it.span);
1200 hir::ItemUnion(..) => {
1201 check_union(tcx, it.id, it.span);
1203 hir::ItemTy(_, ref generics) => {
1204 let def_id = tcx.hir.local_def_id(it.id);
1205 let pty_ty = tcx.type_of(def_id);
1206 check_bounds_are_used(tcx, generics, pty_ty);
1208 hir::ItemForeignMod(ref m) => {
1209 check_abi(tcx, it.span, m.abi);
1211 if m.abi == Abi::RustIntrinsic {
1212 for item in &m.items {
1213 intrinsic::check_intrinsic_type(tcx, item);
1215 } else if m.abi == Abi::PlatformIntrinsic {
1216 for item in &m.items {
1217 intrinsic::check_platform_intrinsic_type(tcx, item);
1220 for item in &m.items {
1221 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1222 if !generics.types.is_empty() {
1223 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1224 "foreign items may not have type parameters");
1225 span_help!(&mut err, item.span,
1226 "consider using specialization instead of \
1231 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1232 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1237 _ => {/* nothing to do */ }
1241 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1242 trait_def_id: DefId,
1244 let item_def_id = tcx.hir.local_def_id(item.id);
1245 // an error would be reported if this fails.
1246 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1249 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1250 impl_item: &hir::ImplItem,
1253 let mut err = struct_span_err!(
1254 tcx.sess, impl_item.span, E0520,
1255 "`{}` specializes an item from a parent `impl`, but \
1256 that item is not marked `default`",
1258 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1261 match tcx.span_of_impl(parent_impl) {
1263 err.span_label(span, "parent `impl` is here");
1264 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1268 err.note(&format!("parent implementation is in crate `{}`", cname));
1275 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1276 trait_def: &ty::TraitDef,
1277 trait_item: &ty::AssociatedItem,
1279 impl_item: &hir::ImplItem)
1281 let ancestors = trait_def.ancestors(tcx, impl_id);
1283 let kind = match impl_item.node {
1284 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1285 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1286 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1289 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1290 .map(|node_item| node_item.map(|parent| parent.defaultness));
1292 if let Some(parent) = parent {
1293 if tcx.impl_item_is_final(&parent) {
1294 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1300 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1303 impl_trait_ref: ty::TraitRef<'tcx>,
1304 impl_item_refs: &[hir::ImplItemRef]) {
1305 let impl_span = tcx.sess.codemap().def_span(impl_span);
1307 // If the trait reference itself is erroneous (so the compilation is going
1308 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1309 // isn't populated for such impls.
1310 if impl_trait_ref.references_error() { return; }
1312 // Locate trait definition and items
1313 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1314 let mut overridden_associated_type = None;
1316 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1318 // Check existing impl methods to see if they are both present in trait
1319 // and compatible with trait signature
1320 for impl_item in impl_items() {
1321 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1322 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1323 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1324 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1326 // Not compatible, but needed for the error message
1327 tcx.associated_items(impl_trait_ref.def_id)
1328 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1331 // Check that impl definition matches trait definition
1332 if let Some(ty_trait_item) = ty_trait_item {
1333 match impl_item.node {
1334 hir::ImplItemKind::Const(..) => {
1335 // Find associated const definition.
1336 if ty_trait_item.kind == ty::AssociatedKind::Const {
1337 compare_const_impl(tcx,
1343 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1344 "item `{}` is an associated const, \
1345 which doesn't match its trait `{}`",
1348 err.span_label(impl_item.span, "does not match trait");
1349 // We can only get the spans from local trait definition
1350 // Same for E0324 and E0325
1351 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1352 err.span_label(trait_span, "item in trait");
1357 hir::ImplItemKind::Method(..) => {
1358 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1359 if ty_trait_item.kind == ty::AssociatedKind::Method {
1360 compare_impl_method(tcx,
1367 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1368 "item `{}` is an associated method, \
1369 which doesn't match its trait `{}`",
1372 err.span_label(impl_item.span, "does not match trait");
1373 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1374 err.span_label(trait_span, "item in trait");
1379 hir::ImplItemKind::Type(_) => {
1380 if ty_trait_item.kind == ty::AssociatedKind::Type {
1381 if ty_trait_item.defaultness.has_value() {
1382 overridden_associated_type = Some(impl_item);
1385 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1386 "item `{}` is an associated type, \
1387 which doesn't match its trait `{}`",
1390 err.span_label(impl_item.span, "does not match trait");
1391 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1392 err.span_label(trait_span, "item in trait");
1399 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1403 // Check for missing items from trait
1404 let mut missing_items = Vec::new();
1405 let mut invalidated_items = Vec::new();
1406 let associated_type_overridden = overridden_associated_type.is_some();
1407 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1408 let is_implemented = trait_def.ancestors(tcx, impl_id)
1409 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1411 .map(|node_item| !node_item.node.is_from_trait())
1414 if !is_implemented && !tcx.impl_is_default(impl_id) {
1415 if !trait_item.defaultness.has_value() {
1416 missing_items.push(trait_item);
1417 } else if associated_type_overridden {
1418 invalidated_items.push(trait_item.name);
1423 if !missing_items.is_empty() {
1424 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1425 "not all trait items implemented, missing: `{}`",
1426 missing_items.iter()
1427 .map(|trait_item| trait_item.name.to_string())
1428 .collect::<Vec<_>>().join("`, `"));
1429 err.span_label(impl_span, format!("missing `{}` in implementation",
1430 missing_items.iter()
1431 .map(|trait_item| trait_item.name.to_string())
1432 .collect::<Vec<_>>().join("`, `")));
1433 for trait_item in missing_items {
1434 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1435 err.span_label(span, format!("`{}` from trait", trait_item.name));
1437 err.note_trait_signature(trait_item.name.to_string(),
1438 trait_item.signature(&tcx));
1444 if !invalidated_items.is_empty() {
1445 let invalidator = overridden_associated_type.unwrap();
1446 span_err!(tcx.sess, invalidator.span, E0399,
1447 "the following trait items need to be reimplemented \
1448 as `{}` was overridden: `{}`",
1450 invalidated_items.iter()
1451 .map(|name| name.to_string())
1452 .collect::<Vec<_>>().join("`, `"))
1456 /// Checks whether a type can be represented in memory. In particular, it
1457 /// identifies types that contain themselves without indirection through a
1458 /// pointer, which would mean their size is unbounded.
1459 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1463 let rty = tcx.type_of(item_def_id);
1465 // Check that it is possible to represent this type. This call identifies
1466 // (1) types that contain themselves and (2) types that contain a different
1467 // recursive type. It is only necessary to throw an error on those that
1468 // contain themselves. For case 2, there must be an inner type that will be
1469 // caught by case 1.
1470 match rty.is_representable(tcx, sp) {
1471 Representability::SelfRecursive(spans) => {
1472 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1474 err.span_label(span, "recursive without indirection");
1479 Representability::Representable | Representability::ContainsRecursive => (),
1484 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1485 let t = tcx.type_of(def_id);
1487 ty::TyAdt(def, substs) if def.is_struct() => {
1488 let fields = &def.non_enum_variant().fields;
1489 if fields.is_empty() {
1490 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1493 let e = fields[0].ty(tcx, substs);
1494 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1495 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1496 .span_label(sp, "SIMD elements must have the same type")
1501 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1502 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1504 span_err!(tcx.sess, sp, E0077,
1505 "SIMD vector element type should be machine type");
1514 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1515 if tcx.adt_def(def_id).repr.packed() {
1516 if tcx.adt_def(def_id).repr.align > 0 {
1517 struct_span_err!(tcx.sess, sp, E0587,
1518 "type has conflicting packed and align representation hints").emit();
1520 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1521 struct_span_err!(tcx.sess, sp, E0588,
1522 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1527 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1529 stack: &mut Vec<DefId>) -> bool {
1530 let t = tcx.type_of(def_id);
1531 if stack.contains(&def_id) {
1532 debug!("check_packed_inner: {:?} is recursive", t);
1536 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1537 if tcx.adt_def(def.did).repr.align > 0 {
1540 // push struct def_id before checking fields
1542 for field in &def.non_enum_variant().fields {
1543 let f = field.ty(tcx, substs);
1545 ty::TyAdt(def, _) => {
1546 if check_packed_inner(tcx, def.did, stack) {
1553 // only need to pop if not early out
1561 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1562 let adt = tcx.adt_def(def_id);
1563 if !adt.repr.transparent() {
1567 // For each field, figure out if it's known to be a ZST and align(1)
1568 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1569 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1570 let param_env = tcx.param_env(field.did);
1571 let layout = tcx.layout_of(param_env.and(ty));
1572 // We are currently checking the type this field came from, so it must be local
1573 let span = tcx.hir.span_if_local(field.did).unwrap();
1574 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1575 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1579 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1580 let non_zst_count = non_zst_fields.clone().count();
1581 if non_zst_count != 1 {
1582 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1583 struct_span_err!(tcx.sess, sp, E0690,
1584 "transparent struct needs exactly one non-zero-sized field, but has {}",
1586 .span_note(field_spans, "non-zero-sized field")
1589 for &(span, zst, align1) in &field_infos {
1591 span_err!(tcx.sess, span, E0691,
1592 "zero-sized field in transparent struct has alignment larger than 1");
1597 #[allow(trivial_numeric_casts)]
1598 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1600 vs: &'tcx [hir::Variant],
1602 let def_id = tcx.hir.local_def_id(id);
1603 let def = tcx.adt_def(def_id);
1604 def.destructor(tcx); // force the destructor to be evaluated
1607 let attributes = tcx.get_attrs(def_id);
1608 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1610 tcx.sess, attr.span, E0084,
1611 "unsupported representation for zero-variant enum")
1612 .span_label(sp, "zero-variant enum")
1617 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1618 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1619 if !tcx.features().repr128 {
1620 emit_feature_err(&tcx.sess.parse_sess,
1623 GateIssue::Language,
1624 "repr with 128-bit type is unstable");
1629 if let Some(e) = v.node.disr_expr {
1630 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1634 let mut disr_vals: Vec<ConstInt> = Vec::new();
1635 for (discr, v) in def.discriminants(tcx).zip(vs) {
1636 // Check for duplicate discriminant values
1637 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1638 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1639 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1640 let i_span = match variant_i.node.disr_expr {
1641 Some(expr) => tcx.hir.span(expr.node_id),
1642 None => tcx.hir.span(variant_i_node_id)
1644 let span = match v.node.disr_expr {
1645 Some(expr) => tcx.hir.span(expr.node_id),
1648 struct_span_err!(tcx.sess, span, E0081,
1649 "discriminant value `{}` already exists", disr_vals[i])
1650 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1651 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1654 disr_vals.push(discr);
1657 check_representable(tcx, sp, def_id);
1660 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1661 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1663 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1664 -> ty::GenericPredicates<'tcx>
1667 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1668 let item_id = tcx.hir.ty_param_owner(node_id);
1669 let item_def_id = tcx.hir.local_def_id(item_id);
1670 let generics = tcx.generics_of(item_def_id);
1671 let index = generics.type_param_to_index[&def_id];
1672 ty::GenericPredicates {
1674 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1676 ty::Predicate::Trait(ref data) => {
1677 data.0.self_ty().is_param(index)
1681 }).cloned().collect()
1685 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1686 -> Option<ty::Region<'tcx>> {
1688 Some(def) => infer::EarlyBoundRegion(span, def.name),
1689 None => infer::MiscVariable(span)
1691 Some(self.next_region_var(v))
1694 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1695 self.next_ty_var(ty::UniverseIndex::ROOT,
1696 TypeVariableOrigin::TypeInference(span))
1699 fn ty_infer_for_def(&self,
1700 ty_param_def: &ty::TypeParameterDef,
1701 span: Span) -> Ty<'tcx> {
1702 self.type_var_for_def(ty::UniverseIndex::ROOT, span, ty_param_def)
1705 fn projected_ty_from_poly_trait_ref(&self,
1708 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1711 let (trait_ref, _) =
1712 self.replace_late_bound_regions_with_fresh_var(
1714 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1717 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1720 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1721 if ty.has_escaping_regions() {
1722 ty // FIXME: normalization and escaping regions
1724 self.normalize_associated_types_in(span, &ty)
1728 fn set_tainted_by_errors(&self) {
1729 self.infcx.set_tainted_by_errors()
1732 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1733 self.write_ty(hir_id, ty)
1737 /// Controls whether the arguments are tupled. This is used for the call
1740 /// Tupling means that all call-side arguments are packed into a tuple and
1741 /// passed as a single parameter. For example, if tupling is enabled, this
1744 /// fn f(x: (isize, isize))
1746 /// Can be called as:
1753 #[derive(Clone, Eq, PartialEq)]
1754 enum TupleArgumentsFlag {
1759 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1760 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1761 param_env: ty::ParamEnv<'tcx>,
1762 body_id: ast::NodeId)
1763 -> FnCtxt<'a, 'gcx, 'tcx> {
1767 err_count_on_creation: inh.tcx.sess.err_count(),
1770 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1771 ast::CRATE_NODE_ID)),
1772 diverges: Cell::new(Diverges::Maybe),
1773 has_errors: Cell::new(false),
1774 enclosing_breakables: RefCell::new(EnclosingBreakables {
1782 pub fn sess(&self) -> &Session {
1786 pub fn err_count_since_creation(&self) -> usize {
1787 self.tcx.sess.err_count() - self.err_count_on_creation
1790 /// Produce warning on the given node, if the current point in the
1791 /// function is unreachable, and there hasn't been another warning.
1792 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1793 if self.diverges.get() == Diverges::Always {
1794 self.diverges.set(Diverges::WarnedAlways);
1796 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1798 self.tcx().lint_node(
1799 lint::builtin::UNREACHABLE_CODE,
1801 &format!("unreachable {}", kind));
1807 code: ObligationCauseCode<'tcx>)
1808 -> ObligationCause<'tcx> {
1809 ObligationCause::new(span, self.body_id, code)
1812 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1813 self.cause(span, ObligationCauseCode::MiscObligation)
1816 /// Resolves type variables in `ty` if possible. Unlike the infcx
1817 /// version (resolve_type_vars_if_possible), this version will
1818 /// also select obligations if it seems useful, in an effort
1819 /// to get more type information.
1820 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1821 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1823 // No TyInfer()? Nothing needs doing.
1824 if !ty.has_infer_types() {
1825 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1829 // If `ty` is a type variable, see whether we already know what it is.
1830 ty = self.resolve_type_vars_if_possible(&ty);
1831 if !ty.has_infer_types() {
1832 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1836 // If not, try resolving pending obligations as much as
1837 // possible. This can help substantially when there are
1838 // indirect dependencies that don't seem worth tracking
1840 self.select_obligations_where_possible();
1841 ty = self.resolve_type_vars_if_possible(&ty);
1843 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1847 fn record_deferred_call_resolution(&self,
1848 closure_def_id: DefId,
1849 r: DeferredCallResolution<'gcx, 'tcx>) {
1850 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1851 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1854 fn remove_deferred_call_resolutions(&self,
1855 closure_def_id: DefId)
1856 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1858 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1859 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1862 pub fn tag(&self) -> String {
1863 let self_ptr: *const FnCtxt = self;
1864 format!("{:?}", self_ptr)
1867 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1868 match self.locals.borrow().get(&nid) {
1871 span_bug!(span, "no type for local variable {}",
1872 self.tcx.hir.node_to_string(nid));
1878 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1879 debug!("write_ty({:?}, {:?}) in fcx {}",
1880 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1881 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1883 if ty.references_error() {
1884 self.has_errors.set(true);
1885 self.set_tainted_by_errors();
1889 // The NodeId and the ItemLocalId must identify the same item. We just pass
1890 // both of them for consistency checking.
1891 pub fn write_method_call(&self,
1893 method: MethodCallee<'tcx>) {
1896 .type_dependent_defs_mut()
1897 .insert(hir_id, Def::Method(method.def_id));
1898 self.write_substs(hir_id, method.substs);
1901 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1902 if !substs.is_noop() {
1903 debug!("write_substs({:?}, {:?}) in fcx {}",
1908 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1912 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1913 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1919 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1920 Entry::Vacant(entry) => { entry.insert(adj); },
1921 Entry::Occupied(mut entry) => {
1922 debug!(" - composing on top of {:?}", entry.get());
1923 match (&entry.get()[..], &adj[..]) {
1924 // Applying any adjustment on top of a NeverToAny
1925 // is a valid NeverToAny adjustment, because it can't
1927 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1929 Adjustment { kind: Adjust::Deref(_), .. },
1930 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1932 Adjustment { kind: Adjust::Deref(_), .. },
1933 .. // Any following adjustments are allowed.
1935 // A reborrow has no effect before a dereference.
1937 // FIXME: currently we never try to compose autoderefs
1938 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1940 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1941 expr, entry.get(), adj)
1943 *entry.get_mut() = adj;
1948 /// Basically whenever we are converting from a type scheme into
1949 /// the fn body space, we always want to normalize associated
1950 /// types as well. This function combines the two.
1951 fn instantiate_type_scheme<T>(&self,
1953 substs: &Substs<'tcx>,
1956 where T : TypeFoldable<'tcx>
1958 let value = value.subst(self.tcx, substs);
1959 let result = self.normalize_associated_types_in(span, &value);
1960 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1967 /// As `instantiate_type_scheme`, but for the bounds found in a
1968 /// generic type scheme.
1969 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1970 -> ty::InstantiatedPredicates<'tcx> {
1971 let bounds = self.tcx.predicates_of(def_id);
1972 let result = bounds.instantiate(self.tcx, substs);
1973 let result = self.normalize_associated_types_in(span, &result);
1974 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1981 /// Replace the anonymized types from the return value of the
1982 /// function with type variables and records the `AnonTypeMap` for
1983 /// later use during writeback. See
1984 /// `InferCtxt::instantiate_anon_types` for more details.
1985 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
1990 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
1992 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
1997 let (value, anon_type_map) = self.register_infer_ok_obligations(
1998 self.instantiate_anon_types(
2006 let mut anon_types = self.anon_types.borrow_mut();
2007 for (ty, decl) in anon_type_map {
2008 let old_value = anon_types.insert(ty, decl);
2009 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2015 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2016 where T : TypeFoldable<'tcx>
2018 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2021 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2023 where T : TypeFoldable<'tcx>
2025 self.inh.partially_normalize_associated_types_in(span,
2031 pub fn require_type_meets(&self,
2034 code: traits::ObligationCauseCode<'tcx>,
2037 self.register_bound(
2040 traits::ObligationCause::new(span, self.body_id, code));
2043 pub fn require_type_is_sized(&self,
2046 code: traits::ObligationCauseCode<'tcx>)
2048 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2049 self.require_type_meets(ty, span, code, lang_item);
2052 pub fn register_bound(&self,
2055 cause: traits::ObligationCause<'tcx>)
2057 self.fulfillment_cx.borrow_mut()
2058 .register_bound(self, self.param_env, ty, def_id, cause);
2061 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2062 let t = AstConv::ast_ty_to_ty(self, ast_t);
2063 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2067 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2068 match self.tables.borrow().node_types().get(id) {
2070 None if self.is_tainted_by_errors() => self.tcx.types.err,
2072 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2073 bug!("no type for node {}: {} in fcx {}",
2074 node_id, self.tcx.hir.node_to_string(node_id),
2080 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2081 /// outlive the region `r`.
2082 pub fn register_wf_obligation(&self,
2085 code: traits::ObligationCauseCode<'tcx>)
2087 // WF obligations never themselves fail, so no real need to give a detailed cause:
2088 let cause = traits::ObligationCause::new(span, self.body_id, code);
2089 self.register_predicate(traits::Obligation::new(cause,
2091 ty::Predicate::WellFormed(ty)));
2094 /// Registers obligations that all types appearing in `substs` are well-formed.
2095 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2097 for ty in substs.types() {
2098 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2102 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2103 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2104 /// trait/region obligations.
2106 /// For example, if there is a function:
2109 /// fn foo<'a,T:'a>(...)
2112 /// and a reference:
2118 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2119 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2120 pub fn add_obligations_for_parameters(&self,
2121 cause: traits::ObligationCause<'tcx>,
2122 predicates: &ty::InstantiatedPredicates<'tcx>)
2124 assert!(!predicates.has_escaping_regions());
2126 debug!("add_obligations_for_parameters(predicates={:?})",
2129 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2130 self.register_predicate(obligation);
2134 // FIXME(arielb1): use this instead of field.ty everywhere
2135 // Only for fields! Returns <none> for methods>
2136 // Indifferent to privacy flags
2137 pub fn field_ty(&self,
2139 field: &'tcx ty::FieldDef,
2140 substs: &Substs<'tcx>)
2143 self.normalize_associated_types_in(span,
2144 &field.ty(self.tcx, substs))
2147 fn check_casts(&self) {
2148 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2149 for cast in deferred_cast_checks.drain(..) {
2154 fn resolve_generator_interiors(&self, def_id: DefId) {
2155 let mut generators = self.deferred_generator_interiors.borrow_mut();
2156 for (body_id, interior) in generators.drain(..) {
2157 self.select_obligations_where_possible();
2158 generator_interior::resolve_interior(self, def_id, body_id, interior);
2162 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2163 // Non-numerics get replaced with ! or () (depending on whether
2164 // feature(never_type) is enabled), unconstrained ints with i32,
2165 // unconstrained floats with f64.
2166 // Fallback becomes very dubious if we have encountered type-checking errors.
2167 // In that case, fallback to TyError.
2168 fn fallback_if_possible(&self, ty: Ty<'tcx>) {
2169 use rustc::ty::error::UnconstrainedNumeric::Neither;
2170 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2172 assert!(ty.is_ty_infer());
2173 let fallback = match self.type_is_unconstrained_numeric(ty) {
2174 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2175 UnconstrainedInt => self.tcx.types.i32,
2176 UnconstrainedFloat => self.tcx.types.f64,
2177 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2180 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2181 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2184 fn select_all_obligations_or_error(&self) {
2185 debug!("select_all_obligations_or_error");
2186 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2187 self.report_fulfillment_errors(&errors, self.inh.body_id);
2191 /// Select as many obligations as we can at present.
2192 fn select_obligations_where_possible(&self) {
2193 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2195 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2199 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2201 hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
2203 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2208 hir::ExprType(ref e, _) => {
2209 self.is_place_expr(e)
2212 hir::ExprUnary(hir::UnDeref, _) |
2213 hir::ExprField(..) |
2214 hir::ExprTupField(..) |
2215 hir::ExprIndex(..) => {
2219 // Partially qualified paths in expressions can only legally
2220 // refer to associated items which are always rvalues.
2221 hir::ExprPath(hir::QPath::TypeRelative(..)) |
2224 hir::ExprMethodCall(..) |
2225 hir::ExprStruct(..) |
2228 hir::ExprMatch(..) |
2229 hir::ExprClosure(..) |
2230 hir::ExprBlock(..) |
2231 hir::ExprRepeat(..) |
2232 hir::ExprArray(..) |
2233 hir::ExprBreak(..) |
2234 hir::ExprAgain(..) |
2236 hir::ExprWhile(..) |
2238 hir::ExprAssign(..) |
2239 hir::ExprInlineAsm(..) |
2240 hir::ExprAssignOp(..) |
2242 hir::ExprUnary(..) |
2244 hir::ExprAddrOf(..) |
2245 hir::ExprBinary(..) |
2246 hir::ExprYield(..) |
2247 hir::ExprCast(..) => {
2253 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2254 /// returns a type of `&T`, but the actual type we assign to the
2255 /// *expression* is `T`. So this function just peels off the return
2256 /// type by one layer to yield `T`.
2257 fn make_overloaded_place_return_type(&self,
2258 method: MethodCallee<'tcx>)
2259 -> ty::TypeAndMut<'tcx>
2261 // extract method return type, which will be &T;
2262 let ret_ty = method.sig.output();
2264 // method returns &T, but the type as visible to user is T, so deref
2265 ret_ty.builtin_deref(true).unwrap()
2268 fn lookup_indexing(&self,
2270 base_expr: &'gcx hir::Expr,
2274 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2276 // FIXME(#18741) -- this is almost but not quite the same as the
2277 // autoderef that normal method probing does. They could likely be
2280 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2281 let mut result = None;
2282 while result.is_none() && autoderef.next().is_some() {
2283 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2285 autoderef.finalize();
2289 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2290 /// (and otherwise adjust) `base_expr`, looking for a type which either
2291 /// supports builtin indexing or overloaded indexing.
2292 /// This loop implements one step in that search; the autoderef loop
2293 /// is implemented by `lookup_indexing`.
2294 fn try_index_step(&self,
2296 base_expr: &hir::Expr,
2297 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2300 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2302 let adjusted_ty = autoderef.unambiguous_final_ty();
2303 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2310 for &unsize in &[false, true] {
2311 let mut self_ty = adjusted_ty;
2313 // We only unsize arrays here.
2314 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2315 self_ty = self.tcx.mk_slice(element_ty);
2321 // If some lookup succeeds, write callee into table and extract index/element
2322 // type from the method signature.
2323 // If some lookup succeeded, install method in table
2324 let input_ty = self.next_ty_var(ty::UniverseIndex::ROOT,
2325 TypeVariableOrigin::AutoDeref(base_expr.span));
2326 let method = self.try_overloaded_place_op(
2327 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2329 let result = method.map(|ok| {
2330 debug!("try_index_step: success, using overloaded indexing");
2331 let method = self.register_infer_ok_obligations(ok);
2333 let mut adjustments = autoderef.adjust_steps(needs);
2334 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2335 let mutbl = match mt.mutbl {
2336 hir::MutImmutable => AutoBorrowMutability::Immutable,
2337 hir::MutMutable => AutoBorrowMutability::Mutable {
2338 // FIXME (#46747): arguably indexing is
2339 // "just another kind of call"; perhaps it
2340 // would be more consistent to allow
2341 // two-phase borrows for .index()
2343 allow_two_phase_borrow: false,
2346 adjustments.push(Adjustment {
2347 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2348 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2355 adjustments.push(Adjustment {
2356 kind: Adjust::Unsize,
2357 target: method.sig.inputs()[0]
2360 self.apply_adjustments(base_expr, adjustments);
2362 self.write_method_call(expr.hir_id, method);
2363 (input_ty, self.make_overloaded_place_return_type(method).ty)
2365 if result.is_some() {
2373 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2374 let (tr, name) = match (op, is_mut) {
2375 (PlaceOp::Deref, false) =>
2376 (self.tcx.lang_items().deref_trait(), "deref"),
2377 (PlaceOp::Deref, true) =>
2378 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2379 (PlaceOp::Index, false) =>
2380 (self.tcx.lang_items().index_trait(), "index"),
2381 (PlaceOp::Index, true) =>
2382 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2384 (tr, Symbol::intern(name))
2387 fn try_overloaded_place_op(&self,
2390 arg_tys: &[Ty<'tcx>],
2393 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2395 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2401 // Try Mut first, if needed.
2402 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2403 let method = match (needs, mut_tr) {
2404 (Needs::MutPlace, Some(trait_did)) => {
2405 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2410 // Otherwise, fall back to the immutable version.
2411 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2412 let method = match (method, imm_tr) {
2413 (None, Some(trait_did)) => {
2414 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2416 (method, _) => method,
2422 fn check_method_argument_types(&self,
2425 method: Result<MethodCallee<'tcx>, ()>,
2426 args_no_rcvr: &'gcx [hir::Expr],
2427 tuple_arguments: TupleArgumentsFlag,
2428 expected: Expectation<'tcx>)
2430 let has_error = match method {
2432 method.substs.references_error() || method.sig.references_error()
2437 let err_inputs = self.err_args(args_no_rcvr.len());
2439 let err_inputs = match tuple_arguments {
2440 DontTupleArguments => err_inputs,
2441 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2444 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2445 false, tuple_arguments, None);
2446 return self.tcx.types.err;
2449 let method = method.unwrap();
2450 // HACK(eddyb) ignore self in the definition (see above).
2451 let expected_arg_tys = self.expected_inputs_for_expected_output(
2454 method.sig.output(),
2455 &method.sig.inputs()[1..]
2457 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2458 args_no_rcvr, method.sig.variadic, tuple_arguments,
2459 self.tcx.hir.span_if_local(method.def_id));
2463 /// Generic function that factors out common logic from function calls,
2464 /// method calls and overloaded operators.
2465 fn check_argument_types(&self,
2468 fn_inputs: &[Ty<'tcx>],
2469 expected_arg_tys: &[Ty<'tcx>],
2470 args: &'gcx [hir::Expr],
2472 tuple_arguments: TupleArgumentsFlag,
2473 def_span: Option<Span>) {
2476 // Grab the argument types, supplying fresh type variables
2477 // if the wrong number of arguments were supplied
2478 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2484 // All the input types from the fn signature must outlive the call
2485 // so as to validate implied bounds.
2486 for &fn_input_ty in fn_inputs {
2487 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2490 let mut expected_arg_tys = expected_arg_tys;
2491 let expected_arg_count = fn_inputs.len();
2493 fn parameter_count_error<'tcx>(sess: &Session,
2496 expected_count: usize,
2500 def_span: Option<Span>,
2502 let mut err = sess.struct_span_err_with_code(sp,
2503 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2504 if variadic {"at least "} else {""},
2506 if expected_count == 1 {""} else {"s"},
2508 if arg_count == 1 {" was"} else {"s were"}),
2509 DiagnosticId::Error(error_code.to_owned()));
2511 if let Some(def_s) = def_span.map(|sp| sess.codemap().def_span(sp)) {
2512 err.span_label(def_s, "defined here");
2515 let sugg_span = sess.codemap().end_point(expr_sp);
2516 // remove closing `)` from the span
2517 let sugg_span = sugg_span.with_hi(sugg_span.lo());
2518 err.span_suggestion(
2520 "expected the unit value `()`; create it with empty parentheses",
2521 String::from("()"));
2523 err.span_label(sp, format!("expected {}{} parameter{}",
2524 if variadic {"at least "} else {""},
2526 if expected_count == 1 {""} else {"s"}));
2531 let formal_tys = if tuple_arguments == TupleArguments {
2532 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2533 match tuple_type.sty {
2534 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2535 parameter_count_error(tcx.sess, sp, expr_sp, arg_types.len(), args.len(),
2536 "E0057", false, def_span, false);
2537 expected_arg_tys = &[];
2538 self.err_args(args.len())
2540 ty::TyTuple(arg_types, _) => {
2541 expected_arg_tys = match expected_arg_tys.get(0) {
2542 Some(&ty) => match ty.sty {
2543 ty::TyTuple(ref tys, _) => &tys,
2551 span_err!(tcx.sess, sp, E0059,
2552 "cannot use call notation; the first type parameter \
2553 for the function trait is neither a tuple nor unit");
2554 expected_arg_tys = &[];
2555 self.err_args(args.len())
2558 } else if expected_arg_count == supplied_arg_count {
2560 } else if variadic {
2561 if supplied_arg_count >= expected_arg_count {
2564 parameter_count_error(tcx.sess, sp, expr_sp, expected_arg_count,
2565 supplied_arg_count, "E0060", true, def_span, false);
2566 expected_arg_tys = &[];
2567 self.err_args(supplied_arg_count)
2570 // is the missing argument of type `()`?
2571 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2572 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2573 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2574 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2578 parameter_count_error(tcx.sess, sp, expr_sp, expected_arg_count,
2579 supplied_arg_count, "E0061", false, def_span, sugg_unit);
2580 expected_arg_tys = &[];
2581 self.err_args(supplied_arg_count)
2584 debug!("check_argument_types: formal_tys={:?}",
2585 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2587 // Check the arguments.
2588 // We do this in a pretty awful way: first we typecheck any arguments
2589 // that are not closures, then we typecheck the closures. This is so
2590 // that we have more information about the types of arguments when we
2591 // typecheck the functions. This isn't really the right way to do this.
2592 for &check_closures in &[false, true] {
2593 debug!("check_closures={}", check_closures);
2595 // More awful hacks: before we check argument types, try to do
2596 // an "opportunistic" vtable resolution of any trait bounds on
2597 // the call. This helps coercions.
2599 self.select_obligations_where_possible();
2602 // For variadic functions, we don't have a declared type for all of
2603 // the arguments hence we only do our usual type checking with
2604 // the arguments who's types we do know.
2605 let t = if variadic {
2607 } else if tuple_arguments == TupleArguments {
2612 for (i, arg) in args.iter().take(t).enumerate() {
2613 // Warn only for the first loop (the "no closures" one).
2614 // Closure arguments themselves can't be diverging, but
2615 // a previous argument can, e.g. `foo(panic!(), || {})`.
2616 if !check_closures {
2617 self.warn_if_unreachable(arg.id, arg.span, "expression");
2620 let is_closure = match arg.node {
2621 hir::ExprClosure(..) => true,
2625 if is_closure != check_closures {
2629 debug!("checking the argument");
2630 let formal_ty = formal_tys[i];
2632 // The special-cased logic below has three functions:
2633 // 1. Provide as good of an expected type as possible.
2634 let expected = expected_arg_tys.get(i).map(|&ty| {
2635 Expectation::rvalue_hint(self, ty)
2638 let checked_ty = self.check_expr_with_expectation(
2640 expected.unwrap_or(ExpectHasType(formal_ty)));
2642 // 2. Coerce to the most detailed type that could be coerced
2643 // to, which is `expected_ty` if `rvalue_hint` returns an
2644 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2645 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2646 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2648 // 3. Relate the expected type and the formal one,
2649 // if the expected type was used for the coercion.
2650 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2654 // We also need to make sure we at least write the ty of the other
2655 // arguments which we skipped above.
2657 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2658 use structured_errors::{VariadicError, StructuredDiagnostic};
2659 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2662 for arg in args.iter().skip(expected_arg_count) {
2663 let arg_ty = self.check_expr(&arg);
2665 // There are a few types which get autopromoted when passed via varargs
2666 // in C but we just error out instead and require explicit casts.
2667 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2669 ty::TyFloat(ast::FloatTy::F32) => {
2670 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2672 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2673 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2675 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2676 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2678 ty::TyFnDef(..) => {
2679 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2680 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2681 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2689 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2690 (0..len).map(|_| self.tcx.types.err).collect()
2693 // AST fragment checking
2696 expected: Expectation<'tcx>)
2702 ast::LitKind::Str(..) => tcx.mk_static_str(),
2703 ast::LitKind::ByteStr(ref v) => {
2704 tcx.mk_imm_ref(tcx.types.re_static,
2705 tcx.mk_array(tcx.types.u8, v.len() as u64))
2707 ast::LitKind::Byte(_) => tcx.types.u8,
2708 ast::LitKind::Char(_) => tcx.types.char,
2709 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2710 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2711 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2712 let opt_ty = expected.to_option(self).and_then(|ty| {
2714 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2715 ty::TyChar => Some(tcx.types.u8),
2716 ty::TyRawPtr(..) => Some(tcx.types.usize),
2717 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2721 opt_ty.unwrap_or_else(
2722 || tcx.mk_int_var(self.next_int_var_id()))
2724 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2725 ast::LitKind::FloatUnsuffixed(_) => {
2726 let opt_ty = expected.to_option(self).and_then(|ty| {
2728 ty::TyFloat(_) => Some(ty),
2732 opt_ty.unwrap_or_else(
2733 || tcx.mk_float_var(self.next_float_var_id()))
2735 ast::LitKind::Bool(_) => tcx.types.bool
2739 fn check_expr_eq_type(&self,
2740 expr: &'gcx hir::Expr,
2741 expected: Ty<'tcx>) {
2742 let ty = self.check_expr_with_hint(expr, expected);
2743 self.demand_eqtype(expr.span, expected, ty);
2746 pub fn check_expr_has_type_or_error(&self,
2747 expr: &'gcx hir::Expr,
2748 expected: Ty<'tcx>) -> Ty<'tcx> {
2749 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2752 fn check_expr_meets_expectation_or_error(&self,
2753 expr: &'gcx hir::Expr,
2754 expected: Expectation<'tcx>) -> Ty<'tcx> {
2755 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2756 let mut ty = self.check_expr_with_expectation(expr, expected);
2758 // While we don't allow *arbitrary* coercions here, we *do* allow
2759 // coercions from ! to `expected`.
2761 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2762 "expression with never type wound up being adjusted");
2763 let adj_ty = self.next_diverging_ty_var(
2764 ty::UniverseIndex::ROOT,
2765 TypeVariableOrigin::AdjustmentType(expr.span));
2766 self.apply_adjustments(expr, vec![Adjustment {
2767 kind: Adjust::NeverToAny,
2773 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2774 // Add help to type error if this is an `if` condition with an assignment
2775 match (expected, &expr.node) {
2776 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2777 let msg = "try comparing for equality";
2778 if let (Ok(left), Ok(right)) = (
2779 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2780 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2782 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2794 fn check_expr_coercable_to_type(&self,
2795 expr: &'gcx hir::Expr,
2796 expected: Ty<'tcx>) -> Ty<'tcx> {
2797 self.check_expr_coercable_to_type_with_needs(expr, expected, Needs::None)
2800 fn check_expr_coercable_to_type_with_needs(&self,
2801 expr: &'gcx hir::Expr,
2805 let ty = self.check_expr_with_expectation_and_needs(
2807 ExpectHasType(expected),
2809 self.demand_coerce(expr, ty, expected)
2812 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2813 expected: Ty<'tcx>) -> Ty<'tcx> {
2814 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2817 fn check_expr_with_expectation(&self,
2818 expr: &'gcx hir::Expr,
2819 expected: Expectation<'tcx>) -> Ty<'tcx> {
2820 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2823 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2824 self.check_expr_with_expectation(expr, NoExpectation)
2827 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2828 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2831 // determine the `self` type, using fresh variables for all variables
2832 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2833 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2835 pub fn impl_self_ty(&self,
2836 span: Span, // (potential) receiver for this impl
2838 -> TypeAndSubsts<'tcx> {
2839 let ity = self.tcx.type_of(did);
2840 debug!("impl_self_ty: ity={:?}", ity);
2842 let substs = self.fresh_substs_for_item(ty::UniverseIndex::ROOT, span, did);
2843 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2845 TypeAndSubsts { substs: substs, ty: substd_ty }
2848 /// Unifies the output type with the expected type early, for more coercions
2849 /// and forward type information on the input expressions.
2850 fn expected_inputs_for_expected_output(&self,
2852 expected_ret: Expectation<'tcx>,
2853 formal_ret: Ty<'tcx>,
2854 formal_args: &[Ty<'tcx>])
2856 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2857 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2858 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2859 // Attempt to apply a subtyping relationship between the formal
2860 // return type (likely containing type variables if the function
2861 // is polymorphic) and the expected return type.
2862 // No argument expectations are produced if unification fails.
2863 let origin = self.misc(call_span);
2864 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2866 // FIXME(#15760) can't use try! here, FromError doesn't default
2867 // to identity so the resulting type is not constrained.
2870 // Process any obligations locally as much as
2871 // we can. We don't care if some things turn
2872 // out unconstrained or ambiguous, as we're
2873 // just trying to get hints here.
2874 let result = self.save_and_restore_in_snapshot_flag(|_| {
2875 let mut fulfill = FulfillmentContext::new();
2876 let ok = ok; // FIXME(#30046)
2877 for obligation in ok.obligations {
2878 fulfill.register_predicate_obligation(self, obligation);
2880 fulfill.select_where_possible(self)
2885 Err(_) => return Err(()),
2888 Err(_) => return Err(()),
2891 // Record all the argument types, with the substitutions
2892 // produced from the above subtyping unification.
2893 Ok(formal_args.iter().map(|ty| {
2894 self.resolve_type_vars_if_possible(ty)
2897 }).unwrap_or(vec![]);
2898 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2899 formal_args, formal_ret,
2900 expected_args, expected_ret);
2904 // Checks a method call.
2905 fn check_method_call(&self,
2906 expr: &'gcx hir::Expr,
2907 segment: &hir::PathSegment,
2909 args: &'gcx [hir::Expr],
2910 expected: Expectation<'tcx>,
2911 needs: Needs) -> Ty<'tcx> {
2912 let rcvr = &args[0];
2913 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
2914 // no need to check for bot/err -- callee does that
2915 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
2917 let method = match self.lookup_method(rcvr_t,
2923 self.write_method_call(expr.hir_id, method);
2927 if segment.name != keywords::Invalid.name() {
2928 self.report_method_error(span,
2939 // Call the generic checker.
2940 self.check_method_argument_types(span,
2948 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2952 .unwrap_or_else(|| span_bug!(return_expr.span,
2953 "check_return_expr called outside fn body"));
2955 let ret_ty = ret_coercion.borrow().expected_ty();
2956 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2957 ret_coercion.borrow_mut()
2959 &self.cause(return_expr.span,
2960 ObligationCauseCode::ReturnType(return_expr.id)),
2963 self.diverges.get());
2967 // A generic function for checking the then and else in an if
2969 fn check_then_else(&self,
2970 cond_expr: &'gcx hir::Expr,
2971 then_expr: &'gcx hir::Expr,
2972 opt_else_expr: Option<&'gcx hir::Expr>,
2974 expected: Expectation<'tcx>) -> Ty<'tcx> {
2975 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2976 let cond_diverges = self.diverges.get();
2977 self.diverges.set(Diverges::Maybe);
2979 let expected = expected.adjust_for_branches(self);
2980 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2981 let then_diverges = self.diverges.get();
2982 self.diverges.set(Diverges::Maybe);
2984 // We've already taken the expected type's preferences
2985 // into account when typing the `then` branch. To figure
2986 // out the initial shot at a LUB, we thus only consider
2987 // `expected` if it represents a *hard* constraint
2988 // (`only_has_type`); otherwise, we just go with a
2989 // fresh type variable.
2990 let coerce_to_ty = expected.coercion_target_type(self, sp);
2991 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2993 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2994 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2996 if let Some(else_expr) = opt_else_expr {
2997 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2998 let else_diverges = self.diverges.get();
3000 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
3002 // We won't diverge unless both branches do (or the condition does).
3003 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3005 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3006 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3008 // If the condition is false we can't diverge.
3009 self.diverges.set(cond_diverges);
3012 let result_ty = coerce.complete(self);
3013 if cond_ty.references_error() {
3020 // Check field access expressions
3021 fn check_field(&self,
3022 expr: &'gcx hir::Expr,
3024 base: &'gcx hir::Expr,
3025 field: &Spanned<ast::Name>) -> Ty<'tcx> {
3026 let expr_t = self.check_expr_with_needs(base, needs);
3027 let expr_t = self.structurally_resolved_type(expr.span,
3029 let mut private_candidate = None;
3030 let mut autoderef = self.autoderef(expr.span, expr_t);
3031 while let Some((base_t, _)) = autoderef.next() {
3033 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3034 debug!("struct named {:?}", base_t);
3035 let (ident, def_scope) =
3036 self.tcx.adjust(field.node, base_def.did, self.body_id);
3037 let fields = &base_def.non_enum_variant().fields;
3038 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3039 let field_ty = self.field_ty(expr.span, field, substs);
3040 if field.vis.is_accessible_from(def_scope, self.tcx) {
3041 let adjustments = autoderef.adjust_steps(needs);
3042 self.apply_adjustments(base, adjustments);
3043 autoderef.finalize();
3045 self.tcx.check_stability(field.did, expr.id, expr.span);
3049 private_candidate = Some((base_def.did, field_ty));
3055 autoderef.unambiguous_final_ty();
3057 if let Some((did, field_ty)) = private_candidate {
3058 let struct_path = self.tcx().item_path_str(did);
3059 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3060 "field `{}` of struct `{}` is private",
3061 field.node, struct_path);
3062 // Also check if an accessible method exists, which is often what is meant.
3063 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3064 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3069 } else if field.node == keywords::Invalid.name() {
3070 self.tcx().types.err
3071 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3072 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3073 "attempted to take value of method `{}` on type `{}`",
3075 .help("maybe a `()` to call it is missing?")
3077 self.tcx().types.err
3079 if !expr_t.is_primitive_ty() {
3080 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3083 ty::TyAdt(def, _) if !def.is_enum() => {
3084 if let Some(suggested_field_name) =
3085 Self::suggest_field_name(def.non_enum_variant(), field, vec![]) {
3086 err.span_label(field.span,
3087 format!("did you mean `{}`?", suggested_field_name));
3089 err.span_label(field.span, "unknown field");
3090 let struct_variant_def = def.non_enum_variant();
3091 let field_names = self.available_field_names(struct_variant_def);
3092 if !field_names.is_empty() {
3093 err.note(&format!("available fields are: {}",
3094 self.name_series_display(field_names)));
3098 ty::TyRawPtr(..) => {
3099 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
3101 self.tcx.hir.node_to_pretty_string(base.id),
3108 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3109 "`{}` is a primitive type and therefore doesn't have fields",
3112 self.tcx().types.err
3116 // Return an hint about the closest match in field names
3117 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3118 field: &Spanned<ast::Name>,
3119 skip: Vec<InternedString>)
3121 let name = field.node.as_str();
3122 let names = variant.fields.iter().filter_map(|field| {
3123 // ignore already set fields and private fields from non-local crates
3124 if skip.iter().any(|x| *x == field.name.as_str()) ||
3125 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3132 find_best_match_for_name(names, &name, None)
3135 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3136 let mut available = Vec::new();
3137 for field in variant.fields.iter() {
3138 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3139 if field.vis.is_accessible_from(def_scope, self.tcx) {
3140 available.push(field.name);
3146 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3147 // dynamic limit, to never omit just one field
3148 let limit = if names.len() == 6 { 6 } else { 5 };
3149 let mut display = names.iter().take(limit)
3150 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3151 if names.len() > limit {
3152 display = format!("{} ... and {} others", display, names.len() - limit);
3157 // Check tuple index expressions
3158 fn check_tup_field(&self,
3159 expr: &'gcx hir::Expr,
3161 base: &'gcx hir::Expr,
3162 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3163 let expr_t = self.check_expr_with_needs(base, needs);
3164 let expr_t = self.structurally_resolved_type(expr.span,
3166 let mut private_candidate = None;
3167 let mut tuple_like = false;
3168 let mut autoderef = self.autoderef(expr.span, expr_t);
3169 while let Some((base_t, _)) = autoderef.next() {
3170 let field = match base_t.sty {
3171 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3172 tuple_like = base_def.non_enum_variant().ctor_kind == CtorKind::Fn;
3173 if !tuple_like { continue }
3175 debug!("tuple struct named {:?}", base_t);
3176 let ident = ast::Ident {
3177 name: Symbol::intern(&idx.node.to_string()),
3178 ctxt: idx.span.ctxt().modern(),
3180 let (ident, def_scope) =
3181 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3182 let fields = &base_def.non_enum_variant().fields;
3183 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3184 let field_ty = self.field_ty(expr.span, field, substs);
3185 if field.vis.is_accessible_from(def_scope, self.tcx) {
3186 self.tcx.check_stability(field.did, expr.id, expr.span);
3189 private_candidate = Some((base_def.did, field_ty));
3196 ty::TyTuple(ref v, _) => {
3198 v.get(idx.node).cloned()
3203 if let Some(field_ty) = field {
3204 let adjustments = autoderef.adjust_steps(needs);
3205 self.apply_adjustments(base, adjustments);
3206 autoderef.finalize();
3210 autoderef.unambiguous_final_ty();
3212 if let Some((did, field_ty)) = private_candidate {
3213 let struct_path = self.tcx().item_path_str(did);
3214 struct_span_err!(self.tcx().sess, expr.span, E0611,
3215 "field `{}` of tuple-struct `{}` is private",
3216 idx.node, struct_path).emit();
3221 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3222 "attempted out-of-bounds tuple index `{}` on type `{}`",
3223 idx.node, expr_t).emit();
3225 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3228 self.tcx().types.err
3231 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3232 -> DiagnosticBuilder {
3233 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3234 "no field `{}` on type `{}`",
3238 fn report_unknown_field(&self,
3240 variant: &'tcx ty::VariantDef,
3242 skip_fields: &[hir::Field],
3244 let mut err = self.type_error_struct_with_diag(
3246 |actual| match ty.sty {
3247 ty::TyAdt(adt, ..) if adt.is_enum() => {
3248 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3249 "{} `{}::{}` has no field named `{}`",
3250 kind_name, actual, variant.name, field.name.node)
3253 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3254 "{} `{}` has no field named `{}`",
3255 kind_name, actual, field.name.node)
3259 // prevent all specified fields from being suggested
3260 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3261 if let Some(field_name) = Self::suggest_field_name(variant,
3263 skip_fields.collect()) {
3264 err.span_label(field.name.span,
3265 format!("field does not exist - did you mean `{}`?", field_name));
3268 ty::TyAdt(adt, ..) => {
3270 err.span_label(field.name.span,
3271 format!("`{}::{}` does not have this field",
3274 err.span_label(field.name.span,
3275 format!("`{}` does not have this field", ty));
3277 let available_field_names = self.available_field_names(variant);
3278 if !available_field_names.is_empty() {
3279 err.note(&format!("available fields are: {}",
3280 self.name_series_display(available_field_names)));
3283 _ => bug!("non-ADT passed to report_unknown_field")
3289 fn check_expr_struct_fields(&self,
3291 expected: Expectation<'tcx>,
3292 expr_id: ast::NodeId,
3294 variant: &'tcx ty::VariantDef,
3295 ast_fields: &'gcx [hir::Field],
3296 check_completeness: bool) {
3300 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3301 .get(0).cloned().unwrap_or(adt_ty);
3302 // re-link the regions that EIfEO can erase.
3303 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3305 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3306 &ty::TyAdt(adt, substs) => {
3307 (substs, adt.adt_kind(), adt.variant_descr())
3309 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3312 let mut remaining_fields = FxHashMap();
3313 for field in &variant.fields {
3314 remaining_fields.insert(field.name.to_ident(), field);
3317 let mut seen_fields = FxHashMap();
3319 let mut error_happened = false;
3321 // Typecheck each field.
3322 for field in ast_fields {
3323 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3324 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3325 seen_fields.insert(field.name.node, field.span);
3327 // we don't look at stability attributes on
3328 // struct-like enums (yet...), but it's definitely not
3329 // a bug to have construct one.
3330 if adt_kind != ty::AdtKind::Enum {
3331 tcx.check_stability(v_field.did, expr_id, field.span);
3334 self.field_ty(field.span, v_field, substs)
3336 error_happened = true;
3337 if let Some(_) = variant.find_field_named(field.name.node) {
3338 let mut err = struct_span_err!(self.tcx.sess,
3341 "field `{}` specified more than once",
3344 err.span_label(field.name.span, "used more than once");
3346 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3347 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3352 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3358 // Make sure to give a type to the field even if there's
3359 // an error, so we can continue typechecking
3360 self.check_expr_coercable_to_type(&field.expr, field_type);
3363 // Make sure the programmer specified correct number of fields.
3364 if kind_name == "union" {
3365 if ast_fields.len() != 1 {
3366 tcx.sess.span_err(span, "union expressions should have exactly one field");
3368 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3369 let len = remaining_fields.len();
3371 let mut displayable_field_names = remaining_fields
3373 .map(|ident| ident.name.as_str())
3374 .collect::<Vec<_>>();
3376 displayable_field_names.sort();
3378 let truncated_fields_error = if len <= 3 {
3381 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3384 let remaining_fields_names = displayable_field_names.iter().take(3)
3385 .map(|n| format!("`{}`", n))
3386 .collect::<Vec<_>>()
3389 struct_span_err!(tcx.sess, span, E0063,
3390 "missing field{} {}{} in initializer of `{}`",
3391 if remaining_fields.len() == 1 { "" } else { "s" },
3392 remaining_fields_names,
3393 truncated_fields_error,
3395 .span_label(span, format!("missing {}{}",
3396 remaining_fields_names,
3397 truncated_fields_error))
3402 fn check_struct_fields_on_error(&self,
3403 fields: &'gcx [hir::Field],
3404 base_expr: &'gcx Option<P<hir::Expr>>) {
3405 for field in fields {
3406 self.check_expr(&field.expr);
3410 self.check_expr(&base);
3416 pub fn check_struct_path(&self,
3418 node_id: ast::NodeId)
3419 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3420 let path_span = match *qpath {
3421 hir::QPath::Resolved(_, ref path) => path.span,
3422 hir::QPath::TypeRelative(ref qself, _) => qself.span
3424 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3425 let variant = match def {
3427 self.set_tainted_by_errors();
3430 Def::Variant(..) => {
3432 ty::TyAdt(adt, substs) => {
3433 Some((adt.variant_of_def(def), adt.did, substs))
3435 _ => bug!("unexpected type: {:?}", ty.sty)
3438 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3439 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3441 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3442 Some((adt.non_enum_variant(), adt.did, substs))
3447 _ => bug!("unexpected definition: {:?}", def)
3450 if let Some((variant, did, substs)) = variant {
3451 // Check bounds on type arguments used in the path.
3452 let bounds = self.instantiate_bounds(path_span, did, substs);
3453 let cause = traits::ObligationCause::new(path_span, self.body_id,
3454 traits::ItemObligation(did));
3455 self.add_obligations_for_parameters(cause, &bounds);
3459 struct_span_err!(self.tcx.sess, path_span, E0071,
3460 "expected struct, variant or union type, found {}",
3461 ty.sort_string(self.tcx))
3462 .span_label(path_span, "not a struct")
3468 fn check_expr_struct(&self,
3470 expected: Expectation<'tcx>,
3472 fields: &'gcx [hir::Field],
3473 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3475 // Find the relevant variant
3476 let (variant, struct_ty) =
3477 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3480 self.check_struct_fields_on_error(fields, base_expr);
3481 return self.tcx.types.err;
3484 let path_span = match *qpath {
3485 hir::QPath::Resolved(_, ref path) => path.span,
3486 hir::QPath::TypeRelative(ref qself, _) => qself.span
3489 // Prohibit struct expressions when non exhaustive flag is set.
3490 if let ty::TyAdt(adt, _) = struct_ty.sty {
3491 if !adt.did.is_local() && adt.is_non_exhaustive() {
3492 span_err!(self.tcx.sess, expr.span, E0639,
3493 "cannot create non-exhaustive {} using struct expression",
3494 adt.variant_descr());
3498 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3499 base_expr.is_none());
3500 if let &Some(ref base_expr) = base_expr {
3501 self.check_expr_has_type_or_error(base_expr, struct_ty);
3502 match struct_ty.sty {
3503 ty::TyAdt(adt, substs) if adt.is_struct() => {
3504 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3505 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3510 .fru_field_types_mut()
3511 .insert(expr.hir_id, fru_field_types);
3514 span_err!(self.tcx.sess, base_expr.span, E0436,
3515 "functional record update syntax requires a struct");
3519 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3525 /// If an expression has any sub-expressions that result in a type error,
3526 /// inspecting that expression's type with `ty.references_error()` will return
3527 /// true. Likewise, if an expression is known to diverge, inspecting its
3528 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3529 /// strict, _|_ can appear in the type of an expression that does not,
3530 /// itself, diverge: for example, fn() -> _|_.)
3531 /// Note that inspecting a type's structure *directly* may expose the fact
3532 /// that there are actually multiple representations for `TyError`, so avoid
3533 /// that when err needs to be handled differently.
3534 fn check_expr_with_expectation_and_needs(&self,
3535 expr: &'gcx hir::Expr,
3536 expected: Expectation<'tcx>,
3537 needs: Needs) -> Ty<'tcx> {
3538 debug!(">> typechecking: expr={:?} expected={:?}",
3541 // Warn for expressions after diverging siblings.
3542 self.warn_if_unreachable(expr.id, expr.span, "expression");
3544 // Hide the outer diverging and has_errors flags.
3545 let old_diverges = self.diverges.get();
3546 let old_has_errors = self.has_errors.get();
3547 self.diverges.set(Diverges::Maybe);
3548 self.has_errors.set(false);
3550 let ty = self.check_expr_kind(expr, expected, needs);
3552 // Warn for non-block expressions with diverging children.
3555 hir::ExprLoop(..) | hir::ExprWhile(..) |
3556 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3558 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3561 // Any expression that produces a value of type `!` must have diverged
3563 self.diverges.set(self.diverges.get() | Diverges::Always);
3566 // Record the type, which applies it effects.
3567 // We need to do this after the warning above, so that
3568 // we don't warn for the diverging expression itself.
3569 self.write_ty(expr.hir_id, ty);
3571 // Combine the diverging and has_error flags.
3572 self.diverges.set(self.diverges.get() | old_diverges);
3573 self.has_errors.set(self.has_errors.get() | old_has_errors);
3575 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3576 debug!("... {:?}, expected is {:?}", ty, expected);
3581 fn check_expr_kind(&self,
3582 expr: &'gcx hir::Expr,
3583 expected: Expectation<'tcx>,
3584 needs: Needs) -> Ty<'tcx> {
3588 hir::ExprBox(ref subexpr) => {
3589 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3591 ty::TyAdt(def, _) if def.is_box()
3592 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3596 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3597 tcx.mk_box(referent_ty)
3600 hir::ExprLit(ref lit) => {
3601 self.check_lit(&lit, expected)
3603 hir::ExprBinary(op, ref lhs, ref rhs) => {
3604 self.check_binop(expr, op, lhs, rhs)
3606 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3607 self.check_binop_assign(expr, op, lhs, rhs)
3609 hir::ExprUnary(unop, ref oprnd) => {
3610 let expected_inner = match unop {
3611 hir::UnNot | hir::UnNeg => {
3618 let needs = match unop {
3619 hir::UnDeref => needs,
3622 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3626 if !oprnd_t.references_error() {
3627 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3630 if let Some(mt) = oprnd_t.builtin_deref(true) {
3632 } else if let Some(ok) = self.try_overloaded_deref(
3633 expr.span, oprnd_t, needs) {
3634 let method = self.register_infer_ok_obligations(ok);
3635 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3636 let mutbl = match mt.mutbl {
3637 hir::MutImmutable => AutoBorrowMutability::Immutable,
3638 hir::MutMutable => AutoBorrowMutability::Mutable {
3639 // (It shouldn't actually matter for unary ops whether
3640 // we enable two-phase borrows or not, since a unary
3641 // op has no additional operands.)
3642 allow_two_phase_borrow: false,
3645 self.apply_adjustments(oprnd, vec![Adjustment {
3646 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3647 target: method.sig.inputs()[0]
3650 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3651 self.write_method_call(expr.hir_id, method);
3653 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3654 "type `{}` cannot be dereferenced",
3656 oprnd_t = tcx.types.err;
3660 let result = self.check_user_unop(expr, oprnd_t, unop);
3661 // If it's builtin, we can reuse the type, this helps inference.
3662 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3667 let result = self.check_user_unop(expr, oprnd_t, unop);
3668 // If it's builtin, we can reuse the type, this helps inference.
3669 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3677 hir::ExprAddrOf(mutbl, ref oprnd) => {
3678 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3680 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3681 if self.is_place_expr(&oprnd) {
3682 // Places may legitimately have unsized types.
3683 // For example, dereferences of a fat pointer and
3684 // the last field of a struct can be unsized.
3685 ExpectHasType(mt.ty)
3687 Expectation::rvalue_hint(self, mt.ty)
3693 let needs = Needs::maybe_mut_place(mutbl);
3694 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3696 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3697 if tm.ty.references_error() {
3700 // Note: at this point, we cannot say what the best lifetime
3701 // is to use for resulting pointer. We want to use the
3702 // shortest lifetime possible so as to avoid spurious borrowck
3703 // errors. Moreover, the longest lifetime will depend on the
3704 // precise details of the value whose address is being taken
3705 // (and how long it is valid), which we don't know yet until type
3706 // inference is complete.
3708 // Therefore, here we simply generate a region variable. The
3709 // region inferencer will then select the ultimate value.
3710 // Finally, borrowck is charged with guaranteeing that the
3711 // value whose address was taken can actually be made to live
3712 // as long as it needs to live.
3713 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3714 tcx.mk_ref(region, tm)
3717 hir::ExprPath(ref qpath) => {
3718 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3719 expr.id, expr.span);
3720 let ty = if def != Def::Err {
3721 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3723 self.set_tainted_by_errors();
3727 // We always require that the type provided as the value for
3728 // a type parameter outlives the moment of instantiation.
3729 let substs = self.tables.borrow().node_substs(expr.hir_id);
3730 self.add_wf_bounds(substs, expr);
3734 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3735 for output in outputs {
3736 self.check_expr(output);
3738 for input in inputs {
3739 self.check_expr(input);
3743 hir::ExprBreak(destination, ref expr_opt) => {
3744 if let Some(target_id) = destination.target_id.opt_id() {
3745 let (e_ty, e_diverges, cause);
3746 if let Some(ref e) = *expr_opt {
3747 // If this is a break with a value, we need to type-check
3748 // the expression. Get an expected type from the loop context.
3749 let opt_coerce_to = {
3750 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3751 enclosing_breakables.find_breakable(target_id)
3754 .map(|coerce| coerce.expected_ty())
3757 // If the loop context is not a `loop { }`, then break with
3758 // a value is illegal, and `opt_coerce_to` will be `None`.
3759 // Just set expectation to error in that case.
3760 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3762 // Recurse without `enclosing_breakables` borrowed.
3763 e_ty = self.check_expr_with_hint(e, coerce_to);
3764 e_diverges = self.diverges.get();
3765 cause = self.misc(e.span);
3767 // Otherwise, this is a break *without* a value. That's
3768 // always legal, and is equivalent to `break ()`.
3769 e_ty = tcx.mk_nil();
3770 e_diverges = Diverges::Maybe;
3771 cause = self.misc(expr.span);
3774 // Now that we have type-checked `expr_opt`, borrow
3775 // the `enclosing_loops` field and let's coerce the
3776 // type of `expr_opt` into what is expected.
3777 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3778 let ctxt = enclosing_breakables.find_breakable(target_id);
3779 if let Some(ref mut coerce) = ctxt.coerce {
3780 if let Some(ref e) = *expr_opt {
3781 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3783 assert!(e_ty.is_nil());
3784 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3787 // If `ctxt.coerce` is `None`, we can just ignore
3788 // the type of the expresison. This is because
3789 // either this was a break *without* a value, in
3790 // which case it is always a legal type (`()`), or
3791 // else an error would have been flagged by the
3792 // `loops` pass for using break with an expression
3793 // where you are not supposed to.
3794 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3797 ctxt.may_break = true;
3799 // Otherwise, we failed to find the enclosing loop;
3800 // this can only happen if the `break` was not
3801 // inside a loop at all, which is caught by the
3802 // loop-checking pass.
3803 assert!(self.tcx.sess.err_count() > 0);
3805 // We still need to assign a type to the inner expression to
3806 // prevent the ICE in #43162.
3807 if let Some(ref e) = *expr_opt {
3808 self.check_expr_with_hint(e, tcx.types.err);
3810 // ... except when we try to 'break rust;'.
3811 // ICE this expression in particular (see #43162).
3812 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3813 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3814 fatally_break_rust(self.tcx.sess);
3820 // the type of a `break` is always `!`, since it diverges
3823 hir::ExprAgain(_) => { tcx.types.never }
3824 hir::ExprRet(ref expr_opt) => {
3825 if self.ret_coercion.is_none() {
3826 struct_span_err!(self.tcx.sess, expr.span, E0572,
3827 "return statement outside of function body").emit();
3828 } else if let Some(ref e) = *expr_opt {
3829 self.check_return_expr(e);
3831 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3832 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3833 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3837 hir::ExprAssign(ref lhs, ref rhs) => {
3838 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3840 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3843 ExpectIfCondition => {
3844 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3845 expected error elsehwere");
3848 // Only check this if not in an `if` condition, as the
3849 // mistyped comparison help is more appropriate.
3850 if !self.is_place_expr(&lhs) {
3851 struct_span_err!(self.tcx.sess, expr.span, E0070,
3852 "invalid left-hand side expression")
3853 .span_label(expr.span, "left-hand of expression not valid")
3859 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3861 if lhs_ty.references_error() || rhs_ty.references_error() {
3867 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3868 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3869 expr.span, expected)
3871 hir::ExprWhile(ref cond, ref body, _) => {
3872 let ctxt = BreakableCtxt {
3873 // cannot use break with a value from a while loop
3878 self.with_breakable_ctxt(expr.id, ctxt, || {
3879 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3880 let cond_diverging = self.diverges.get();
3881 self.check_block_no_value(&body);
3883 // We may never reach the body so it diverging means nothing.
3884 self.diverges.set(cond_diverging);
3889 hir::ExprLoop(ref body, _, source) => {
3890 let coerce = match source {
3891 // you can only use break with a value from a normal `loop { }`
3892 hir::LoopSource::Loop => {
3893 let coerce_to = expected.coercion_target_type(self, body.span);
3894 Some(CoerceMany::new(coerce_to))
3897 hir::LoopSource::WhileLet |
3898 hir::LoopSource::ForLoop => {
3903 let ctxt = BreakableCtxt {
3905 may_break: false, // will get updated if/when we find a `break`
3908 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3909 self.check_block_no_value(&body);
3913 // No way to know whether it's diverging because
3914 // of a `break` or an outer `break` or `return.
3915 self.diverges.set(Diverges::Maybe);
3918 // If we permit break with a value, then result type is
3919 // the LUB of the breaks (possibly ! if none); else, it
3920 // is nil. This makes sense because infinite loops
3921 // (which would have type !) are only possible iff we
3922 // permit break with a value [1].
3923 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3924 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3926 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3927 self.check_match(expr, &discrim, arms, expected, match_src)
3929 hir::ExprClosure(capture, ref decl, body_id, _, gen) => {
3930 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
3932 hir::ExprBlock(ref body) => {
3933 self.check_block_with_expected(&body, expected)
3935 hir::ExprCall(ref callee, ref args) => {
3936 self.check_call(expr, &callee, args, expected)
3938 hir::ExprMethodCall(ref segment, span, ref args) => {
3939 self.check_method_call(expr, segment, span, args, expected, needs)
3941 hir::ExprCast(ref e, ref t) => {
3942 // Find the type of `e`. Supply hints based on the type we are casting to,
3944 let t_cast = self.to_ty(t);
3945 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3946 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3947 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3948 let diverges = self.diverges.get();
3950 // Eagerly check for some obvious errors.
3951 if t_expr.references_error() || t_cast.references_error() {
3954 // Defer other checks until we're done type checking.
3955 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3956 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3958 deferred_cast_checks.push(cast_check);
3961 Err(ErrorReported) => {
3967 hir::ExprType(ref e, ref t) => {
3968 let typ = self.to_ty(&t);
3969 self.check_expr_eq_type(&e, typ);
3972 hir::ExprArray(ref args) => {
3973 let uty = expected.to_option(self).and_then(|uty| {
3975 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3980 let element_ty = if !args.is_empty() {
3981 let coerce_to = uty.unwrap_or_else(
3982 || self.next_ty_var(ty::UniverseIndex::ROOT,
3983 TypeVariableOrigin::TypeInference(expr.span)));
3984 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3985 assert_eq!(self.diverges.get(), Diverges::Maybe);
3987 let e_ty = self.check_expr_with_hint(e, coerce_to);
3988 let cause = self.misc(e.span);
3989 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3991 coerce.complete(self)
3993 self.next_ty_var(ty::UniverseIndex::ROOT,
3994 TypeVariableOrigin::TypeInference(expr.span))
3996 tcx.mk_array(element_ty, args.len() as u64)
3998 hir::ExprRepeat(ref element, count) => {
3999 let count_def_id = tcx.hir.body_owner_def_id(count);
4000 let param_env = ty::ParamEnv::empty(traits::Reveal::UserFacing);
4001 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4002 let count = tcx.const_eval(param_env.and((count_def_id, substs)));
4004 if let Err(ref err) = count {
4005 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
4008 let uty = match expected {
4009 ExpectHasType(uty) => {
4011 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4018 let (element_ty, t) = match uty {
4020 self.check_expr_coercable_to_type(&element, uty);
4024 let t: Ty = self.next_ty_var(ty::UniverseIndex::ROOT,
4025 TypeVariableOrigin::MiscVariable(element.span));
4026 let element_ty = self.check_expr_has_type_or_error(&element, t);
4031 if let Ok(count) = count {
4032 let zero_or_one = count.val.to_const_int().and_then(|count| {
4033 count.to_u64().map(|count| count <= 1)
4034 }).unwrap_or(false);
4036 // For [foo, ..n] where n > 1, `foo` must have
4038 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4039 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4043 if element_ty.references_error() {
4045 } else if let Ok(count) = count {
4046 tcx.mk_ty(ty::TyArray(t, count))
4051 hir::ExprTup(ref elts) => {
4052 let flds = expected.only_has_type(self).and_then(|ty| {
4053 let ty = self.resolve_type_vars_with_obligations(ty);
4055 ty::TyTuple(ref flds, _) => Some(&flds[..]),
4060 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4061 let t = match flds {
4062 Some(ref fs) if i < fs.len() => {
4064 self.check_expr_coercable_to_type(&e, ety);
4068 self.check_expr_with_expectation(&e, NoExpectation)
4073 let tuple = tcx.mk_tup(elt_ts_iter, false);
4074 if tuple.references_error() {
4077 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4081 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4082 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4084 hir::ExprField(ref base, ref field) => {
4085 self.check_field(expr, needs, &base, field)
4087 hir::ExprTupField(ref base, idx) => {
4088 self.check_tup_field(expr, needs, &base, idx)
4090 hir::ExprIndex(ref base, ref idx) => {
4091 let base_t = self.check_expr_with_needs(&base, needs);
4092 let idx_t = self.check_expr(&idx);
4094 if base_t.references_error() {
4096 } else if idx_t.references_error() {
4099 let base_t = self.structurally_resolved_type(expr.span, base_t);
4100 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4101 Some((index_ty, element_ty)) => {
4102 self.demand_coerce(idx, idx_t, index_ty);
4106 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4107 "cannot index into a value of type `{}`",
4109 // Try to give some advice about indexing tuples.
4110 if let ty::TyTuple(..) = base_t.sty {
4111 let mut needs_note = true;
4112 // If the index is an integer, we can show the actual
4113 // fixed expression:
4114 if let hir::ExprLit(ref lit) = idx.node {
4115 if let ast::LitKind::Int(i,
4116 ast::LitIntType::Unsuffixed) = lit.node {
4117 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4118 if let Ok(snip) = snip {
4119 err.span_suggestion(expr.span,
4120 "to access tuple elements, use",
4121 format!("{}.{}", snip, i));
4127 err.help("to access tuple elements, use tuple indexing \
4128 syntax (e.g. `tuple.0`)");
4137 hir::ExprYield(ref value) => {
4138 match self.yield_ty {
4140 self.check_expr_coercable_to_type(&value, ty);
4143 struct_span_err!(self.tcx.sess, expr.span, E0627,
4144 "yield statement outside of generator literal").emit();
4152 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4153 // The newly resolved definition is written into `type_dependent_defs`.
4154 fn finish_resolving_struct_path(&self,
4157 node_id: ast::NodeId)
4161 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4162 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4163 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4166 hir::QPath::TypeRelative(ref qself, ref segment) => {
4167 let ty = self.to_ty(qself);
4169 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4174 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4177 // Write back the new resolution.
4178 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4179 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4186 // Resolve associated value path into a base type and associated constant or method definition.
4187 // The newly resolved definition is written into `type_dependent_defs`.
4188 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4189 qpath: &'b hir::QPath,
4190 node_id: ast::NodeId,
4192 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4194 let (ty, item_segment) = match *qpath {
4195 hir::QPath::Resolved(ref opt_qself, ref path) => {
4197 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4198 &path.segments[..]);
4200 hir::QPath::TypeRelative(ref qself, ref segment) => {
4201 (self.to_ty(qself), segment)
4204 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4205 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4206 // Return directly on cache hit. This is useful to avoid doubly reporting
4207 // errors with default match binding modes. See #44614.
4208 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4210 let item_name = item_segment.name;
4211 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4214 let def = match error {
4215 method::MethodError::PrivateMatch(def, _) => def,
4218 if item_name != keywords::Invalid.name() {
4219 self.report_method_error(span, ty, item_name, None, error, None);
4225 // Write back the new resolution.
4226 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4227 (def, Some(ty), slice::from_ref(&**item_segment))
4230 pub fn check_decl_initializer(&self,
4231 local: &'gcx hir::Local,
4232 init: &'gcx hir::Expr) -> Ty<'tcx>
4234 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4235 // for #42640 (default match binding modes).
4238 let ref_bindings = local.pat.contains_explicit_ref_binding();
4240 let local_ty = self.local_ty(init.span, local.id);
4241 if let Some(m) = ref_bindings {
4242 // Somewhat subtle: if we have a `ref` binding in the pattern,
4243 // we want to avoid introducing coercions for the RHS. This is
4244 // both because it helps preserve sanity and, in the case of
4245 // ref mut, for soundness (issue #23116). In particular, in
4246 // the latter case, we need to be clear that the type of the
4247 // referent for the reference that results is *equal to* the
4248 // type of the place it is referencing, and not some
4249 // supertype thereof.
4250 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4251 self.demand_eqtype(init.span, local_ty, init_ty);
4254 self.check_expr_coercable_to_type(init, local_ty)
4258 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4259 let t = self.local_ty(local.span, local.id);
4260 self.write_ty(local.hir_id, t);
4262 if let Some(ref init) = local.init {
4263 let init_ty = self.check_decl_initializer(local, &init);
4264 if init_ty.references_error() {
4265 self.write_ty(local.hir_id, init_ty);
4269 self.check_pat_walk(&local.pat, t,
4270 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4272 let pat_ty = self.node_ty(local.pat.hir_id);
4273 if pat_ty.references_error() {
4274 self.write_ty(local.hir_id, pat_ty);
4278 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4279 // Don't do all the complex logic below for DeclItem.
4281 hir::StmtDecl(ref decl, _) => {
4283 hir::DeclLocal(_) => {}
4284 hir::DeclItem(_) => {
4289 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4292 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4294 // Hide the outer diverging and has_errors flags.
4295 let old_diverges = self.diverges.get();
4296 let old_has_errors = self.has_errors.get();
4297 self.diverges.set(Diverges::Maybe);
4298 self.has_errors.set(false);
4301 hir::StmtDecl(ref decl, _) => {
4303 hir::DeclLocal(ref l) => {
4304 self.check_decl_local(&l);
4306 hir::DeclItem(_) => {/* ignore for now */}
4309 hir::StmtExpr(ref expr, _) => {
4310 // Check with expected type of ()
4311 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4313 hir::StmtSemi(ref expr, _) => {
4314 self.check_expr(&expr);
4318 // Combine the diverging and has_error flags.
4319 self.diverges.set(self.diverges.get() | old_diverges);
4320 self.has_errors.set(self.has_errors.get() | old_has_errors);
4323 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4324 let unit = self.tcx.mk_nil();
4325 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4327 // if the block produces a `!` value, that can always be
4328 // (effectively) coerced to unit.
4330 self.demand_suptype(blk.span, unit, ty);
4334 fn check_block_with_expected(&self,
4335 blk: &'gcx hir::Block,
4336 expected: Expectation<'tcx>) -> Ty<'tcx> {
4338 let mut fcx_ps = self.ps.borrow_mut();
4339 let unsafety_state = fcx_ps.recurse(blk);
4340 replace(&mut *fcx_ps, unsafety_state)
4343 // In some cases, blocks have just one exit, but other blocks
4344 // can be targeted by multiple breaks. This cannot happen in
4345 // normal Rust syntax today, but it can happen when we desugar
4346 // a `do catch { ... }` expression.
4350 // 'a: { if true { break 'a Err(()); } Ok(()) }
4352 // Here we would wind up with two coercions, one from
4353 // `Err(())` and the other from the tail expression
4354 // `Ok(())`. If the tail expression is omitted, that's a
4355 // "forced unit" -- unless the block diverges, in which
4356 // case we can ignore the tail expression (e.g., `'a: {
4357 // break 'a 22; }` would not force the type of the block
4359 let tail_expr = blk.expr.as_ref();
4360 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4361 let coerce = if blk.targeted_by_break {
4362 CoerceMany::new(coerce_to_ty)
4364 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4365 Some(e) => slice::from_ref(e),
4368 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4371 let prev_diverges = self.diverges.get();
4372 let ctxt = BreakableCtxt {
4373 coerce: Some(coerce),
4377 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4378 for s in &blk.stmts {
4382 // check the tail expression **without** holding the
4383 // `enclosing_breakables` lock below.
4384 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4386 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4387 let ctxt = enclosing_breakables.find_breakable(blk.id);
4388 let coerce = ctxt.coerce.as_mut().unwrap();
4389 if let Some(tail_expr_ty) = tail_expr_ty {
4390 let tail_expr = tail_expr.unwrap();
4391 let cause = self.cause(tail_expr.span,
4392 ObligationCauseCode::BlockTailExpression(blk.id));
4397 self.diverges.get());
4399 // Subtle: if there is no explicit tail expression,
4400 // that is typically equivalent to a tail expression
4401 // of `()` -- except if the block diverges. In that
4402 // case, there is no value supplied from the tail
4403 // expression (assuming there are no other breaks,
4404 // this implies that the type of the block will be
4407 // #41425 -- label the implicit `()` as being the
4408 // "found type" here, rather than the "expected type".
4410 // #44579 -- if the block was recovered during parsing,
4411 // the type would be nonsensical and it is not worth it
4412 // to perform the type check, so we avoid generating the
4413 // diagnostic output.
4414 if !self.diverges.get().always() && !blk.recovered {
4415 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4416 if let Some(expected_ty) = expected.only_has_type(self) {
4417 self.consider_hint_about_removing_semicolon(blk,
4427 // If we can break from the block, then the block's exit is always reachable
4428 // (... as long as the entry is reachable) - regardless of the tail of the block.
4429 self.diverges.set(prev_diverges);
4432 let mut ty = ctxt.coerce.unwrap().complete(self);
4434 if self.has_errors.get() || ty.references_error() {
4435 ty = self.tcx.types.err
4438 self.write_ty(blk.hir_id, ty);
4440 *self.ps.borrow_mut() = prev;
4444 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4445 /// suggestion can be made, `None` otherwise.
4446 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4447 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4448 // `while` before reaching it, as block tail returns are not available in them.
4449 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4450 let parent = self.tcx.hir.get(fn_id);
4452 if let Node::NodeItem(&hir::Item {
4453 name, node: hir::ItemFn(ref decl, ..), ..
4455 decl.clone().and_then(|decl| {
4456 // This is less than ideal, it will not suggest a return type span on any
4457 // method called `main`, regardless of whether it is actually the entry point,
4458 // but it will still present it as the reason for the expected type.
4459 Some((decl, name != Symbol::intern("main")))
4461 } else if let Node::NodeTraitItem(&hir::TraitItem {
4462 node: hir::TraitItemKind::Method(hir::MethodSig {
4466 decl.clone().and_then(|decl| {
4469 } else if let Node::NodeImplItem(&hir::ImplItem {
4470 node: hir::ImplItemKind::Method(hir::MethodSig {
4474 decl.clone().and_then(|decl| {
4485 /// On implicit return expressions with mismatched types, provide the following suggestions:
4487 /// - Point out the method's return type as the reason for the expected type
4488 /// - Possible missing semicolon
4489 /// - Possible missing return type if the return type is the default, and not `fn main()`
4490 pub fn suggest_mismatched_types_on_tail(&self,
4491 err: &mut DiagnosticBuilder<'tcx>,
4492 expression: &'gcx hir::Expr,
4496 blk_id: ast::NodeId) {
4497 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4499 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4500 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4504 /// A common error is to forget to add a semicolon at the end of a block:
4508 /// bar_that_returns_u32()
4512 /// This routine checks if the return expression in a block would make sense on its own as a
4513 /// statement and the return type has been left as default or has been specified as `()`. If so,
4514 /// it suggests adding a semicolon.
4515 fn suggest_missing_semicolon(&self,
4516 err: &mut DiagnosticBuilder<'tcx>,
4517 expression: &'gcx hir::Expr,
4520 if expected.is_nil() {
4521 // `BlockTailExpression` only relevant if the tail expr would be
4522 // useful on its own.
4523 match expression.node {
4525 hir::ExprMethodCall(..) |
4527 hir::ExprWhile(..) |
4529 hir::ExprMatch(..) |
4530 hir::ExprBlock(..) => {
4531 let sp = self.tcx.sess.codemap().next_point(cause_span);
4532 err.span_suggestion(sp,
4533 "try adding a semicolon",
4542 /// A possible error is to forget to add a return type that is needed:
4546 /// bar_that_returns_u32()
4550 /// This routine checks if the return type is left as default, the method is not part of an
4551 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4553 fn suggest_missing_return_type(&self,
4554 err: &mut DiagnosticBuilder<'tcx>,
4555 fn_decl: &hir::FnDecl,
4558 can_suggest: bool) {
4559 // Only suggest changing the return type for methods that
4560 // haven't set a return type at all (and aren't `fn main()` or an impl).
4561 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4562 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4563 err.span_suggestion(span,
4564 "try adding a return type",
4566 self.resolve_type_vars_with_obligations(found)));
4568 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4569 err.span_label(span, "possibly return type missing here?");
4571 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4572 // `fn main()` must return `()`, do not suggest changing return type
4573 err.span_label(span, "expected `()` because of default return type");
4575 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4576 // Only point to return type if the expected type is the return type, as if they
4577 // are not, the expectation must have been caused by something else.
4578 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4580 let ty = AstConv::ast_ty_to_ty(self, ty);
4581 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4582 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4583 if ty.sty == expected.sty {
4584 err.span_label(sp, format!("expected `{}` because of return type",
4592 /// A common error is to add an extra semicolon:
4595 /// fn foo() -> usize {
4600 /// This routine checks if the final statement in a block is an
4601 /// expression with an explicit semicolon whose type is compatible
4602 /// with `expected_ty`. If so, it suggests removing the semicolon.
4603 fn consider_hint_about_removing_semicolon(&self,
4604 blk: &'gcx hir::Block,
4605 expected_ty: Ty<'tcx>,
4606 err: &mut DiagnosticBuilder) {
4607 // Be helpful when the user wrote `{... expr;}` and
4608 // taking the `;` off is enough to fix the error.
4609 let last_stmt = match blk.stmts.last() {
4613 let last_expr = match last_stmt.node {
4614 hir::StmtSemi(ref e, _) => e,
4617 let last_expr_ty = self.node_ty(last_expr.hir_id);
4618 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4621 let original_span = original_sp(last_stmt.span, blk.span);
4622 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4623 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4626 // Instantiates the given path, which must refer to an item with the given
4627 // number of type parameters and type.
4628 pub fn instantiate_value_path(&self,
4629 segments: &[hir::PathSegment],
4630 opt_self_ty: Option<Ty<'tcx>>,
4633 node_id: ast::NodeId)
4635 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4640 // We need to extract the type parameters supplied by the user in
4641 // the path `path`. Due to the current setup, this is a bit of a
4642 // tricky-process; the problem is that resolve only tells us the
4643 // end-point of the path resolution, and not the intermediate steps.
4644 // Luckily, we can (at least for now) deduce the intermediate steps
4645 // just from the end-point.
4647 // There are basically four cases to consider:
4649 // 1. Reference to a constructor of enum variant or struct:
4651 // struct Foo<T>(...)
4652 // enum E<T> { Foo(...) }
4654 // In these cases, the parameters are declared in the type
4657 // 2. Reference to a fn item or a free constant:
4661 // In this case, the path will again always have the form
4662 // `a::b::foo::<T>` where only the final segment should have
4663 // type parameters. However, in this case, those parameters are
4664 // declared on a value, and hence are in the `FnSpace`.
4666 // 3. Reference to a method or an associated constant:
4668 // impl<A> SomeStruct<A> {
4672 // Here we can have a path like
4673 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4674 // may appear in two places. The penultimate segment,
4675 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4676 // final segment, `foo::<B>` contains parameters in fn space.
4678 // 4. Reference to a local variable
4680 // Local variables can't have any type parameters.
4682 // The first step then is to categorize the segments appropriately.
4684 assert!(!segments.is_empty());
4686 let mut ufcs_associated = None;
4687 let mut type_segment = None;
4688 let mut fn_segment = None;
4690 // Case 1. Reference to a struct/variant constructor.
4691 Def::StructCtor(def_id, ..) |
4692 Def::VariantCtor(def_id, ..) => {
4693 // Everything but the final segment should have no
4694 // parameters at all.
4695 let mut generics = self.tcx.generics_of(def_id);
4696 if let Some(def_id) = generics.parent {
4697 // Variant and struct constructors use the
4698 // generics of their parent type definition.
4699 generics = self.tcx.generics_of(def_id);
4701 type_segment = Some((segments.last().unwrap(), generics));
4704 // Case 2. Reference to a top-level value.
4706 Def::Const(def_id) |
4707 Def::Static(def_id, _) => {
4708 fn_segment = Some((segments.last().unwrap(),
4709 self.tcx.generics_of(def_id)));
4712 // Case 3. Reference to a method or associated const.
4713 Def::Method(def_id) |
4714 Def::AssociatedConst(def_id) => {
4715 let container = self.tcx.associated_item(def_id).container;
4717 ty::TraitContainer(trait_did) => {
4718 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4720 ty::ImplContainer(_) => {}
4723 let generics = self.tcx.generics_of(def_id);
4724 if segments.len() >= 2 {
4725 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4726 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4728 // `<T>::assoc` will end up here, and so can `T::assoc`.
4729 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4730 ufcs_associated = Some((container, self_ty));
4732 fn_segment = Some((segments.last().unwrap(), generics));
4735 // Case 4. Local variable, no generics.
4736 Def::Local(..) | Def::Upvar(..) => {}
4738 _ => bug!("unexpected definition: {:?}", def),
4741 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4743 // Now that we have categorized what space the parameters for each
4744 // segment belong to, let's sort out the parameters that the user
4745 // provided (if any) into their appropriate spaces. We'll also report
4746 // errors if type parameters are provided in an inappropriate place.
4747 let poly_segments = type_segment.is_some() as usize +
4748 fn_segment.is_some() as usize;
4749 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4752 Def::Local(nid) | Def::Upvar(nid, ..) => {
4753 let ty = self.local_ty(span, nid);
4754 let ty = self.normalize_associated_types_in(span, &ty);
4755 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4761 // Now we have to compare the types that the user *actually*
4762 // provided against the types that were *expected*. If the user
4763 // did not provide any types, then we want to substitute inference
4764 // variables. If the user provided some types, we may still need
4765 // to add defaults. If the user provided *too many* types, that's
4767 self.check_path_parameter_count(span, &mut type_segment, false);
4768 self.check_path_parameter_count(span, &mut fn_segment, false);
4769 self.check_impl_trait(span, &mut fn_segment);
4771 let (fn_start, has_self) = match (type_segment, fn_segment) {
4772 (_, Some((_, generics))) => {
4773 (generics.parent_count(), generics.has_self)
4775 (Some((_, generics)), None) => {
4776 (generics.own_count(), generics.has_self)
4778 (None, None) => (0, false)
4780 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4781 let mut i = def.index as usize;
4783 let segment = if i < fn_start {
4784 i -= has_self as usize;
4790 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4791 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4794 if let Some(lifetime) = lifetimes.get(i) {
4795 AstConv::ast_region_to_region(self, lifetime, Some(def))
4797 self.re_infer(span, Some(def)).unwrap()
4800 let mut i = def.index as usize;
4802 let segment = if i < fn_start {
4803 // Handle Self first, so we can adjust the index to match the AST.
4804 if has_self && i == 0 {
4805 return opt_self_ty.unwrap_or_else(|| {
4806 self.type_var_for_def(ty::UniverseIndex::ROOT, span, def)
4809 i -= has_self as usize;
4815 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4816 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4819 // Skip over the lifetimes in the same segment.
4820 if let Some((_, generics)) = segment {
4821 i -= generics.regions.len();
4824 if let Some(ast_ty) = types.get(i) {
4825 // A provided type parameter.
4827 } else if !infer_types && def.has_default {
4828 // No type parameter provided, but a default exists.
4829 let default = self.tcx.type_of(def.def_id);
4832 default.subst_spanned(self.tcx, substs, Some(span))
4835 // No type parameters were provided, we can infer all.
4836 // This can also be reached in some error cases:
4837 // We prefer to use inference variables instead of
4838 // TyError to let type inference recover somewhat.
4839 self.type_var_for_def(ty::UniverseIndex::ROOT, span, def)
4843 // The things we are substituting into the type should not contain
4844 // escaping late-bound regions, and nor should the base type scheme.
4845 let ty = self.tcx.type_of(def.def_id());
4846 assert!(!substs.has_escaping_regions());
4847 assert!(!ty.has_escaping_regions());
4849 // Add all the obligations that are required, substituting and
4850 // normalized appropriately.
4851 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4852 self.add_obligations_for_parameters(
4853 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4856 // Substitute the values for the type parameters into the type of
4857 // the referenced item.
4858 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4860 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4861 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4862 // is inherent, there is no `Self` parameter, instead, the impl needs
4863 // type parameters, which we can infer by unifying the provided `Self`
4864 // with the substituted impl type.
4865 let ty = self.tcx.type_of(impl_def_id);
4867 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4868 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4869 Ok(ok) => self.register_infer_ok_obligations(ok),
4872 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4879 self.check_rustc_args_require_const(def.def_id(), node_id, span);
4881 debug!("instantiate_value_path: type of {:?} is {:?}",
4884 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4888 fn check_rustc_args_require_const(&self,
4890 node_id: ast::NodeId,
4892 // We're only interested in functions tagged with
4893 // #[rustc_args_required_const], so ignore anything that's not.
4894 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
4898 // If our calling expression is indeed the function itself, we're good!
4899 // If not, generate an error that this can only be called directly.
4900 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
4901 Node::NodeExpr(expr) => {
4903 hir::ExprCall(ref callee, ..) => {
4904 if callee.id == node_id {
4914 self.tcx.sess.span_err(span, "this function can only be invoked \
4915 directly, not through a function pointer");
4918 /// Report errors if the provided parameters are too few or too many.
4919 fn check_path_parameter_count(&self,
4921 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4922 is_method_call: bool) {
4923 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4924 (&[][..], &[][..], true, &[][..]),
4925 |(s, _)| s.parameters.as_ref().map_or(
4926 (&[][..], &[][..], s.infer_types, &[][..]),
4927 |p| (&p.lifetimes[..], &p.types[..],
4928 s.infer_types, &p.bindings[..])));
4929 let infer_lifetimes = lifetimes.len() == 0;
4931 let count_lifetime_params = |n| {
4932 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4934 let count_type_params = |n| {
4935 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4938 // Check provided type parameters.
4939 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4940 if generics.parent.is_none() {
4941 &generics.types[generics.has_self as usize..]
4946 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4947 if types.len() > type_defs.len() {
4948 let span = types[type_defs.len()].span;
4949 let expected_text = count_type_params(type_defs.len());
4950 let actual_text = count_type_params(types.len());
4951 struct_span_err!(self.tcx.sess, span, E0087,
4952 "too many type parameters provided: \
4953 expected at most {}, found {}",
4954 expected_text, actual_text)
4955 .span_label(span, format!("expected {}", expected_text))
4958 // To prevent derived errors to accumulate due to extra
4959 // type parameters, we force instantiate_value_path to
4960 // use inference variables instead of the provided types.
4962 } else if types.len() < required_len && !infer_types {
4963 let expected_text = count_type_params(required_len);
4964 let actual_text = count_type_params(types.len());
4965 struct_span_err!(self.tcx.sess, span, E0089,
4966 "too few type parameters provided: \
4967 expected {}, found {}",
4968 expected_text, actual_text)
4969 .span_label(span, format!("expected {}", expected_text))
4973 if !bindings.is_empty() {
4974 AstConv::prohibit_projection(self, bindings[0].span);
4977 // Check provided lifetime parameters.
4978 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4979 let required_len = lifetime_defs.len();
4981 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4982 let has_late_bound_lifetime_defs =
4983 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4984 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4985 // Report this as a lint only if no error was reported previously.
4986 let primary_msg = "cannot specify lifetime arguments explicitly \
4987 if late bound lifetime parameters are present";
4988 let note_msg = "the late bound lifetime parameter is introduced here";
4989 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4990 lifetimes.len() < required_len && !infer_lifetimes) {
4991 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4992 err.span_note(span_late, note_msg);
4996 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4997 multispan.push_span_label(span_late, note_msg.to_string());
4998 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4999 lifetimes[0].id, multispan, primary_msg);
5004 if lifetimes.len() > lifetime_defs.len() {
5005 let span = lifetimes[lifetime_defs.len()].span;
5006 let expected_text = count_lifetime_params(lifetime_defs.len());
5007 let actual_text = count_lifetime_params(lifetimes.len());
5008 struct_span_err!(self.tcx.sess, span, E0088,
5009 "too many lifetime parameters provided: \
5010 expected at most {}, found {}",
5011 expected_text, actual_text)
5012 .span_label(span, format!("expected {}", expected_text))
5014 } else if lifetimes.len() < required_len && !infer_lifetimes {
5015 let expected_text = count_lifetime_params(lifetime_defs.len());
5016 let actual_text = count_lifetime_params(lifetimes.len());
5017 struct_span_err!(self.tcx.sess, span, E0090,
5018 "too few lifetime parameters provided: \
5019 expected {}, found {}",
5020 expected_text, actual_text)
5021 .span_label(span, format!("expected {}", expected_text))
5026 /// Report error if there is an explicit type parameter when using `impl Trait`.
5027 fn check_impl_trait(&self,
5029 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
5030 use hir::SyntheticTyParamKind::*;
5032 segment.map(|(path_segment, generics)| {
5033 let explicit = !path_segment.infer_types;
5034 let impl_trait = generics.types.iter()
5036 match ty_param.synthetic {
5037 Some(ImplTrait) => true,
5042 if explicit && impl_trait {
5043 let mut err = struct_span_err! {
5047 "cannot provide explicit type parameters when `impl Trait` is \
5048 used in argument position."
5056 // Resolves `typ` by a single level if `typ` is a type variable.
5057 // If no resolution is possible, then an error is reported.
5058 // Numeric inference variables may be left unresolved.
5059 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5060 let ty = self.resolve_type_vars_with_obligations(ty);
5061 if !ty.is_ty_var() {
5064 if !self.is_tainted_by_errors() {
5065 self.need_type_info((**self).body_id, sp, ty);
5067 self.demand_suptype(sp, self.tcx.types.err, ty);
5072 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5073 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5074 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5077 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5078 index = enclosing_breakables.stack.len();
5079 enclosing_breakables.by_id.insert(id, index);
5080 enclosing_breakables.stack.push(ctxt);
5084 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5085 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5086 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5087 enclosing_breakables.stack.pop().expect("missing breakable context")
5093 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5094 generics: &hir::Generics,
5096 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5097 generics.ty_params().count(), ty);
5099 // make a vector of booleans initially false, set to true when used
5100 if generics.ty_params().next().is_none() { return; }
5101 let mut tps_used = vec![false; generics.ty_params().count()];
5103 let lifetime_count = generics.lifetimes().count();
5105 for leaf_ty in ty.walk() {
5106 if let ty::TyParam(ty::ParamTy {idx, ..}) = leaf_ty.sty {
5107 debug!("Found use of ty param num {}", idx);
5108 tps_used[idx as usize - lifetime_count] = true;
5109 } else if let ty::TyError = leaf_ty.sty {
5110 // If there already another error, do not emit an error for not using a type Parameter
5111 assert!(tcx.sess.err_count() > 0);
5116 for (&used, param) in tps_used.iter().zip(generics.ty_params()) {
5118 struct_span_err!(tcx.sess, param.span, E0091,
5119 "type parameter `{}` is unused",
5121 .span_label(param.span, "unused type parameter")
5127 fn fatally_break_rust(sess: &Session) {
5128 let handler = sess.diagnostic();
5129 handler.span_bug_no_panic(
5131 "It looks like you're trying to break rust; would you like some ICE?",
5133 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5134 handler.note_without_error(
5135 "we would appreciate a joke overview: \
5136 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5138 handler.note_without_error(&format!("rustc {} running on {}",
5139 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5140 ::session::config::host_triple(),