1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 n.b.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
89 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use namespace::Namespace;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::anon_types::AnonTypeDecl;
94 use rustc::infer::type_variable::{TypeVariableOrigin};
95 use rustc::middle::region;
96 use rustc::mir::interpret::{GlobalId};
97 use rustc::ty::subst::{Kind, UnpackedKind, Subst, Substs};
98 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
99 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate};
100 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
101 use rustc::ty::fold::TypeFoldable;
102 use rustc::ty::maps::Providers;
103 use rustc::ty::util::{Representability, IntTypeExt, Discr};
104 use errors::{DiagnosticBuilder, DiagnosticId};
106 use require_c_abi_if_variadic;
107 use session::{CompileIncomplete, config, Session};
110 use util::common::{ErrorReported, indenter};
111 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
113 use std::cell::{Cell, RefCell, Ref, RefMut};
114 use rustc_data_structures::sync::Lrc;
115 use std::collections::hash_map::Entry;
117 use std::fmt::Display;
118 use std::mem::replace;
120 use std::ops::{self, Deref};
121 use rustc_target::spec::abi::Abi;
124 use syntax::codemap::{original_sp, Spanned};
125 use syntax::feature_gate::{GateIssue, emit_feature_err};
127 use syntax::symbol::{Symbol, LocalInternedString, keywords};
128 use syntax::util::lev_distance::find_best_match_for_name;
129 use syntax_pos::{self, BytePos, Span, MultiSpan};
131 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
132 use rustc::hir::itemlikevisit::ItemLikeVisitor;
133 use rustc::hir::map::Node;
134 use rustc::hir::{self, PatKind};
135 use rustc::middle::lang_items;
151 mod generator_interior;
155 /// A wrapper for InferCtxt's `in_progress_tables` field.
156 #[derive(Copy, Clone)]
157 struct MaybeInProgressTables<'a, 'tcx: 'a> {
158 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
161 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
162 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
163 match self.maybe_tables {
164 Some(tables) => tables.borrow(),
166 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
171 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
172 match self.maybe_tables {
173 Some(tables) => tables.borrow_mut(),
175 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
182 /// closures defined within the function. For example:
185 /// bar(move|| { ... })
188 /// Here, the function `foo()` and the closure passed to
189 /// `bar()` will each have their own `FnCtxt`, but they will
190 /// share the inherited fields.
191 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
192 infcx: InferCtxt<'a, 'gcx, 'tcx>,
194 tables: MaybeInProgressTables<'a, 'tcx>,
196 locals: RefCell<NodeMap<Ty<'tcx>>>,
198 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
200 // When we process a call like `c()` where `c` is a closure type,
201 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
202 // `FnOnce` closure. In that case, we defer full resolution of the
203 // call until upvar inference can kick in and make the
204 // decision. We keep these deferred resolutions grouped by the
205 // def-id of the closure, so that once we decide, we can easily go
206 // back and process them.
207 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
209 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
211 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
213 // Anonymized types found in explicit return types and their
214 // associated fresh inference variable. Writeback resolves these
215 // variables to get the concrete type, which can be used to
216 // deanonymize TyAnon, after typeck is done with all functions.
217 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
219 /// Each type parameter has an implicit region bound that
220 /// indicates it must outlive at least the function body (the user
221 /// may specify stronger requirements). This field indicates the
222 /// region of the callee. If it is `None`, then the parameter
223 /// environment is for an item or something where the "callee" is
225 implicit_region_bound: Option<ty::Region<'tcx>>,
227 body_id: Option<hir::BodyId>,
230 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
231 type Target = InferCtxt<'a, 'gcx, 'tcx>;
232 fn deref(&self) -> &Self::Target {
237 /// When type-checking an expression, we propagate downward
238 /// whatever type hint we are able in the form of an `Expectation`.
239 #[derive(Copy, Clone, Debug)]
240 pub enum Expectation<'tcx> {
241 /// We know nothing about what type this expression should have.
244 /// This expression is an `if` condition, it must resolve to `bool`.
247 /// This expression should have the type given (or some subtype)
248 ExpectHasType(Ty<'tcx>),
250 /// This expression will be cast to the `Ty`
251 ExpectCastableToType(Ty<'tcx>),
253 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
254 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
255 ExpectRvalueLikeUnsized(Ty<'tcx>),
258 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
259 // Disregard "castable to" expectations because they
260 // can lead us astray. Consider for example `if cond
261 // {22} else {c} as u8` -- if we propagate the
262 // "castable to u8" constraint to 22, it will pick the
263 // type 22u8, which is overly constrained (c might not
264 // be a u8). In effect, the problem is that the
265 // "castable to" expectation is not the tightest thing
266 // we can say, so we want to drop it in this case.
267 // The tightest thing we can say is "must unify with
268 // else branch". Note that in the case of a "has type"
269 // constraint, this limitation does not hold.
271 // If the expected type is just a type variable, then don't use
272 // an expected type. Otherwise, we might write parts of the type
273 // when checking the 'then' block which are incompatible with the
275 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
277 ExpectHasType(ety) => {
278 let ety = fcx.shallow_resolve(ety);
279 if !ety.is_ty_var() {
285 ExpectRvalueLikeUnsized(ety) => {
286 ExpectRvalueLikeUnsized(ety)
292 /// Provide an expectation for an rvalue expression given an *optional*
293 /// hint, which is not required for type safety (the resulting type might
294 /// be checked higher up, as is the case with `&expr` and `box expr`), but
295 /// is useful in determining the concrete type.
297 /// The primary use case is where the expected type is a fat pointer,
298 /// like `&[isize]`. For example, consider the following statement:
300 /// let x: &[isize] = &[1, 2, 3];
302 /// In this case, the expected type for the `&[1, 2, 3]` expression is
303 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
304 /// expectation `ExpectHasType([isize])`, that would be too strong --
305 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
306 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
307 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
308 /// which still is useful, because it informs integer literals and the like.
309 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
310 /// for examples of where this comes up,.
311 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
312 match fcx.tcx.struct_tail(ty).sty {
313 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
314 ExpectRvalueLikeUnsized(ty)
316 _ => ExpectHasType(ty)
320 // Resolves `expected` by a single level if it is a variable. If
321 // there is no expected type or resolution is not possible (e.g.,
322 // no constraints yet present), just returns `None`.
323 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
325 NoExpectation => NoExpectation,
326 ExpectIfCondition => ExpectIfCondition,
327 ExpectCastableToType(t) => {
328 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
330 ExpectHasType(t) => {
331 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
333 ExpectRvalueLikeUnsized(t) => {
334 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
339 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
340 match self.resolve(fcx) {
341 NoExpectation => None,
342 ExpectIfCondition => Some(fcx.tcx.types.bool),
343 ExpectCastableToType(ty) |
345 ExpectRvalueLikeUnsized(ty) => Some(ty),
349 /// It sometimes happens that we want to turn an expectation into
350 /// a **hard constraint** (i.e., something that must be satisfied
351 /// for the program to type-check). `only_has_type` will return
352 /// such a constraint, if it exists.
353 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
354 match self.resolve(fcx) {
355 ExpectHasType(ty) => Some(ty),
356 ExpectIfCondition => Some(fcx.tcx.types.bool),
357 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
361 /// Like `only_has_type`, but instead of returning `None` if no
362 /// hard constraint exists, creates a fresh type variable.
363 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
364 self.only_has_type(fcx)
365 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
369 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
376 fn maybe_mut_place(m: hir::Mutability) -> Self {
378 hir::MutMutable => Needs::MutPlace,
379 hir::MutImmutable => Needs::None,
384 #[derive(Copy, Clone)]
385 pub struct UnsafetyState {
386 pub def: ast::NodeId,
387 pub unsafety: hir::Unsafety,
388 pub unsafe_push_count: u32,
393 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
394 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
397 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
398 match self.unsafety {
399 // If this unsafe, then if the outer function was already marked as
400 // unsafe we shouldn't attribute the unsafe'ness to the block. This
401 // way the block can be warned about instead of ignoring this
402 // extraneous block (functions are never warned about).
403 hir::Unsafety::Unsafe if self.from_fn => *self,
406 let (unsafety, def, count) = match blk.rules {
407 hir::PushUnsafeBlock(..) =>
408 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
409 hir::PopUnsafeBlock(..) =>
410 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
411 hir::UnsafeBlock(..) =>
412 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
414 (unsafety, self.def, self.unsafe_push_count),
418 unsafe_push_count: count,
425 #[derive(Debug, Copy, Clone)]
431 /// Tracks whether executing a node may exit normally (versus
432 /// return/break/panic, which "diverge", leaving dead code in their
433 /// wake). Tracked semi-automatically (through type variables marked
434 /// as diverging), with some manual adjustments for control-flow
435 /// primitives (approximating a CFG).
436 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
438 /// Potentially unknown, some cases converge,
439 /// others require a CFG to determine them.
442 /// Definitely known to diverge and therefore
443 /// not reach the next sibling or its parent.
446 /// Same as `Always` but with a reachability
447 /// warning already emitted
451 // Convenience impls for combinig `Diverges`.
453 impl ops::BitAnd for Diverges {
455 fn bitand(self, other: Self) -> Self {
456 cmp::min(self, other)
460 impl ops::BitOr for Diverges {
462 fn bitor(self, other: Self) -> Self {
463 cmp::max(self, other)
467 impl ops::BitAndAssign for Diverges {
468 fn bitand_assign(&mut self, other: Self) {
469 *self = *self & other;
473 impl ops::BitOrAssign for Diverges {
474 fn bitor_assign(&mut self, other: Self) {
475 *self = *self | other;
480 fn always(self) -> bool {
481 self >= Diverges::Always
485 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
488 // this is `null` for loops where break with a value is illegal,
489 // such as `while`, `for`, and `while let`
490 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
493 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
494 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
495 by_id: NodeMap<usize>,
498 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
499 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
500 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
501 bug!("could not find enclosing breakable with id {}", target_id);
507 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
508 body_id: ast::NodeId,
510 /// The parameter environment used for proving trait obligations
511 /// in this function. This can change when we descend into
512 /// closures (as they bring new things into scope), hence it is
513 /// not part of `Inherited` (as of the time of this writing,
514 /// closures do not yet change the environment, but they will
516 param_env: ty::ParamEnv<'tcx>,
518 // Number of errors that had been reported when we started
519 // checking this function. On exit, if we find that *more* errors
520 // have been reported, we will skip regionck and other work that
521 // expects the types within the function to be consistent.
522 err_count_on_creation: usize,
524 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
526 yield_ty: Option<Ty<'tcx>>,
528 ps: RefCell<UnsafetyState>,
530 /// Whether the last checked node generates a divergence (e.g.,
531 /// `return` will set this to Always). In general, when entering
532 /// an expression or other node in the tree, the initial value
533 /// indicates whether prior parts of the containing expression may
534 /// have diverged. It is then typically set to `Maybe` (and the
535 /// old value remembered) for processing the subparts of the
536 /// current expression. As each subpart is processed, they may set
537 /// the flag to `Always` etc. Finally, at the end, we take the
538 /// result and "union" it with the original value, so that when we
539 /// return the flag indicates if any subpart of the the parent
540 /// expression (up to and including this part) has diverged. So,
541 /// if you read it after evaluating a subexpression `X`, the value
542 /// you get indicates whether any subexpression that was
543 /// evaluating up to and including `X` diverged.
545 /// We currently use this flag only for diagnostic purposes:
547 /// - To warn about unreachable code: if, after processing a
548 /// sub-expression but before we have applied the effects of the
549 /// current node, we see that the flag is set to `Always`, we
550 /// can issue a warning. This corresponds to something like
551 /// `foo(return)`; we warn on the `foo()` expression. (We then
552 /// update the flag to `WarnedAlways` to suppress duplicate
553 /// reports.) Similarly, if we traverse to a fresh statement (or
554 /// tail expression) from a `Always` setting, we will issue a
555 /// warning. This corresponds to something like `{return;
556 /// foo();}` or `{return; 22}`, where we would warn on the
559 /// An expression represents dead-code if, after checking it,
560 /// the diverges flag is set to something other than `Maybe`.
561 diverges: Cell<Diverges>,
563 /// Whether any child nodes have any type errors.
564 has_errors: Cell<bool>,
566 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
568 inh: &'a Inherited<'a, 'gcx, 'tcx>,
571 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
572 type Target = Inherited<'a, 'gcx, 'tcx>;
573 fn deref(&self) -> &Self::Target {
578 /// Helper type of a temporary returned by Inherited::build(...).
579 /// Necessary because we can't write the following bound:
580 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
581 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
582 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
586 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
587 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
588 -> InheritedBuilder<'a, 'gcx, 'tcx> {
589 let hir_id_root = if def_id.is_local() {
590 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
591 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
592 DefId::local(hir_id.owner)
598 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
604 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
605 fn enter<F, R>(&'tcx mut self, f: F) -> R
606 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
608 let def_id = self.def_id;
609 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
613 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
614 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
616 let item_id = tcx.hir.as_local_node_id(def_id);
617 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
618 let implicit_region_bound = body_id.map(|body_id| {
619 let body = tcx.hir.body(body_id);
620 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
624 tables: MaybeInProgressTables {
625 maybe_tables: infcx.in_progress_tables,
628 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
629 locals: RefCell::new(NodeMap()),
630 deferred_call_resolutions: RefCell::new(DefIdMap()),
631 deferred_cast_checks: RefCell::new(Vec::new()),
632 deferred_generator_interiors: RefCell::new(Vec::new()),
633 anon_types: RefCell::new(DefIdMap()),
634 implicit_region_bound,
639 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
640 debug!("register_predicate({:?})", obligation);
641 if obligation.has_escaping_regions() {
642 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
647 .register_predicate_obligation(self, obligation);
650 fn register_predicates<I>(&self, obligations: I)
651 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
652 for obligation in obligations {
653 self.register_predicate(obligation);
657 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
658 self.register_predicates(infer_ok.obligations);
662 fn normalize_associated_types_in<T>(&self,
664 body_id: ast::NodeId,
665 param_env: ty::ParamEnv<'tcx>,
667 where T : TypeFoldable<'tcx>
669 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
670 self.register_infer_ok_obligations(ok)
674 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
676 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
677 fn visit_item(&mut self, i: &'tcx hir::Item) {
678 check_item_type(self.tcx, i);
680 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
681 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
684 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
685 tcx.sess.track_errors(|| {
686 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
687 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
691 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
692 tcx.sess.track_errors(|| {
693 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
697 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
698 tcx.typeck_item_bodies(LOCAL_CRATE)
701 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
702 -> Result<(), CompileIncomplete>
704 debug_assert!(crate_num == LOCAL_CRATE);
705 Ok(tcx.sess.track_errors(|| {
706 for body_owner_def_id in tcx.body_owners() {
707 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
712 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
713 wfcheck::check_item_well_formed(tcx, def_id);
716 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
717 wfcheck::check_trait_item(tcx, def_id);
720 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
721 wfcheck::check_impl_item(tcx, def_id);
724 pub fn provide(providers: &mut Providers) {
725 method::provide(providers);
726 *providers = Providers {
732 check_item_well_formed,
733 check_trait_item_well_formed,
734 check_impl_item_well_formed,
739 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
741 -> Option<ty::Destructor> {
742 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
745 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
746 /// with information about it's body-id and fn-decl (if any). Otherwise,
749 /// If this function returns "some", then `typeck_tables(def_id)` will
750 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
751 /// may not succeed. In some cases where this function returns `None`
752 /// (notably closures), `typeck_tables(def_id)` would wind up
753 /// redirecting to the owning function.
754 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
756 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
758 match tcx.hir.get(id) {
759 hir::map::NodeItem(item) => {
761 hir::ItemConst(_, body) |
762 hir::ItemStatic(_, _, body) =>
764 hir::ItemFn(ref decl, .., body) =>
765 Some((body, Some(decl))),
770 hir::map::NodeTraitItem(item) => {
772 hir::TraitItemKind::Const(_, Some(body)) =>
774 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
775 Some((body, Some(&sig.decl))),
780 hir::map::NodeImplItem(item) => {
782 hir::ImplItemKind::Const(_, body) =>
784 hir::ImplItemKind::Method(ref sig, body) =>
785 Some((body, Some(&sig.decl))),
790 hir::map::NodeExpr(expr) => {
791 // FIXME(eddyb) Closures should have separate
792 // function definition IDs and expression IDs.
793 // Type-checking should not let closures get
794 // this far in a constant position.
795 // Assume that everything other than closures
796 // is a constant "initializer" expression.
798 hir::ExprClosure(..) =>
801 Some((hir::BodyId { node_id: expr.id }, None)),
808 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
811 // Closures' tables come from their outermost function,
812 // as they are part of the same "inference environment".
813 let outer_def_id = tcx.closure_base_def_id(def_id);
814 if outer_def_id != def_id {
815 return tcx.has_typeck_tables(outer_def_id);
818 let id = tcx.hir.as_local_node_id(def_id).unwrap();
819 primary_body_of(tcx, id).is_some()
822 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
825 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
828 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
830 -> &'tcx ty::TypeckTables<'tcx> {
831 // Closures' tables come from their outermost function,
832 // as they are part of the same "inference environment".
833 let outer_def_id = tcx.closure_base_def_id(def_id);
834 if outer_def_id != def_id {
835 return tcx.typeck_tables_of(outer_def_id);
838 let id = tcx.hir.as_local_node_id(def_id).unwrap();
839 let span = tcx.hir.span(id);
841 // Figure out what primary body this item has.
842 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
843 span_bug!(span, "can't type-check body of {:?}", def_id);
845 let body = tcx.hir.body(body_id);
847 let tables = Inherited::build(tcx, def_id).enter(|inh| {
848 let param_env = tcx.param_env(def_id);
849 let fcx = if let Some(decl) = fn_decl {
850 let fn_sig = tcx.fn_sig(def_id);
852 check_abi(tcx, span, fn_sig.abi());
854 // Compute the fty from point of view of inside fn.
856 tcx.liberate_late_bound_regions(def_id, &fn_sig);
858 inh.normalize_associated_types_in(body.value.span,
863 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
866 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
867 let expected_type = tcx.type_of(def_id);
868 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
869 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
871 // Gather locals in statics (because of block expressions).
872 // This is technically unnecessary because locals in static items are forbidden,
873 // but prevents type checking from blowing up before const checking can properly
875 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
877 fcx.check_expr_coercable_to_type(&body.value, expected_type);
882 // All type checking constraints were added, try to fallback unsolved variables.
883 fcx.select_obligations_where_possible(false);
884 let mut fallback_has_occurred = false;
885 for ty in &fcx.unsolved_variables() {
886 fallback_has_occurred |= fcx.fallback_if_possible(ty);
888 fcx.select_obligations_where_possible(fallback_has_occurred);
890 // Even though coercion casts provide type hints, we check casts after fallback for
891 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
894 // Closure and generater analysis may run after fallback
895 // because they don't constrain other type variables.
896 fcx.closure_analyze(body);
897 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
898 fcx.resolve_generator_interiors(def_id);
899 fcx.select_all_obligations_or_error();
901 if fn_decl.is_some() {
902 fcx.regionck_fn(id, body);
904 fcx.regionck_expr(body);
907 fcx.resolve_type_vars_in_body(body)
910 // Consistency check our TypeckTables instance can hold all ItemLocalIds
911 // it will need to hold.
912 assert_eq!(tables.local_id_root,
913 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
917 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
918 if !tcx.sess.target.target.is_abi_supported(abi) {
919 struct_span_err!(tcx.sess, span, E0570,
920 "The ABI `{}` is not supported for the current target", abi).emit()
924 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
925 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
928 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
929 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
932 // infer the variable's type
933 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
934 self.fcx.locals.borrow_mut().insert(nid, var_ty);
938 // take type that the user specified
939 self.fcx.locals.borrow_mut().insert(nid, typ);
946 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
947 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
948 NestedVisitorMap::None
951 // Add explicitly-declared locals.
952 fn visit_local(&mut self, local: &'gcx hir::Local) {
953 let o_ty = match local.ty {
955 let o_ty = self.fcx.to_ty(&ty);
957 let (c_ty, _orig_values) = self.fcx.inh.infcx.canonicalize_response(&o_ty);
958 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
959 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
965 self.assign(local.span, local.id, o_ty);
967 debug!("Local variable {:?} is assigned type {}",
969 self.fcx.ty_to_string(
970 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
971 intravisit::walk_local(self, local);
974 // Add pattern bindings.
975 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
976 if let PatKind::Binding(_, _, ref path1, _) = p.node {
977 let var_ty = self.assign(p.span, p.id, None);
979 self.fcx.require_type_is_sized(var_ty, p.span,
980 traits::VariableType(p.id));
982 debug!("Pattern binding {} is assigned to {} with type {:?}",
984 self.fcx.ty_to_string(
985 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
988 intravisit::walk_pat(self, p);
991 // Don't descend into the bodies of nested closures
992 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
993 _: hir::BodyId, _: Span, _: ast::NodeId) { }
996 /// When `check_fn` is invoked on a generator (i.e., a body that
997 /// includes yield), it returns back some information about the yield
999 struct GeneratorTypes<'tcx> {
1000 /// Type of value that is yielded.
1001 yield_ty: ty::Ty<'tcx>,
1003 /// Types that are captured (see `GeneratorInterior` for more).
1004 interior: ty::Ty<'tcx>,
1006 /// Indicates if the generator is movable or static (immovable)
1007 movability: hir::GeneratorMovability,
1010 /// Helper used for fns and closures. Does the grungy work of checking a function
1011 /// body and returns the function context used for that purpose, since in the case of a fn item
1012 /// there is still a bit more to do.
1015 /// * inherited: other fields inherited from the enclosing fn (if any)
1016 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1017 param_env: ty::ParamEnv<'tcx>,
1018 fn_sig: ty::FnSig<'tcx>,
1019 decl: &'gcx hir::FnDecl,
1021 body: &'gcx hir::Body,
1022 can_be_generator: Option<hir::GeneratorMovability>)
1023 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1025 let mut fn_sig = fn_sig.clone();
1027 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1029 // Create the function context. This is either derived from scratch or,
1030 // in the case of function expressions, based on the outer context.
1031 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1032 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1034 let ret_ty = fn_sig.output();
1035 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1036 let ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &ret_ty);
1037 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1038 fn_sig = fcx.tcx.mk_fn_sig(
1039 fn_sig.inputs().iter().cloned(),
1046 let span = body.value.span;
1048 if body.is_generator && can_be_generator.is_some() {
1049 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1050 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1051 fcx.yield_ty = Some(yield_ty);
1054 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1056 // Add formal parameters.
1057 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1058 // Check the pattern.
1059 fcx.check_pat_walk(&arg.pat, arg_ty,
1060 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1062 // Check that argument is Sized.
1063 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1064 // for simple cases like `fn foo(x: Trait)`,
1065 // where we would error once on the parameter as a whole, and once on the binding `x`.
1066 if arg.pat.simple_name().is_none() {
1067 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1070 fcx.write_ty(arg.hir_id, arg_ty);
1073 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1074 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1076 fcx.check_return_expr(&body.value);
1078 // We insert the deferred_generator_interiors entry after visiting the body.
1079 // This ensures that all nested generators appear before the entry of this generator.
1080 // resolve_generator_interiors relies on this property.
1081 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1082 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1083 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1084 Some(GeneratorTypes {
1085 yield_ty: fcx.yield_ty.unwrap(),
1087 movability: can_be_generator.unwrap(),
1093 // Finalize the return check by taking the LUB of the return types
1094 // we saw and assigning it to the expected return type. This isn't
1095 // really expected to fail, since the coercions would have failed
1096 // earlier when trying to find a LUB.
1098 // However, the behavior around `!` is sort of complex. In the
1099 // event that the `actual_return_ty` comes back as `!`, that
1100 // indicates that the fn either does not return or "returns" only
1101 // values of type `!`. In this case, if there is an expected
1102 // return type that is *not* `!`, that should be ok. But if the
1103 // return type is being inferred, we want to "fallback" to `!`:
1105 // let x = move || panic!();
1107 // To allow for that, I am creating a type variable with diverging
1108 // fallback. This was deemed ever so slightly better than unifying
1109 // the return value with `!` because it allows for the caller to
1110 // make more assumptions about the return type (e.g., they could do
1112 // let y: Option<u32> = Some(x());
1114 // which would then cause this return type to become `u32`, not
1116 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1117 let mut actual_return_ty = coercion.complete(&fcx);
1118 if actual_return_ty.is_never() {
1119 actual_return_ty = fcx.next_diverging_ty_var(
1120 TypeVariableOrigin::DivergingFn(span));
1122 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1124 // Check that the main return type implements the termination trait.
1125 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1126 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1129 config::EntryMain => {
1130 let substs = fcx.tcx.mk_substs(iter::once(Kind::from(ret_ty)));
1131 let trait_ref = ty::TraitRef::new(term_id, substs);
1132 let return_ty_span = decl.output.span();
1133 let cause = traits::ObligationCause::new(
1134 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1136 inherited.register_predicate(
1137 traits::Obligation::new(
1138 cause, param_env, trait_ref.to_predicate()));
1140 config::EntryStart => {},
1149 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1152 let def_id = tcx.hir.local_def_id(id);
1153 let def = tcx.adt_def(def_id);
1154 def.destructor(tcx); // force the destructor to be evaluated
1155 check_representable(tcx, span, def_id);
1157 if def.repr.simd() {
1158 check_simd(tcx, span, def_id);
1161 check_transparent(tcx, span, def_id);
1162 check_packed(tcx, span, def_id);
1165 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1168 let def_id = tcx.hir.local_def_id(id);
1169 let def = tcx.adt_def(def_id);
1170 def.destructor(tcx); // force the destructor to be evaluated
1171 check_representable(tcx, span, def_id);
1173 check_packed(tcx, span, def_id);
1176 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1177 debug!("check_item_type(it.id={}, it.name={})",
1179 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1180 let _indenter = indenter();
1182 // Consts can play a role in type-checking, so they are included here.
1183 hir::ItemStatic(..) => {
1184 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1186 hir::ItemConst(..) => {
1187 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1188 if it.attrs.iter().any(|a| a.check_name("wasm_custom_section")) {
1189 let def_id = tcx.hir.local_def_id(it.id);
1190 check_const_is_u8_array(tcx, def_id, it.span);
1193 hir::ItemEnum(ref enum_definition, _) => {
1196 &enum_definition.variants,
1199 hir::ItemFn(..) => {} // entirely within check_item_body
1200 hir::ItemImpl(.., ref impl_item_refs) => {
1201 debug!("ItemImpl {} with id {}", it.name, it.id);
1202 let impl_def_id = tcx.hir.local_def_id(it.id);
1203 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1204 check_impl_items_against_trait(tcx,
1209 let trait_def_id = impl_trait_ref.def_id;
1210 check_on_unimplemented(tcx, trait_def_id, it);
1213 hir::ItemTrait(..) => {
1214 let def_id = tcx.hir.local_def_id(it.id);
1215 check_on_unimplemented(tcx, def_id, it);
1217 hir::ItemStruct(..) => {
1218 check_struct(tcx, it.id, it.span);
1220 hir::ItemUnion(..) => {
1221 check_union(tcx, it.id, it.span);
1223 hir::ItemTy(_, ref generics) => {
1224 let def_id = tcx.hir.local_def_id(it.id);
1225 let pty_ty = tcx.type_of(def_id);
1226 check_bounds_are_used(tcx, generics, pty_ty);
1228 hir::ItemForeignMod(ref m) => {
1229 check_abi(tcx, it.span, m.abi);
1231 if m.abi == Abi::RustIntrinsic {
1232 for item in &m.items {
1233 intrinsic::check_intrinsic_type(tcx, item);
1235 } else if m.abi == Abi::PlatformIntrinsic {
1236 for item in &m.items {
1237 intrinsic::check_platform_intrinsic_type(tcx, item);
1240 for item in &m.items {
1241 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1242 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1243 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1244 "foreign items may not have type parameters");
1245 err.span_label(item.span, "can't have type parameters");
1246 // FIXME: once we start storing spans for type arguments, turn this into a
1248 err.help("use specialization instead of type parameters by replacing them \
1249 with concrete types like `u32`");
1253 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1254 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1259 _ => {/* nothing to do */ }
1263 fn check_const_is_u8_array<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1266 match tcx.type_of(def_id).sty {
1267 ty::TyArray(t, _) => {
1269 ty::TyUint(ast::UintTy::U8) => return,
1275 tcx.sess.span_err(span, "must be an array of bytes like `[u8; N]`");
1278 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1279 trait_def_id: DefId,
1281 let item_def_id = tcx.hir.local_def_id(item.id);
1282 // an error would be reported if this fails.
1283 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1286 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1287 impl_item: &hir::ImplItem,
1290 let mut err = struct_span_err!(
1291 tcx.sess, impl_item.span, E0520,
1292 "`{}` specializes an item from a parent `impl`, but \
1293 that item is not marked `default`",
1295 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1298 match tcx.span_of_impl(parent_impl) {
1300 err.span_label(span, "parent `impl` is here");
1301 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1305 err.note(&format!("parent implementation is in crate `{}`", cname));
1312 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1313 trait_def: &ty::TraitDef,
1314 trait_item: &ty::AssociatedItem,
1316 impl_item: &hir::ImplItem)
1318 let ancestors = trait_def.ancestors(tcx, impl_id);
1320 let kind = match impl_item.node {
1321 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1322 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1323 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1326 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1327 .map(|node_item| node_item.map(|parent| parent.defaultness));
1329 if let Some(parent) = parent {
1330 if tcx.impl_item_is_final(&parent) {
1331 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1337 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1340 impl_trait_ref: ty::TraitRef<'tcx>,
1341 impl_item_refs: &[hir::ImplItemRef]) {
1342 let impl_span = tcx.sess.codemap().def_span(impl_span);
1344 // If the trait reference itself is erroneous (so the compilation is going
1345 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1346 // isn't populated for such impls.
1347 if impl_trait_ref.references_error() { return; }
1349 // Locate trait definition and items
1350 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1351 let mut overridden_associated_type = None;
1353 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1355 // Check existing impl methods to see if they are both present in trait
1356 // and compatible with trait signature
1357 for impl_item in impl_items() {
1358 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1359 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1360 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1361 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1363 // Not compatible, but needed for the error message
1364 tcx.associated_items(impl_trait_ref.def_id)
1365 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1368 // Check that impl definition matches trait definition
1369 if let Some(ty_trait_item) = ty_trait_item {
1370 match impl_item.node {
1371 hir::ImplItemKind::Const(..) => {
1372 // Find associated const definition.
1373 if ty_trait_item.kind == ty::AssociatedKind::Const {
1374 compare_const_impl(tcx,
1380 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1381 "item `{}` is an associated const, \
1382 which doesn't match its trait `{}`",
1385 err.span_label(impl_item.span, "does not match trait");
1386 // We can only get the spans from local trait definition
1387 // Same for E0324 and E0325
1388 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1389 err.span_label(trait_span, "item in trait");
1394 hir::ImplItemKind::Method(..) => {
1395 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1396 if ty_trait_item.kind == ty::AssociatedKind::Method {
1397 compare_impl_method(tcx,
1404 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1405 "item `{}` is an associated method, \
1406 which doesn't match its trait `{}`",
1409 err.span_label(impl_item.span, "does not match trait");
1410 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1411 err.span_label(trait_span, "item in trait");
1416 hir::ImplItemKind::Type(_) => {
1417 if ty_trait_item.kind == ty::AssociatedKind::Type {
1418 if ty_trait_item.defaultness.has_value() {
1419 overridden_associated_type = Some(impl_item);
1422 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1423 "item `{}` is an associated type, \
1424 which doesn't match its trait `{}`",
1427 err.span_label(impl_item.span, "does not match trait");
1428 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1429 err.span_label(trait_span, "item in trait");
1436 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1440 // Check for missing items from trait
1441 let mut missing_items = Vec::new();
1442 let mut invalidated_items = Vec::new();
1443 let associated_type_overridden = overridden_associated_type.is_some();
1444 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1445 let is_implemented = trait_def.ancestors(tcx, impl_id)
1446 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1448 .map(|node_item| !node_item.node.is_from_trait())
1451 if !is_implemented && !tcx.impl_is_default(impl_id) {
1452 if !trait_item.defaultness.has_value() {
1453 missing_items.push(trait_item);
1454 } else if associated_type_overridden {
1455 invalidated_items.push(trait_item.name);
1460 if !missing_items.is_empty() {
1461 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1462 "not all trait items implemented, missing: `{}`",
1463 missing_items.iter()
1464 .map(|trait_item| trait_item.name.to_string())
1465 .collect::<Vec<_>>().join("`, `"));
1466 err.span_label(impl_span, format!("missing `{}` in implementation",
1467 missing_items.iter()
1468 .map(|trait_item| trait_item.name.to_string())
1469 .collect::<Vec<_>>().join("`, `")));
1470 for trait_item in missing_items {
1471 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1472 err.span_label(span, format!("`{}` from trait", trait_item.name));
1474 err.note_trait_signature(trait_item.name.to_string(),
1475 trait_item.signature(&tcx));
1481 if !invalidated_items.is_empty() {
1482 let invalidator = overridden_associated_type.unwrap();
1483 span_err!(tcx.sess, invalidator.span, E0399,
1484 "the following trait items need to be reimplemented \
1485 as `{}` was overridden: `{}`",
1487 invalidated_items.iter()
1488 .map(|name| name.to_string())
1489 .collect::<Vec<_>>().join("`, `"))
1493 /// Checks whether a type can be represented in memory. In particular, it
1494 /// identifies types that contain themselves without indirection through a
1495 /// pointer, which would mean their size is unbounded.
1496 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1500 let rty = tcx.type_of(item_def_id);
1502 // Check that it is possible to represent this type. This call identifies
1503 // (1) types that contain themselves and (2) types that contain a different
1504 // recursive type. It is only necessary to throw an error on those that
1505 // contain themselves. For case 2, there must be an inner type that will be
1506 // caught by case 1.
1507 match rty.is_representable(tcx, sp) {
1508 Representability::SelfRecursive(spans) => {
1509 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1511 err.span_label(span, "recursive without indirection");
1516 Representability::Representable | Representability::ContainsRecursive => (),
1521 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1522 let t = tcx.type_of(def_id);
1524 ty::TyAdt(def, substs) if def.is_struct() => {
1525 let fields = &def.non_enum_variant().fields;
1526 if fields.is_empty() {
1527 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1530 let e = fields[0].ty(tcx, substs);
1531 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1532 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1533 .span_label(sp, "SIMD elements must have the same type")
1538 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1539 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1541 span_err!(tcx.sess, sp, E0077,
1542 "SIMD vector element type should be machine type");
1551 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1552 let repr = tcx.adt_def(def_id).repr;
1554 for attr in tcx.get_attrs(def_id).iter() {
1555 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1556 if let attr::ReprPacked(pack) = r {
1557 if pack != repr.pack {
1558 struct_span_err!(tcx.sess, sp, E0634,
1559 "type has conflicting packed representation hints").emit();
1565 struct_span_err!(tcx.sess, sp, E0587,
1566 "type has conflicting packed and align representation hints").emit();
1568 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1569 struct_span_err!(tcx.sess, sp, E0588,
1570 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1575 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1577 stack: &mut Vec<DefId>) -> bool {
1578 let t = tcx.type_of(def_id);
1579 if stack.contains(&def_id) {
1580 debug!("check_packed_inner: {:?} is recursive", t);
1584 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1585 if tcx.adt_def(def.did).repr.align > 0 {
1588 // push struct def_id before checking fields
1590 for field in &def.non_enum_variant().fields {
1591 let f = field.ty(tcx, substs);
1593 ty::TyAdt(def, _) => {
1594 if check_packed_inner(tcx, def.did, stack) {
1601 // only need to pop if not early out
1609 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1610 let adt = tcx.adt_def(def_id);
1611 if !adt.repr.transparent() {
1615 // For each field, figure out if it's known to be a ZST and align(1)
1616 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1617 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1618 let param_env = tcx.param_env(field.did);
1619 let layout = tcx.layout_of(param_env.and(ty));
1620 // We are currently checking the type this field came from, so it must be local
1621 let span = tcx.hir.span_if_local(field.did).unwrap();
1622 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1623 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1627 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1628 let non_zst_count = non_zst_fields.clone().count();
1629 if non_zst_count != 1 {
1630 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1631 struct_span_err!(tcx.sess, sp, E0690,
1632 "transparent struct needs exactly one non-zero-sized field, but has {}",
1634 .span_note(field_spans, "non-zero-sized field")
1637 for &(span, zst, align1) in &field_infos {
1639 span_err!(tcx.sess, span, E0691,
1640 "zero-sized field in transparent struct has alignment larger than 1");
1645 #[allow(trivial_numeric_casts)]
1646 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1648 vs: &'tcx [hir::Variant],
1650 let def_id = tcx.hir.local_def_id(id);
1651 let def = tcx.adt_def(def_id);
1652 def.destructor(tcx); // force the destructor to be evaluated
1655 let attributes = tcx.get_attrs(def_id);
1656 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1658 tcx.sess, attr.span, E0084,
1659 "unsupported representation for zero-variant enum")
1660 .span_label(sp, "zero-variant enum")
1665 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1666 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1667 if !tcx.features().repr128 {
1668 emit_feature_err(&tcx.sess.parse_sess,
1671 GateIssue::Language,
1672 "repr with 128-bit type is unstable");
1677 if let Some(e) = v.node.disr_expr {
1678 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1682 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1683 for (discr, v) in def.discriminants(tcx).zip(vs) {
1684 // Check for duplicate discriminant values
1685 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1686 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1687 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1688 let i_span = match variant_i.node.disr_expr {
1689 Some(expr) => tcx.hir.span(expr.node_id),
1690 None => tcx.hir.span(variant_i_node_id)
1692 let span = match v.node.disr_expr {
1693 Some(expr) => tcx.hir.span(expr.node_id),
1696 struct_span_err!(tcx.sess, span, E0081,
1697 "discriminant value `{}` already exists", disr_vals[i])
1698 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1699 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1702 disr_vals.push(discr);
1705 check_representable(tcx, sp, def_id);
1708 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1709 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1711 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1712 -> ty::GenericPredicates<'tcx>
1715 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1716 let item_id = tcx.hir.ty_param_owner(node_id);
1717 let item_def_id = tcx.hir.local_def_id(item_id);
1718 let generics = tcx.generics_of(item_def_id);
1719 let index = generics.param_def_id_to_index[&def_id];
1720 ty::GenericPredicates {
1722 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1724 ty::Predicate::Trait(ref data) => {
1725 data.skip_binder().self_ty().is_param(index)
1729 }).cloned().collect()
1733 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1734 -> Option<ty::Region<'tcx>> {
1736 Some(def) => infer::EarlyBoundRegion(span, def.name),
1737 None => infer::MiscVariable(span)
1739 Some(self.next_region_var(v))
1742 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1743 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1746 fn ty_infer_for_def(&self,
1747 ty_param_def: &ty::GenericParamDef,
1748 span: Span) -> Ty<'tcx> {
1749 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1755 fn projected_ty_from_poly_trait_ref(&self,
1758 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1761 let (trait_ref, _) =
1762 self.replace_late_bound_regions_with_fresh_var(
1764 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1767 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1770 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1771 if ty.has_escaping_regions() {
1772 ty // FIXME: normalization and escaping regions
1774 self.normalize_associated_types_in(span, &ty)
1778 fn set_tainted_by_errors(&self) {
1779 self.infcx.set_tainted_by_errors()
1782 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1783 self.write_ty(hir_id, ty)
1787 /// Controls whether the arguments are tupled. This is used for the call
1790 /// Tupling means that all call-side arguments are packed into a tuple and
1791 /// passed as a single parameter. For example, if tupling is enabled, this
1794 /// fn f(x: (isize, isize))
1796 /// Can be called as:
1803 #[derive(Clone, Eq, PartialEq)]
1804 enum TupleArgumentsFlag {
1809 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1810 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1811 param_env: ty::ParamEnv<'tcx>,
1812 body_id: ast::NodeId)
1813 -> FnCtxt<'a, 'gcx, 'tcx> {
1817 err_count_on_creation: inh.tcx.sess.err_count(),
1820 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1821 ast::CRATE_NODE_ID)),
1822 diverges: Cell::new(Diverges::Maybe),
1823 has_errors: Cell::new(false),
1824 enclosing_breakables: RefCell::new(EnclosingBreakables {
1832 pub fn sess(&self) -> &Session {
1836 pub fn err_count_since_creation(&self) -> usize {
1837 self.tcx.sess.err_count() - self.err_count_on_creation
1840 /// Produce warning on the given node, if the current point in the
1841 /// function is unreachable, and there hasn't been another warning.
1842 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1843 if self.diverges.get() == Diverges::Always {
1844 self.diverges.set(Diverges::WarnedAlways);
1846 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1848 self.tcx().lint_node(
1849 lint::builtin::UNREACHABLE_CODE,
1851 &format!("unreachable {}", kind));
1857 code: ObligationCauseCode<'tcx>)
1858 -> ObligationCause<'tcx> {
1859 ObligationCause::new(span, self.body_id, code)
1862 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1863 self.cause(span, ObligationCauseCode::MiscObligation)
1866 /// Resolves type variables in `ty` if possible. Unlike the infcx
1867 /// version (resolve_type_vars_if_possible), this version will
1868 /// also select obligations if it seems useful, in an effort
1869 /// to get more type information.
1870 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1871 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1873 // No TyInfer()? Nothing needs doing.
1874 if !ty.has_infer_types() {
1875 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1879 // If `ty` is a type variable, see whether we already know what it is.
1880 ty = self.resolve_type_vars_if_possible(&ty);
1881 if !ty.has_infer_types() {
1882 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1886 // If not, try resolving pending obligations as much as
1887 // possible. This can help substantially when there are
1888 // indirect dependencies that don't seem worth tracking
1890 self.select_obligations_where_possible(false);
1891 ty = self.resolve_type_vars_if_possible(&ty);
1893 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1897 fn record_deferred_call_resolution(&self,
1898 closure_def_id: DefId,
1899 r: DeferredCallResolution<'gcx, 'tcx>) {
1900 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1901 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1904 fn remove_deferred_call_resolutions(&self,
1905 closure_def_id: DefId)
1906 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1908 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1909 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1912 pub fn tag(&self) -> String {
1913 let self_ptr: *const FnCtxt = self;
1914 format!("{:?}", self_ptr)
1917 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1918 match self.locals.borrow().get(&nid) {
1921 span_bug!(span, "no type for local variable {}",
1922 self.tcx.hir.node_to_string(nid));
1928 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1929 debug!("write_ty({:?}, {:?}) in fcx {}",
1930 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1931 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1933 if ty.references_error() {
1934 self.has_errors.set(true);
1935 self.set_tainted_by_errors();
1939 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
1940 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
1941 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
1944 // The NodeId and the ItemLocalId must identify the same item. We just pass
1945 // both of them for consistency checking.
1946 pub fn write_method_call(&self,
1948 method: MethodCallee<'tcx>) {
1951 .type_dependent_defs_mut()
1952 .insert(hir_id, Def::Method(method.def_id));
1953 self.write_substs(hir_id, method.substs);
1956 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1957 if !substs.is_noop() {
1958 debug!("write_substs({:?}, {:?}) in fcx {}",
1963 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1967 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1968 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1974 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1975 Entry::Vacant(entry) => { entry.insert(adj); },
1976 Entry::Occupied(mut entry) => {
1977 debug!(" - composing on top of {:?}", entry.get());
1978 match (&entry.get()[..], &adj[..]) {
1979 // Applying any adjustment on top of a NeverToAny
1980 // is a valid NeverToAny adjustment, because it can't
1982 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1984 Adjustment { kind: Adjust::Deref(_), .. },
1985 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1987 Adjustment { kind: Adjust::Deref(_), .. },
1988 .. // Any following adjustments are allowed.
1990 // A reborrow has no effect before a dereference.
1992 // FIXME: currently we never try to compose autoderefs
1993 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1995 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1996 expr, entry.get(), adj)
1998 *entry.get_mut() = adj;
2003 /// Basically whenever we are converting from a type scheme into
2004 /// the fn body space, we always want to normalize associated
2005 /// types as well. This function combines the two.
2006 fn instantiate_type_scheme<T>(&self,
2008 substs: &Substs<'tcx>,
2011 where T : TypeFoldable<'tcx>
2013 let value = value.subst(self.tcx, substs);
2014 let result = self.normalize_associated_types_in(span, &value);
2015 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2022 /// As `instantiate_type_scheme`, but for the bounds found in a
2023 /// generic type scheme.
2024 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2025 -> ty::InstantiatedPredicates<'tcx> {
2026 let bounds = self.tcx.predicates_of(def_id);
2027 let result = bounds.instantiate(self.tcx, substs);
2028 let result = self.normalize_associated_types_in(span, &result);
2029 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2036 /// Replace the anonymized types from the return value of the
2037 /// function with type variables and records the `AnonTypeMap` for
2038 /// later use during writeback. See
2039 /// `InferCtxt::instantiate_anon_types` for more details.
2040 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2045 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2047 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2052 let (value, anon_type_map) = self.register_infer_ok_obligations(
2053 self.instantiate_anon_types(
2061 let mut anon_types = self.anon_types.borrow_mut();
2062 for (ty, decl) in anon_type_map {
2063 let old_value = anon_types.insert(ty, decl);
2064 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2070 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2071 where T : TypeFoldable<'tcx>
2073 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2076 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2078 where T : TypeFoldable<'tcx>
2080 self.inh.partially_normalize_associated_types_in(span,
2086 pub fn require_type_meets(&self,
2089 code: traits::ObligationCauseCode<'tcx>,
2092 self.register_bound(
2095 traits::ObligationCause::new(span, self.body_id, code));
2098 pub fn require_type_is_sized(&self,
2101 code: traits::ObligationCauseCode<'tcx>)
2103 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2104 self.require_type_meets(ty, span, code, lang_item);
2107 pub fn register_bound(&self,
2110 cause: traits::ObligationCause<'tcx>)
2112 self.fulfillment_cx.borrow_mut()
2113 .register_bound(self, self.param_env, ty, def_id, cause);
2116 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2117 let t = AstConv::ast_ty_to_ty(self, ast_t);
2118 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2122 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2123 match self.tables.borrow().node_types().get(id) {
2125 None if self.is_tainted_by_errors() => self.tcx.types.err,
2127 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2128 bug!("no type for node {}: {} in fcx {}",
2129 node_id, self.tcx.hir.node_to_string(node_id),
2135 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2136 /// outlive the region `r`.
2137 pub fn register_wf_obligation(&self,
2140 code: traits::ObligationCauseCode<'tcx>)
2142 // WF obligations never themselves fail, so no real need to give a detailed cause:
2143 let cause = traits::ObligationCause::new(span, self.body_id, code);
2144 self.register_predicate(traits::Obligation::new(cause,
2146 ty::Predicate::WellFormed(ty)));
2149 /// Registers obligations that all types appearing in `substs` are well-formed.
2150 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2152 for ty in substs.types() {
2153 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2157 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2158 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2159 /// trait/region obligations.
2161 /// For example, if there is a function:
2164 /// fn foo<'a,T:'a>(...)
2167 /// and a reference:
2173 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2174 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2175 pub fn add_obligations_for_parameters(&self,
2176 cause: traits::ObligationCause<'tcx>,
2177 predicates: &ty::InstantiatedPredicates<'tcx>)
2179 assert!(!predicates.has_escaping_regions());
2181 debug!("add_obligations_for_parameters(predicates={:?})",
2184 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2185 self.register_predicate(obligation);
2189 // FIXME(arielb1): use this instead of field.ty everywhere
2190 // Only for fields! Returns <none> for methods>
2191 // Indifferent to privacy flags
2192 pub fn field_ty(&self,
2194 field: &'tcx ty::FieldDef,
2195 substs: &Substs<'tcx>)
2198 self.normalize_associated_types_in(span,
2199 &field.ty(self.tcx, substs))
2202 fn check_casts(&self) {
2203 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2204 for cast in deferred_cast_checks.drain(..) {
2209 fn resolve_generator_interiors(&self, def_id: DefId) {
2210 let mut generators = self.deferred_generator_interiors.borrow_mut();
2211 for (body_id, interior) in generators.drain(..) {
2212 self.select_obligations_where_possible(false);
2213 generator_interior::resolve_interior(self, def_id, body_id, interior);
2217 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2218 // Non-numerics get replaced with ! or () (depending on whether
2219 // feature(never_type) is enabled, unconstrained ints with i32,
2220 // unconstrained floats with f64.
2221 // Fallback becomes very dubious if we have encountered type-checking errors.
2222 // In that case, fallback to TyError.
2223 // The return value indicates whether fallback has occured.
2224 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2225 use rustc::ty::error::UnconstrainedNumeric::Neither;
2226 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2228 assert!(ty.is_ty_infer());
2229 let fallback = match self.type_is_unconstrained_numeric(ty) {
2230 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2231 UnconstrainedInt => self.tcx.types.i32,
2232 UnconstrainedFloat => self.tcx.types.f64,
2233 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2234 Neither => return false,
2236 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2237 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2241 fn select_all_obligations_or_error(&self) {
2242 debug!("select_all_obligations_or_error");
2243 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2244 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2248 /// Select as many obligations as we can at present.
2249 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2250 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2253 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2258 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2260 hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
2262 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2267 hir::ExprType(ref e, _) => {
2268 self.is_place_expr(e)
2271 hir::ExprUnary(hir::UnDeref, _) |
2272 hir::ExprField(..) |
2273 hir::ExprIndex(..) => {
2277 // Partially qualified paths in expressions can only legally
2278 // refer to associated items which are always rvalues.
2279 hir::ExprPath(hir::QPath::TypeRelative(..)) |
2282 hir::ExprMethodCall(..) |
2283 hir::ExprStruct(..) |
2286 hir::ExprMatch(..) |
2287 hir::ExprClosure(..) |
2288 hir::ExprBlock(..) |
2289 hir::ExprRepeat(..) |
2290 hir::ExprArray(..) |
2291 hir::ExprBreak(..) |
2292 hir::ExprAgain(..) |
2294 hir::ExprWhile(..) |
2296 hir::ExprAssign(..) |
2297 hir::ExprInlineAsm(..) |
2298 hir::ExprAssignOp(..) |
2300 hir::ExprUnary(..) |
2302 hir::ExprAddrOf(..) |
2303 hir::ExprBinary(..) |
2304 hir::ExprYield(..) |
2305 hir::ExprCast(..) => {
2311 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2312 /// returns a type of `&T`, but the actual type we assign to the
2313 /// *expression* is `T`. So this function just peels off the return
2314 /// type by one layer to yield `T`.
2315 fn make_overloaded_place_return_type(&self,
2316 method: MethodCallee<'tcx>)
2317 -> ty::TypeAndMut<'tcx>
2319 // extract method return type, which will be &T;
2320 let ret_ty = method.sig.output();
2322 // method returns &T, but the type as visible to user is T, so deref
2323 ret_ty.builtin_deref(true).unwrap()
2326 fn lookup_indexing(&self,
2328 base_expr: &'gcx hir::Expr,
2332 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2334 // FIXME(#18741) -- this is almost but not quite the same as the
2335 // autoderef that normal method probing does. They could likely be
2338 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2339 let mut result = None;
2340 while result.is_none() && autoderef.next().is_some() {
2341 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2343 autoderef.finalize();
2347 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2348 /// (and otherwise adjust) `base_expr`, looking for a type which either
2349 /// supports builtin indexing or overloaded indexing.
2350 /// This loop implements one step in that search; the autoderef loop
2351 /// is implemented by `lookup_indexing`.
2352 fn try_index_step(&self,
2354 base_expr: &hir::Expr,
2355 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2358 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2360 let adjusted_ty = autoderef.unambiguous_final_ty();
2361 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2368 for &unsize in &[false, true] {
2369 let mut self_ty = adjusted_ty;
2371 // We only unsize arrays here.
2372 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2373 self_ty = self.tcx.mk_slice(element_ty);
2379 // If some lookup succeeds, write callee into table and extract index/element
2380 // type from the method signature.
2381 // If some lookup succeeded, install method in table
2382 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2383 let method = self.try_overloaded_place_op(
2384 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2386 let result = method.map(|ok| {
2387 debug!("try_index_step: success, using overloaded indexing");
2388 let method = self.register_infer_ok_obligations(ok);
2390 let mut adjustments = autoderef.adjust_steps(needs);
2391 if let ty::TyRef(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2392 let mutbl = match r_mutbl {
2393 hir::MutImmutable => AutoBorrowMutability::Immutable,
2394 hir::MutMutable => AutoBorrowMutability::Mutable {
2395 // Indexing can be desugared to a method call,
2396 // so maybe we could use two-phase here.
2397 // See the documentation of AllowTwoPhase for why that's
2398 // not the case today.
2399 allow_two_phase_borrow: AllowTwoPhase::No,
2402 adjustments.push(Adjustment {
2403 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2404 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2411 adjustments.push(Adjustment {
2412 kind: Adjust::Unsize,
2413 target: method.sig.inputs()[0]
2416 self.apply_adjustments(base_expr, adjustments);
2418 self.write_method_call(expr.hir_id, method);
2419 (input_ty, self.make_overloaded_place_return_type(method).ty)
2421 if result.is_some() {
2429 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2430 let (tr, name) = match (op, is_mut) {
2431 (PlaceOp::Deref, false) =>
2432 (self.tcx.lang_items().deref_trait(), "deref"),
2433 (PlaceOp::Deref, true) =>
2434 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2435 (PlaceOp::Index, false) =>
2436 (self.tcx.lang_items().index_trait(), "index"),
2437 (PlaceOp::Index, true) =>
2438 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2440 (tr, Symbol::intern(name))
2443 fn try_overloaded_place_op(&self,
2446 arg_tys: &[Ty<'tcx>],
2449 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2451 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2457 // Try Mut first, if needed.
2458 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2459 let method = match (needs, mut_tr) {
2460 (Needs::MutPlace, Some(trait_did)) => {
2461 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2466 // Otherwise, fall back to the immutable version.
2467 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2468 let method = match (method, imm_tr) {
2469 (None, Some(trait_did)) => {
2470 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2472 (method, _) => method,
2478 fn check_method_argument_types(&self,
2481 method: Result<MethodCallee<'tcx>, ()>,
2482 args_no_rcvr: &'gcx [hir::Expr],
2483 tuple_arguments: TupleArgumentsFlag,
2484 expected: Expectation<'tcx>)
2486 let has_error = match method {
2488 method.substs.references_error() || method.sig.references_error()
2493 let err_inputs = self.err_args(args_no_rcvr.len());
2495 let err_inputs = match tuple_arguments {
2496 DontTupleArguments => err_inputs,
2497 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2500 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2501 false, tuple_arguments, None);
2502 return self.tcx.types.err;
2505 let method = method.unwrap();
2506 // HACK(eddyb) ignore self in the definition (see above).
2507 let expected_arg_tys = self.expected_inputs_for_expected_output(
2510 method.sig.output(),
2511 &method.sig.inputs()[1..]
2513 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2514 args_no_rcvr, method.sig.variadic, tuple_arguments,
2515 self.tcx.hir.span_if_local(method.def_id));
2519 /// Generic function that factors out common logic from function calls,
2520 /// method calls and overloaded operators.
2521 fn check_argument_types(&self,
2524 fn_inputs: &[Ty<'tcx>],
2525 mut expected_arg_tys: &[Ty<'tcx>],
2526 args: &'gcx [hir::Expr],
2528 tuple_arguments: TupleArgumentsFlag,
2529 def_span: Option<Span>) {
2532 // Grab the argument types, supplying fresh type variables
2533 // if the wrong number of arguments were supplied
2534 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2540 // All the input types from the fn signature must outlive the call
2541 // so as to validate implied bounds.
2542 for &fn_input_ty in fn_inputs {
2543 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2546 let expected_arg_count = fn_inputs.len();
2548 let param_count_error = |expected_count: usize,
2553 let mut err = tcx.sess.struct_span_err_with_code(sp,
2554 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2555 if variadic {"at least "} else {""},
2557 if expected_count == 1 {""} else {"s"},
2559 if arg_count == 1 {" was"} else {"s were"}),
2560 DiagnosticId::Error(error_code.to_owned()));
2562 if let Some(def_s) = def_span.map(|sp| tcx.sess.codemap().def_span(sp)) {
2563 err.span_label(def_s, "defined here");
2566 let sugg_span = tcx.sess.codemap().end_point(expr_sp);
2567 // remove closing `)` from the span
2568 let sugg_span = sugg_span.shrink_to_lo();
2569 err.span_suggestion(
2571 "expected the unit value `()`; create it with empty parentheses",
2572 String::from("()"));
2574 err.span_label(sp, format!("expected {}{} parameter{}",
2575 if variadic {"at least "} else {""},
2577 if expected_count == 1 {""} else {"s"}));
2582 let formal_tys = if tuple_arguments == TupleArguments {
2583 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2584 match tuple_type.sty {
2585 ty::TyTuple(arg_types) if arg_types.len() != args.len() => {
2586 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2587 expected_arg_tys = &[];
2588 self.err_args(args.len())
2590 ty::TyTuple(arg_types) => {
2591 expected_arg_tys = match expected_arg_tys.get(0) {
2592 Some(&ty) => match ty.sty {
2593 ty::TyTuple(ref tys) => &tys,
2601 span_err!(tcx.sess, sp, E0059,
2602 "cannot use call notation; the first type parameter \
2603 for the function trait is neither a tuple nor unit");
2604 expected_arg_tys = &[];
2605 self.err_args(args.len())
2608 } else if expected_arg_count == supplied_arg_count {
2610 } else if variadic {
2611 if supplied_arg_count >= expected_arg_count {
2614 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2615 expected_arg_tys = &[];
2616 self.err_args(supplied_arg_count)
2619 // is the missing argument of type `()`?
2620 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2621 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2622 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2623 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2627 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2629 expected_arg_tys = &[];
2630 self.err_args(supplied_arg_count)
2632 // If there is no expectation, expect formal_tys.
2633 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2639 debug!("check_argument_types: formal_tys={:?}",
2640 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2642 // Check the arguments.
2643 // We do this in a pretty awful way: first we typecheck any arguments
2644 // that are not closures, then we typecheck the closures. This is so
2645 // that we have more information about the types of arguments when we
2646 // typecheck the functions. This isn't really the right way to do this.
2647 for &check_closures in &[false, true] {
2648 debug!("check_closures={}", check_closures);
2650 // More awful hacks: before we check argument types, try to do
2651 // an "opportunistic" vtable resolution of any trait bounds on
2652 // the call. This helps coercions.
2654 self.select_obligations_where_possible(false);
2657 // For variadic functions, we don't have a declared type for all of
2658 // the arguments hence we only do our usual type checking with
2659 // the arguments who's types we do know.
2660 let t = if variadic {
2662 } else if tuple_arguments == TupleArguments {
2667 for (i, arg) in args.iter().take(t).enumerate() {
2668 // Warn only for the first loop (the "no closures" one).
2669 // Closure arguments themselves can't be diverging, but
2670 // a previous argument can, e.g. `foo(panic!(), || {})`.
2671 if !check_closures {
2672 self.warn_if_unreachable(arg.id, arg.span, "expression");
2675 let is_closure = match arg.node {
2676 hir::ExprClosure(..) => true,
2680 if is_closure != check_closures {
2684 debug!("checking the argument");
2685 let formal_ty = formal_tys[i];
2687 // The special-cased logic below has three functions:
2688 // 1. Provide as good of an expected type as possible.
2689 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2691 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2693 // 2. Coerce to the most detailed type that could be coerced
2694 // to, which is `expected_ty` if `rvalue_hint` returns an
2695 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2696 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2697 // We're processing function arguments so we definitely want to use
2698 // two-phase borrows.
2699 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2701 // 3. Relate the expected type and the formal one,
2702 // if the expected type was used for the coercion.
2703 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2707 // We also need to make sure we at least write the ty of the other
2708 // arguments which we skipped above.
2710 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2711 use structured_errors::{VariadicError, StructuredDiagnostic};
2712 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2715 for arg in args.iter().skip(expected_arg_count) {
2716 let arg_ty = self.check_expr(&arg);
2718 // There are a few types which get autopromoted when passed via varargs
2719 // in C but we just error out instead and require explicit casts.
2720 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2722 ty::TyFloat(ast::FloatTy::F32) => {
2723 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2725 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2726 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2728 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2729 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2731 ty::TyFnDef(..) => {
2732 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2733 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2734 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2742 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2743 (0..len).map(|_| self.tcx.types.err).collect()
2746 // AST fragment checking
2749 expected: Expectation<'tcx>)
2755 ast::LitKind::Str(..) => tcx.mk_static_str(),
2756 ast::LitKind::ByteStr(ref v) => {
2757 tcx.mk_imm_ref(tcx.types.re_static,
2758 tcx.mk_array(tcx.types.u8, v.len() as u64))
2760 ast::LitKind::Byte(_) => tcx.types.u8,
2761 ast::LitKind::Char(_) => tcx.types.char,
2762 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2763 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2764 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2765 let opt_ty = expected.to_option(self).and_then(|ty| {
2767 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2768 ty::TyChar => Some(tcx.types.u8),
2769 ty::TyRawPtr(..) => Some(tcx.types.usize),
2770 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2774 opt_ty.unwrap_or_else(
2775 || tcx.mk_int_var(self.next_int_var_id()))
2777 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2778 ast::LitKind::FloatUnsuffixed(_) => {
2779 let opt_ty = expected.to_option(self).and_then(|ty| {
2781 ty::TyFloat(_) => Some(ty),
2785 opt_ty.unwrap_or_else(
2786 || tcx.mk_float_var(self.next_float_var_id()))
2788 ast::LitKind::Bool(_) => tcx.types.bool
2792 fn check_expr_eq_type(&self,
2793 expr: &'gcx hir::Expr,
2794 expected: Ty<'tcx>) {
2795 let ty = self.check_expr_with_hint(expr, expected);
2796 self.demand_eqtype(expr.span, expected, ty);
2799 pub fn check_expr_has_type_or_error(&self,
2800 expr: &'gcx hir::Expr,
2801 expected: Ty<'tcx>) -> Ty<'tcx> {
2802 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2805 fn check_expr_meets_expectation_or_error(&self,
2806 expr: &'gcx hir::Expr,
2807 expected: Expectation<'tcx>) -> Ty<'tcx> {
2808 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2809 let mut ty = self.check_expr_with_expectation(expr, expected);
2811 // While we don't allow *arbitrary* coercions here, we *do* allow
2812 // coercions from ! to `expected`.
2814 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2815 "expression with never type wound up being adjusted");
2816 let adj_ty = self.next_diverging_ty_var(
2817 TypeVariableOrigin::AdjustmentType(expr.span));
2818 self.apply_adjustments(expr, vec![Adjustment {
2819 kind: Adjust::NeverToAny,
2825 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2826 // Add help to type error if this is an `if` condition with an assignment
2827 match (expected, &expr.node) {
2828 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2829 let msg = "try comparing for equality";
2830 if let (Ok(left), Ok(right)) = (
2831 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2832 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2834 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2846 fn check_expr_coercable_to_type(&self,
2847 expr: &'gcx hir::Expr,
2848 expected: Ty<'tcx>) -> Ty<'tcx> {
2849 let ty = self.check_expr_with_hint(expr, expected);
2850 // checks don't need two phase
2851 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2854 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2855 expected: Ty<'tcx>) -> Ty<'tcx> {
2856 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2859 fn check_expr_with_expectation(&self,
2860 expr: &'gcx hir::Expr,
2861 expected: Expectation<'tcx>) -> Ty<'tcx> {
2862 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2865 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2866 self.check_expr_with_expectation(expr, NoExpectation)
2869 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2870 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2873 // determine the `self` type, using fresh variables for all variables
2874 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2875 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2877 pub fn impl_self_ty(&self,
2878 span: Span, // (potential) receiver for this impl
2880 -> TypeAndSubsts<'tcx> {
2881 let ity = self.tcx.type_of(did);
2882 debug!("impl_self_ty: ity={:?}", ity);
2884 let substs = self.fresh_substs_for_item(span, did);
2885 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2887 TypeAndSubsts { substs: substs, ty: substd_ty }
2890 /// Unifies the output type with the expected type early, for more coercions
2891 /// and forward type information on the input expressions.
2892 fn expected_inputs_for_expected_output(&self,
2894 expected_ret: Expectation<'tcx>,
2895 formal_ret: Ty<'tcx>,
2896 formal_args: &[Ty<'tcx>])
2898 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2899 let ret_ty = match expected_ret.only_has_type(self) {
2901 None => return Vec::new()
2903 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2904 // Attempt to apply a subtyping relationship between the formal
2905 // return type (likely containing type variables if the function
2906 // is polymorphic) and the expected return type.
2907 // No argument expectations are produced if unification fails.
2908 let origin = self.misc(call_span);
2909 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
2911 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
2912 // to identity so the resulting type is not constrained.
2915 // Process any obligations locally as much as
2916 // we can. We don't care if some things turn
2917 // out unconstrained or ambiguous, as we're
2918 // just trying to get hints here.
2919 self.save_and_restore_in_snapshot_flag(|_| {
2920 let mut fulfill = TraitEngine::new(self.tcx);
2921 for obligation in ok.obligations {
2922 fulfill.register_predicate_obligation(self, obligation);
2924 fulfill.select_where_possible(self)
2925 }).map_err(|_| ())?;
2927 Err(_) => return Err(()),
2930 // Record all the argument types, with the substitutions
2931 // produced from the above subtyping unification.
2932 Ok(formal_args.iter().map(|ty| {
2933 self.resolve_type_vars_if_possible(ty)
2935 }).unwrap_or(Vec::new());
2936 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2937 formal_args, formal_ret,
2938 expect_args, expected_ret);
2942 // Checks a method call.
2943 fn check_method_call(&self,
2944 expr: &'gcx hir::Expr,
2945 segment: &hir::PathSegment,
2947 args: &'gcx [hir::Expr],
2948 expected: Expectation<'tcx>,
2949 needs: Needs) -> Ty<'tcx> {
2950 let rcvr = &args[0];
2951 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
2952 // no need to check for bot/err -- callee does that
2953 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
2955 let method = match self.lookup_method(rcvr_t,
2961 self.write_method_call(expr.hir_id, method);
2965 if segment.name != keywords::Invalid.name() {
2966 self.report_method_error(span,
2977 // Call the generic checker.
2978 self.check_method_argument_types(span,
2986 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2990 .unwrap_or_else(|| span_bug!(return_expr.span,
2991 "check_return_expr called outside fn body"));
2993 let ret_ty = ret_coercion.borrow().expected_ty();
2994 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2995 ret_coercion.borrow_mut()
2997 &self.cause(return_expr.span,
2998 ObligationCauseCode::ReturnType(return_expr.id)),
3004 // A generic function for checking the then and else in an if
3006 fn check_then_else(&self,
3007 cond_expr: &'gcx hir::Expr,
3008 then_expr: &'gcx hir::Expr,
3009 opt_else_expr: Option<&'gcx hir::Expr>,
3011 expected: Expectation<'tcx>) -> Ty<'tcx> {
3012 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3013 let cond_diverges = self.diverges.get();
3014 self.diverges.set(Diverges::Maybe);
3016 let expected = expected.adjust_for_branches(self);
3017 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3018 let then_diverges = self.diverges.get();
3019 self.diverges.set(Diverges::Maybe);
3021 // We've already taken the expected type's preferences
3022 // into account when typing the `then` branch. To figure
3023 // out the initial shot at a LUB, we thus only consider
3024 // `expected` if it represents a *hard* constraint
3025 // (`only_has_type`); otherwise, we just go with a
3026 // fresh type variable.
3027 let coerce_to_ty = expected.coercion_target_type(self, sp);
3028 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3030 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3031 coerce.coerce(self, &if_cause, then_expr, then_ty);
3033 if let Some(else_expr) = opt_else_expr {
3034 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3035 let else_diverges = self.diverges.get();
3037 coerce.coerce(self, &if_cause, else_expr, else_ty);
3039 // We won't diverge unless both branches do (or the condition does).
3040 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3042 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3043 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3045 // If the condition is false we can't diverge.
3046 self.diverges.set(cond_diverges);
3049 let result_ty = coerce.complete(self);
3050 if cond_ty.references_error() {
3057 // Check field access expressions
3058 fn check_field(&self,
3059 expr: &'gcx hir::Expr,
3061 base: &'gcx hir::Expr,
3062 field: &Spanned<ast::Name>) -> Ty<'tcx> {
3063 let expr_t = self.check_expr_with_needs(base, needs);
3064 let expr_t = self.structurally_resolved_type(base.span,
3066 let mut private_candidate = None;
3067 let mut autoderef = self.autoderef(expr.span, expr_t);
3068 while let Some((base_t, _)) = autoderef.next() {
3070 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3071 debug!("struct named {:?}", base_t);
3072 let (ident, def_scope) =
3073 self.tcx.adjust(field.node, base_def.did, self.body_id);
3074 let fields = &base_def.non_enum_variant().fields;
3075 if let Some(index) = fields.iter().position(|f| f.name.to_ident() == ident) {
3076 let field = &fields[index];
3077 let field_ty = self.field_ty(expr.span, field, substs);
3078 // Save the index of all fields regardless of their visibility in case
3079 // of error recovery.
3080 self.write_field_index(expr.id, index);
3081 if field.vis.is_accessible_from(def_scope, self.tcx) {
3082 let adjustments = autoderef.adjust_steps(needs);
3083 self.apply_adjustments(base, adjustments);
3084 autoderef.finalize();
3086 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3089 private_candidate = Some((base_def.did, field_ty));
3092 ty::TyTuple(ref tys) => {
3093 let fstr = field.node.as_str();
3094 if let Ok(index) = fstr.parse::<usize>() {
3095 if fstr == index.to_string() {
3096 if let Some(field_ty) = tys.get(index) {
3097 let adjustments = autoderef.adjust_steps(needs);
3098 self.apply_adjustments(base, adjustments);
3099 autoderef.finalize();
3101 self.write_field_index(expr.id, index);
3110 autoderef.unambiguous_final_ty();
3112 if let Some((did, field_ty)) = private_candidate {
3113 let struct_path = self.tcx().item_path_str(did);
3114 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3115 "field `{}` of struct `{}` is private",
3116 field.node, struct_path);
3117 // Also check if an accessible method exists, which is often what is meant.
3118 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3119 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3124 } else if field.node == keywords::Invalid.name() {
3125 self.tcx().types.err
3126 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3127 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3128 "attempted to take value of method `{}` on type `{}`",
3130 .help("maybe a `()` to call it is missing?")
3132 self.tcx().types.err
3134 if !expr_t.is_primitive_ty() {
3135 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3138 ty::TyAdt(def, _) if !def.is_enum() => {
3139 if let Some(suggested_field_name) =
3140 Self::suggest_field_name(def.non_enum_variant(), field, vec![]) {
3141 err.span_label(field.span,
3142 format!("did you mean `{}`?", suggested_field_name));
3144 err.span_label(field.span, "unknown field");
3145 let struct_variant_def = def.non_enum_variant();
3146 let field_names = self.available_field_names(struct_variant_def);
3147 if !field_names.is_empty() {
3148 err.note(&format!("available fields are: {}",
3149 self.name_series_display(field_names)));
3153 ty::TyRawPtr(..) => {
3154 let base = self.tcx.hir.node_to_pretty_string(base.id);
3155 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3156 let suggestion = format!("(*{}).{}", base, field.node);
3157 err.span_suggestion(field.span, &msg, suggestion);
3163 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3164 "`{}` is a primitive type and therefore doesn't have fields",
3167 self.tcx().types.err
3171 // Return an hint about the closest match in field names
3172 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3173 field: &Spanned<ast::Name>,
3174 skip: Vec<LocalInternedString>)
3176 let name = field.node.as_str();
3177 let names = variant.fields.iter().filter_map(|field| {
3178 // ignore already set fields and private fields from non-local crates
3179 if skip.iter().any(|x| *x == field.name.as_str()) ||
3180 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3187 find_best_match_for_name(names, &name, None)
3190 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3191 let mut available = Vec::new();
3192 for field in variant.fields.iter() {
3193 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3194 if field.vis.is_accessible_from(def_scope, self.tcx) {
3195 available.push(field.name);
3201 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3202 // dynamic limit, to never omit just one field
3203 let limit = if names.len() == 6 { 6 } else { 5 };
3204 let mut display = names.iter().take(limit)
3205 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3206 if names.len() > limit {
3207 display = format!("{} ... and {} others", display, names.len() - limit);
3212 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3213 -> DiagnosticBuilder {
3214 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3215 "no field `{}` on type `{}`",
3219 fn report_unknown_field(&self,
3221 variant: &'tcx ty::VariantDef,
3223 skip_fields: &[hir::Field],
3225 let mut err = self.type_error_struct_with_diag(
3227 |actual| match ty.sty {
3228 ty::TyAdt(adt, ..) if adt.is_enum() => {
3229 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3230 "{} `{}::{}` has no field named `{}`",
3231 kind_name, actual, variant.name, field.name.node)
3234 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3235 "{} `{}` has no field named `{}`",
3236 kind_name, actual, field.name.node)
3240 // prevent all specified fields from being suggested
3241 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3242 if let Some(field_name) = Self::suggest_field_name(variant,
3244 skip_fields.collect()) {
3245 err.span_label(field.name.span,
3246 format!("field does not exist - did you mean `{}`?", field_name));
3249 ty::TyAdt(adt, ..) => {
3251 err.span_label(field.name.span,
3252 format!("`{}::{}` does not have this field",
3255 err.span_label(field.name.span,
3256 format!("`{}` does not have this field", ty));
3258 let available_field_names = self.available_field_names(variant);
3259 if !available_field_names.is_empty() {
3260 err.note(&format!("available fields are: {}",
3261 self.name_series_display(available_field_names)));
3264 _ => bug!("non-ADT passed to report_unknown_field")
3270 fn check_expr_struct_fields(&self,
3272 expected: Expectation<'tcx>,
3273 expr_id: ast::NodeId,
3275 variant: &'tcx ty::VariantDef,
3276 ast_fields: &'gcx [hir::Field],
3277 check_completeness: bool) -> bool {
3281 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3282 .get(0).cloned().unwrap_or(adt_ty);
3283 // re-link the regions that EIfEO can erase.
3284 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3286 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3287 &ty::TyAdt(adt, substs) => {
3288 (substs, adt.adt_kind(), adt.variant_descr())
3290 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3293 let mut remaining_fields = FxHashMap();
3294 for (i, field) in variant.fields.iter().enumerate() {
3295 remaining_fields.insert(field.name.to_ident(), (i, field));
3298 let mut seen_fields = FxHashMap();
3300 let mut error_happened = false;
3302 // Typecheck each field.
3303 for field in ast_fields {
3304 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3305 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3306 seen_fields.insert(ident, field.span);
3307 self.write_field_index(field.id, i);
3309 // we don't look at stability attributes on
3310 // struct-like enums (yet...), but it's definitely not
3311 // a bug to have construct one.
3312 if adt_kind != ty::AdtKind::Enum {
3313 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3316 self.field_ty(field.span, v_field, substs)
3318 error_happened = true;
3319 if let Some(prev_span) = seen_fields.get(&ident) {
3320 let mut err = struct_span_err!(self.tcx.sess,
3323 "field `{}` specified more than once",
3326 err.span_label(field.name.span, "used more than once");
3327 err.span_label(*prev_span, format!("first use of `{}`", ident));
3331 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3337 // Make sure to give a type to the field even if there's
3338 // an error, so we can continue typechecking
3339 self.check_expr_coercable_to_type(&field.expr, field_type);
3342 // Make sure the programmer specified correct number of fields.
3343 if kind_name == "union" {
3344 if ast_fields.len() != 1 {
3345 tcx.sess.span_err(span, "union expressions should have exactly one field");
3347 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3348 let len = remaining_fields.len();
3350 let mut displayable_field_names = remaining_fields
3352 .map(|ident| ident.name.as_str())
3353 .collect::<Vec<_>>();
3355 displayable_field_names.sort();
3357 let truncated_fields_error = if len <= 3 {
3360 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3363 let remaining_fields_names = displayable_field_names.iter().take(3)
3364 .map(|n| format!("`{}`", n))
3365 .collect::<Vec<_>>()
3368 struct_span_err!(tcx.sess, span, E0063,
3369 "missing field{} {}{} in initializer of `{}`",
3370 if remaining_fields.len() == 1 { "" } else { "s" },
3371 remaining_fields_names,
3372 truncated_fields_error,
3374 .span_label(span, format!("missing {}{}",
3375 remaining_fields_names,
3376 truncated_fields_error))
3382 fn check_struct_fields_on_error(&self,
3383 fields: &'gcx [hir::Field],
3384 base_expr: &'gcx Option<P<hir::Expr>>) {
3385 for field in fields {
3386 self.check_expr(&field.expr);
3390 self.check_expr(&base);
3396 pub fn check_struct_path(&self,
3398 node_id: ast::NodeId)
3399 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3400 let path_span = match *qpath {
3401 hir::QPath::Resolved(_, ref path) => path.span,
3402 hir::QPath::TypeRelative(ref qself, _) => qself.span
3404 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3405 let variant = match def {
3407 self.set_tainted_by_errors();
3410 Def::Variant(..) => {
3412 ty::TyAdt(adt, substs) => {
3413 Some((adt.variant_of_def(def), adt.did, substs))
3415 _ => bug!("unexpected type: {:?}", ty.sty)
3418 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3419 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3421 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3422 Some((adt.non_enum_variant(), adt.did, substs))
3427 _ => bug!("unexpected definition: {:?}", def)
3430 if let Some((variant, did, substs)) = variant {
3431 // Check bounds on type arguments used in the path.
3432 let bounds = self.instantiate_bounds(path_span, did, substs);
3433 let cause = traits::ObligationCause::new(path_span, self.body_id,
3434 traits::ItemObligation(did));
3435 self.add_obligations_for_parameters(cause, &bounds);
3439 struct_span_err!(self.tcx.sess, path_span, E0071,
3440 "expected struct, variant or union type, found {}",
3441 ty.sort_string(self.tcx))
3442 .span_label(path_span, "not a struct")
3448 fn check_expr_struct(&self,
3450 expected: Expectation<'tcx>,
3452 fields: &'gcx [hir::Field],
3453 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3455 // Find the relevant variant
3456 let (variant, struct_ty) =
3457 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3460 self.check_struct_fields_on_error(fields, base_expr);
3461 return self.tcx.types.err;
3464 let path_span = match *qpath {
3465 hir::QPath::Resolved(_, ref path) => path.span,
3466 hir::QPath::TypeRelative(ref qself, _) => qself.span
3469 // Prohibit struct expressions when non exhaustive flag is set.
3470 if let ty::TyAdt(adt, _) = struct_ty.sty {
3471 if !adt.did.is_local() && adt.is_non_exhaustive() {
3472 span_err!(self.tcx.sess, expr.span, E0639,
3473 "cannot create non-exhaustive {} using struct expression",
3474 adt.variant_descr());
3478 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3479 variant, fields, base_expr.is_none());
3480 if let &Some(ref base_expr) = base_expr {
3481 // If check_expr_struct_fields hit an error, do not attempt to populate
3482 // the fields with the base_expr. This could cause us to hit errors later
3483 // when certain fields are assumed to exist that in fact do not.
3484 if !error_happened {
3485 self.check_expr_has_type_or_error(base_expr, struct_ty);
3486 match struct_ty.sty {
3487 ty::TyAdt(adt, substs) if adt.is_struct() => {
3488 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3489 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3494 .fru_field_types_mut()
3495 .insert(expr.hir_id, fru_field_types);
3498 span_err!(self.tcx.sess, base_expr.span, E0436,
3499 "functional record update syntax requires a struct");
3504 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3510 /// If an expression has any sub-expressions that result in a type error,
3511 /// inspecting that expression's type with `ty.references_error()` will return
3512 /// true. Likewise, if an expression is known to diverge, inspecting its
3513 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3514 /// strict, _|_ can appear in the type of an expression that does not,
3515 /// itself, diverge: for example, fn() -> _|_.)
3516 /// Note that inspecting a type's structure *directly* may expose the fact
3517 /// that there are actually multiple representations for `TyError`, so avoid
3518 /// that when err needs to be handled differently.
3519 fn check_expr_with_expectation_and_needs(&self,
3520 expr: &'gcx hir::Expr,
3521 expected: Expectation<'tcx>,
3522 needs: Needs) -> Ty<'tcx> {
3523 debug!(">> typechecking: expr={:?} expected={:?}",
3526 // Warn for expressions after diverging siblings.
3527 self.warn_if_unreachable(expr.id, expr.span, "expression");
3529 // Hide the outer diverging and has_errors flags.
3530 let old_diverges = self.diverges.get();
3531 let old_has_errors = self.has_errors.get();
3532 self.diverges.set(Diverges::Maybe);
3533 self.has_errors.set(false);
3535 let ty = self.check_expr_kind(expr, expected, needs);
3537 // Warn for non-block expressions with diverging children.
3540 hir::ExprLoop(..) | hir::ExprWhile(..) |
3541 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3543 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3546 // Any expression that produces a value of type `!` must have diverged
3548 self.diverges.set(self.diverges.get() | Diverges::Always);
3551 // Record the type, which applies it effects.
3552 // We need to do this after the warning above, so that
3553 // we don't warn for the diverging expression itself.
3554 self.write_ty(expr.hir_id, ty);
3556 // Combine the diverging and has_error flags.
3557 self.diverges.set(self.diverges.get() | old_diverges);
3558 self.has_errors.set(self.has_errors.get() | old_has_errors);
3560 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3561 debug!("... {:?}, expected is {:?}", ty, expected);
3566 fn check_expr_kind(&self,
3567 expr: &'gcx hir::Expr,
3568 expected: Expectation<'tcx>,
3569 needs: Needs) -> Ty<'tcx> {
3573 hir::ExprBox(ref subexpr) => {
3574 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3576 ty::TyAdt(def, _) if def.is_box()
3577 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3581 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3582 tcx.mk_box(referent_ty)
3585 hir::ExprLit(ref lit) => {
3586 self.check_lit(&lit, expected)
3588 hir::ExprBinary(op, ref lhs, ref rhs) => {
3589 self.check_binop(expr, op, lhs, rhs)
3591 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3592 self.check_binop_assign(expr, op, lhs, rhs)
3594 hir::ExprUnary(unop, ref oprnd) => {
3595 let expected_inner = match unop {
3596 hir::UnNot | hir::UnNeg => {
3603 let needs = match unop {
3604 hir::UnDeref => needs,
3607 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3611 if !oprnd_t.references_error() {
3612 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3615 if let Some(mt) = oprnd_t.builtin_deref(true) {
3617 } else if let Some(ok) = self.try_overloaded_deref(
3618 expr.span, oprnd_t, needs) {
3619 let method = self.register_infer_ok_obligations(ok);
3620 if let ty::TyRef(region, _, mutbl) = method.sig.inputs()[0].sty {
3621 let mutbl = match mutbl {
3622 hir::MutImmutable => AutoBorrowMutability::Immutable,
3623 hir::MutMutable => AutoBorrowMutability::Mutable {
3624 // (It shouldn't actually matter for unary ops whether
3625 // we enable two-phase borrows or not, since a unary
3626 // op has no additional operands.)
3627 allow_two_phase_borrow: AllowTwoPhase::No,
3630 self.apply_adjustments(oprnd, vec![Adjustment {
3631 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3632 target: method.sig.inputs()[0]
3635 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3636 self.write_method_call(expr.hir_id, method);
3638 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3639 "type `{}` cannot be dereferenced",
3641 oprnd_t = tcx.types.err;
3645 let result = self.check_user_unop(expr, oprnd_t, unop);
3646 // If it's builtin, we can reuse the type, this helps inference.
3647 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3652 let result = self.check_user_unop(expr, oprnd_t, unop);
3653 // If it's builtin, we can reuse the type, this helps inference.
3654 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3662 hir::ExprAddrOf(mutbl, ref oprnd) => {
3663 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3665 ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
3666 if self.is_place_expr(&oprnd) {
3667 // Places may legitimately have unsized types.
3668 // For example, dereferences of a fat pointer and
3669 // the last field of a struct can be unsized.
3672 Expectation::rvalue_hint(self, ty)
3678 let needs = Needs::maybe_mut_place(mutbl);
3679 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3681 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3682 if tm.ty.references_error() {
3685 // Note: at this point, we cannot say what the best lifetime
3686 // is to use for resulting pointer. We want to use the
3687 // shortest lifetime possible so as to avoid spurious borrowck
3688 // errors. Moreover, the longest lifetime will depend on the
3689 // precise details of the value whose address is being taken
3690 // (and how long it is valid), which we don't know yet until type
3691 // inference is complete.
3693 // Therefore, here we simply generate a region variable. The
3694 // region inferencer will then select the ultimate value.
3695 // Finally, borrowck is charged with guaranteeing that the
3696 // value whose address was taken can actually be made to live
3697 // as long as it needs to live.
3698 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3699 tcx.mk_ref(region, tm)
3702 hir::ExprPath(ref qpath) => {
3703 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3704 expr.id, expr.span);
3705 let ty = if def != Def::Err {
3706 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3708 self.set_tainted_by_errors();
3712 // We always require that the type provided as the value for
3713 // a type parameter outlives the moment of instantiation.
3714 let substs = self.tables.borrow().node_substs(expr.hir_id);
3715 self.add_wf_bounds(substs, expr);
3719 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3720 for output in outputs {
3721 self.check_expr(output);
3723 for input in inputs {
3724 self.check_expr(input);
3728 hir::ExprBreak(destination, ref expr_opt) => {
3729 if let Some(target_id) = destination.target_id.opt_id() {
3731 if let Some(ref e) = *expr_opt {
3732 // If this is a break with a value, we need to type-check
3733 // the expression. Get an expected type from the loop context.
3734 let opt_coerce_to = {
3735 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3736 enclosing_breakables.find_breakable(target_id)
3739 .map(|coerce| coerce.expected_ty())
3742 // If the loop context is not a `loop { }`, then break with
3743 // a value is illegal, and `opt_coerce_to` will be `None`.
3744 // Just set expectation to error in that case.
3745 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3747 // Recurse without `enclosing_breakables` borrowed.
3748 e_ty = self.check_expr_with_hint(e, coerce_to);
3749 cause = self.misc(e.span);
3751 // Otherwise, this is a break *without* a value. That's
3752 // always legal, and is equivalent to `break ()`.
3753 e_ty = tcx.mk_nil();
3754 cause = self.misc(expr.span);
3757 // Now that we have type-checked `expr_opt`, borrow
3758 // the `enclosing_loops` field and let's coerce the
3759 // type of `expr_opt` into what is expected.
3760 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3761 let ctxt = enclosing_breakables.find_breakable(target_id);
3762 if let Some(ref mut coerce) = ctxt.coerce {
3763 if let Some(ref e) = *expr_opt {
3764 coerce.coerce(self, &cause, e, e_ty);
3766 assert!(e_ty.is_nil());
3767 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3770 // If `ctxt.coerce` is `None`, we can just ignore
3771 // the type of the expresison. This is because
3772 // either this was a break *without* a value, in
3773 // which case it is always a legal type (`()`), or
3774 // else an error would have been flagged by the
3775 // `loops` pass for using break with an expression
3776 // where you are not supposed to.
3777 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3780 ctxt.may_break = true;
3782 // Otherwise, we failed to find the enclosing loop;
3783 // this can only happen if the `break` was not
3784 // inside a loop at all, which is caught by the
3785 // loop-checking pass.
3786 assert!(self.tcx.sess.err_count() > 0);
3788 // We still need to assign a type to the inner expression to
3789 // prevent the ICE in #43162.
3790 if let Some(ref e) = *expr_opt {
3791 self.check_expr_with_hint(e, tcx.types.err);
3793 // ... except when we try to 'break rust;'.
3794 // ICE this expression in particular (see #43162).
3795 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3796 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3797 fatally_break_rust(self.tcx.sess);
3803 // the type of a `break` is always `!`, since it diverges
3806 hir::ExprAgain(_) => { tcx.types.never }
3807 hir::ExprRet(ref expr_opt) => {
3808 if self.ret_coercion.is_none() {
3809 struct_span_err!(self.tcx.sess, expr.span, E0572,
3810 "return statement outside of function body").emit();
3811 } else if let Some(ref e) = *expr_opt {
3812 self.check_return_expr(e);
3814 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3815 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3816 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3820 hir::ExprAssign(ref lhs, ref rhs) => {
3821 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3823 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3826 ExpectIfCondition => {
3827 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3828 expected error elsehwere");
3831 // Only check this if not in an `if` condition, as the
3832 // mistyped comparison help is more appropriate.
3833 if !self.is_place_expr(&lhs) {
3834 struct_span_err!(self.tcx.sess, expr.span, E0070,
3835 "invalid left-hand side expression")
3836 .span_label(expr.span, "left-hand of expression not valid")
3842 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3844 if lhs_ty.references_error() || rhs_ty.references_error() {
3850 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3851 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3852 expr.span, expected)
3854 hir::ExprWhile(ref cond, ref body, _) => {
3855 let ctxt = BreakableCtxt {
3856 // cannot use break with a value from a while loop
3861 self.with_breakable_ctxt(expr.id, ctxt, || {
3862 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3863 let cond_diverging = self.diverges.get();
3864 self.check_block_no_value(&body);
3866 // We may never reach the body so it diverging means nothing.
3867 self.diverges.set(cond_diverging);
3872 hir::ExprLoop(ref body, _, source) => {
3873 let coerce = match source {
3874 // you can only use break with a value from a normal `loop { }`
3875 hir::LoopSource::Loop => {
3876 let coerce_to = expected.coercion_target_type(self, body.span);
3877 Some(CoerceMany::new(coerce_to))
3880 hir::LoopSource::WhileLet |
3881 hir::LoopSource::ForLoop => {
3886 let ctxt = BreakableCtxt {
3888 may_break: false, // will get updated if/when we find a `break`
3891 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3892 self.check_block_no_value(&body);
3896 // No way to know whether it's diverging because
3897 // of a `break` or an outer `break` or `return.
3898 self.diverges.set(Diverges::Maybe);
3901 // If we permit break with a value, then result type is
3902 // the LUB of the breaks (possibly ! if none); else, it
3903 // is nil. This makes sense because infinite loops
3904 // (which would have type !) are only possible iff we
3905 // permit break with a value [1].
3906 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3907 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3909 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3910 self.check_match(expr, &discrim, arms, expected, match_src)
3912 hir::ExprClosure(capture, ref decl, body_id, _, gen) => {
3913 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
3915 hir::ExprBlock(ref body) => {
3916 self.check_block_with_expected(&body, expected)
3918 hir::ExprCall(ref callee, ref args) => {
3919 self.check_call(expr, &callee, args, expected)
3921 hir::ExprMethodCall(ref segment, span, ref args) => {
3922 self.check_method_call(expr, segment, span, args, expected, needs)
3924 hir::ExprCast(ref e, ref t) => {
3925 // Find the type of `e`. Supply hints based on the type we are casting to,
3927 let t_cast = self.to_ty(t);
3928 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3929 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3930 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3932 // Eagerly check for some obvious errors.
3933 if t_expr.references_error() || t_cast.references_error() {
3936 // Defer other checks until we're done type checking.
3937 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3938 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
3940 deferred_cast_checks.push(cast_check);
3943 Err(ErrorReported) => {
3949 hir::ExprType(ref e, ref t) => {
3950 let typ = self.to_ty(&t);
3951 self.check_expr_eq_type(&e, typ);
3954 hir::ExprArray(ref args) => {
3955 let uty = expected.to_option(self).and_then(|uty| {
3957 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3962 let element_ty = if !args.is_empty() {
3963 let coerce_to = uty.unwrap_or_else(
3964 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3965 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3966 assert_eq!(self.diverges.get(), Diverges::Maybe);
3968 let e_ty = self.check_expr_with_hint(e, coerce_to);
3969 let cause = self.misc(e.span);
3970 coerce.coerce(self, &cause, e, e_ty);
3972 coerce.complete(self)
3974 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3976 tcx.mk_array(element_ty, args.len() as u64)
3978 hir::ExprRepeat(ref element, count) => {
3979 let count_def_id = tcx.hir.body_owner_def_id(count);
3980 let param_env = ty::ParamEnv::empty();
3981 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
3982 let instance = ty::Instance::resolve(
3988 let global_id = GlobalId {
3992 let count = tcx.const_eval(param_env.and(global_id));
3994 if let Err(ref err) = count {
3995 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
3998 let uty = match expected {
3999 ExpectHasType(uty) => {
4001 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4008 let (element_ty, t) = match uty {
4010 self.check_expr_coercable_to_type(&element, uty);
4014 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4015 let element_ty = self.check_expr_has_type_or_error(&element, t);
4020 if let Ok(count) = count {
4021 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4023 // For [foo, ..n] where n > 1, `foo` must have
4025 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4026 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4030 if element_ty.references_error() {
4032 } else if let Ok(count) = count {
4033 tcx.mk_ty(ty::TyArray(t, count))
4038 hir::ExprTup(ref elts) => {
4039 let flds = expected.only_has_type(self).and_then(|ty| {
4040 let ty = self.resolve_type_vars_with_obligations(ty);
4042 ty::TyTuple(ref flds) => Some(&flds[..]),
4047 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4048 let t = match flds {
4049 Some(ref fs) if i < fs.len() => {
4051 self.check_expr_coercable_to_type(&e, ety);
4055 self.check_expr_with_expectation(&e, NoExpectation)
4060 let tuple = tcx.mk_tup(elt_ts_iter);
4061 if tuple.references_error() {
4064 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4068 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4069 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4071 hir::ExprField(ref base, ref field) => {
4072 self.check_field(expr, needs, &base, field)
4074 hir::ExprIndex(ref base, ref idx) => {
4075 let base_t = self.check_expr_with_needs(&base, needs);
4076 let idx_t = self.check_expr(&idx);
4078 if base_t.references_error() {
4080 } else if idx_t.references_error() {
4083 let base_t = self.structurally_resolved_type(base.span, base_t);
4084 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4085 Some((index_ty, element_ty)) => {
4086 // two-phase not needed because index_ty is never mutable
4087 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4091 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4092 "cannot index into a value of type `{}`",
4094 // Try to give some advice about indexing tuples.
4095 if let ty::TyTuple(..) = base_t.sty {
4096 let mut needs_note = true;
4097 // If the index is an integer, we can show the actual
4098 // fixed expression:
4099 if let hir::ExprLit(ref lit) = idx.node {
4100 if let ast::LitKind::Int(i,
4101 ast::LitIntType::Unsuffixed) = lit.node {
4102 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4103 if let Ok(snip) = snip {
4104 err.span_suggestion(expr.span,
4105 "to access tuple elements, use",
4106 format!("{}.{}", snip, i));
4112 err.help("to access tuple elements, use tuple indexing \
4113 syntax (e.g. `tuple.0`)");
4122 hir::ExprYield(ref value) => {
4123 match self.yield_ty {
4125 self.check_expr_coercable_to_type(&value, ty);
4128 struct_span_err!(self.tcx.sess, expr.span, E0627,
4129 "yield statement outside of generator literal").emit();
4137 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4138 // The newly resolved definition is written into `type_dependent_defs`.
4139 fn finish_resolving_struct_path(&self,
4142 node_id: ast::NodeId)
4146 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4147 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4148 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4151 hir::QPath::TypeRelative(ref qself, ref segment) => {
4152 let ty = self.to_ty(qself);
4154 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4159 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4162 // Write back the new resolution.
4163 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4164 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4171 // Resolve associated value path into a base type and associated constant or method definition.
4172 // The newly resolved definition is written into `type_dependent_defs`.
4173 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4174 qpath: &'b hir::QPath,
4175 node_id: ast::NodeId,
4177 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4179 let (ty, item_segment) = match *qpath {
4180 hir::QPath::Resolved(ref opt_qself, ref path) => {
4182 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4183 &path.segments[..]);
4185 hir::QPath::TypeRelative(ref qself, ref segment) => {
4186 (self.to_ty(qself), segment)
4189 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4190 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4191 // Return directly on cache hit. This is useful to avoid doubly reporting
4192 // errors with default match binding modes. See #44614.
4193 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4195 let item_name = item_segment.name;
4196 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4199 let def = match error {
4200 method::MethodError::PrivateMatch(def, _) => def,
4203 if item_name != keywords::Invalid.name() {
4204 self.report_method_error(span, ty, item_name, None, error, None);
4210 // Write back the new resolution.
4211 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4212 (def, Some(ty), slice::from_ref(&**item_segment))
4215 pub fn check_decl_initializer(&self,
4216 local: &'gcx hir::Local,
4217 init: &'gcx hir::Expr) -> Ty<'tcx>
4219 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4220 // for #42640 (default match binding modes).
4223 let ref_bindings = local.pat.contains_explicit_ref_binding();
4225 let local_ty = self.local_ty(init.span, local.id);
4226 if let Some(m) = ref_bindings {
4227 // Somewhat subtle: if we have a `ref` binding in the pattern,
4228 // we want to avoid introducing coercions for the RHS. This is
4229 // both because it helps preserve sanity and, in the case of
4230 // ref mut, for soundness (issue #23116). In particular, in
4231 // the latter case, we need to be clear that the type of the
4232 // referent for the reference that results is *equal to* the
4233 // type of the place it is referencing, and not some
4234 // supertype thereof.
4235 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4236 self.demand_eqtype(init.span, local_ty, init_ty);
4239 self.check_expr_coercable_to_type(init, local_ty)
4243 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4244 let t = self.local_ty(local.span, local.id);
4245 self.write_ty(local.hir_id, t);
4247 if let Some(ref init) = local.init {
4248 let init_ty = self.check_decl_initializer(local, &init);
4249 if init_ty.references_error() {
4250 self.write_ty(local.hir_id, init_ty);
4254 self.check_pat_walk(&local.pat, t,
4255 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4257 let pat_ty = self.node_ty(local.pat.hir_id);
4258 if pat_ty.references_error() {
4259 self.write_ty(local.hir_id, pat_ty);
4263 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4264 // Don't do all the complex logic below for DeclItem.
4266 hir::StmtDecl(ref decl, _) => {
4268 hir::DeclLocal(_) => {}
4269 hir::DeclItem(_) => {
4274 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4277 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4279 // Hide the outer diverging and has_errors flags.
4280 let old_diverges = self.diverges.get();
4281 let old_has_errors = self.has_errors.get();
4282 self.diverges.set(Diverges::Maybe);
4283 self.has_errors.set(false);
4286 hir::StmtDecl(ref decl, _) => {
4288 hir::DeclLocal(ref l) => {
4289 self.check_decl_local(&l);
4291 hir::DeclItem(_) => {/* ignore for now */}
4294 hir::StmtExpr(ref expr, _) => {
4295 // Check with expected type of ()
4296 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4298 hir::StmtSemi(ref expr, _) => {
4299 self.check_expr(&expr);
4303 // Combine the diverging and has_error flags.
4304 self.diverges.set(self.diverges.get() | old_diverges);
4305 self.has_errors.set(self.has_errors.get() | old_has_errors);
4308 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4309 let unit = self.tcx.mk_nil();
4310 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4312 // if the block produces a `!` value, that can always be
4313 // (effectively) coerced to unit.
4315 self.demand_suptype(blk.span, unit, ty);
4319 fn check_block_with_expected(&self,
4320 blk: &'gcx hir::Block,
4321 expected: Expectation<'tcx>) -> Ty<'tcx> {
4323 let mut fcx_ps = self.ps.borrow_mut();
4324 let unsafety_state = fcx_ps.recurse(blk);
4325 replace(&mut *fcx_ps, unsafety_state)
4328 // In some cases, blocks have just one exit, but other blocks
4329 // can be targeted by multiple breaks. This cannot happen in
4330 // normal Rust syntax today, but it can happen when we desugar
4331 // a `do catch { ... }` expression.
4335 // 'a: { if true { break 'a Err(()); } Ok(()) }
4337 // Here we would wind up with two coercions, one from
4338 // `Err(())` and the other from the tail expression
4339 // `Ok(())`. If the tail expression is omitted, that's a
4340 // "forced unit" -- unless the block diverges, in which
4341 // case we can ignore the tail expression (e.g., `'a: {
4342 // break 'a 22; }` would not force the type of the block
4344 let tail_expr = blk.expr.as_ref();
4345 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4346 let coerce = if blk.targeted_by_break {
4347 CoerceMany::new(coerce_to_ty)
4349 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4350 Some(e) => slice::from_ref(e),
4353 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4356 let prev_diverges = self.diverges.get();
4357 let ctxt = BreakableCtxt {
4358 coerce: Some(coerce),
4362 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4363 for s in &blk.stmts {
4367 // check the tail expression **without** holding the
4368 // `enclosing_breakables` lock below.
4369 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4371 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4372 let ctxt = enclosing_breakables.find_breakable(blk.id);
4373 let coerce = ctxt.coerce.as_mut().unwrap();
4374 if let Some(tail_expr_ty) = tail_expr_ty {
4375 let tail_expr = tail_expr.unwrap();
4376 let cause = self.cause(tail_expr.span,
4377 ObligationCauseCode::BlockTailExpression(blk.id));
4383 // Subtle: if there is no explicit tail expression,
4384 // that is typically equivalent to a tail expression
4385 // of `()` -- except if the block diverges. In that
4386 // case, there is no value supplied from the tail
4387 // expression (assuming there are no other breaks,
4388 // this implies that the type of the block will be
4391 // #41425 -- label the implicit `()` as being the
4392 // "found type" here, rather than the "expected type".
4394 // #44579 -- if the block was recovered during parsing,
4395 // the type would be nonsensical and it is not worth it
4396 // to perform the type check, so we avoid generating the
4397 // diagnostic output.
4398 if !self.diverges.get().always() && !blk.recovered {
4399 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4400 if let Some(expected_ty) = expected.only_has_type(self) {
4401 self.consider_hint_about_removing_semicolon(blk,
4411 // If we can break from the block, then the block's exit is always reachable
4412 // (... as long as the entry is reachable) - regardless of the tail of the block.
4413 self.diverges.set(prev_diverges);
4416 let mut ty = ctxt.coerce.unwrap().complete(self);
4418 if self.has_errors.get() || ty.references_error() {
4419 ty = self.tcx.types.err
4422 self.write_ty(blk.hir_id, ty);
4424 *self.ps.borrow_mut() = prev;
4428 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4429 /// suggestion can be made, `None` otherwise.
4430 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4431 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4432 // `while` before reaching it, as block tail returns are not available in them.
4433 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4434 let parent = self.tcx.hir.get(fn_id);
4436 if let Node::NodeItem(&hir::Item {
4437 name, node: hir::ItemFn(ref decl, ..), ..
4439 decl.clone().and_then(|decl| {
4440 // This is less than ideal, it will not suggest a return type span on any
4441 // method called `main`, regardless of whether it is actually the entry point,
4442 // but it will still present it as the reason for the expected type.
4443 Some((decl, name != Symbol::intern("main")))
4445 } else if let Node::NodeTraitItem(&hir::TraitItem {
4446 node: hir::TraitItemKind::Method(hir::MethodSig {
4450 decl.clone().and_then(|decl| {
4453 } else if let Node::NodeImplItem(&hir::ImplItem {
4454 node: hir::ImplItemKind::Method(hir::MethodSig {
4458 decl.clone().and_then(|decl| {
4469 /// On implicit return expressions with mismatched types, provide the following suggestions:
4471 /// - Point out the method's return type as the reason for the expected type
4472 /// - Possible missing semicolon
4473 /// - Possible missing return type if the return type is the default, and not `fn main()`
4474 pub fn suggest_mismatched_types_on_tail(&self,
4475 err: &mut DiagnosticBuilder<'tcx>,
4476 expression: &'gcx hir::Expr,
4480 blk_id: ast::NodeId) {
4481 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4483 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4484 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4488 /// A common error is to forget to add a semicolon at the end of a block:
4492 /// bar_that_returns_u32()
4496 /// This routine checks if the return expression in a block would make sense on its own as a
4497 /// statement and the return type has been left as default or has been specified as `()`. If so,
4498 /// it suggests adding a semicolon.
4499 fn suggest_missing_semicolon(&self,
4500 err: &mut DiagnosticBuilder<'tcx>,
4501 expression: &'gcx hir::Expr,
4504 if expected.is_nil() {
4505 // `BlockTailExpression` only relevant if the tail expr would be
4506 // useful on its own.
4507 match expression.node {
4509 hir::ExprMethodCall(..) |
4511 hir::ExprWhile(..) |
4513 hir::ExprMatch(..) |
4514 hir::ExprBlock(..) => {
4515 let sp = self.tcx.sess.codemap().next_point(cause_span);
4516 err.span_suggestion(sp,
4517 "try adding a semicolon",
4526 /// A possible error is to forget to add a return type that is needed:
4530 /// bar_that_returns_u32()
4534 /// This routine checks if the return type is left as default, the method is not part of an
4535 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4537 fn suggest_missing_return_type(&self,
4538 err: &mut DiagnosticBuilder<'tcx>,
4539 fn_decl: &hir::FnDecl,
4542 can_suggest: bool) {
4543 // Only suggest changing the return type for methods that
4544 // haven't set a return type at all (and aren't `fn main()` or an impl).
4545 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4546 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4547 err.span_suggestion(span,
4548 "try adding a return type",
4550 self.resolve_type_vars_with_obligations(found)));
4552 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4553 err.span_label(span, "possibly return type missing here?");
4555 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4556 // `fn main()` must return `()`, do not suggest changing return type
4557 err.span_label(span, "expected `()` because of default return type");
4559 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4560 // Only point to return type if the expected type is the return type, as if they
4561 // are not, the expectation must have been caused by something else.
4562 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4564 let ty = AstConv::ast_ty_to_ty(self, ty);
4565 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4566 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4567 if ty.sty == expected.sty {
4568 err.span_label(sp, format!("expected `{}` because of return type",
4576 /// A common error is to add an extra semicolon:
4579 /// fn foo() -> usize {
4584 /// This routine checks if the final statement in a block is an
4585 /// expression with an explicit semicolon whose type is compatible
4586 /// with `expected_ty`. If so, it suggests removing the semicolon.
4587 fn consider_hint_about_removing_semicolon(&self,
4588 blk: &'gcx hir::Block,
4589 expected_ty: Ty<'tcx>,
4590 err: &mut DiagnosticBuilder) {
4591 // Be helpful when the user wrote `{... expr;}` and
4592 // taking the `;` off is enough to fix the error.
4593 let last_stmt = match blk.stmts.last() {
4597 let last_expr = match last_stmt.node {
4598 hir::StmtSemi(ref e, _) => e,
4601 let last_expr_ty = self.node_ty(last_expr.hir_id);
4602 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4605 let original_span = original_sp(last_stmt.span, blk.span);
4606 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4607 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4610 // Instantiates the given path, which must refer to an item with the given
4611 // number of type parameters and type.
4612 pub fn instantiate_value_path(&self,
4613 segments: &[hir::PathSegment],
4614 opt_self_ty: Option<Ty<'tcx>>,
4617 node_id: ast::NodeId)
4619 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4624 // We need to extract the type parameters supplied by the user in
4625 // the path `path`. Due to the current setup, this is a bit of a
4626 // tricky-process; the problem is that resolve only tells us the
4627 // end-point of the path resolution, and not the intermediate steps.
4628 // Luckily, we can (at least for now) deduce the intermediate steps
4629 // just from the end-point.
4631 // There are basically four cases to consider:
4633 // 1. Reference to a constructor of enum variant or struct:
4635 // struct Foo<T>(...)
4636 // enum E<T> { Foo(...) }
4638 // In these cases, the parameters are declared in the type
4641 // 2. Reference to a fn item or a free constant:
4645 // In this case, the path will again always have the form
4646 // `a::b::foo::<T>` where only the final segment should have
4647 // type parameters. However, in this case, those parameters are
4648 // declared on a value, and hence are in the `FnSpace`.
4650 // 3. Reference to a method or an associated constant:
4652 // impl<A> SomeStruct<A> {
4656 // Here we can have a path like
4657 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4658 // may appear in two places. The penultimate segment,
4659 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4660 // final segment, `foo::<B>` contains parameters in fn space.
4662 // 4. Reference to a local variable
4664 // Local variables can't have any type parameters.
4666 // The first step then is to categorize the segments appropriately.
4668 assert!(!segments.is_empty());
4670 let mut ufcs_associated = None;
4671 let mut type_segment = None;
4672 let mut fn_segment = None;
4674 // Case 1. Reference to a struct/variant constructor.
4675 Def::StructCtor(def_id, ..) |
4676 Def::VariantCtor(def_id, ..) => {
4677 // Everything but the final segment should have no
4678 // parameters at all.
4679 let mut generics = self.tcx.generics_of(def_id);
4680 if let Some(def_id) = generics.parent {
4681 // Variant and struct constructors use the
4682 // generics of their parent type definition.
4683 generics = self.tcx.generics_of(def_id);
4685 type_segment = Some((segments.last().unwrap(), generics));
4688 // Case 2. Reference to a top-level value.
4690 Def::Const(def_id) |
4691 Def::Static(def_id, _) => {
4692 fn_segment = Some((segments.last().unwrap(),
4693 self.tcx.generics_of(def_id)));
4696 // Case 3. Reference to a method or associated const.
4697 Def::Method(def_id) |
4698 Def::AssociatedConst(def_id) => {
4699 let container = self.tcx.associated_item(def_id).container;
4701 ty::TraitContainer(trait_did) => {
4702 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4704 ty::ImplContainer(_) => {}
4707 let generics = self.tcx.generics_of(def_id);
4708 if segments.len() >= 2 {
4709 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4710 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4712 // `<T>::assoc` will end up here, and so can `T::assoc`.
4713 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4714 ufcs_associated = Some((container, self_ty));
4716 fn_segment = Some((segments.last().unwrap(), generics));
4719 // Case 4. Local variable, no generics.
4720 Def::Local(..) | Def::Upvar(..) => {}
4722 _ => bug!("unexpected definition: {:?}", def),
4725 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4727 // Now that we have categorized what space the parameters for each
4728 // segment belong to, let's sort out the parameters that the user
4729 // provided (if any) into their appropriate spaces. We'll also report
4730 // errors if type parameters are provided in an inappropriate place.
4731 let poly_segments = type_segment.is_some() as usize +
4732 fn_segment.is_some() as usize;
4733 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4736 Def::Local(nid) | Def::Upvar(nid, ..) => {
4737 let ty = self.local_ty(span, nid);
4738 let ty = self.normalize_associated_types_in(span, &ty);
4739 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4745 // Now we have to compare the types that the user *actually*
4746 // provided against the types that were *expected*. If the user
4747 // did not provide any types, then we want to substitute inference
4748 // variables. If the user provided some types, we may still need
4749 // to add defaults. If the user provided *too many* types, that's
4751 let supress_mismatch = self.check_impl_trait(span, &mut fn_segment);
4752 self.check_path_parameter_count(span, &mut type_segment, false, supress_mismatch);
4753 self.check_path_parameter_count(span, &mut fn_segment, false, supress_mismatch);
4755 let (fn_start, has_self) = match (type_segment, fn_segment) {
4756 (_, Some((_, generics))) => {
4757 (generics.parent_count, generics.has_self)
4759 (Some((_, generics)), None) => {
4760 (generics.params.len(), generics.has_self)
4762 (None, None) => (0, false)
4764 let substs = Substs::for_item(self.tcx, def.def_id(), |param, substs| {
4765 let mut i = param.index as usize;
4767 let segment = if i < fn_start {
4768 if let GenericParamDefKind::Type(_) = param.kind {
4769 // Handle Self first, so we can adjust the index to match the AST.
4770 if has_self && i == 0 {
4771 return opt_self_ty.map(|ty| Kind::from(ty)).unwrap_or_else(|| {
4772 self.var_for_def(span, param)
4776 i -= has_self as usize;
4784 GenericParamDefKind::Lifetime => {
4785 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4786 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4789 if let Some(lifetime) = lifetimes.get(i) {
4790 AstConv::ast_region_to_region(self, lifetime, Some(param)).into()
4792 self.re_infer(span, Some(param)).unwrap().into()
4795 GenericParamDefKind::Type(_) => {
4796 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4797 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4800 // Skip over the lifetimes in the same segment.
4801 if let Some((_, generics)) = segment {
4802 i -= generics.own_counts().lifetimes;
4805 let has_default = match param.kind {
4806 GenericParamDefKind::Type(ty) => ty.has_default,
4810 if let Some(ast_ty) = types.get(i) {
4811 // A provided type parameter.
4812 self.to_ty(ast_ty).into()
4813 } else if !infer_types && has_default {
4814 // No type parameter provided, but a default exists.
4815 let default = self.tcx.type_of(param.def_id);
4818 default.subst_spanned(self.tcx, substs, Some(span))
4821 // No type parameters were provided, we can infer all.
4822 // This can also be reached in some error cases:
4823 // We prefer to use inference variables instead of
4824 // TyError to let type inference recover somewhat.
4825 self.var_for_def(span, param)
4831 // The things we are substituting into the type should not contain
4832 // escaping late-bound regions, and nor should the base type scheme.
4833 let ty = self.tcx.type_of(def.def_id());
4834 assert!(!substs.has_escaping_regions());
4835 assert!(!ty.has_escaping_regions());
4837 // Add all the obligations that are required, substituting and
4838 // normalized appropriately.
4839 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4840 self.add_obligations_for_parameters(
4841 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4844 // Substitute the values for the type parameters into the type of
4845 // the referenced item.
4846 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4848 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4849 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4850 // is inherent, there is no `Self` parameter, instead, the impl needs
4851 // type parameters, which we can infer by unifying the provided `Self`
4852 // with the substituted impl type.
4853 let ty = self.tcx.type_of(impl_def_id);
4855 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4856 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4857 Ok(ok) => self.register_infer_ok_obligations(ok),
4860 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4867 self.check_rustc_args_require_const(def.def_id(), node_id, span);
4869 debug!("instantiate_value_path: type of {:?} is {:?}",
4872 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4876 fn check_rustc_args_require_const(&self,
4878 node_id: ast::NodeId,
4880 // We're only interested in functions tagged with
4881 // #[rustc_args_required_const], so ignore anything that's not.
4882 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
4886 // If our calling expression is indeed the function itself, we're good!
4887 // If not, generate an error that this can only be called directly.
4888 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
4889 Node::NodeExpr(expr) => {
4891 hir::ExprCall(ref callee, ..) => {
4892 if callee.id == node_id {
4902 self.tcx.sess.span_err(span, "this function can only be invoked \
4903 directly, not through a function pointer");
4906 /// Report errors if the provided parameters are too few or too many.
4907 fn check_path_parameter_count(&self,
4909 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4910 is_method_call: bool,
4911 supress_mismatch_error: bool) {
4912 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4913 (&[][..], &[][..], true, &[][..]),
4914 |(s, _)| s.parameters.as_ref().map_or(
4915 (&[][..], &[][..], s.infer_types, &[][..]),
4916 |p| (&p.lifetimes[..], &p.types[..],
4917 s.infer_types, &p.bindings[..])));
4918 let infer_lifetimes = lifetimes.len() == 0;
4920 let count_lifetime_params = |n| {
4921 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4923 let count_type_params = |n| {
4924 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4927 // Check provided parameters.
4928 let ((ty_required, ty_accepted), lt_accepted) =
4929 segment.map_or(((0, 0), 0), |(_, generics)| {
4935 let mut lt_accepted = 0;
4936 let mut ty_params = ParamRange { required: 0, accepted: 0 };
4937 for param in &generics.params {
4939 GenericParamDefKind::Lifetime => {
4942 GenericParamDefKind::Type(ty) => {
4943 ty_params.accepted += 1;
4944 if !ty.has_default {
4945 ty_params.required += 1;
4950 if generics.parent.is_none() && generics.has_self {
4951 ty_params.required -= 1;
4952 ty_params.accepted -= 1;
4955 ((ty_params.required, ty_params.accepted), lt_accepted)
4958 if types.len() > ty_accepted {
4959 let span = types[ty_accepted].span;
4960 let expected_text = count_type_params(ty_accepted);
4961 let actual_text = count_type_params(types.len());
4962 struct_span_err!(self.tcx.sess, span, E0087,
4963 "too many type parameters provided: \
4964 expected at most {}, found {}",
4965 expected_text, actual_text)
4966 .span_label(span, format!("expected {}", expected_text))
4969 // To prevent derived errors to accumulate due to extra
4970 // type parameters, we force instantiate_value_path to
4971 // use inference variables instead of the provided types.
4973 } else if types.len() < ty_required && !infer_types && !supress_mismatch_error {
4974 let expected_text = count_type_params(ty_required);
4975 let actual_text = count_type_params(types.len());
4976 struct_span_err!(self.tcx.sess, span, E0089,
4977 "too few type parameters provided: \
4978 expected {}, found {}",
4979 expected_text, actual_text)
4980 .span_label(span, format!("expected {}", expected_text))
4984 if !bindings.is_empty() {
4985 AstConv::prohibit_projection(self, bindings[0].span);
4988 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4989 let has_late_bound_lifetime_defs =
4990 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4991 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4992 // Report this as a lint only if no error was reported previously.
4993 let primary_msg = "cannot specify lifetime arguments explicitly \
4994 if late bound lifetime parameters are present";
4995 let note_msg = "the late bound lifetime parameter is introduced here";
4996 if !is_method_call && (lifetimes.len() > lt_accepted ||
4997 lifetimes.len() < lt_accepted && !infer_lifetimes) {
4998 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4999 err.span_note(span_late, note_msg);
5003 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
5004 multispan.push_span_label(span_late, note_msg.to_string());
5005 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
5006 lifetimes[0].id, multispan, primary_msg);
5011 if lifetimes.len() > lt_accepted {
5012 let span = lifetimes[lt_accepted].span;
5013 let expected_text = count_lifetime_params(lt_accepted);
5014 let actual_text = count_lifetime_params(lifetimes.len());
5015 struct_span_err!(self.tcx.sess, span, E0088,
5016 "too many lifetime parameters provided: \
5017 expected at most {}, found {}",
5018 expected_text, actual_text)
5019 .span_label(span, format!("expected {}", expected_text))
5021 } else if lifetimes.len() < lt_accepted && !infer_lifetimes {
5022 let expected_text = count_lifetime_params(lt_accepted);
5023 let actual_text = count_lifetime_params(lifetimes.len());
5024 struct_span_err!(self.tcx.sess, span, E0090,
5025 "too few lifetime parameters provided: \
5026 expected {}, found {}",
5027 expected_text, actual_text)
5028 .span_label(span, format!("expected {}", expected_text))
5033 /// Report error if there is an explicit type parameter when using `impl Trait`.
5034 fn check_impl_trait(&self,
5036 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>)
5038 let segment = segment.map(|(path_segment, generics)| {
5039 let explicit = !path_segment.infer_types;
5040 let impl_trait = generics.params.iter().any(|param| {
5041 if let ty::GenericParamDefKind::Type(ty) = param.kind {
5042 if let Some(hir::SyntheticTyParamKind::ImplTrait) = ty.synthetic {
5049 if explicit && impl_trait {
5050 let mut err = struct_span_err! {
5054 "cannot provide explicit type parameters when `impl Trait` is \
5055 used in argument position."
5064 segment.unwrap_or(false)
5067 // Resolves `typ` by a single level if `typ` is a type variable.
5068 // If no resolution is possible, then an error is reported.
5069 // Numeric inference variables may be left unresolved.
5070 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5071 let ty = self.resolve_type_vars_with_obligations(ty);
5072 if !ty.is_ty_var() {
5075 if !self.is_tainted_by_errors() {
5076 self.need_type_info_err((**self).body_id, sp, ty)
5077 .note("type must be known at this point")
5080 self.demand_suptype(sp, self.tcx.types.err, ty);
5085 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5086 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5087 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5090 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5091 index = enclosing_breakables.stack.len();
5092 enclosing_breakables.by_id.insert(id, index);
5093 enclosing_breakables.stack.push(ctxt);
5097 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5098 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5099 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5100 enclosing_breakables.stack.pop().expect("missing breakable context")
5106 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5107 generics: &hir::Generics,
5109 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5110 generics.ty_params().count(), ty);
5112 // make a vector of booleans initially false, set to true when used
5113 if generics.ty_params().next().is_none() { return; }
5114 let mut tps_used = vec![false; generics.ty_params().count()];
5116 let lifetime_count = generics.lifetimes().count();
5118 for leaf_ty in ty.walk() {
5119 if let ty::TyParam(ty::ParamTy {idx, ..}) = leaf_ty.sty {
5120 debug!("Found use of ty param num {}", idx);
5121 tps_used[idx as usize - lifetime_count] = true;
5122 } else if let ty::TyError = leaf_ty.sty {
5123 // If there already another error, do not emit an error for not using a type Parameter
5124 assert!(tcx.sess.err_count() > 0);
5129 for (&used, param) in tps_used.iter().zip(generics.ty_params()) {
5131 struct_span_err!(tcx.sess, param.span, E0091,
5132 "type parameter `{}` is unused",
5134 .span_label(param.span, "unused type parameter")
5140 fn fatally_break_rust(sess: &Session) {
5141 let handler = sess.diagnostic();
5142 handler.span_bug_no_panic(
5144 "It looks like you're trying to break rust; would you like some ICE?",
5146 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5147 handler.note_without_error(
5148 "we would appreciate a joke overview: \
5149 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5151 handler.note_without_error(&format!("rustc {} running on {}",
5152 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5153 ::session::config::host_triple(),