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};
90 use rustc_back::slice::ref_slice;
91 use namespace::Namespace;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::type_variable::{TypeVariableOrigin};
94 use rustc::middle::region;
95 use rustc::ty::subst::{Kind, Subst, Substs};
96 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
97 use rustc::ty::{ParamTy, LvaluePreference, NoPreference, PreferMutLvalue};
98 use rustc::ty::{self, Ty, TyCtxt, Visibility};
99 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
100 use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
101 use rustc::ty::maps::Providers;
102 use rustc::ty::util::{Representability, IntTypeExt};
103 use errors::DiagnosticBuilder;
104 use require_c_abi_if_variadic;
105 use session::{CompileIncomplete, Session};
108 use util::common::{ErrorReported, indenter};
109 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
111 use std::cell::{Cell, RefCell, Ref, RefMut};
113 use std::collections::hash_map::Entry;
115 use std::fmt::Display;
116 use std::mem::replace;
117 use std::ops::{self, Deref};
118 use syntax::abi::Abi;
120 use syntax::codemap::{self, original_sp, Spanned};
121 use syntax::feature_gate::{GateIssue, emit_feature_err};
123 use syntax::symbol::{Symbol, InternedString, keywords};
124 use syntax::util::lev_distance::find_best_match_for_name;
125 use syntax_pos::{self, BytePos, Span, MultiSpan};
127 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
128 use rustc::hir::itemlikevisit::ItemLikeVisitor;
129 use rustc::hir::map::Node;
130 use rustc::hir::{self, PatKind};
131 use rustc::middle::lang_items;
132 use rustc_back::slice;
133 use rustc_const_math::ConstInt;
149 mod generator_interior;
153 /// A wrapper for InferCtxt's `in_progress_tables` field.
154 #[derive(Copy, Clone)]
155 struct MaybeInProgressTables<'a, 'tcx: 'a> {
156 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
159 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
160 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
161 match self.maybe_tables {
162 Some(tables) => tables.borrow(),
164 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
169 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
170 match self.maybe_tables {
171 Some(tables) => tables.borrow_mut(),
173 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
180 /// closures defined within the function. For example:
183 /// bar(move|| { ... })
186 /// Here, the function `foo()` and the closure passed to
187 /// `bar()` will each have their own `FnCtxt`, but they will
188 /// share the inherited fields.
189 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
190 infcx: InferCtxt<'a, 'gcx, 'tcx>,
192 tables: MaybeInProgressTables<'a, 'tcx>,
194 locals: RefCell<NodeMap<Ty<'tcx>>>,
196 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
198 // When we process a call like `c()` where `c` is a closure type,
199 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
200 // `FnOnce` closure. In that case, we defer full resolution of the
201 // call until upvar inference can kick in and make the
202 // decision. We keep these deferred resolutions grouped by the
203 // def-id of the closure, so that once we decide, we can easily go
204 // back and process them.
205 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
207 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
209 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
211 // Anonymized types found in explicit return types and their
212 // associated fresh inference variable. Writeback resolves these
213 // variables to get the concrete type, which can be used to
214 // deanonymize TyAnon, after typeck is done with all functions.
215 anon_types: RefCell<NodeMap<Ty<'tcx>>>,
217 /// Each type parameter has an implicit region bound that
218 /// indicates it must outlive at least the function body (the user
219 /// may specify stronger requirements). This field indicates the
220 /// region of the callee. If it is `None`, then the parameter
221 /// environment is for an item or something where the "callee" is
223 implicit_region_bound: Option<ty::Region<'tcx>>,
225 body_id: Option<hir::BodyId>,
228 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
229 type Target = InferCtxt<'a, 'gcx, 'tcx>;
230 fn deref(&self) -> &Self::Target {
235 /// When type-checking an expression, we propagate downward
236 /// whatever type hint we are able in the form of an `Expectation`.
237 #[derive(Copy, Clone, Debug)]
238 pub enum Expectation<'tcx> {
239 /// We know nothing about what type this expression should have.
242 /// This expression is an `if` condition, it must resolve to `bool`.
245 /// This expression should have the type given (or some subtype)
246 ExpectHasType(Ty<'tcx>),
248 /// This expression will be cast to the `Ty`
249 ExpectCastableToType(Ty<'tcx>),
251 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
252 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
253 ExpectRvalueLikeUnsized(Ty<'tcx>),
256 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
257 // Disregard "castable to" expectations because they
258 // can lead us astray. Consider for example `if cond
259 // {22} else {c} as u8` -- if we propagate the
260 // "castable to u8" constraint to 22, it will pick the
261 // type 22u8, which is overly constrained (c might not
262 // be a u8). In effect, the problem is that the
263 // "castable to" expectation is not the tightest thing
264 // we can say, so we want to drop it in this case.
265 // The tightest thing we can say is "must unify with
266 // else branch". Note that in the case of a "has type"
267 // constraint, this limitation does not hold.
269 // If the expected type is just a type variable, then don't use
270 // an expected type. Otherwise, we might write parts of the type
271 // when checking the 'then' block which are incompatible with the
273 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
275 ExpectHasType(ety) => {
276 let ety = fcx.shallow_resolve(ety);
277 if !ety.is_ty_var() {
283 ExpectRvalueLikeUnsized(ety) => {
284 ExpectRvalueLikeUnsized(ety)
290 /// Provide an expectation for an rvalue expression given an *optional*
291 /// hint, which is not required for type safety (the resulting type might
292 /// be checked higher up, as is the case with `&expr` and `box expr`), but
293 /// is useful in determining the concrete type.
295 /// The primary use case is where the expected type is a fat pointer,
296 /// like `&[isize]`. For example, consider the following statement:
298 /// let x: &[isize] = &[1, 2, 3];
300 /// In this case, the expected type for the `&[1, 2, 3]` expression is
301 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
302 /// expectation `ExpectHasType([isize])`, that would be too strong --
303 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
304 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
305 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
306 /// which still is useful, because it informs integer literals and the like.
307 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
308 /// for examples of where this comes up,.
309 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
310 match fcx.tcx.struct_tail(ty).sty {
311 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
312 ExpectRvalueLikeUnsized(ty)
314 _ => ExpectHasType(ty)
318 // Resolves `expected` by a single level if it is a variable. If
319 // there is no expected type or resolution is not possible (e.g.,
320 // no constraints yet present), just returns `None`.
321 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
323 NoExpectation => NoExpectation,
324 ExpectIfCondition => ExpectIfCondition,
325 ExpectCastableToType(t) => {
326 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
328 ExpectHasType(t) => {
329 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
331 ExpectRvalueLikeUnsized(t) => {
332 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
337 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
338 match self.resolve(fcx) {
339 NoExpectation => None,
340 ExpectIfCondition => Some(fcx.tcx.types.bool),
341 ExpectCastableToType(ty) |
343 ExpectRvalueLikeUnsized(ty) => Some(ty),
347 /// It sometimes happens that we want to turn an expectation into
348 /// a **hard constraint** (i.e., something that must be satisfied
349 /// for the program to type-check). `only_has_type` will return
350 /// such a constraint, if it exists.
351 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
352 match self.resolve(fcx) {
353 ExpectHasType(ty) => Some(ty),
354 ExpectIfCondition => Some(fcx.tcx.types.bool),
355 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
359 /// Like `only_has_type`, but instead of returning `None` if no
360 /// hard constraint exists, creates a fresh type variable.
361 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
362 self.only_has_type(fcx)
363 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
367 #[derive(Copy, Clone)]
368 pub struct UnsafetyState {
369 pub def: ast::NodeId,
370 pub unsafety: hir::Unsafety,
371 pub unsafe_push_count: u32,
376 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
377 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
380 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
381 match self.unsafety {
382 // If this unsafe, then if the outer function was already marked as
383 // unsafe we shouldn't attribute the unsafe'ness to the block. This
384 // way the block can be warned about instead of ignoring this
385 // extraneous block (functions are never warned about).
386 hir::Unsafety::Unsafe if self.from_fn => *self,
389 let (unsafety, def, count) = match blk.rules {
390 hir::PushUnsafeBlock(..) =>
391 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
392 hir::PopUnsafeBlock(..) =>
393 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
394 hir::UnsafeBlock(..) =>
395 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
397 (unsafety, self.def, self.unsafe_push_count),
401 unsafe_push_count: count,
408 #[derive(Debug, Copy, Clone)]
414 /// Tracks whether executing a node may exit normally (versus
415 /// return/break/panic, which "diverge", leaving dead code in their
416 /// wake). Tracked semi-automatically (through type variables marked
417 /// as diverging), with some manual adjustments for control-flow
418 /// primitives (approximating a CFG).
419 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
421 /// Potentially unknown, some cases converge,
422 /// others require a CFG to determine them.
425 /// Definitely known to diverge and therefore
426 /// not reach the next sibling or its parent.
429 /// Same as `Always` but with a reachability
430 /// warning already emitted
434 // Convenience impls for combinig `Diverges`.
436 impl ops::BitAnd for Diverges {
438 fn bitand(self, other: Self) -> Self {
439 cmp::min(self, other)
443 impl ops::BitOr for Diverges {
445 fn bitor(self, other: Self) -> Self {
446 cmp::max(self, other)
450 impl ops::BitAndAssign for Diverges {
451 fn bitand_assign(&mut self, other: Self) {
452 *self = *self & other;
456 impl ops::BitOrAssign for Diverges {
457 fn bitor_assign(&mut self, other: Self) {
458 *self = *self | other;
463 fn always(self) -> bool {
464 self >= Diverges::Always
468 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
471 // this is `null` for loops where break with a value is illegal,
472 // such as `while`, `for`, and `while let`
473 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
476 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
477 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
478 by_id: NodeMap<usize>,
481 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
482 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
483 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
484 bug!("could not find enclosing breakable with id {}", target_id);
490 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
491 body_id: ast::NodeId,
493 /// The parameter environment used for proving trait obligations
494 /// in this function. This can change when we descend into
495 /// closures (as they bring new things into scope), hence it is
496 /// not part of `Inherited` (as of the time of this writing,
497 /// closures do not yet change the environment, but they will
499 param_env: ty::ParamEnv<'tcx>,
501 // Number of errors that had been reported when we started
502 // checking this function. On exit, if we find that *more* errors
503 // have been reported, we will skip regionck and other work that
504 // expects the types within the function to be consistent.
505 err_count_on_creation: usize,
507 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
509 yield_ty: Option<Ty<'tcx>>,
511 ps: RefCell<UnsafetyState>,
513 /// Whether the last checked node generates a divergence (e.g.,
514 /// `return` will set this to Always). In general, when entering
515 /// an expression or other node in the tree, the initial value
516 /// indicates whether prior parts of the containing expression may
517 /// have diverged. It is then typically set to `Maybe` (and the
518 /// old value remembered) for processing the subparts of the
519 /// current expression. As each subpart is processed, they may set
520 /// the flag to `Always` etc. Finally, at the end, we take the
521 /// result and "union" it with the original value, so that when we
522 /// return the flag indicates if any subpart of the the parent
523 /// expression (up to and including this part) has diverged. So,
524 /// if you read it after evaluating a subexpression `X`, the value
525 /// you get indicates whether any subexpression that was
526 /// evaluating up to and including `X` diverged.
528 /// We use this flag for two purposes:
530 /// - To warn about unreachable code: if, after processing a
531 /// sub-expression but before we have applied the effects of the
532 /// current node, we see that the flag is set to `Always`, we
533 /// can issue a warning. This corresponds to something like
534 /// `foo(return)`; we warn on the `foo()` expression. (We then
535 /// update the flag to `WarnedAlways` to suppress duplicate
536 /// reports.) Similarly, if we traverse to a fresh statement (or
537 /// tail expression) from a `Always` setting, we will issue a
538 /// warning. This corresponds to something like `{return;
539 /// foo();}` or `{return; 22}`, where we would warn on the
542 /// - To permit assignment into a local variable or other lvalue
543 /// (including the "return slot") of type `!`. This is allowed
544 /// if **either** the type of value being assigned is `!`, which
545 /// means the current code is dead, **or** the expression's
546 /// diverging flag is true, which means that a diverging value was
547 /// wrapped (e.g., `let x: ! = foo(return)`).
549 /// To repeat the last point: an expression represents dead-code
550 /// if, after checking it, **either** its type is `!` OR the
551 /// diverges flag is set to something other than `Maybe`.
552 diverges: Cell<Diverges>,
554 /// Whether any child nodes have any type errors.
555 has_errors: Cell<bool>,
557 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
559 inh: &'a Inherited<'a, 'gcx, 'tcx>,
562 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
563 type Target = Inherited<'a, 'gcx, 'tcx>;
564 fn deref(&self) -> &Self::Target {
569 /// Helper type of a temporary returned by Inherited::build(...).
570 /// Necessary because we can't write the following bound:
571 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
572 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
573 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
577 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
578 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
579 -> InheritedBuilder<'a, 'gcx, 'tcx> {
580 let hir_id_root = if def_id.is_local() {
581 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
582 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
583 DefId::local(hir_id.owner)
589 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
595 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
596 fn enter<F, R>(&'tcx mut self, f: F) -> R
597 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
599 let def_id = self.def_id;
600 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
604 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
605 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
607 let item_id = tcx.hir.as_local_node_id(def_id);
608 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
609 let implicit_region_bound = body_id.map(|body_id| {
610 let body = tcx.hir.body(body_id);
611 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
615 tables: MaybeInProgressTables {
616 maybe_tables: infcx.in_progress_tables,
619 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
620 locals: RefCell::new(NodeMap()),
621 deferred_call_resolutions: RefCell::new(DefIdMap()),
622 deferred_cast_checks: RefCell::new(Vec::new()),
623 deferred_generator_interiors: RefCell::new(Vec::new()),
624 anon_types: RefCell::new(NodeMap()),
625 implicit_region_bound,
630 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
631 debug!("register_predicate({:?})", obligation);
632 if obligation.has_escaping_regions() {
633 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
638 .register_predicate_obligation(self, obligation);
641 fn register_predicates<I>(&self, obligations: I)
642 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
643 for obligation in obligations {
644 self.register_predicate(obligation);
648 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
649 self.register_predicates(infer_ok.obligations);
653 fn normalize_associated_types_in<T>(&self,
655 body_id: ast::NodeId,
656 param_env: ty::ParamEnv<'tcx>,
658 where T : TypeFoldable<'tcx>
660 let ok = self.normalize_associated_types_in_as_infer_ok(span, body_id, param_env, value);
661 self.register_infer_ok_obligations(ok)
664 fn normalize_associated_types_in_as_infer_ok<T>(&self,
666 body_id: ast::NodeId,
667 param_env: ty::ParamEnv<'tcx>,
670 where T : TypeFoldable<'tcx>
672 debug!("normalize_associated_types_in(value={:?})", value);
673 let mut selcx = traits::SelectionContext::new(self);
674 let cause = ObligationCause::misc(span, body_id);
675 let traits::Normalized { value, obligations } =
676 traits::normalize(&mut selcx, param_env, cause, value);
677 debug!("normalize_associated_types_in: result={:?} predicates={:?}",
680 InferOk { value, obligations }
683 /// Replace any late-bound regions bound in `value` with
684 /// free variants attached to `all_outlive_scope`.
685 fn liberate_late_bound_regions<T>(&self,
686 all_outlive_scope: DefId,
687 value: &ty::Binder<T>)
689 where T: TypeFoldable<'tcx>
691 self.tcx.replace_late_bound_regions(value, |br| {
692 self.tcx.mk_region(ty::ReFree(ty::FreeRegion {
693 scope: all_outlive_scope,
700 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
702 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
703 fn visit_item(&mut self, i: &'tcx hir::Item) {
704 check_item_type(self.tcx, i);
706 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
707 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
710 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
711 tcx.sess.track_errors(|| {
712 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
713 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
717 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
718 tcx.sess.track_errors(|| {
719 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
723 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
724 tcx.typeck_item_bodies(LOCAL_CRATE)
727 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
728 -> Result<(), CompileIncomplete>
730 debug_assert!(crate_num == LOCAL_CRATE);
731 Ok(tcx.sess.track_errors(|| {
732 for body_owner_def_id in tcx.body_owners() {
733 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
738 pub fn provide(providers: &mut Providers) {
739 *providers = Providers {
751 fn generator_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
753 -> Option<ty::PolyGenSig<'tcx>> {
754 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
755 let hir_id = tcx.hir.node_to_hir_id(node_id);
756 tcx.typeck_tables_of(def_id).generator_sigs()[hir_id].map(|s| ty::Binder(s))
759 fn closure_kind<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
762 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
763 let hir_id = tcx.hir.node_to_hir_id(node_id);
764 tcx.typeck_tables_of(def_id).closure_kinds()[hir_id].0
767 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
769 -> Option<ty::Destructor> {
770 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
773 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
774 /// with information about it's body-id and fn-decl (if any). Otherwise,
777 /// If this function returns "some", then `typeck_tables(def_id)` will
778 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
779 /// may not succeed. In some cases where this function returns `None`
780 /// (notably closures), `typeck_tables(def_id)` would wind up
781 /// redirecting to the owning function.
782 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
784 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
786 match tcx.hir.get(id) {
787 hir::map::NodeItem(item) => {
789 hir::ItemConst(_, body) |
790 hir::ItemStatic(_, _, body) =>
792 hir::ItemFn(ref decl, .., body) =>
793 Some((body, Some(decl))),
798 hir::map::NodeTraitItem(item) => {
800 hir::TraitItemKind::Const(_, Some(body)) =>
802 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
803 Some((body, Some(&sig.decl))),
808 hir::map::NodeImplItem(item) => {
810 hir::ImplItemKind::Const(_, body) =>
812 hir::ImplItemKind::Method(ref sig, body) =>
813 Some((body, Some(&sig.decl))),
818 hir::map::NodeExpr(expr) => {
819 // FIXME(eddyb) Closures should have separate
820 // function definition IDs and expression IDs.
821 // Type-checking should not let closures get
822 // this far in a constant position.
823 // Assume that everything other than closures
824 // is a constant "initializer" expression.
826 hir::ExprClosure(..) =>
829 Some((hir::BodyId { node_id: expr.id }, None)),
836 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
839 // Closures' tables come from their outermost function,
840 // as they are part of the same "inference environment".
841 let outer_def_id = tcx.closure_base_def_id(def_id);
842 if outer_def_id != def_id {
843 return tcx.has_typeck_tables(outer_def_id);
846 let id = tcx.hir.as_local_node_id(def_id).unwrap();
847 primary_body_of(tcx, id).is_some()
850 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
853 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
856 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
858 -> &'tcx ty::TypeckTables<'tcx> {
859 // Closures' tables come from their outermost function,
860 // as they are part of the same "inference environment".
861 let outer_def_id = tcx.closure_base_def_id(def_id);
862 if outer_def_id != def_id {
863 return tcx.typeck_tables_of(outer_def_id);
866 let id = tcx.hir.as_local_node_id(def_id).unwrap();
867 let span = tcx.hir.span(id);
869 // Figure out what primary body this item has.
870 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
871 span_bug!(span, "can't type-check body of {:?}", def_id);
873 let body = tcx.hir.body(body_id);
875 let tables = Inherited::build(tcx, def_id).enter(|inh| {
876 let param_env = tcx.param_env(def_id);
877 let fcx = if let Some(decl) = fn_decl {
878 let fn_sig = tcx.fn_sig(def_id);
880 check_abi(tcx, span, fn_sig.abi());
882 // Compute the fty from point of view of inside fn.
884 inh.liberate_late_bound_regions(def_id, &fn_sig);
886 inh.normalize_associated_types_in(body.value.span,
891 check_fn(&inh, param_env, fn_sig, decl, id, body, false).0
893 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
894 let expected_type = tcx.type_of(def_id);
895 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
896 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
898 // Gather locals in statics (because of block expressions).
899 // This is technically unnecessary because locals in static items are forbidden,
900 // but prevents type checking from blowing up before const checking can properly
902 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
904 fcx.check_expr_coercable_to_type(&body.value, expected_type);
909 fcx.select_all_obligations_and_apply_defaults();
910 fcx.closure_analyze(body);
911 fcx.select_obligations_where_possible();
913 fcx.resolve_generator_interiors(def_id);
914 fcx.select_all_obligations_or_error();
916 if fn_decl.is_some() {
917 fcx.regionck_fn(id, body);
919 fcx.regionck_expr(body);
922 fcx.resolve_type_vars_in_body(body)
925 // Consistency check our TypeckTables instance can hold all ItemLocalIds
926 // it will need to hold.
927 assert_eq!(tables.local_id_root,
928 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
932 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
933 if !tcx.sess.target.target.is_abi_supported(abi) {
934 struct_span_err!(tcx.sess, span, E0570,
935 "The ABI `{}` is not supported for the current target", abi).emit()
939 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
940 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
943 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
944 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
947 // infer the variable's type
948 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
949 self.fcx.locals.borrow_mut().insert(nid, var_ty);
953 // take type that the user specified
954 self.fcx.locals.borrow_mut().insert(nid, typ);
961 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
962 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
963 NestedVisitorMap::None
966 // Add explicitly-declared locals.
967 fn visit_local(&mut self, local: &'gcx hir::Local) {
968 let o_ty = match local.ty {
969 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
972 self.assign(local.span, local.id, o_ty);
973 debug!("Local variable {:?} is assigned type {}",
975 self.fcx.ty_to_string(
976 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
977 intravisit::walk_local(self, local);
980 // Add pattern bindings.
981 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
982 if let PatKind::Binding(_, _, ref path1, _) = p.node {
983 let var_ty = self.assign(p.span, p.id, None);
985 self.fcx.require_type_is_sized(var_ty, p.span,
986 traits::VariableType(p.id));
988 debug!("Pattern binding {} is assigned to {} with type {:?}",
990 self.fcx.ty_to_string(
991 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
994 intravisit::walk_pat(self, p);
997 // Don't descend into the bodies of nested closures
998 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
999 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1002 /// Helper used for fns and closures. Does the grungy work of checking a function
1003 /// body and returns the function context used for that purpose, since in the case of a fn item
1004 /// there is still a bit more to do.
1007 /// * inherited: other fields inherited from the enclosing fn (if any)
1008 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1009 param_env: ty::ParamEnv<'tcx>,
1010 fn_sig: ty::FnSig<'tcx>,
1011 decl: &'gcx hir::FnDecl,
1013 body: &'gcx hir::Body,
1014 can_be_generator: bool)
1015 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<ty::GeneratorInterior<'tcx>>)
1017 let mut fn_sig = fn_sig.clone();
1019 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1021 // Create the function context. This is either derived from scratch or,
1022 // in the case of function expressions, based on the outer context.
1023 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1024 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1026 let ret_ty = fn_sig.output();
1027 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1028 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
1029 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1030 fn_sig = fcx.tcx.mk_fn_sig(
1031 fn_sig.inputs().iter().cloned(),
1038 let span = body.value.span;
1040 if body.is_generator && can_be_generator {
1041 fcx.yield_ty = Some(fcx.next_ty_var(TypeVariableOrigin::TypeInference(span)));
1044 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1046 // Add formal parameters.
1047 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1048 // Check the pattern.
1049 fcx.check_pat_walk(&arg.pat, arg_ty,
1050 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1052 // Check that argument is Sized.
1053 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1054 // for simple cases like `fn foo(x: Trait)`,
1055 // where we would error once on the parameter as a whole, and once on the binding `x`.
1056 if arg.pat.simple_name().is_none() {
1057 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1060 fcx.write_ty(arg.hir_id, arg_ty);
1063 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1064 let gen_ty = if can_be_generator && body.is_generator {
1065 let gen_sig = ty::GenSig {
1066 yield_ty: fcx.yield_ty.unwrap(),
1069 inherited.tables.borrow_mut().generator_sigs_mut().insert(fn_hir_id, Some(gen_sig));
1071 let witness = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1072 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), witness));
1073 let interior = ty::GeneratorInterior::new(witness);
1075 inherited.tables.borrow_mut().generator_interiors_mut().insert(fn_hir_id, interior);
1079 inherited.tables.borrow_mut().generator_sigs_mut().insert(fn_hir_id, None);
1082 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1084 fcx.check_return_expr(&body.value);
1086 // Finalize the return check by taking the LUB of the return types
1087 // we saw and assigning it to the expected return type. This isn't
1088 // really expected to fail, since the coercions would have failed
1089 // earlier when trying to find a LUB.
1091 // However, the behavior around `!` is sort of complex. In the
1092 // event that the `actual_return_ty` comes back as `!`, that
1093 // indicates that the fn either does not return or "returns" only
1094 // values of type `!`. In this case, if there is an expected
1095 // return type that is *not* `!`, that should be ok. But if the
1096 // return type is being inferred, we want to "fallback" to `!`:
1098 // let x = move || panic!();
1100 // To allow for that, I am creating a type variable with diverging
1101 // fallback. This was deemed ever so slightly better than unifying
1102 // the return value with `!` because it allows for the caller to
1103 // make more assumptions about the return type (e.g., they could do
1105 // let y: Option<u32> = Some(x());
1107 // which would then cause this return type to become `u32`, not
1109 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1110 let mut actual_return_ty = coercion.complete(&fcx);
1111 if actual_return_ty.is_never() {
1112 actual_return_ty = fcx.next_diverging_ty_var(
1113 TypeVariableOrigin::DivergingFn(span));
1115 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1120 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1123 let def_id = tcx.hir.local_def_id(id);
1124 let def = tcx.adt_def(def_id);
1125 def.destructor(tcx); // force the destructor to be evaluated
1126 check_representable(tcx, span, def_id);
1128 if def.repr.simd() {
1129 check_simd(tcx, span, def_id);
1132 check_packed(tcx, span, def_id);
1135 fn check_union<'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 check_packed(tcx, span, def_id);
1146 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1147 debug!("check_item_type(it.id={}, it.name={})",
1149 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1150 let _indenter = indenter();
1152 // Consts can play a role in type-checking, so they are included here.
1153 hir::ItemStatic(..) |
1154 hir::ItemConst(..) => {
1155 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1157 hir::ItemEnum(ref enum_definition, _) => {
1160 &enum_definition.variants,
1163 hir::ItemFn(..) => {} // entirely within check_item_body
1164 hir::ItemImpl(.., ref impl_item_refs) => {
1165 debug!("ItemImpl {} with id {}", it.name, it.id);
1166 let impl_def_id = tcx.hir.local_def_id(it.id);
1167 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1168 check_impl_items_against_trait(tcx,
1173 let trait_def_id = impl_trait_ref.def_id;
1174 check_on_unimplemented(tcx, trait_def_id, it);
1177 hir::ItemTrait(..) => {
1178 let def_id = tcx.hir.local_def_id(it.id);
1179 check_on_unimplemented(tcx, def_id, it);
1181 hir::ItemStruct(..) => {
1182 check_struct(tcx, it.id, it.span);
1184 hir::ItemUnion(..) => {
1185 check_union(tcx, it.id, it.span);
1187 hir::ItemTy(_, ref generics) => {
1188 let def_id = tcx.hir.local_def_id(it.id);
1189 let pty_ty = tcx.type_of(def_id);
1190 check_bounds_are_used(tcx, generics, pty_ty);
1192 hir::ItemForeignMod(ref m) => {
1193 check_abi(tcx, it.span, m.abi);
1195 if m.abi == Abi::RustIntrinsic {
1196 for item in &m.items {
1197 intrinsic::check_intrinsic_type(tcx, item);
1199 } else if m.abi == Abi::PlatformIntrinsic {
1200 for item in &m.items {
1201 intrinsic::check_platform_intrinsic_type(tcx, item);
1204 for item in &m.items {
1205 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1206 if !generics.types.is_empty() {
1207 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1208 "foreign items may not have type parameters");
1209 span_help!(&mut err, item.span,
1210 "consider using specialization instead of \
1215 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1216 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1221 _ => {/* nothing to do */ }
1225 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1226 trait_def_id: DefId,
1228 let item_def_id = tcx.hir.local_def_id(item.id);
1229 // an error would be reported if this fails.
1230 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1233 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1234 impl_item: &hir::ImplItem,
1237 let mut err = struct_span_err!(
1238 tcx.sess, impl_item.span, E0520,
1239 "`{}` specializes an item from a parent `impl`, but \
1240 that item is not marked `default`",
1242 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1245 match tcx.span_of_impl(parent_impl) {
1247 err.span_label(span, "parent `impl` is here");
1248 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1252 err.note(&format!("parent implementation is in crate `{}`", cname));
1259 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1260 trait_def: &ty::TraitDef,
1261 trait_item: &ty::AssociatedItem,
1263 impl_item: &hir::ImplItem)
1265 let ancestors = trait_def.ancestors(tcx, impl_id);
1267 let kind = match impl_item.node {
1268 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1269 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1270 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1273 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1274 .map(|node_item| node_item.map(|parent| parent.defaultness));
1276 if let Some(parent) = parent {
1277 if tcx.impl_item_is_final(&parent) {
1278 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1284 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1287 impl_trait_ref: ty::TraitRef<'tcx>,
1288 impl_item_refs: &[hir::ImplItemRef]) {
1289 // If the trait reference itself is erroneous (so the compilation is going
1290 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1291 // isn't populated for such impls.
1292 if impl_trait_ref.references_error() { return; }
1294 // Locate trait definition and items
1295 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1296 let mut overridden_associated_type = None;
1298 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1300 // Check existing impl methods to see if they are both present in trait
1301 // and compatible with trait signature
1302 for impl_item in impl_items() {
1303 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1304 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1305 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1306 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1308 // Not compatible, but needed for the error message
1309 tcx.associated_items(impl_trait_ref.def_id)
1310 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1313 // Check that impl definition matches trait definition
1314 if let Some(ty_trait_item) = ty_trait_item {
1315 match impl_item.node {
1316 hir::ImplItemKind::Const(..) => {
1317 // Find associated const definition.
1318 if ty_trait_item.kind == ty::AssociatedKind::Const {
1319 compare_const_impl(tcx,
1325 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1326 "item `{}` is an associated const, \
1327 which doesn't match its trait `{}`",
1330 err.span_label(impl_item.span, "does not match trait");
1331 // We can only get the spans from local trait definition
1332 // Same for E0324 and E0325
1333 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1334 err.span_label(trait_span, "item in trait");
1339 hir::ImplItemKind::Method(..) => {
1340 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1341 if ty_trait_item.kind == ty::AssociatedKind::Method {
1342 let err_count = tcx.sess.err_count();
1343 compare_impl_method(tcx,
1349 true); // start with old-broken-mode
1350 if err_count == tcx.sess.err_count() {
1351 // old broken mode did not report an error. Try with the new mode.
1352 compare_impl_method(tcx,
1358 false); // use the new mode
1361 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1362 "item `{}` is an associated method, \
1363 which doesn't match its trait `{}`",
1366 err.span_label(impl_item.span, "does not match trait");
1367 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1368 err.span_label(trait_span, "item in trait");
1373 hir::ImplItemKind::Type(_) => {
1374 if ty_trait_item.kind == ty::AssociatedKind::Type {
1375 if ty_trait_item.defaultness.has_value() {
1376 overridden_associated_type = Some(impl_item);
1379 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1380 "item `{}` is an associated type, \
1381 which doesn't match its trait `{}`",
1384 err.span_label(impl_item.span, "does not match trait");
1385 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1386 err.span_label(trait_span, "item in trait");
1393 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1397 // Check for missing items from trait
1398 let mut missing_items = Vec::new();
1399 let mut invalidated_items = Vec::new();
1400 let associated_type_overridden = overridden_associated_type.is_some();
1401 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1402 let is_implemented = trait_def.ancestors(tcx, impl_id)
1403 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1405 .map(|node_item| !node_item.node.is_from_trait())
1408 if !is_implemented {
1409 if !trait_item.defaultness.has_value() {
1410 missing_items.push(trait_item);
1411 } else if associated_type_overridden {
1412 invalidated_items.push(trait_item.name);
1417 if !missing_items.is_empty() {
1418 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1419 "not all trait items implemented, missing: `{}`",
1420 missing_items.iter()
1421 .map(|trait_item| trait_item.name.to_string())
1422 .collect::<Vec<_>>().join("`, `"));
1423 err.span_label(impl_span, format!("missing `{}` in implementation",
1424 missing_items.iter()
1425 .map(|trait_item| trait_item.name.to_string())
1426 .collect::<Vec<_>>().join("`, `")));
1427 for trait_item in missing_items {
1428 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1429 err.span_label(span, format!("`{}` from trait", trait_item.name));
1431 err.note_trait_signature(trait_item.name.to_string(),
1432 trait_item.signature(&tcx));
1438 if !invalidated_items.is_empty() {
1439 let invalidator = overridden_associated_type.unwrap();
1440 span_err!(tcx.sess, invalidator.span, E0399,
1441 "the following trait items need to be reimplemented \
1442 as `{}` was overridden: `{}`",
1444 invalidated_items.iter()
1445 .map(|name| name.to_string())
1446 .collect::<Vec<_>>().join("`, `"))
1450 /// Checks whether a type can be represented in memory. In particular, it
1451 /// identifies types that contain themselves without indirection through a
1452 /// pointer, which would mean their size is unbounded.
1453 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1457 let rty = tcx.type_of(item_def_id);
1459 // Check that it is possible to represent this type. This call identifies
1460 // (1) types that contain themselves and (2) types that contain a different
1461 // recursive type. It is only necessary to throw an error on those that
1462 // contain themselves. For case 2, there must be an inner type that will be
1463 // caught by case 1.
1464 match rty.is_representable(tcx, sp) {
1465 Representability::SelfRecursive(spans) => {
1466 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1468 err.span_label(span, "recursive without indirection");
1473 Representability::Representable | Representability::ContainsRecursive => (),
1478 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1479 let t = tcx.type_of(def_id);
1481 ty::TyAdt(def, substs) if def.is_struct() => {
1482 let fields = &def.struct_variant().fields;
1483 if fields.is_empty() {
1484 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1487 let e = fields[0].ty(tcx, substs);
1488 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1489 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1490 .span_label(sp, "SIMD elements must have the same type")
1495 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1496 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1498 span_err!(tcx.sess, sp, E0077,
1499 "SIMD vector element type should be machine type");
1508 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1509 if tcx.adt_def(def_id).repr.packed() {
1510 if tcx.adt_def(def_id).repr.align > 0 {
1511 struct_span_err!(tcx.sess, sp, E0587,
1512 "type has conflicting packed and align representation hints").emit();
1514 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1515 struct_span_err!(tcx.sess, sp, E0588,
1516 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1521 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1523 stack: &mut Vec<DefId>) -> bool {
1524 let t = tcx.type_of(def_id);
1525 if stack.contains(&def_id) {
1526 debug!("check_packed_inner: {:?} is recursive", t);
1530 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1531 if tcx.adt_def(def.did).repr.align > 0 {
1534 // push struct def_id before checking fields
1536 for field in &def.struct_variant().fields {
1537 let f = field.ty(tcx, substs);
1539 ty::TyAdt(def, _) => {
1540 if check_packed_inner(tcx, def.did, stack) {
1547 // only need to pop if not early out
1555 #[allow(trivial_numeric_casts)]
1556 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1558 vs: &'tcx [hir::Variant],
1560 let def_id = tcx.hir.local_def_id(id);
1561 let def = tcx.adt_def(def_id);
1562 def.destructor(tcx); // force the destructor to be evaluated
1564 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1566 tcx.sess, sp, E0084,
1567 "unsupported representation for zero-variant enum")
1568 .span_label(sp, "unsupported enum representation")
1572 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1573 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1574 if !tcx.sess.features.borrow().repr128 {
1575 emit_feature_err(&tcx.sess.parse_sess,
1578 GateIssue::Language,
1579 "repr with 128-bit type is unstable");
1584 if let Some(e) = v.node.disr_expr {
1585 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1589 let mut disr_vals: Vec<ConstInt> = Vec::new();
1590 for (discr, v) in def.discriminants(tcx).zip(vs) {
1591 // Check for duplicate discriminant values
1592 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1593 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1594 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1595 let i_span = match variant_i.node.disr_expr {
1596 Some(expr) => tcx.hir.span(expr.node_id),
1597 None => tcx.hir.span(variant_i_node_id)
1599 let span = match v.node.disr_expr {
1600 Some(expr) => tcx.hir.span(expr.node_id),
1603 struct_span_err!(tcx.sess, span, E0081,
1604 "discriminant value `{}` already exists", disr_vals[i])
1605 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1606 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1609 disr_vals.push(discr);
1612 check_representable(tcx, sp, def_id);
1615 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1616 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1618 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1619 -> ty::GenericPredicates<'tcx>
1622 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1623 let item_id = tcx.hir.ty_param_owner(node_id);
1624 let item_def_id = tcx.hir.local_def_id(item_id);
1625 let generics = tcx.generics_of(item_def_id);
1626 let index = generics.type_param_to_index[&def_id.index];
1627 ty::GenericPredicates {
1629 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1631 ty::Predicate::Trait(ref data) => {
1632 data.0.self_ty().is_param(index)
1636 }).cloned().collect()
1640 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1641 -> Option<ty::Region<'tcx>> {
1643 Some(def) => infer::EarlyBoundRegion(span, def.name),
1644 None => infer::MiscVariable(span)
1646 Some(self.next_region_var(v))
1649 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1650 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1653 fn ty_infer_for_def(&self,
1654 ty_param_def: &ty::TypeParameterDef,
1655 substs: &[Kind<'tcx>],
1656 span: Span) -> Ty<'tcx> {
1657 self.type_var_for_def(span, ty_param_def, substs)
1660 fn projected_ty_from_poly_trait_ref(&self,
1663 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1666 let (trait_ref, _) =
1667 self.replace_late_bound_regions_with_fresh_var(
1669 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1672 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1675 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1676 if ty.has_escaping_regions() {
1677 ty // FIXME: normalization and escaping regions
1679 self.normalize_associated_types_in(span, &ty)
1683 fn set_tainted_by_errors(&self) {
1684 self.infcx.set_tainted_by_errors()
1687 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1688 self.write_ty(hir_id, ty)
1692 /// Controls whether the arguments are tupled. This is used for the call
1695 /// Tupling means that all call-side arguments are packed into a tuple and
1696 /// passed as a single parameter. For example, if tupling is enabled, this
1699 /// fn f(x: (isize, isize))
1701 /// Can be called as:
1708 #[derive(Clone, Eq, PartialEq)]
1709 enum TupleArgumentsFlag {
1714 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1715 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1716 param_env: ty::ParamEnv<'tcx>,
1717 body_id: ast::NodeId)
1718 -> FnCtxt<'a, 'gcx, 'tcx> {
1722 err_count_on_creation: inh.tcx.sess.err_count(),
1725 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1726 ast::CRATE_NODE_ID)),
1727 diverges: Cell::new(Diverges::Maybe),
1728 has_errors: Cell::new(false),
1729 enclosing_breakables: RefCell::new(EnclosingBreakables {
1737 pub fn sess(&self) -> &Session {
1741 pub fn err_count_since_creation(&self) -> usize {
1742 self.tcx.sess.err_count() - self.err_count_on_creation
1745 /// Produce warning on the given node, if the current point in the
1746 /// function is unreachable, and there hasn't been another warning.
1747 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1748 if self.diverges.get() == Diverges::Always {
1749 self.diverges.set(Diverges::WarnedAlways);
1751 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1753 self.tcx().lint_node(
1754 lint::builtin::UNREACHABLE_CODE,
1756 &format!("unreachable {}", kind));
1762 code: ObligationCauseCode<'tcx>)
1763 -> ObligationCause<'tcx> {
1764 ObligationCause::new(span, self.body_id, code)
1767 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1768 self.cause(span, ObligationCauseCode::MiscObligation)
1771 /// Resolves type variables in `ty` if possible. Unlike the infcx
1772 /// version (resolve_type_vars_if_possible), this version will
1773 /// also select obligations if it seems useful, in an effort
1774 /// to get more type information.
1775 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1776 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1778 // No TyInfer()? Nothing needs doing.
1779 if !ty.has_infer_types() {
1780 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1784 // If `ty` is a type variable, see whether we already know what it is.
1785 ty = self.resolve_type_vars_if_possible(&ty);
1786 if !ty.has_infer_types() {
1787 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1791 // If not, try resolving pending obligations as much as
1792 // possible. This can help substantially when there are
1793 // indirect dependencies that don't seem worth tracking
1795 self.select_obligations_where_possible();
1796 ty = self.resolve_type_vars_if_possible(&ty);
1798 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1802 fn record_deferred_call_resolution(&self,
1803 closure_def_id: DefId,
1804 r: DeferredCallResolution<'gcx, 'tcx>) {
1805 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1806 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1809 fn remove_deferred_call_resolutions(&self,
1810 closure_def_id: DefId)
1811 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1813 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1814 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1817 pub fn tag(&self) -> String {
1818 let self_ptr: *const FnCtxt = self;
1819 format!("{:?}", self_ptr)
1822 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1823 match self.locals.borrow().get(&nid) {
1826 span_bug!(span, "no type for local variable {}",
1827 self.tcx.hir.node_to_string(nid));
1833 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1834 debug!("write_ty({:?}, {:?}) in fcx {}",
1835 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1836 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1838 if ty.references_error() {
1839 self.has_errors.set(true);
1840 self.set_tainted_by_errors();
1844 // The NodeId and the ItemLocalId must identify the same item. We just pass
1845 // both of them for consistency checking.
1846 pub fn write_method_call(&self,
1848 method: MethodCallee<'tcx>) {
1851 .type_dependent_defs_mut()
1852 .insert(hir_id, Def::Method(method.def_id));
1853 self.write_substs(hir_id, method.substs);
1856 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1857 if !substs.is_noop() {
1858 debug!("write_substs({:?}, {:?}) in fcx {}",
1863 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1867 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1868 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1874 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1875 Entry::Vacant(entry) => { entry.insert(adj); },
1876 Entry::Occupied(mut entry) => {
1877 debug!(" - composing on top of {:?}", entry.get());
1878 match (&entry.get()[..], &adj[..]) {
1879 // Applying any adjustment on top of a NeverToAny
1880 // is a valid NeverToAny adjustment, because it can't
1882 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1884 Adjustment { kind: Adjust::Deref(_), .. },
1885 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1887 Adjustment { kind: Adjust::Deref(_), .. },
1888 .. // Any following adjustments are allowed.
1890 // A reborrow has no effect before a dereference.
1892 // FIXME: currently we never try to compose autoderefs
1893 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1895 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1896 expr, entry.get(), adj)
1898 *entry.get_mut() = adj;
1903 /// Basically whenever we are converting from a type scheme into
1904 /// the fn body space, we always want to normalize associated
1905 /// types as well. This function combines the two.
1906 fn instantiate_type_scheme<T>(&self,
1908 substs: &Substs<'tcx>,
1911 where T : TypeFoldable<'tcx>
1913 let value = value.subst(self.tcx, substs);
1914 let result = self.normalize_associated_types_in(span, &value);
1915 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1922 /// As `instantiate_type_scheme`, but for the bounds found in a
1923 /// generic type scheme.
1924 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1925 -> ty::InstantiatedPredicates<'tcx> {
1926 let bounds = self.tcx.predicates_of(def_id);
1927 let result = bounds.instantiate(self.tcx, substs);
1928 let result = self.normalize_associated_types_in(span, &result);
1929 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1936 /// Replace all anonymized types with fresh inference variables
1937 /// and record them for writeback.
1938 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1939 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1940 if let ty::TyAnon(def_id, substs) = ty.sty {
1941 // Use the same type variable if the exact same TyAnon appears more
1942 // than once in the return type (e.g. if it's passed to a type alias).
1943 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1944 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1947 let span = self.tcx.def_span(def_id);
1948 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1949 self.anon_types.borrow_mut().insert(id, ty_var);
1951 let predicates_of = self.tcx.predicates_of(def_id);
1952 let bounds = predicates_of.instantiate(self.tcx, substs);
1954 for predicate in bounds.predicates {
1955 // Change the predicate to refer to the type variable,
1956 // which will be the concrete type, instead of the TyAnon.
1957 // This also instantiates nested `impl Trait`.
1958 let predicate = self.instantiate_anon_types(&predicate);
1960 // Require that the predicate holds for the concrete type.
1961 let cause = traits::ObligationCause::new(span, self.body_id,
1962 traits::SizedReturnType);
1963 self.register_predicate(traits::Obligation::new(cause,
1975 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1976 where T : TypeFoldable<'tcx>
1978 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
1981 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1983 where T : TypeFoldable<'tcx>
1985 self.inh.normalize_associated_types_in_as_infer_ok(span,
1991 pub fn require_type_meets(&self,
1994 code: traits::ObligationCauseCode<'tcx>,
1997 self.register_bound(
2000 traits::ObligationCause::new(span, self.body_id, code));
2003 pub fn require_type_is_sized(&self,
2006 code: traits::ObligationCauseCode<'tcx>)
2008 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2009 self.require_type_meets(ty, span, code, lang_item);
2012 pub fn register_bound(&self,
2015 cause: traits::ObligationCause<'tcx>)
2017 self.fulfillment_cx.borrow_mut()
2018 .register_bound(self, self.param_env, ty, def_id, cause);
2021 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2022 let t = AstConv::ast_ty_to_ty(self, ast_t);
2023 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2027 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2028 match self.tables.borrow().node_types().get(id) {
2030 None if self.is_tainted_by_errors() => self.tcx.types.err,
2032 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2033 bug!("no type for node {}: {} in fcx {}",
2034 node_id, self.tcx.hir.node_to_string(node_id),
2040 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2041 /// outlive the region `r`.
2042 pub fn register_wf_obligation(&self,
2045 code: traits::ObligationCauseCode<'tcx>)
2047 // WF obligations never themselves fail, so no real need to give a detailed cause:
2048 let cause = traits::ObligationCause::new(span, self.body_id, code);
2049 self.register_predicate(traits::Obligation::new(cause,
2051 ty::Predicate::WellFormed(ty)));
2054 /// Registers obligations that all types appearing in `substs` are well-formed.
2055 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2057 for ty in substs.types() {
2058 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2062 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2063 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2064 /// trait/region obligations.
2066 /// For example, if there is a function:
2069 /// fn foo<'a,T:'a>(...)
2072 /// and a reference:
2078 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2079 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2080 pub fn add_obligations_for_parameters(&self,
2081 cause: traits::ObligationCause<'tcx>,
2082 predicates: &ty::InstantiatedPredicates<'tcx>)
2084 assert!(!predicates.has_escaping_regions());
2086 debug!("add_obligations_for_parameters(predicates={:?})",
2089 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2090 self.register_predicate(obligation);
2094 // FIXME(arielb1): use this instead of field.ty everywhere
2095 // Only for fields! Returns <none> for methods>
2096 // Indifferent to privacy flags
2097 pub fn field_ty(&self,
2099 field: &'tcx ty::FieldDef,
2100 substs: &Substs<'tcx>)
2103 self.normalize_associated_types_in(span,
2104 &field.ty(self.tcx, substs))
2107 fn check_casts(&self) {
2108 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2109 for cast in deferred_cast_checks.drain(..) {
2114 fn resolve_generator_interiors(&self, def_id: DefId) {
2115 let mut deferred_generator_interiors = self.deferred_generator_interiors.borrow_mut();
2116 for (body_id, witness) in deferred_generator_interiors.drain(..) {
2117 generator_interior::resolve_interior(self, def_id, body_id, witness);
2121 /// Apply "fallbacks" to some types
2122 /// unconstrained types get replaced with ! or () (depending on whether
2123 /// feature(never_type) is enabled), unconstrained ints with i32, and
2124 /// unconstrained floats with f64.
2125 fn default_type_parameters(&self) {
2126 use rustc::ty::error::UnconstrainedNumeric::Neither;
2127 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2129 // Defaulting inference variables becomes very dubious if we have
2130 // encountered type-checking errors. Therefore, if we think we saw
2131 // some errors in this function, just resolve all uninstanted type
2132 // varibles to TyError.
2133 if self.is_tainted_by_errors() {
2134 for ty in &self.unsolved_variables() {
2135 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2136 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2137 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2143 for ty in &self.unsolved_variables() {
2144 let resolved = self.resolve_type_vars_if_possible(ty);
2145 if self.type_var_diverges(resolved) {
2146 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2148 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2149 self.tcx.mk_diverging_default());
2151 match self.type_is_unconstrained_numeric(resolved) {
2152 UnconstrainedInt => {
2153 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2155 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2157 UnconstrainedFloat => {
2158 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2160 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2168 // Implements type inference fallback algorithm
2169 fn select_all_obligations_and_apply_defaults(&self) {
2170 self.select_obligations_where_possible();
2171 self.default_type_parameters();
2172 self.select_obligations_where_possible();
2175 fn select_all_obligations_or_error(&self) {
2176 debug!("select_all_obligations_or_error");
2178 // upvar inference should have ensured that all deferred call
2179 // resolutions are handled by now.
2180 assert!(self.deferred_call_resolutions.borrow().is_empty());
2182 self.select_all_obligations_and_apply_defaults();
2184 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2186 match fulfillment_cx.select_all_or_error(self) {
2188 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2192 /// Select as many obligations as we can at present.
2193 fn select_obligations_where_possible(&self) {
2194 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2196 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2200 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2201 /// returns a type of `&T`, but the actual type we assign to the
2202 /// *expression* is `T`. So this function just peels off the return
2203 /// type by one layer to yield `T`.
2204 fn make_overloaded_lvalue_return_type(&self,
2205 method: MethodCallee<'tcx>)
2206 -> ty::TypeAndMut<'tcx>
2208 // extract method return type, which will be &T;
2209 let ret_ty = method.sig.output();
2211 // method returns &T, but the type as visible to user is T, so deref
2212 ret_ty.builtin_deref(true, NoPreference).unwrap()
2215 fn lookup_indexing(&self,
2217 base_expr: &'gcx hir::Expr,
2220 lvalue_pref: LvaluePreference)
2221 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2223 // FIXME(#18741) -- this is almost but not quite the same as the
2224 // autoderef that normal method probing does. They could likely be
2227 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2228 let mut result = None;
2229 while result.is_none() && autoderef.next().is_some() {
2230 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2232 autoderef.finalize();
2236 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2237 /// (and otherwise adjust) `base_expr`, looking for a type which either
2238 /// supports builtin indexing or overloaded indexing.
2239 /// This loop implements one step in that search; the autoderef loop
2240 /// is implemented by `lookup_indexing`.
2241 fn try_index_step(&self,
2243 base_expr: &hir::Expr,
2244 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2245 lvalue_pref: LvaluePreference,
2247 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2249 let adjusted_ty = autoderef.unambiguous_final_ty();
2250 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2257 // First, try built-in indexing.
2258 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2259 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2260 debug!("try_index_step: success, using built-in indexing");
2261 let adjustments = autoderef.adjust_steps(lvalue_pref);
2262 self.apply_adjustments(base_expr, adjustments);
2263 return Some((self.tcx.types.usize, ty));
2268 for &unsize in &[false, true] {
2269 let mut self_ty = adjusted_ty;
2271 // We only unsize arrays here.
2272 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2273 self_ty = self.tcx.mk_slice(element_ty);
2279 // If some lookup succeeds, write callee into table and extract index/element
2280 // type from the method signature.
2281 // If some lookup succeeded, install method in table
2282 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2283 let method = self.try_overloaded_lvalue_op(
2284 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2286 let result = method.map(|ok| {
2287 debug!("try_index_step: success, using overloaded indexing");
2288 let method = self.register_infer_ok_obligations(ok);
2290 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2291 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2292 adjustments.push(Adjustment {
2293 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2294 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2301 adjustments.push(Adjustment {
2302 kind: Adjust::Unsize,
2303 target: method.sig.inputs()[0]
2306 self.apply_adjustments(base_expr, adjustments);
2308 self.write_method_call(expr.hir_id, method);
2309 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2311 if result.is_some() {
2319 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2320 let (tr, name) = match (op, is_mut) {
2321 (LvalueOp::Deref, false) =>
2322 (self.tcx.lang_items().deref_trait(), "deref"),
2323 (LvalueOp::Deref, true) =>
2324 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2325 (LvalueOp::Index, false) =>
2326 (self.tcx.lang_items().index_trait(), "index"),
2327 (LvalueOp::Index, true) =>
2328 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2330 (tr, Symbol::intern(name))
2333 fn try_overloaded_lvalue_op(&self,
2336 arg_tys: &[Ty<'tcx>],
2337 lvalue_pref: LvaluePreference,
2339 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2341 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2347 // Try Mut first, if preferred.
2348 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2349 let method = match (lvalue_pref, mut_tr) {
2350 (PreferMutLvalue, Some(trait_did)) => {
2351 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2356 // Otherwise, fall back to the immutable version.
2357 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2358 let method = match (method, imm_tr) {
2359 (None, Some(trait_did)) => {
2360 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2362 (method, _) => method,
2368 fn check_method_argument_types(&self,
2371 method: Result<MethodCallee<'tcx>, ()>,
2372 args_no_rcvr: &'gcx [hir::Expr],
2373 tuple_arguments: TupleArgumentsFlag,
2374 expected: Expectation<'tcx>)
2376 let has_error = match method {
2378 method.substs.references_error() || method.sig.references_error()
2383 let err_inputs = self.err_args(args_no_rcvr.len());
2385 let err_inputs = match tuple_arguments {
2386 DontTupleArguments => err_inputs,
2387 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2390 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2391 false, tuple_arguments, None);
2392 return self.tcx.types.err;
2395 let method = method.unwrap();
2396 // HACK(eddyb) ignore self in the definition (see above).
2397 let expected_arg_tys = self.expected_inputs_for_expected_output(
2400 method.sig.output(),
2401 &method.sig.inputs()[1..]
2403 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2404 args_no_rcvr, method.sig.variadic, tuple_arguments,
2405 self.tcx.hir.span_if_local(method.def_id));
2409 /// Generic function that factors out common logic from function calls,
2410 /// method calls and overloaded operators.
2411 fn check_argument_types(&self,
2414 fn_inputs: &[Ty<'tcx>],
2415 expected_arg_tys: &[Ty<'tcx>],
2416 args: &'gcx [hir::Expr],
2418 tuple_arguments: TupleArgumentsFlag,
2419 def_span: Option<Span>) {
2422 // Grab the argument types, supplying fresh type variables
2423 // if the wrong number of arguments were supplied
2424 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2430 // All the input types from the fn signature must outlive the call
2431 // so as to validate implied bounds.
2432 for &fn_input_ty in fn_inputs {
2433 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2436 let mut expected_arg_tys = expected_arg_tys;
2437 let expected_arg_count = fn_inputs.len();
2439 let sp_args = if args.len() > 0 {
2440 let (first, args) = args.split_at(1);
2441 let mut sp_tmp = first[0].span;
2443 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2444 if ! sp_opt.is_some() {
2447 sp_tmp = sp_opt.unwrap();
2454 fn parameter_count_error<'tcx>(sess: &Session,
2457 expected_count: usize,
2461 def_span: Option<Span>,
2463 let mut err = sess.struct_span_err_with_code(sp,
2464 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2465 if variadic {"at least "} else {""},
2467 if expected_count == 1 {""} else {"s"},
2469 if arg_count == 1 {" was"} else {"s were"}),
2472 if let Some(def_s) = def_span {
2473 err.span_label(def_s, "defined here");
2476 let sugg_span = expr_sp.end_point();
2477 // remove closing `)` from the span
2478 let sugg_span = sugg_span.with_hi(sugg_span.lo());
2479 err.span_suggestion(
2481 "expected the unit value `()`; create it with empty parentheses",
2482 String::from("()"));
2484 err.span_label(sp, format!("expected {}{} parameter{}",
2485 if variadic {"at least "} else {""},
2487 if expected_count == 1 {""} else {"s"}));
2492 let formal_tys = if tuple_arguments == TupleArguments {
2493 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2494 match tuple_type.sty {
2495 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2496 parameter_count_error(tcx.sess, sp_args, expr_sp, arg_types.len(), args.len(),
2497 "E0057", false, def_span, false);
2498 expected_arg_tys = &[];
2499 self.err_args(args.len())
2501 ty::TyTuple(arg_types, _) => {
2502 expected_arg_tys = match expected_arg_tys.get(0) {
2503 Some(&ty) => match ty.sty {
2504 ty::TyTuple(ref tys, _) => &tys,
2512 span_err!(tcx.sess, sp, E0059,
2513 "cannot use call notation; the first type parameter \
2514 for the function trait is neither a tuple nor unit");
2515 expected_arg_tys = &[];
2516 self.err_args(args.len())
2519 } else if expected_arg_count == supplied_arg_count {
2521 } else if variadic {
2522 if supplied_arg_count >= expected_arg_count {
2525 parameter_count_error(tcx.sess, sp_args, expr_sp, expected_arg_count,
2526 supplied_arg_count, "E0060", true, def_span, false);
2527 expected_arg_tys = &[];
2528 self.err_args(supplied_arg_count)
2531 // is the missing argument of type `()`?
2532 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2533 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2534 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2535 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2539 parameter_count_error(tcx.sess, sp_args, expr_sp, expected_arg_count,
2540 supplied_arg_count, "E0061", false, def_span, sugg_unit);
2541 expected_arg_tys = &[];
2542 self.err_args(supplied_arg_count)
2545 debug!("check_argument_types: formal_tys={:?}",
2546 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2548 // Check the arguments.
2549 // We do this in a pretty awful way: first we typecheck any arguments
2550 // that are not closures, then we typecheck the closures. This is so
2551 // that we have more information about the types of arguments when we
2552 // typecheck the functions. This isn't really the right way to do this.
2553 for &check_closures in &[false, true] {
2554 debug!("check_closures={}", check_closures);
2556 // More awful hacks: before we check argument types, try to do
2557 // an "opportunistic" vtable resolution of any trait bounds on
2558 // the call. This helps coercions.
2560 self.select_obligations_where_possible();
2563 // For variadic functions, we don't have a declared type for all of
2564 // the arguments hence we only do our usual type checking with
2565 // the arguments who's types we do know.
2566 let t = if variadic {
2568 } else if tuple_arguments == TupleArguments {
2573 for (i, arg) in args.iter().take(t).enumerate() {
2574 // Warn only for the first loop (the "no closures" one).
2575 // Closure arguments themselves can't be diverging, but
2576 // a previous argument can, e.g. `foo(panic!(), || {})`.
2577 if !check_closures {
2578 self.warn_if_unreachable(arg.id, arg.span, "expression");
2581 let is_closure = match arg.node {
2582 hir::ExprClosure(..) => true,
2586 if is_closure != check_closures {
2590 debug!("checking the argument");
2591 let formal_ty = formal_tys[i];
2593 // The special-cased logic below has three functions:
2594 // 1. Provide as good of an expected type as possible.
2595 let expected = expected_arg_tys.get(i).map(|&ty| {
2596 Expectation::rvalue_hint(self, ty)
2599 let checked_ty = self.check_expr_with_expectation(
2601 expected.unwrap_or(ExpectHasType(formal_ty)));
2603 // 2. Coerce to the most detailed type that could be coerced
2604 // to, which is `expected_ty` if `rvalue_hint` returns an
2605 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2606 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2607 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2609 // 3. Relate the expected type and the formal one,
2610 // if the expected type was used for the coercion.
2611 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2615 // We also need to make sure we at least write the ty of the other
2616 // arguments which we skipped above.
2618 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2619 type_error_struct!(s, span, t, E0617,
2620 "can't pass `{}` to variadic function, cast to `{}`",
2624 for arg in args.iter().skip(expected_arg_count) {
2625 let arg_ty = self.check_expr(&arg);
2627 // There are a few types which get autopromoted when passed via varargs
2628 // in C but we just error out instead and require explicit casts.
2629 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2631 ty::TyFloat(ast::FloatTy::F32) => {
2632 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2634 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2635 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2637 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2638 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2640 ty::TyFnDef(..) => {
2641 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2642 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2643 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2651 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2652 (0..len).map(|_| self.tcx.types.err).collect()
2655 // AST fragment checking
2658 expected: Expectation<'tcx>)
2664 ast::LitKind::Str(..) => tcx.mk_static_str(),
2665 ast::LitKind::ByteStr(ref v) => {
2666 tcx.mk_imm_ref(tcx.types.re_static,
2667 tcx.mk_array(tcx.types.u8, v.len() as u64))
2669 ast::LitKind::Byte(_) => tcx.types.u8,
2670 ast::LitKind::Char(_) => tcx.types.char,
2671 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2672 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2673 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2674 let opt_ty = expected.to_option(self).and_then(|ty| {
2676 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2677 ty::TyChar => Some(tcx.types.u8),
2678 ty::TyRawPtr(..) => Some(tcx.types.usize),
2679 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2683 opt_ty.unwrap_or_else(
2684 || tcx.mk_int_var(self.next_int_var_id()))
2686 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2687 ast::LitKind::FloatUnsuffixed(_) => {
2688 let opt_ty = expected.to_option(self).and_then(|ty| {
2690 ty::TyFloat(_) => Some(ty),
2694 opt_ty.unwrap_or_else(
2695 || tcx.mk_float_var(self.next_float_var_id()))
2697 ast::LitKind::Bool(_) => tcx.types.bool
2701 fn check_expr_eq_type(&self,
2702 expr: &'gcx hir::Expr,
2703 expected: Ty<'tcx>) {
2704 let ty = self.check_expr_with_hint(expr, expected);
2705 self.demand_eqtype(expr.span, expected, ty);
2708 pub fn check_expr_has_type_or_error(&self,
2709 expr: &'gcx hir::Expr,
2710 expected: Ty<'tcx>) -> Ty<'tcx> {
2711 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2714 fn check_expr_meets_expectation_or_error(&self,
2715 expr: &'gcx hir::Expr,
2716 expected: Expectation<'tcx>) -> Ty<'tcx> {
2717 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2718 let mut ty = self.check_expr_with_expectation(expr, expected);
2720 // While we don't allow *arbitrary* coercions here, we *do* allow
2721 // coercions from ! to `expected`.
2723 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2724 "expression with never type wound up being adjusted");
2725 let adj_ty = self.next_diverging_ty_var(
2726 TypeVariableOrigin::AdjustmentType(expr.span));
2727 self.apply_adjustments(expr, vec![Adjustment {
2728 kind: Adjust::NeverToAny,
2734 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2735 // Add help to type error if this is an `if` condition with an assignment
2736 match (expected, &expr.node) {
2737 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2738 let msg = "try comparing for equality";
2739 if let (Ok(left), Ok(right)) = (
2740 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2741 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2743 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2755 fn check_expr_coercable_to_type(&self,
2756 expr: &'gcx hir::Expr,
2757 expected: Ty<'tcx>) -> Ty<'tcx> {
2758 let ty = self.check_expr_with_hint(expr, expected);
2759 self.demand_coerce(expr, ty, expected);
2763 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2764 expected: Ty<'tcx>) -> Ty<'tcx> {
2765 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2768 fn check_expr_with_expectation(&self,
2769 expr: &'gcx hir::Expr,
2770 expected: Expectation<'tcx>) -> Ty<'tcx> {
2771 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2774 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2775 self.check_expr_with_expectation(expr, NoExpectation)
2778 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2779 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2780 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2783 // determine the `self` type, using fresh variables for all variables
2784 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2785 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2787 pub fn impl_self_ty(&self,
2788 span: Span, // (potential) receiver for this impl
2790 -> TypeAndSubsts<'tcx> {
2791 let ity = self.tcx.type_of(did);
2792 debug!("impl_self_ty: ity={:?}", ity);
2794 let substs = self.fresh_substs_for_item(span, did);
2795 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2797 TypeAndSubsts { substs: substs, ty: substd_ty }
2800 /// Unifies the output type with the expected type early, for more coercions
2801 /// and forward type information on the input expressions.
2802 fn expected_inputs_for_expected_output(&self,
2804 expected_ret: Expectation<'tcx>,
2805 formal_ret: Ty<'tcx>,
2806 formal_args: &[Ty<'tcx>])
2808 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2809 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2810 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2811 // Attempt to apply a subtyping relationship between the formal
2812 // return type (likely containing type variables if the function
2813 // is polymorphic) and the expected return type.
2814 // No argument expectations are produced if unification fails.
2815 let origin = self.misc(call_span);
2816 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2818 // FIXME(#15760) can't use try! here, FromError doesn't default
2819 // to identity so the resulting type is not constrained.
2822 // Process any obligations locally as much as
2823 // we can. We don't care if some things turn
2824 // out unconstrained or ambiguous, as we're
2825 // just trying to get hints here.
2826 let result = self.save_and_restore_in_snapshot_flag(|_| {
2827 let mut fulfill = FulfillmentContext::new();
2828 let ok = ok; // FIXME(#30046)
2829 for obligation in ok.obligations {
2830 fulfill.register_predicate_obligation(self, obligation);
2832 fulfill.select_where_possible(self)
2837 Err(_) => return Err(()),
2840 Err(_) => return Err(()),
2843 // Record all the argument types, with the substitutions
2844 // produced from the above subtyping unification.
2845 Ok(formal_args.iter().map(|ty| {
2846 self.resolve_type_vars_if_possible(ty)
2849 }).unwrap_or(vec![]);
2850 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2851 formal_args, formal_ret,
2852 expected_args, expected_ret);
2856 // Checks a method call.
2857 fn check_method_call(&self,
2858 expr: &'gcx hir::Expr,
2859 segment: &hir::PathSegment,
2861 args: &'gcx [hir::Expr],
2862 expected: Expectation<'tcx>,
2863 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2864 let rcvr = &args[0];
2865 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2866 // no need to check for bot/err -- callee does that
2867 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2869 let method = match self.lookup_method(rcvr_t,
2875 self.write_method_call(expr.hir_id, method);
2879 if segment.name != keywords::Invalid.name() {
2880 self.report_method_error(span,
2891 // Call the generic checker.
2892 self.check_method_argument_types(span,
2900 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2904 .unwrap_or_else(|| span_bug!(return_expr.span,
2905 "check_return_expr called outside fn body"));
2907 let ret_ty = ret_coercion.borrow().expected_ty();
2908 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2909 ret_coercion.borrow_mut()
2911 &self.cause(return_expr.span,
2912 ObligationCauseCode::ReturnType(return_expr.id)),
2915 self.diverges.get());
2919 // A generic function for checking the then and else in an if
2921 fn check_then_else(&self,
2922 cond_expr: &'gcx hir::Expr,
2923 then_expr: &'gcx hir::Expr,
2924 opt_else_expr: Option<&'gcx hir::Expr>,
2926 expected: Expectation<'tcx>) -> Ty<'tcx> {
2927 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2928 let cond_diverges = self.diverges.get();
2929 self.diverges.set(Diverges::Maybe);
2931 let expected = expected.adjust_for_branches(self);
2932 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2933 let then_diverges = self.diverges.get();
2934 self.diverges.set(Diverges::Maybe);
2936 // We've already taken the expected type's preferences
2937 // into account when typing the `then` branch. To figure
2938 // out the initial shot at a LUB, we thus only consider
2939 // `expected` if it represents a *hard* constraint
2940 // (`only_has_type`); otherwise, we just go with a
2941 // fresh type variable.
2942 let coerce_to_ty = expected.coercion_target_type(self, sp);
2943 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2945 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2946 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2948 if let Some(else_expr) = opt_else_expr {
2949 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2950 let else_diverges = self.diverges.get();
2952 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2954 // We won't diverge unless both branches do (or the condition does).
2955 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2957 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2958 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2960 // If the condition is false we can't diverge.
2961 self.diverges.set(cond_diverges);
2964 let result_ty = coerce.complete(self);
2965 if cond_ty.references_error() {
2972 // Check field access expressions
2973 fn check_field(&self,
2974 expr: &'gcx hir::Expr,
2975 lvalue_pref: LvaluePreference,
2976 base: &'gcx hir::Expr,
2977 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2978 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2979 let expr_t = self.structurally_resolved_type(expr.span,
2981 let mut private_candidate = None;
2982 let mut autoderef = self.autoderef(expr.span, expr_t);
2983 while let Some((base_t, _)) = autoderef.next() {
2985 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2986 debug!("struct named {:?}", base_t);
2987 let (ident, def_scope) =
2988 self.tcx.adjust(field.node, base_def.did, self.body_id);
2989 let fields = &base_def.struct_variant().fields;
2990 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
2991 let field_ty = self.field_ty(expr.span, field, substs);
2992 if field.vis.is_accessible_from(def_scope, self.tcx) {
2993 let adjustments = autoderef.adjust_steps(lvalue_pref);
2994 self.apply_adjustments(base, adjustments);
2995 autoderef.finalize();
2997 self.tcx.check_stability(field.did, expr.id, expr.span);
3001 private_candidate = Some((base_def.did, field_ty));
3007 autoderef.unambiguous_final_ty();
3009 if let Some((did, field_ty)) = private_candidate {
3010 let struct_path = self.tcx().item_path_str(did);
3011 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3012 "field `{}` of struct `{}` is private",
3013 field.node, struct_path);
3014 // Also check if an accessible method exists, which is often what is meant.
3015 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3016 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3021 } else if field.node == keywords::Invalid.name() {
3022 self.tcx().types.err
3023 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3024 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3025 "attempted to take value of method `{}` on type `{}`",
3027 .help("maybe a `()` to call it is missing?")
3029 self.tcx().types.err
3031 if !expr_t.is_primitive_ty() {
3032 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3035 ty::TyAdt(def, _) if !def.is_enum() => {
3036 if let Some(suggested_field_name) =
3037 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
3038 err.span_label(field.span,
3039 format!("did you mean `{}`?", suggested_field_name));
3041 err.span_label(field.span, "unknown field");
3042 let struct_variant_def = def.struct_variant();
3043 let field_names = self.available_field_names(struct_variant_def);
3044 if !field_names.is_empty() {
3045 err.note(&format!("available fields are: {}",
3046 self.name_series_display(field_names)));
3050 ty::TyRawPtr(..) => {
3051 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
3053 self.tcx.hir.node_to_pretty_string(base.id),
3060 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3061 "`{}` is a primitive type and therefore doesn't have fields",
3064 self.tcx().types.err
3068 // Return an hint about the closest match in field names
3069 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3070 field: &Spanned<ast::Name>,
3071 skip: Vec<InternedString>)
3073 let name = field.node.as_str();
3074 let names = variant.fields.iter().filter_map(|field| {
3075 // ignore already set fields and private fields from non-local crates
3076 if skip.iter().any(|x| *x == field.name.as_str()) ||
3077 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3084 find_best_match_for_name(names, &name, None)
3087 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3088 let mut available = Vec::new();
3089 for field in variant.fields.iter() {
3090 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3091 if field.vis.is_accessible_from(def_scope, self.tcx) {
3092 available.push(field.name);
3098 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3099 // dynamic limit, to never omit just one field
3100 let limit = if names.len() == 6 { 6 } else { 5 };
3101 let mut display = names.iter().take(limit)
3102 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3103 if names.len() > limit {
3104 display = format!("{} ... and {} others", display, names.len() - limit);
3109 // Check tuple index expressions
3110 fn check_tup_field(&self,
3111 expr: &'gcx hir::Expr,
3112 lvalue_pref: LvaluePreference,
3113 base: &'gcx hir::Expr,
3114 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3115 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3116 let expr_t = self.structurally_resolved_type(expr.span,
3118 let mut private_candidate = None;
3119 let mut tuple_like = false;
3120 let mut autoderef = self.autoderef(expr.span, expr_t);
3121 while let Some((base_t, _)) = autoderef.next() {
3122 let field = match base_t.sty {
3123 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3124 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3125 if !tuple_like { continue }
3127 debug!("tuple struct named {:?}", base_t);
3128 let ident = ast::Ident {
3129 name: Symbol::intern(&idx.node.to_string()),
3130 ctxt: idx.span.ctxt().modern(),
3132 let (ident, def_scope) =
3133 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3134 let fields = &base_def.struct_variant().fields;
3135 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3136 let field_ty = self.field_ty(expr.span, field, substs);
3137 if field.vis.is_accessible_from(def_scope, self.tcx) {
3138 self.tcx.check_stability(field.did, expr.id, expr.span);
3141 private_candidate = Some((base_def.did, field_ty));
3148 ty::TyTuple(ref v, _) => {
3150 v.get(idx.node).cloned()
3155 if let Some(field_ty) = field {
3156 let adjustments = autoderef.adjust_steps(lvalue_pref);
3157 self.apply_adjustments(base, adjustments);
3158 autoderef.finalize();
3162 autoderef.unambiguous_final_ty();
3164 if let Some((did, field_ty)) = private_candidate {
3165 let struct_path = self.tcx().item_path_str(did);
3166 struct_span_err!(self.tcx().sess, expr.span, E0611,
3167 "field `{}` of tuple-struct `{}` is private",
3168 idx.node, struct_path).emit();
3173 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3174 "attempted out-of-bounds tuple index `{}` on type `{}`",
3175 idx.node, expr_t).emit();
3177 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3180 self.tcx().types.err
3183 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3184 -> DiagnosticBuilder {
3185 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3186 "no field `{}` on type `{}`",
3190 fn report_unknown_field(&self,
3192 variant: &'tcx ty::VariantDef,
3194 skip_fields: &[hir::Field],
3196 let mut err = self.type_error_struct_with_diag(
3198 |actual| match ty.sty {
3199 ty::TyAdt(adt, ..) if adt.is_enum() => {
3200 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3201 "{} `{}::{}` has no field named `{}`",
3202 kind_name, actual, variant.name, field.name.node)
3205 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3206 "{} `{}` has no field named `{}`",
3207 kind_name, actual, field.name.node)
3211 // prevent all specified fields from being suggested
3212 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3213 if let Some(field_name) = Self::suggest_field_name(variant,
3215 skip_fields.collect()) {
3216 err.span_label(field.name.span,
3217 format!("field does not exist - did you mean `{}`?", field_name));
3220 ty::TyAdt(adt, ..) => {
3222 err.span_label(field.name.span,
3223 format!("`{}::{}` does not have this field",
3226 err.span_label(field.name.span,
3227 format!("`{}` does not have this field", ty));
3229 let available_field_names = self.available_field_names(variant);
3230 if !available_field_names.is_empty() {
3231 err.note(&format!("available fields are: {}",
3232 self.name_series_display(available_field_names)));
3235 _ => bug!("non-ADT passed to report_unknown_field")
3241 fn check_expr_struct_fields(&self,
3243 expected: Expectation<'tcx>,
3244 expr_id: ast::NodeId,
3246 variant: &'tcx ty::VariantDef,
3247 ast_fields: &'gcx [hir::Field],
3248 check_completeness: bool) {
3252 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3253 .get(0).cloned().unwrap_or(adt_ty);
3254 // re-link the regions that EIfEO can erase.
3255 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3257 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3258 &ty::TyAdt(adt, substs) => {
3259 (substs, adt.adt_kind(), adt.variant_descr())
3261 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3264 let mut remaining_fields = FxHashMap();
3265 for field in &variant.fields {
3266 remaining_fields.insert(field.name.to_ident(), field);
3269 let mut seen_fields = FxHashMap();
3271 let mut error_happened = false;
3273 // Typecheck each field.
3274 for field in ast_fields {
3275 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3276 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3277 seen_fields.insert(field.name.node, field.span);
3279 // we don't look at stability attributes on
3280 // struct-like enums (yet...), but it's definitely not
3281 // a bug to have construct one.
3282 if adt_kind != ty::AdtKind::Enum {
3283 tcx.check_stability(v_field.did, expr_id, field.span);
3286 self.field_ty(field.span, v_field, substs)
3288 error_happened = true;
3289 if let Some(_) = variant.find_field_named(field.name.node) {
3290 let mut err = struct_span_err!(self.tcx.sess,
3293 "field `{}` specified more than once",
3296 err.span_label(field.name.span, "used more than once");
3298 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3299 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3304 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3310 // Make sure to give a type to the field even if there's
3311 // an error, so we can continue typechecking
3312 self.check_expr_coercable_to_type(&field.expr, field_type);
3315 // Make sure the programmer specified correct number of fields.
3316 if kind_name == "union" {
3317 if ast_fields.len() != 1 {
3318 tcx.sess.span_err(span, "union expressions should have exactly one field");
3320 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3321 let len = remaining_fields.len();
3323 let mut displayable_field_names = remaining_fields
3325 .map(|ident| ident.name.as_str())
3326 .collect::<Vec<_>>();
3328 displayable_field_names.sort();
3330 let truncated_fields_error = if len <= 3 {
3333 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3336 let remaining_fields_names = displayable_field_names.iter().take(3)
3337 .map(|n| format!("`{}`", n))
3338 .collect::<Vec<_>>()
3341 struct_span_err!(tcx.sess, span, E0063,
3342 "missing field{} {}{} in initializer of `{}`",
3343 if remaining_fields.len() == 1 { "" } else { "s" },
3344 remaining_fields_names,
3345 truncated_fields_error,
3347 .span_label(span, format!("missing {}{}",
3348 remaining_fields_names,
3349 truncated_fields_error))
3354 fn check_struct_fields_on_error(&self,
3355 fields: &'gcx [hir::Field],
3356 base_expr: &'gcx Option<P<hir::Expr>>) {
3357 for field in fields {
3358 self.check_expr(&field.expr);
3362 self.check_expr(&base);
3368 pub fn check_struct_path(&self,
3370 node_id: ast::NodeId)
3371 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3372 let path_span = match *qpath {
3373 hir::QPath::Resolved(_, ref path) => path.span,
3374 hir::QPath::TypeRelative(ref qself, _) => qself.span
3376 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3377 let variant = match def {
3379 self.set_tainted_by_errors();
3382 Def::Variant(..) => {
3384 ty::TyAdt(adt, substs) => {
3385 Some((adt.variant_of_def(def), adt.did, substs))
3387 _ => bug!("unexpected type: {:?}", ty.sty)
3390 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3391 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3393 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3394 Some((adt.struct_variant(), adt.did, substs))
3399 _ => bug!("unexpected definition: {:?}", def)
3402 if let Some((variant, did, substs)) = variant {
3403 // Check bounds on type arguments used in the path.
3404 let bounds = self.instantiate_bounds(path_span, did, substs);
3405 let cause = traits::ObligationCause::new(path_span, self.body_id,
3406 traits::ItemObligation(did));
3407 self.add_obligations_for_parameters(cause, &bounds);
3411 struct_span_err!(self.tcx.sess, path_span, E0071,
3412 "expected struct, variant or union type, found {}",
3413 ty.sort_string(self.tcx))
3414 .span_label(path_span, "not a struct")
3420 fn check_expr_struct(&self,
3422 expected: Expectation<'tcx>,
3424 fields: &'gcx [hir::Field],
3425 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3427 // Find the relevant variant
3428 let (variant, struct_ty) =
3429 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3432 self.check_struct_fields_on_error(fields, base_expr);
3433 return self.tcx.types.err;
3436 let path_span = match *qpath {
3437 hir::QPath::Resolved(_, ref path) => path.span,
3438 hir::QPath::TypeRelative(ref qself, _) => qself.span
3441 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3442 base_expr.is_none());
3443 if let &Some(ref base_expr) = base_expr {
3444 self.check_expr_has_type_or_error(base_expr, struct_ty);
3445 match struct_ty.sty {
3446 ty::TyAdt(adt, substs) if adt.is_struct() => {
3447 let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
3448 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3453 .fru_field_types_mut()
3454 .insert(expr.hir_id, fru_field_types);
3457 span_err!(self.tcx.sess, base_expr.span, E0436,
3458 "functional record update syntax requires a struct");
3462 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3468 /// If an expression has any sub-expressions that result in a type error,
3469 /// inspecting that expression's type with `ty.references_error()` will return
3470 /// true. Likewise, if an expression is known to diverge, inspecting its
3471 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3472 /// strict, _|_ can appear in the type of an expression that does not,
3473 /// itself, diverge: for example, fn() -> _|_.)
3474 /// Note that inspecting a type's structure *directly* may expose the fact
3475 /// that there are actually multiple representations for `TyError`, so avoid
3476 /// that when err needs to be handled differently.
3477 fn check_expr_with_expectation_and_lvalue_pref(&self,
3478 expr: &'gcx hir::Expr,
3479 expected: Expectation<'tcx>,
3480 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3481 debug!(">> typechecking: expr={:?} expected={:?}",
3484 // Warn for expressions after diverging siblings.
3485 self.warn_if_unreachable(expr.id, expr.span, "expression");
3487 // Hide the outer diverging and has_errors flags.
3488 let old_diverges = self.diverges.get();
3489 let old_has_errors = self.has_errors.get();
3490 self.diverges.set(Diverges::Maybe);
3491 self.has_errors.set(false);
3493 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3495 // Warn for non-block expressions with diverging children.
3498 hir::ExprLoop(..) | hir::ExprWhile(..) |
3499 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3501 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3504 // Any expression that produces a value of type `!` must have diverged
3506 self.diverges.set(self.diverges.get() | Diverges::Always);
3509 // Record the type, which applies it effects.
3510 // We need to do this after the warning above, so that
3511 // we don't warn for the diverging expression itself.
3512 self.write_ty(expr.hir_id, ty);
3514 // Combine the diverging and has_error flags.
3515 self.diverges.set(self.diverges.get() | old_diverges);
3516 self.has_errors.set(self.has_errors.get() | old_has_errors);
3518 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3519 debug!("... {:?}, expected is {:?}", ty, expected);
3524 fn check_expr_kind(&self,
3525 expr: &'gcx hir::Expr,
3526 expected: Expectation<'tcx>,
3527 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3531 hir::ExprBox(ref subexpr) => {
3532 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3534 ty::TyAdt(def, _) if def.is_box()
3535 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3539 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3540 tcx.mk_box(referent_ty)
3543 hir::ExprLit(ref lit) => {
3544 self.check_lit(&lit, expected)
3546 hir::ExprBinary(op, ref lhs, ref rhs) => {
3547 self.check_binop(expr, op, lhs, rhs)
3549 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3550 self.check_binop_assign(expr, op, lhs, rhs)
3552 hir::ExprUnary(unop, ref oprnd) => {
3553 let expected_inner = match unop {
3554 hir::UnNot | hir::UnNeg => {
3561 let lvalue_pref = match unop {
3562 hir::UnDeref => lvalue_pref,
3565 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3569 if !oprnd_t.references_error() {
3570 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3573 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3575 } else if let Some(ok) = self.try_overloaded_deref(
3576 expr.span, oprnd_t, lvalue_pref) {
3577 let method = self.register_infer_ok_obligations(ok);
3578 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3579 self.apply_adjustments(oprnd, vec![Adjustment {
3580 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3581 target: method.sig.inputs()[0]
3584 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3585 self.write_method_call(expr.hir_id, method);
3587 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3588 "type `{}` cannot be dereferenced",
3590 oprnd_t = tcx.types.err;
3594 let result = self.check_user_unop(expr, oprnd_t, unop);
3595 // If it's builtin, we can reuse the type, this helps inference.
3596 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3601 let result = self.check_user_unop(expr, oprnd_t, unop);
3602 // If it's builtin, we can reuse the type, this helps inference.
3603 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3611 hir::ExprAddrOf(mutbl, ref oprnd) => {
3612 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3614 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3615 if self.tcx.expr_is_lval(&oprnd) {
3616 // Lvalues may legitimately have unsized types.
3617 // For example, dereferences of a fat pointer and
3618 // the last field of a struct can be unsized.
3619 ExpectHasType(mt.ty)
3621 Expectation::rvalue_hint(self, mt.ty)
3627 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3628 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3630 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3631 if tm.ty.references_error() {
3634 // Note: at this point, we cannot say what the best lifetime
3635 // is to use for resulting pointer. We want to use the
3636 // shortest lifetime possible so as to avoid spurious borrowck
3637 // errors. Moreover, the longest lifetime will depend on the
3638 // precise details of the value whose address is being taken
3639 // (and how long it is valid), which we don't know yet until type
3640 // inference is complete.
3642 // Therefore, here we simply generate a region variable. The
3643 // region inferencer will then select the ultimate value.
3644 // Finally, borrowck is charged with guaranteeing that the
3645 // value whose address was taken can actually be made to live
3646 // as long as it needs to live.
3647 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3648 tcx.mk_ref(region, tm)
3651 hir::ExprPath(ref qpath) => {
3652 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3653 expr.id, expr.span);
3654 let ty = if def != Def::Err {
3655 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3657 self.set_tainted_by_errors();
3661 // We always require that the type provided as the value for
3662 // a type parameter outlives the moment of instantiation.
3663 let substs = self.tables.borrow().node_substs(expr.hir_id);
3664 self.add_wf_bounds(substs, expr);
3668 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3669 for output in outputs {
3670 self.check_expr(output);
3672 for input in inputs {
3673 self.check_expr(input);
3677 hir::ExprBreak(destination, ref expr_opt) => {
3678 if let Some(target_id) = destination.target_id.opt_id() {
3679 let (e_ty, e_diverges, cause);
3680 if let Some(ref e) = *expr_opt {
3681 // If this is a break with a value, we need to type-check
3682 // the expression. Get an expected type from the loop context.
3683 let opt_coerce_to = {
3684 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3685 enclosing_breakables.find_breakable(target_id)
3688 .map(|coerce| coerce.expected_ty())
3691 // If the loop context is not a `loop { }`, then break with
3692 // a value is illegal, and `opt_coerce_to` will be `None`.
3693 // Just set expectation to error in that case.
3694 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3696 // Recurse without `enclosing_breakables` borrowed.
3697 e_ty = self.check_expr_with_hint(e, coerce_to);
3698 e_diverges = self.diverges.get();
3699 cause = self.misc(e.span);
3701 // Otherwise, this is a break *without* a value. That's
3702 // always legal, and is equivalent to `break ()`.
3703 e_ty = tcx.mk_nil();
3704 e_diverges = Diverges::Maybe;
3705 cause = self.misc(expr.span);
3708 // Now that we have type-checked `expr_opt`, borrow
3709 // the `enclosing_loops` field and let's coerce the
3710 // type of `expr_opt` into what is expected.
3711 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3712 let ctxt = enclosing_breakables.find_breakable(target_id);
3713 if let Some(ref mut coerce) = ctxt.coerce {
3714 if let Some(ref e) = *expr_opt {
3715 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3717 assert!(e_ty.is_nil());
3718 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3721 // If `ctxt.coerce` is `None`, we can just ignore
3722 // the type of the expresison. This is because
3723 // either this was a break *without* a value, in
3724 // which case it is always a legal type (`()`), or
3725 // else an error would have been flagged by the
3726 // `loops` pass for using break with an expression
3727 // where you are not supposed to.
3728 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3731 ctxt.may_break = true;
3733 // Otherwise, we failed to find the enclosing loop;
3734 // this can only happen if the `break` was not
3735 // inside a loop at all, which is caught by the
3736 // loop-checking pass.
3737 assert!(self.tcx.sess.err_count() > 0);
3739 // We still need to assign a type to the inner expression to
3740 // prevent the ICE in #43162.
3741 if let Some(ref e) = *expr_opt {
3742 self.check_expr_with_hint(e, tcx.types.err);
3744 // ... except when we try to 'break rust;'.
3745 // ICE this expression in particular (see #43162).
3746 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3747 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3748 fatally_break_rust(self.tcx.sess);
3754 // the type of a `break` is always `!`, since it diverges
3757 hir::ExprAgain(_) => { tcx.types.never }
3758 hir::ExprRet(ref expr_opt) => {
3759 if self.ret_coercion.is_none() {
3760 struct_span_err!(self.tcx.sess, expr.span, E0572,
3761 "return statement outside of function body").emit();
3762 } else if let Some(ref e) = *expr_opt {
3763 self.check_return_expr(e);
3765 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3766 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3767 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3771 hir::ExprAssign(ref lhs, ref rhs) => {
3772 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3774 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3777 ExpectIfCondition => {
3778 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3779 expected error elsehwere");
3782 // Only check this if not in an `if` condition, as the
3783 // mistyped comparison help is more appropriate.
3784 if !self.tcx.expr_is_lval(&lhs) {
3785 struct_span_err!(self.tcx.sess, expr.span, E0070,
3786 "invalid left-hand side expression")
3787 .span_label(expr.span, "left-hand of expression not valid")
3793 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3795 if lhs_ty.references_error() || rhs_ty.references_error() {
3801 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3802 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3803 expr.span, expected)
3805 hir::ExprWhile(ref cond, ref body, _) => {
3806 let ctxt = BreakableCtxt {
3807 // cannot use break with a value from a while loop
3812 self.with_breakable_ctxt(expr.id, ctxt, || {
3813 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3814 let cond_diverging = self.diverges.get();
3815 self.check_block_no_value(&body);
3817 // We may never reach the body so it diverging means nothing.
3818 self.diverges.set(cond_diverging);
3823 hir::ExprLoop(ref body, _, source) => {
3824 let coerce = match source {
3825 // you can only use break with a value from a normal `loop { }`
3826 hir::LoopSource::Loop => {
3827 let coerce_to = expected.coercion_target_type(self, body.span);
3828 Some(CoerceMany::new(coerce_to))
3831 hir::LoopSource::WhileLet |
3832 hir::LoopSource::ForLoop => {
3837 let ctxt = BreakableCtxt {
3839 may_break: false, // will get updated if/when we find a `break`
3842 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3843 self.check_block_no_value(&body);
3847 // No way to know whether it's diverging because
3848 // of a `break` or an outer `break` or `return.
3849 self.diverges.set(Diverges::Maybe);
3852 // If we permit break with a value, then result type is
3853 // the LUB of the breaks (possibly ! if none); else, it
3854 // is nil. This makes sense because infinite loops
3855 // (which would have type !) are only possible iff we
3856 // permit break with a value [1].
3857 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3858 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3860 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3861 self.check_match(expr, &discrim, arms, expected, match_src)
3863 hir::ExprClosure(capture, ref decl, body_id, _, _) => {
3864 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3866 hir::ExprBlock(ref body) => {
3867 self.check_block_with_expected(&body, expected)
3869 hir::ExprCall(ref callee, ref args) => {
3870 self.check_call(expr, &callee, args, expected)
3872 hir::ExprMethodCall(ref segment, span, ref args) => {
3873 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3875 hir::ExprCast(ref e, ref t) => {
3876 // Find the type of `e`. Supply hints based on the type we are casting to,
3878 let t_cast = self.to_ty(t);
3879 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3880 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3881 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3882 let diverges = self.diverges.get();
3884 // Eagerly check for some obvious errors.
3885 if t_expr.references_error() || t_cast.references_error() {
3888 // Defer other checks until we're done type checking.
3889 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3890 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3892 deferred_cast_checks.push(cast_check);
3895 Err(ErrorReported) => {
3901 hir::ExprType(ref e, ref t) => {
3902 let typ = self.to_ty(&t);
3903 self.check_expr_eq_type(&e, typ);
3906 hir::ExprArray(ref args) => {
3907 let uty = expected.to_option(self).and_then(|uty| {
3909 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3914 let element_ty = if !args.is_empty() {
3915 let coerce_to = uty.unwrap_or_else(
3916 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3917 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3918 assert_eq!(self.diverges.get(), Diverges::Maybe);
3920 let e_ty = self.check_expr_with_hint(e, coerce_to);
3921 let cause = self.misc(e.span);
3922 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3924 coerce.complete(self)
3926 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3928 tcx.mk_array(element_ty, args.len() as u64)
3930 hir::ExprRepeat(ref element, count) => {
3931 let count_def_id = tcx.hir.body_owner_def_id(count);
3932 let param_env = ty::ParamEnv::empty(traits::Reveal::UserFacing);
3933 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
3934 let count = tcx.const_eval(param_env.and((count_def_id, substs)));
3936 if let Err(ref err) = count {
3937 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
3940 let uty = match expected {
3941 ExpectHasType(uty) => {
3943 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3950 let (element_ty, t) = match uty {
3952 self.check_expr_coercable_to_type(&element, uty);
3956 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3957 let element_ty = self.check_expr_has_type_or_error(&element, t);
3962 if let Ok(count) = count {
3963 let zero_or_one = count.val.to_const_int().and_then(|count| {
3964 count.to_u64().map(|count| count <= 1)
3965 }).unwrap_or(false);
3967 // For [foo, ..n] where n > 1, `foo` must have
3969 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3970 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3974 if element_ty.references_error() {
3976 } else if let Ok(count) = count {
3977 tcx.mk_ty(ty::TyArray(t, count))
3982 hir::ExprTup(ref elts) => {
3983 let flds = expected.only_has_type(self).and_then(|ty| {
3984 let ty = self.resolve_type_vars_with_obligations(ty);
3986 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3991 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3992 let t = match flds {
3993 Some(ref fs) if i < fs.len() => {
3995 self.check_expr_coercable_to_type(&e, ety);
3999 self.check_expr_with_expectation(&e, NoExpectation)
4004 let tuple = tcx.mk_tup(elt_ts_iter, false);
4005 if tuple.references_error() {
4008 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4012 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4013 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4015 hir::ExprField(ref base, ref field) => {
4016 self.check_field(expr, lvalue_pref, &base, field)
4018 hir::ExprTupField(ref base, idx) => {
4019 self.check_tup_field(expr, lvalue_pref, &base, idx)
4021 hir::ExprIndex(ref base, ref idx) => {
4022 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
4023 let idx_t = self.check_expr(&idx);
4025 if base_t.references_error() {
4027 } else if idx_t.references_error() {
4030 let base_t = self.structurally_resolved_type(expr.span, base_t);
4031 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
4032 Some((index_ty, element_ty)) => {
4033 self.demand_coerce(idx, idx_t, index_ty);
4037 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4038 "cannot index into a value of type `{}`",
4040 // Try to give some advice about indexing tuples.
4041 if let ty::TyTuple(..) = base_t.sty {
4042 let mut needs_note = true;
4043 // If the index is an integer, we can show the actual
4044 // fixed expression:
4045 if let hir::ExprLit(ref lit) = idx.node {
4046 if let ast::LitKind::Int(i,
4047 ast::LitIntType::Unsuffixed) = lit.node {
4048 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4049 if let Ok(snip) = snip {
4050 err.span_suggestion(expr.span,
4051 "to access tuple elements, use",
4052 format!("{}.{}", snip, i));
4058 err.help("to access tuple elements, use tuple indexing \
4059 syntax (e.g. `tuple.0`)");
4068 hir::ExprYield(ref value) => {
4069 match self.yield_ty {
4071 self.check_expr_coercable_to_type(&value, ty);
4074 struct_span_err!(self.tcx.sess, expr.span, E0627,
4075 "yield statement outside of generator literal").emit();
4083 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4084 // The newly resolved definition is written into `type_dependent_defs`.
4085 fn finish_resolving_struct_path(&self,
4088 node_id: ast::NodeId)
4092 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4093 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4094 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4097 hir::QPath::TypeRelative(ref qself, ref segment) => {
4098 let ty = self.to_ty(qself);
4100 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4105 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4108 // Write back the new resolution.
4109 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4110 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4117 // Resolve associated value path into a base type and associated constant or method definition.
4118 // The newly resolved definition is written into `type_dependent_defs`.
4119 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4120 qpath: &'b hir::QPath,
4121 node_id: ast::NodeId,
4123 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4125 let (ty, item_segment) = match *qpath {
4126 hir::QPath::Resolved(ref opt_qself, ref path) => {
4128 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4129 &path.segments[..]);
4131 hir::QPath::TypeRelative(ref qself, ref segment) => {
4132 (self.to_ty(qself), segment)
4135 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4136 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4137 // Return directly on cache hit. This is useful to avoid doubly reporting
4138 // errors with default match binding modes. See #44614.
4139 return (*cached_def, Some(ty), slice::ref_slice(&**item_segment))
4141 let item_name = item_segment.name;
4142 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4145 let def = match error {
4146 method::MethodError::PrivateMatch(def, _) => def,
4149 if item_name != keywords::Invalid.name() {
4150 self.report_method_error(span, ty, item_name, None, error, None);
4156 // Write back the new resolution.
4157 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4158 (def, Some(ty), slice::ref_slice(&**item_segment))
4161 pub fn check_decl_initializer(&self,
4162 local: &'gcx hir::Local,
4163 init: &'gcx hir::Expr) -> Ty<'tcx>
4165 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4166 // for #42640 (default match binding modes).
4169 let ref_bindings = local.pat.contains_explicit_ref_binding();
4171 let local_ty = self.local_ty(init.span, local.id);
4172 if let Some(m) = ref_bindings {
4173 // Somewhat subtle: if we have a `ref` binding in the pattern,
4174 // we want to avoid introducing coercions for the RHS. This is
4175 // both because it helps preserve sanity and, in the case of
4176 // ref mut, for soundness (issue #23116). In particular, in
4177 // the latter case, we need to be clear that the type of the
4178 // referent for the reference that results is *equal to* the
4179 // type of the lvalue it is referencing, and not some
4180 // supertype thereof.
4181 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4182 self.demand_eqtype(init.span, init_ty, local_ty);
4185 self.check_expr_coercable_to_type(init, local_ty)
4189 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4190 let t = self.local_ty(local.span, local.id);
4191 self.write_ty(local.hir_id, t);
4193 if let Some(ref init) = local.init {
4194 let init_ty = self.check_decl_initializer(local, &init);
4195 if init_ty.references_error() {
4196 self.write_ty(local.hir_id, init_ty);
4200 self.check_pat_walk(&local.pat, t,
4201 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4203 let pat_ty = self.node_ty(local.pat.hir_id);
4204 if pat_ty.references_error() {
4205 self.write_ty(local.hir_id, pat_ty);
4209 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4210 // Don't do all the complex logic below for DeclItem.
4212 hir::StmtDecl(ref decl, _) => {
4214 hir::DeclLocal(_) => {}
4215 hir::DeclItem(_) => {
4220 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4223 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4225 // Hide the outer diverging and has_errors flags.
4226 let old_diverges = self.diverges.get();
4227 let old_has_errors = self.has_errors.get();
4228 self.diverges.set(Diverges::Maybe);
4229 self.has_errors.set(false);
4232 hir::StmtDecl(ref decl, _) => {
4234 hir::DeclLocal(ref l) => {
4235 self.check_decl_local(&l);
4237 hir::DeclItem(_) => {/* ignore for now */}
4240 hir::StmtExpr(ref expr, _) => {
4241 // Check with expected type of ()
4242 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4244 hir::StmtSemi(ref expr, _) => {
4245 self.check_expr(&expr);
4249 // Combine the diverging and has_error flags.
4250 self.diverges.set(self.diverges.get() | old_diverges);
4251 self.has_errors.set(self.has_errors.get() | old_has_errors);
4254 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4255 let unit = self.tcx.mk_nil();
4256 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4258 // if the block produces a `!` value, that can always be
4259 // (effectively) coerced to unit.
4261 self.demand_suptype(blk.span, unit, ty);
4265 fn check_block_with_expected(&self,
4266 blk: &'gcx hir::Block,
4267 expected: Expectation<'tcx>) -> Ty<'tcx> {
4269 let mut fcx_ps = self.ps.borrow_mut();
4270 let unsafety_state = fcx_ps.recurse(blk);
4271 replace(&mut *fcx_ps, unsafety_state)
4274 // In some cases, blocks have just one exit, but other blocks
4275 // can be targeted by multiple breaks. This cannot happen in
4276 // normal Rust syntax today, but it can happen when we desugar
4277 // a `do catch { ... }` expression.
4281 // 'a: { if true { break 'a Err(()); } Ok(()) }
4283 // Here we would wind up with two coercions, one from
4284 // `Err(())` and the other from the tail expression
4285 // `Ok(())`. If the tail expression is omitted, that's a
4286 // "forced unit" -- unless the block diverges, in which
4287 // case we can ignore the tail expression (e.g., `'a: {
4288 // break 'a 22; }` would not force the type of the block
4290 let tail_expr = blk.expr.as_ref();
4291 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4292 let coerce = if blk.targeted_by_break {
4293 CoerceMany::new(coerce_to_ty)
4295 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4296 Some(e) => ref_slice(e),
4299 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4302 let prev_diverges = self.diverges.get();
4303 let ctxt = BreakableCtxt {
4304 coerce: Some(coerce),
4308 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4309 for s in &blk.stmts {
4313 // check the tail expression **without** holding the
4314 // `enclosing_breakables` lock below.
4315 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4317 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4318 let ctxt = enclosing_breakables.find_breakable(blk.id);
4319 let coerce = ctxt.coerce.as_mut().unwrap();
4320 if let Some(tail_expr_ty) = tail_expr_ty {
4321 let tail_expr = tail_expr.unwrap();
4322 let cause = self.cause(tail_expr.span,
4323 ObligationCauseCode::BlockTailExpression(blk.id));
4328 self.diverges.get());
4330 // Subtle: if there is no explicit tail expression,
4331 // that is typically equivalent to a tail expression
4332 // of `()` -- except if the block diverges. In that
4333 // case, there is no value supplied from the tail
4334 // expression (assuming there are no other breaks,
4335 // this implies that the type of the block will be
4338 // #41425 -- label the implicit `()` as being the
4339 // "found type" here, rather than the "expected type".
4340 if !self.diverges.get().always() {
4341 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4342 if let Some(expected_ty) = expected.only_has_type(self) {
4343 self.consider_hint_about_removing_semicolon(blk,
4353 // If we can break from the block, then the block's exit is always reachable
4354 // (... as long as the entry is reachable) - regardless of the tail of the block.
4355 self.diverges.set(prev_diverges);
4358 let mut ty = ctxt.coerce.unwrap().complete(self);
4360 if self.has_errors.get() || ty.references_error() {
4361 ty = self.tcx.types.err
4364 self.write_ty(blk.hir_id, ty);
4366 *self.ps.borrow_mut() = prev;
4370 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4371 /// suggestion can be made, `None` otherwise.
4372 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4373 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4374 // `while` before reaching it, as block tail returns are not available in them.
4375 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4376 let parent = self.tcx.hir.get(fn_id);
4378 if let Node::NodeItem(&hir::Item {
4379 name, node: hir::ItemFn(ref decl, ..), ..
4381 decl.clone().and_then(|decl| {
4382 // This is less than ideal, it will not suggest a return type span on any
4383 // method called `main`, regardless of whether it is actually the entry point,
4384 // but it will still present it as the reason for the expected type.
4385 Some((decl, name != Symbol::intern("main")))
4387 } else if let Node::NodeTraitItem(&hir::TraitItem {
4388 node: hir::TraitItemKind::Method(hir::MethodSig {
4392 decl.clone().and_then(|decl| {
4395 } else if let Node::NodeImplItem(&hir::ImplItem {
4396 node: hir::ImplItemKind::Method(hir::MethodSig {
4400 decl.clone().and_then(|decl| {
4411 /// On implicit return expressions with mismatched types, provide the following suggestions:
4413 /// - Point out the method's return type as the reason for the expected type
4414 /// - Possible missing semicolon
4415 /// - Possible missing return type if the return type is the default, and not `fn main()`
4416 pub fn suggest_mismatched_types_on_tail(&self,
4417 err: &mut DiagnosticBuilder<'tcx>,
4418 expression: &'gcx hir::Expr,
4422 blk_id: ast::NodeId) {
4423 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4425 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4426 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4430 /// A common error is to forget to add a semicolon at the end of a block:
4434 /// bar_that_returns_u32()
4438 /// This routine checks if the return expression in a block would make sense on its own as a
4439 /// statement and the return type has been left as default or has been specified as `()`. If so,
4440 /// it suggests adding a semicolon.
4441 fn suggest_missing_semicolon(&self,
4442 err: &mut DiagnosticBuilder<'tcx>,
4443 expression: &'gcx hir::Expr,
4446 if expected.is_nil() {
4447 // `BlockTailExpression` only relevant if the tail expr would be
4448 // useful on its own.
4449 match expression.node {
4451 hir::ExprMethodCall(..) |
4453 hir::ExprWhile(..) |
4455 hir::ExprMatch(..) |
4456 hir::ExprBlock(..) => {
4457 let sp = cause_span.next_point();
4458 err.span_suggestion(sp,
4459 "try adding a semicolon",
4468 /// A possible error is to forget to add a return type that is needed:
4472 /// bar_that_returns_u32()
4476 /// This routine checks if the return type is left as default, the method is not part of an
4477 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4479 fn suggest_missing_return_type(&self,
4480 err: &mut DiagnosticBuilder<'tcx>,
4481 fn_decl: &hir::FnDecl,
4484 can_suggest: bool) {
4485 // Only suggest changing the return type for methods that
4486 // haven't set a return type at all (and aren't `fn main()` or an impl).
4487 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4488 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4489 err.span_suggestion(span,
4490 "try adding a return type",
4491 format!("-> {} ", found));
4493 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4494 err.span_label(span, "possibly return type missing here?");
4496 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4497 // `fn main()` must return `()`, do not suggest changing return type
4498 err.span_label(span, "expected `()` because of default return type");
4500 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4501 // Only point to return type if the expected type is the return type, as if they
4502 // are not, the expectation must have been caused by something else.
4503 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4505 let ty = AstConv::ast_ty_to_ty(self, ty);
4506 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4507 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4508 if ty.sty == expected.sty {
4509 err.span_label(sp, format!("expected `{}` because of return type",
4517 /// A common error is to add an extra semicolon:
4520 /// fn foo() -> usize {
4525 /// This routine checks if the final statement in a block is an
4526 /// expression with an explicit semicolon whose type is compatible
4527 /// with `expected_ty`. If so, it suggests removing the semicolon.
4528 fn consider_hint_about_removing_semicolon(&self,
4529 blk: &'gcx hir::Block,
4530 expected_ty: Ty<'tcx>,
4531 err: &mut DiagnosticBuilder) {
4532 // Be helpful when the user wrote `{... expr;}` and
4533 // taking the `;` off is enough to fix the error.
4534 let last_stmt = match blk.stmts.last() {
4538 let last_expr = match last_stmt.node {
4539 hir::StmtSemi(ref e, _) => e,
4542 let last_expr_ty = self.node_ty(last_expr.hir_id);
4543 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4546 let original_span = original_sp(last_stmt.span, blk.span);
4547 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4548 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4551 // Instantiates the given path, which must refer to an item with the given
4552 // number of type parameters and type.
4553 pub fn instantiate_value_path(&self,
4554 segments: &[hir::PathSegment],
4555 opt_self_ty: Option<Ty<'tcx>>,
4558 node_id: ast::NodeId)
4560 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4565 // We need to extract the type parameters supplied by the user in
4566 // the path `path`. Due to the current setup, this is a bit of a
4567 // tricky-process; the problem is that resolve only tells us the
4568 // end-point of the path resolution, and not the intermediate steps.
4569 // Luckily, we can (at least for now) deduce the intermediate steps
4570 // just from the end-point.
4572 // There are basically four cases to consider:
4574 // 1. Reference to a constructor of enum variant or struct:
4576 // struct Foo<T>(...)
4577 // enum E<T> { Foo(...) }
4579 // In these cases, the parameters are declared in the type
4582 // 2. Reference to a fn item or a free constant:
4586 // In this case, the path will again always have the form
4587 // `a::b::foo::<T>` where only the final segment should have
4588 // type parameters. However, in this case, those parameters are
4589 // declared on a value, and hence are in the `FnSpace`.
4591 // 3. Reference to a method or an associated constant:
4593 // impl<A> SomeStruct<A> {
4597 // Here we can have a path like
4598 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4599 // may appear in two places. The penultimate segment,
4600 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4601 // final segment, `foo::<B>` contains parameters in fn space.
4603 // 4. Reference to a local variable
4605 // Local variables can't have any type parameters.
4607 // The first step then is to categorize the segments appropriately.
4609 assert!(!segments.is_empty());
4611 let mut ufcs_associated = None;
4612 let mut type_segment = None;
4613 let mut fn_segment = None;
4615 // Case 1. Reference to a struct/variant constructor.
4616 Def::StructCtor(def_id, ..) |
4617 Def::VariantCtor(def_id, ..) => {
4618 // Everything but the final segment should have no
4619 // parameters at all.
4620 let mut generics = self.tcx.generics_of(def_id);
4621 if let Some(def_id) = generics.parent {
4622 // Variant and struct constructors use the
4623 // generics of their parent type definition.
4624 generics = self.tcx.generics_of(def_id);
4626 type_segment = Some((segments.last().unwrap(), generics));
4629 // Case 2. Reference to a top-level value.
4631 Def::Const(def_id) |
4632 Def::Static(def_id, _) => {
4633 fn_segment = Some((segments.last().unwrap(),
4634 self.tcx.generics_of(def_id)));
4637 // Case 3. Reference to a method or associated const.
4638 Def::Method(def_id) |
4639 Def::AssociatedConst(def_id) => {
4640 let container = self.tcx.associated_item(def_id).container;
4642 ty::TraitContainer(trait_did) => {
4643 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4645 ty::ImplContainer(_) => {}
4648 let generics = self.tcx.generics_of(def_id);
4649 if segments.len() >= 2 {
4650 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4651 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4653 // `<T>::assoc` will end up here, and so can `T::assoc`.
4654 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4655 ufcs_associated = Some((container, self_ty));
4657 fn_segment = Some((segments.last().unwrap(), generics));
4660 // Case 4. Local variable, no generics.
4661 Def::Local(..) | Def::Upvar(..) => {}
4663 _ => bug!("unexpected definition: {:?}", def),
4666 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4668 // Now that we have categorized what space the parameters for each
4669 // segment belong to, let's sort out the parameters that the user
4670 // provided (if any) into their appropriate spaces. We'll also report
4671 // errors if type parameters are provided in an inappropriate place.
4672 let poly_segments = type_segment.is_some() as usize +
4673 fn_segment.is_some() as usize;
4674 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4677 Def::Local(nid) | Def::Upvar(nid, ..) => {
4678 let ty = self.local_ty(span, nid);
4679 let ty = self.normalize_associated_types_in(span, &ty);
4680 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4686 // Now we have to compare the types that the user *actually*
4687 // provided against the types that were *expected*. If the user
4688 // did not provide any types, then we want to substitute inference
4689 // variables. If the user provided some types, we may still need
4690 // to add defaults. If the user provided *too many* types, that's
4692 self.check_path_parameter_count(span, &mut type_segment, false);
4693 self.check_path_parameter_count(span, &mut fn_segment, false);
4694 self.check_impl_trait(span, &mut fn_segment);
4696 let (fn_start, has_self) = match (type_segment, fn_segment) {
4697 (_, Some((_, generics))) => {
4698 (generics.parent_count(), generics.has_self)
4700 (Some((_, generics)), None) => {
4701 (generics.own_count(), generics.has_self)
4703 (None, None) => (0, false)
4705 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4706 let mut i = def.index as usize;
4708 let segment = if i < fn_start {
4709 i -= has_self as usize;
4715 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4716 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4719 if let Some(lifetime) = lifetimes.get(i) {
4720 AstConv::ast_region_to_region(self, lifetime, Some(def))
4722 self.re_infer(span, Some(def)).unwrap()
4725 let mut i = def.index as usize;
4727 let segment = if i < fn_start {
4728 // Handle Self first, so we can adjust the index to match the AST.
4729 if has_self && i == 0 {
4730 return opt_self_ty.unwrap_or_else(|| {
4731 self.type_var_for_def(span, def, substs)
4734 i -= has_self as usize;
4740 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4741 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4744 // Skip over the lifetimes in the same segment.
4745 if let Some((_, generics)) = segment {
4746 i -= generics.regions.len();
4749 if let Some(ast_ty) = types.get(i) {
4750 // A provided type parameter.
4752 } else if !infer_types && def.has_default {
4753 // No type parameter provided, but a default exists.
4754 let default = self.tcx.type_of(def.def_id);
4757 default.subst_spanned(self.tcx, substs, Some(span))
4760 // No type parameters were provided, we can infer all.
4761 // This can also be reached in some error cases:
4762 // We prefer to use inference variables instead of
4763 // TyError to let type inference recover somewhat.
4764 self.type_var_for_def(span, def, substs)
4768 // The things we are substituting into the type should not contain
4769 // escaping late-bound regions, and nor should the base type scheme.
4770 let ty = self.tcx.type_of(def.def_id());
4771 assert!(!substs.has_escaping_regions());
4772 assert!(!ty.has_escaping_regions());
4774 // Add all the obligations that are required, substituting and
4775 // normalized appropriately.
4776 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4777 self.add_obligations_for_parameters(
4778 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4781 // Substitute the values for the type parameters into the type of
4782 // the referenced item.
4783 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4785 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4786 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4787 // is inherent, there is no `Self` parameter, instead, the impl needs
4788 // type parameters, which we can infer by unifying the provided `Self`
4789 // with the substituted impl type.
4790 let ty = self.tcx.type_of(impl_def_id);
4792 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4793 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4794 Ok(ok) => self.register_infer_ok_obligations(ok),
4797 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4804 debug!("instantiate_value_path: type of {:?} is {:?}",
4807 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4811 /// Report errors if the provided parameters are too few or too many.
4812 fn check_path_parameter_count(&self,
4814 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4815 is_method_call: bool) {
4816 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4817 (&[][..], &[][..], true, &[][..]),
4818 |(s, _)| s.parameters.as_ref().map_or(
4819 (&[][..], &[][..], s.infer_types, &[][..]),
4820 |p| (&p.lifetimes[..], &p.types[..],
4821 s.infer_types, &p.bindings[..])));
4822 let infer_lifetimes = lifetimes.len() == 0;
4824 let count_lifetime_params = |n| {
4825 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4827 let count_type_params = |n| {
4828 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4831 // Check provided type parameters.
4832 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4833 if generics.parent.is_none() {
4834 &generics.types[generics.has_self as usize..]
4839 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4840 if types.len() > type_defs.len() {
4841 let span = types[type_defs.len()].span;
4842 let expected_text = count_type_params(type_defs.len());
4843 let actual_text = count_type_params(types.len());
4844 struct_span_err!(self.tcx.sess, span, E0087,
4845 "too many type parameters provided: \
4846 expected at most {}, found {}",
4847 expected_text, actual_text)
4848 .span_label(span, format!("expected {}", expected_text))
4851 // To prevent derived errors to accumulate due to extra
4852 // type parameters, we force instantiate_value_path to
4853 // use inference variables instead of the provided types.
4855 } else if types.len() < required_len && !infer_types {
4856 let expected_text = count_type_params(required_len);
4857 let actual_text = count_type_params(types.len());
4858 struct_span_err!(self.tcx.sess, span, E0089,
4859 "too few type parameters provided: \
4860 expected {}, found {}",
4861 expected_text, actual_text)
4862 .span_label(span, format!("expected {}", expected_text))
4866 if !bindings.is_empty() {
4867 AstConv::prohibit_projection(self, bindings[0].span);
4870 // Check provided lifetime parameters.
4871 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4872 let required_len = lifetime_defs.len();
4874 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4875 let has_late_bound_lifetime_defs =
4876 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4877 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4878 // Report this as a lint only if no error was reported previously.
4879 let primary_msg = "cannot specify lifetime arguments explicitly \
4880 if late bound lifetime parameters are present";
4881 let note_msg = "the late bound lifetime parameter is introduced here";
4882 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4883 lifetimes.len() < required_len && !infer_lifetimes) {
4884 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4885 err.span_note(span_late, note_msg);
4889 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4890 multispan.push_span_label(span_late, note_msg.to_string());
4891 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4892 lifetimes[0].id, multispan, primary_msg);
4897 if lifetimes.len() > lifetime_defs.len() {
4898 let span = lifetimes[lifetime_defs.len()].span;
4899 let expected_text = count_lifetime_params(lifetime_defs.len());
4900 let actual_text = count_lifetime_params(lifetimes.len());
4901 struct_span_err!(self.tcx.sess, span, E0088,
4902 "too many lifetime parameters provided: \
4903 expected at most {}, found {}",
4904 expected_text, actual_text)
4905 .span_label(span, format!("expected {}", expected_text))
4907 } else if lifetimes.len() < required_len && !infer_lifetimes {
4908 let expected_text = count_lifetime_params(lifetime_defs.len());
4909 let actual_text = count_lifetime_params(lifetimes.len());
4910 struct_span_err!(self.tcx.sess, span, E0090,
4911 "too few lifetime parameters provided: \
4912 expected {}, found {}",
4913 expected_text, actual_text)
4914 .span_label(span, format!("expected {}", expected_text))
4919 /// Report error if there is an explicit type parameter when using `impl Trait`.
4920 fn check_impl_trait(&self,
4922 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
4923 use hir::SyntheticTyParamKind::*;
4925 segment.map(|(path_segment, generics)| {
4926 let explicit = !path_segment.infer_types;
4927 let impl_trait = generics.types.iter()
4929 match ty_param.synthetic {
4930 Some(ImplTrait) => true,
4935 if explicit && impl_trait {
4936 let mut err = struct_span_err! {
4940 "cannot provide explicit type parameters when `impl Trait` is \
4941 used in argument position."
4949 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4951 where F: Fn() -> Ty<'tcx>
4953 let mut ty = self.resolve_type_vars_with_obligations(ty);
4956 let alternative = f();
4959 if alternative.is_ty_var() || alternative.references_error() {
4960 if !self.is_tainted_by_errors() {
4961 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4962 "the type of this value must be known in this context")
4965 self.demand_suptype(sp, self.tcx.types.err, ty);
4966 ty = self.tcx.types.err;
4968 self.demand_suptype(sp, alternative, ty);
4976 // Resolves `typ` by a single level if `typ` is a type variable. If no
4977 // resolution is possible, then an error is reported.
4978 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4979 self.structurally_resolve_type_or_else(sp, ty, || {
4984 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4985 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4986 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4989 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4990 index = enclosing_breakables.stack.len();
4991 enclosing_breakables.by_id.insert(id, index);
4992 enclosing_breakables.stack.push(ctxt);
4996 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4997 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4998 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4999 enclosing_breakables.stack.pop().expect("missing breakable context")
5005 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5006 generics: &hir::Generics,
5008 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5009 generics.ty_params.len(), ty);
5011 // make a vector of booleans initially false, set to true when used
5012 if generics.ty_params.is_empty() { return; }
5013 let mut tps_used = vec![false; generics.ty_params.len()];
5015 for leaf_ty in ty.walk() {
5016 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
5017 debug!("Found use of ty param num {}", idx);
5018 tps_used[idx as usize - generics.lifetimes.len()] = true;
5022 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
5024 struct_span_err!(tcx.sess, param.span, E0091,
5025 "type parameter `{}` is unused",
5027 .span_label(param.span, "unused type parameter")
5033 fn fatally_break_rust(sess: &Session) {
5034 let handler = sess.diagnostic();
5035 handler.span_bug_no_panic(
5037 "It looks like you're trying to break rust; would you like some ICE?",
5039 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5040 handler.note_without_error(
5041 "we would appreciate a joke overview: \
5042 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5044 handler.note_without_error(&format!("rustc {} running on {}",
5045 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5046 ::session::config::host_triple(),