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.item_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::coercion::{CoerceMany, DynamicCoerceMany};
81 pub use self::compare_method::{compare_impl_method, compare_const_impl};
82 use self::TupleArgumentsFlag::*;
85 use fmt_macros::{Parser, Piece, Position};
86 use hir::def::{Def, CtorKind};
87 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
88 use rustc_back::slice::ref_slice;
89 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
90 use rustc::infer::type_variable::{TypeVariableOrigin};
91 use rustc::ty::subst::{Kind, Subst, Substs};
92 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode, Reveal};
93 use rustc::ty::{ParamTy, ParameterEnvironment};
94 use rustc::ty::{LvaluePreference, NoPreference, PreferMutLvalue};
95 use rustc::ty::{self, Ty, TyCtxt, Visibility};
96 use rustc::ty::{MethodCall, MethodCallee};
97 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
98 use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
99 use rustc::ty::maps::Providers;
100 use rustc::ty::util::{Representability, IntTypeExt};
101 use errors::DiagnosticBuilder;
102 use require_c_abi_if_variadic;
103 use session::{Session, CompileResult};
106 use util::common::{ErrorReported, indenter};
107 use util::nodemap::{DefIdMap, FxHashMap, NodeMap};
109 use std::cell::{Cell, RefCell};
110 use std::collections::hash_map::Entry;
112 use std::mem::replace;
113 use std::ops::{self, Deref};
114 use syntax::abi::Abi;
116 use syntax::codemap::{self, original_sp, Spanned};
117 use syntax::feature_gate::{GateIssue, emit_feature_err};
119 use syntax::symbol::{Symbol, InternedString, keywords};
120 use syntax::util::lev_distance::find_best_match_for_name;
121 use syntax_pos::{self, BytePos, Span, DUMMY_SP};
123 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
124 use rustc::hir::itemlikevisit::ItemLikeVisitor;
125 use rustc::hir::{self, PatKind};
126 use rustc::middle::lang_items;
127 use rustc_back::slice;
128 use rustc::middle::const_val::eval_length;
129 use rustc_const_math::ConstInt;
148 /// closures defined within the function. For example:
151 /// bar(move|| { ... })
154 /// Here, the function `foo()` and the closure passed to
155 /// `bar()` will each have their own `FnCtxt`, but they will
156 /// share the inherited fields.
157 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
158 infcx: InferCtxt<'a, 'gcx, 'tcx>,
160 locals: RefCell<NodeMap<Ty<'tcx>>>,
162 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
164 // When we process a call like `c()` where `c` is a closure type,
165 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
166 // `FnOnce` closure. In that case, we defer full resolution of the
167 // call until upvar inference can kick in and make the
168 // decision. We keep these deferred resolutions grouped by the
169 // def-id of the closure, so that once we decide, we can easily go
170 // back and process them.
171 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolutionHandler<'gcx, 'tcx>>>>,
173 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
175 // Anonymized types found in explicit return types and their
176 // associated fresh inference variable. Writeback resolves these
177 // variables to get the concrete type, which can be used to
178 // deanonymize TyAnon, after typeck is done with all functions.
179 anon_types: RefCell<NodeMap<Ty<'tcx>>>,
182 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
183 type Target = InferCtxt<'a, 'gcx, 'tcx>;
184 fn deref(&self) -> &Self::Target {
189 trait DeferredCallResolution<'gcx, 'tcx> {
190 fn resolve<'a>(&mut self, fcx: &FnCtxt<'a, 'gcx, 'tcx>);
193 type DeferredCallResolutionHandler<'gcx, 'tcx> = Box<DeferredCallResolution<'gcx, 'tcx>+'tcx>;
195 /// When type-checking an expression, we propagate downward
196 /// whatever type hint we are able in the form of an `Expectation`.
197 #[derive(Copy, Clone, Debug)]
198 pub enum Expectation<'tcx> {
199 /// We know nothing about what type this expression should have.
202 /// This expression should have the type given (or some subtype)
203 ExpectHasType(Ty<'tcx>),
205 /// This expression will be cast to the `Ty`
206 ExpectCastableToType(Ty<'tcx>),
208 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
209 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
210 ExpectRvalueLikeUnsized(Ty<'tcx>),
213 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
214 // Disregard "castable to" expectations because they
215 // can lead us astray. Consider for example `if cond
216 // {22} else {c} as u8` -- if we propagate the
217 // "castable to u8" constraint to 22, it will pick the
218 // type 22u8, which is overly constrained (c might not
219 // be a u8). In effect, the problem is that the
220 // "castable to" expectation is not the tightest thing
221 // we can say, so we want to drop it in this case.
222 // The tightest thing we can say is "must unify with
223 // else branch". Note that in the case of a "has type"
224 // constraint, this limitation does not hold.
226 // If the expected type is just a type variable, then don't use
227 // an expected type. Otherwise, we might write parts of the type
228 // when checking the 'then' block which are incompatible with the
230 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
232 ExpectHasType(ety) => {
233 let ety = fcx.shallow_resolve(ety);
234 if !ety.is_ty_var() {
240 ExpectRvalueLikeUnsized(ety) => {
241 ExpectRvalueLikeUnsized(ety)
247 /// Provide an expectation for an rvalue expression given an *optional*
248 /// hint, which is not required for type safety (the resulting type might
249 /// be checked higher up, as is the case with `&expr` and `box expr`), but
250 /// is useful in determining the concrete type.
252 /// The primary use case is where the expected type is a fat pointer,
253 /// like `&[isize]`. For example, consider the following statement:
255 /// let x: &[isize] = &[1, 2, 3];
257 /// In this case, the expected type for the `&[1, 2, 3]` expression is
258 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
259 /// expectation `ExpectHasType([isize])`, that would be too strong --
260 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
261 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
262 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
263 /// which still is useful, because it informs integer literals and the like.
264 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
265 /// for examples of where this comes up,.
266 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
267 match fcx.tcx.struct_tail(ty).sty {
268 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
269 ExpectRvalueLikeUnsized(ty)
271 _ => ExpectHasType(ty)
275 // Resolves `expected` by a single level if it is a variable. If
276 // there is no expected type or resolution is not possible (e.g.,
277 // no constraints yet present), just returns `None`.
278 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
283 ExpectCastableToType(t) => {
284 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
286 ExpectHasType(t) => {
287 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
289 ExpectRvalueLikeUnsized(t) => {
290 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
295 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
296 match self.resolve(fcx) {
297 NoExpectation => None,
298 ExpectCastableToType(ty) |
300 ExpectRvalueLikeUnsized(ty) => Some(ty),
304 /// It sometimes happens that we want to turn an expectation into
305 /// a **hard constraint** (i.e., something that must be satisfied
306 /// for the program to type-check). `only_has_type` will return
307 /// such a constraint, if it exists.
308 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
309 match self.resolve(fcx) {
310 ExpectHasType(ty) => Some(ty),
315 /// Like `only_has_type`, but instead of returning `None` if no
316 /// hard constraint exists, creates a fresh type variable.
317 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
318 self.only_has_type(fcx)
319 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
323 #[derive(Copy, Clone)]
324 pub struct UnsafetyState {
325 pub def: ast::NodeId,
326 pub unsafety: hir::Unsafety,
327 pub unsafe_push_count: u32,
332 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
333 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
336 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
337 match self.unsafety {
338 // If this unsafe, then if the outer function was already marked as
339 // unsafe we shouldn't attribute the unsafe'ness to the block. This
340 // way the block can be warned about instead of ignoring this
341 // extraneous block (functions are never warned about).
342 hir::Unsafety::Unsafe if self.from_fn => *self,
345 let (unsafety, def, count) = match blk.rules {
346 hir::PushUnsafeBlock(..) =>
347 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
348 hir::PopUnsafeBlock(..) =>
349 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
350 hir::UnsafeBlock(..) =>
351 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
353 (unsafety, self.def, self.unsafe_push_count),
355 UnsafetyState{ def: def,
357 unsafe_push_count: count,
364 #[derive(Debug, Copy, Clone)]
370 #[derive(Copy, Clone, Debug)]
371 pub struct AdjustedRcvr<'a> {
372 pub rcvr_expr: &'a hir::Expr,
373 pub autoderefs: usize,
377 /// Tracks whether executing a node may exit normally (versus
378 /// return/break/panic, which "diverge", leaving dead code in their
379 /// wake). Tracked semi-automatically (through type variables marked
380 /// as diverging), with some manual adjustments for control-flow
381 /// primitives (approximating a CFG).
382 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
384 /// Potentially unknown, some cases converge,
385 /// others require a CFG to determine them.
388 /// Definitely known to diverge and therefore
389 /// not reach the next sibling or its parent.
392 /// Same as `Always` but with a reachability
393 /// warning already emitted
397 // Convenience impls for combinig `Diverges`.
399 impl ops::BitAnd for Diverges {
401 fn bitand(self, other: Self) -> Self {
402 cmp::min(self, other)
406 impl ops::BitOr for Diverges {
408 fn bitor(self, other: Self) -> Self {
409 cmp::max(self, other)
413 impl ops::BitAndAssign for Diverges {
414 fn bitand_assign(&mut self, other: Self) {
415 *self = *self & other;
419 impl ops::BitOrAssign for Diverges {
420 fn bitor_assign(&mut self, other: Self) {
421 *self = *self | other;
426 fn always(self) -> bool {
427 self >= Diverges::Always
431 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
434 // this is `null` for loops where break with a value is illegal,
435 // such as `while`, `for`, and `while let`
436 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
439 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
440 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
441 by_id: NodeMap<usize>,
444 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
445 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
446 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
447 bug!("could not find enclosing breakable with id {}", target_id);
453 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
454 ast_ty_to_ty_cache: RefCell<NodeMap<Ty<'tcx>>>,
456 body_id: ast::NodeId,
458 // Number of errors that had been reported when we started
459 // checking this function. On exit, if we find that *more* errors
460 // have been reported, we will skip regionck and other work that
461 // expects the types within the function to be consistent.
462 err_count_on_creation: usize,
464 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
466 ps: RefCell<UnsafetyState>,
468 /// Whether the last checked node generates a divergence (e.g.,
469 /// `return` will set this to Always). In general, when entering
470 /// an expression or other node in the tree, the initial value
471 /// indicates whether prior parts of the containing expression may
472 /// have diverged. It is then typically set to `Maybe` (and the
473 /// old value remembered) for processing the subparts of the
474 /// current expression. As each subpart is processed, they may set
475 /// the flag to `Always` etc. Finally, at the end, we take the
476 /// result and "union" it with the original value, so that when we
477 /// return the flag indicates if any subpart of the the parent
478 /// expression (up to and including this part) has diverged. So,
479 /// if you read it after evaluating a subexpression `X`, the value
480 /// you get indicates whether any subexpression that was
481 /// evaluating up to and including `X` diverged.
483 /// We use this flag for two purposes:
485 /// - To warn about unreachable code: if, after processing a
486 /// sub-expression but before we have applied the effects of the
487 /// current node, we see that the flag is set to `Always`, we
488 /// can issue a warning. This corresponds to something like
489 /// `foo(return)`; we warn on the `foo()` expression. (We then
490 /// update the flag to `WarnedAlways` to suppress duplicate
491 /// reports.) Similarly, if we traverse to a fresh statement (or
492 /// tail expression) from a `Always` setting, we will isssue a
493 /// warning. This corresponds to something like `{return;
494 /// foo();}` or `{return; 22}`, where we would warn on the
497 /// - To permit assignment into a local variable or other lvalue
498 /// (including the "return slot") of type `!`. This is allowed
499 /// if **either** the type of value being assigned is `!`, which
500 /// means the current code is dead, **or** the expression's
501 /// divering flag is true, which means that a divering value was
502 /// wrapped (e.g., `let x: ! = foo(return)`).
504 /// To repeat the last point: an expression represents dead-code
505 /// if, after checking it, **either** its type is `!` OR the
506 /// diverges flag is set to something other than `Maybe`.
507 diverges: Cell<Diverges>,
509 /// Whether any child nodes have any type errors.
510 has_errors: Cell<bool>,
512 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
514 inh: &'a Inherited<'a, 'gcx, 'tcx>,
517 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
518 type Target = Inherited<'a, 'gcx, 'tcx>;
519 fn deref(&self) -> &Self::Target {
524 /// Helper type of a temporary returned by Inherited::build(...).
525 /// Necessary because we can't write the following bound:
526 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
527 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
528 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>
531 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
532 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, id: ast::NodeId)
533 -> InheritedBuilder<'a, 'gcx, 'tcx> {
534 let tables = ty::TypeckTables::empty();
535 let param_env = ParameterEnvironment::for_item(tcx, id);
537 infcx: tcx.infer_ctxt((tables, param_env), Reveal::UserFacing)
542 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
543 fn enter<F, R>(&'tcx mut self, f: F) -> R
544 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
546 self.infcx.enter(|infcx| f(Inherited::new(infcx)))
550 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
551 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>) -> Self {
554 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
555 locals: RefCell::new(NodeMap()),
556 deferred_call_resolutions: RefCell::new(DefIdMap()),
557 deferred_cast_checks: RefCell::new(Vec::new()),
558 anon_types: RefCell::new(NodeMap()),
562 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
563 debug!("register_predicate({:?})", obligation);
564 if obligation.has_escaping_regions() {
565 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
570 .register_predicate_obligation(self, obligation);
573 fn register_predicates(&self, obligations: Vec<traits::PredicateObligation<'tcx>>) {
574 for obligation in obligations {
575 self.register_predicate(obligation);
579 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
580 self.register_predicates(infer_ok.obligations);
584 fn normalize_associated_types_in<T>(&self,
586 body_id: ast::NodeId,
588 where T : TypeFoldable<'tcx>
590 let ok = self.normalize_associated_types_in_as_infer_ok(span, body_id, value);
591 self.register_infer_ok_obligations(ok)
594 fn normalize_associated_types_in_as_infer_ok<T>(&self,
596 body_id: ast::NodeId,
599 where T : TypeFoldable<'tcx>
601 debug!("normalize_associated_types_in(value={:?})", value);
602 let mut selcx = traits::SelectionContext::new(self);
603 let cause = ObligationCause::misc(span, body_id);
604 let traits::Normalized { value, obligations } =
605 traits::normalize(&mut selcx, cause, value);
606 debug!("normalize_associated_types_in: result={:?} predicates={:?}",
609 InferOk { value, obligations }
613 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
615 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
616 fn visit_item(&mut self, i: &'tcx hir::Item) {
617 check_item_type(self.tcx, i);
619 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
620 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
623 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CompileResult {
624 tcx.sess.track_errors(|| {
625 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
626 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
630 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CompileResult {
631 tcx.sess.track_errors(|| {
632 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
636 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CompileResult {
637 tcx.typeck_item_bodies(LOCAL_CRATE)
640 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) -> CompileResult {
641 debug_assert!(crate_num == LOCAL_CRATE);
642 tcx.sess.track_errors(|| {
643 tcx.visit_all_bodies_in_krate(|body_owner_def_id, _body_id| {
644 tcx.typeck_tables_of(body_owner_def_id);
649 pub fn provide(providers: &mut Providers) {
650 *providers = Providers {
661 fn closure_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
663 -> ty::PolyFnSig<'tcx> {
664 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
665 tcx.typeck_tables_of(def_id).closure_tys[&node_id]
668 fn closure_kind<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
671 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
672 tcx.typeck_tables_of(def_id).closure_kinds[&node_id]
675 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
677 -> Option<ty::Destructor> {
678 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
681 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
682 /// with information about it's body-id and fn-decl (if any). Otherwise,
685 /// If this function returns "some", then `typeck_tables(def_id)` will
686 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
687 /// may not succeed. In some cases where this function returns `None`
688 /// (notably closures), `typeck_tables(def_id)` would wind up
689 /// redirecting to the owning function.
690 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
692 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
694 match tcx.hir.get(id) {
695 hir::map::NodeItem(item) => {
697 hir::ItemConst(_, body) |
698 hir::ItemStatic(_, _, body) =>
700 hir::ItemFn(ref decl, .., body) =>
701 Some((body, Some(decl))),
706 hir::map::NodeTraitItem(item) => {
708 hir::TraitItemKind::Const(_, Some(body)) =>
710 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
711 Some((body, Some(&sig.decl))),
716 hir::map::NodeImplItem(item) => {
718 hir::ImplItemKind::Const(_, body) =>
720 hir::ImplItemKind::Method(ref sig, body) =>
721 Some((body, Some(&sig.decl))),
726 hir::map::NodeExpr(expr) => {
727 // FIXME(eddyb) Closures should have separate
728 // function definition IDs and expression IDs.
729 // Type-checking should not let closures get
730 // this far in a constant position.
731 // Assume that everything other than closures
732 // is a constant "initializer" expression.
734 hir::ExprClosure(..) =>
737 Some((hir::BodyId { node_id: expr.id }, None)),
744 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
747 // Closures' tables come from their outermost function,
748 // as they are part of the same "inference environment".
749 let outer_def_id = tcx.closure_base_def_id(def_id);
750 if outer_def_id != def_id {
751 return tcx.has_typeck_tables(outer_def_id);
754 let id = tcx.hir.as_local_node_id(def_id).unwrap();
755 primary_body_of(tcx, id).is_some()
758 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
760 -> &'tcx ty::TypeckTables<'tcx> {
761 // Closures' tables come from their outermost function,
762 // as they are part of the same "inference environment".
763 let outer_def_id = tcx.closure_base_def_id(def_id);
764 if outer_def_id != def_id {
765 return tcx.typeck_tables_of(outer_def_id);
768 let id = tcx.hir.as_local_node_id(def_id).unwrap();
769 let span = tcx.hir.span(id);
771 // Figure out what primary body this item has.
772 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
773 span_bug!(span, "can't type-check body of {:?}", def_id);
775 let body = tcx.hir.body(body_id);
777 Inherited::build(tcx, id).enter(|inh| {
778 let fcx = if let Some(decl) = fn_decl {
779 let fn_sig = tcx.type_of(def_id).fn_sig();
781 check_abi(tcx, span, fn_sig.abi());
783 // Compute the fty from point of view of inside fn.
784 let fn_scope = inh.tcx.call_site_extent(id, body_id.node_id);
786 fn_sig.subst(inh.tcx, &inh.parameter_environment.free_substs);
788 inh.tcx.liberate_late_bound_regions(Some(fn_scope), &fn_sig);
790 inh.normalize_associated_types_in(body.value.span, body_id.node_id, &fn_sig);
792 check_fn(&inh, fn_sig, decl, id, body)
794 let fcx = FnCtxt::new(&inh, body.value.id);
795 let expected_type = tcx.type_of(def_id);
796 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
797 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
799 // Gather locals in statics (because of block expressions).
800 // This is technically unnecessary because locals in static items are forbidden,
801 // but prevents type checking from blowing up before const checking can properly
803 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
805 fcx.check_expr_coercable_to_type(&body.value, expected_type);
810 fcx.select_all_obligations_and_apply_defaults();
811 fcx.closure_analyze(body);
812 fcx.select_obligations_where_possible();
814 fcx.select_all_obligations_or_error();
816 if fn_decl.is_some() {
817 fcx.regionck_fn(id, body);
819 fcx.regionck_expr(body);
822 fcx.resolve_type_vars_in_body(body)
826 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
827 if !tcx.sess.target.target.is_abi_supported(abi) {
828 struct_span_err!(tcx.sess, span, E0570,
829 "The ABI `{}` is not supported for the current target", abi).emit()
833 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
834 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
837 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
838 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
841 // infer the variable's type
842 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
843 self.fcx.locals.borrow_mut().insert(nid, var_ty);
847 // take type that the user specified
848 self.fcx.locals.borrow_mut().insert(nid, typ);
855 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
856 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
857 NestedVisitorMap::None
860 // Add explicitly-declared locals.
861 fn visit_local(&mut self, local: &'gcx hir::Local) {
862 let o_ty = match local.ty {
863 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
866 self.assign(local.span, local.id, o_ty);
867 debug!("Local variable {:?} is assigned type {}",
869 self.fcx.ty_to_string(
870 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
871 intravisit::walk_local(self, local);
874 // Add pattern bindings.
875 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
876 if let PatKind::Binding(_, _, ref path1, _) = p.node {
877 let var_ty = self.assign(p.span, p.id, None);
879 self.fcx.require_type_is_sized(var_ty, p.span,
880 traits::VariableType(p.id));
882 debug!("Pattern binding {} is assigned to {} with type {:?}",
884 self.fcx.ty_to_string(
885 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
888 intravisit::walk_pat(self, p);
891 // Don't descend into the bodies of nested closures
892 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
893 _: hir::BodyId, _: Span, _: ast::NodeId) { }
896 /// Helper used for fns and closures. Does the grungy work of checking a function
897 /// body and returns the function context used for that purpose, since in the case of a fn item
898 /// there is still a bit more to do.
901 /// * inherited: other fields inherited from the enclosing fn (if any)
902 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
903 fn_sig: ty::FnSig<'tcx>,
904 decl: &'gcx hir::FnDecl,
906 body: &'gcx hir::Body)
907 -> FnCtxt<'a, 'gcx, 'tcx>
909 let mut fn_sig = fn_sig.clone();
911 debug!("check_fn(sig={:?}, fn_id={})", fn_sig, fn_id);
913 // Create the function context. This is either derived from scratch or,
914 // in the case of function expressions, based on the outer context.
915 let mut fcx = FnCtxt::new(inherited, body.value.id);
916 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
918 let ret_ty = fn_sig.output();
919 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::ReturnType);
920 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
921 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
922 fn_sig = fcx.tcx.mk_fn_sig(
923 fn_sig.inputs().iter().cloned(),
930 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
932 // Add formal parameters.
933 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
934 // The type of the argument must be well-formed.
936 // NB -- this is now checked in wfcheck, but that
937 // currently only results in warnings, so we issue an
938 // old-style WF obligation here so that we still get the
939 // errors that we used to get.
940 fcx.register_old_wf_obligation(arg_ty, arg.pat.span, traits::MiscObligation);
942 // Check the pattern.
943 fcx.check_pat_arg(&arg.pat, arg_ty, true);
944 fcx.write_ty(arg.id, arg_ty);
947 inherited.tables.borrow_mut().liberated_fn_sigs.insert(fn_id, fn_sig);
949 fcx.check_return_expr(&body.value);
951 // Finalize the return check by taking the LUB of the return types
952 // we saw and assigning it to the expected return type. This isn't
953 // really expected to fail, since the coercions would have failed
954 // earlier when trying to find a LUB.
956 // However, the behavior around `!` is sort of complex. In the
957 // event that the `actual_return_ty` comes back as `!`, that
958 // indicates that the fn either does not return or "returns" only
959 // values of type `!`. In this case, if there is an expected
960 // return type that is *not* `!`, that should be ok. But if the
961 // return type is being inferred, we want to "fallback" to `!`:
963 // let x = move || panic!();
965 // To allow for that, I am creating a type variable with diverging
966 // fallback. This was deemed ever so slightly better than unifying
967 // the return value with `!` because it allows for the caller to
968 // make more assumptions about the return type (e.g., they could do
970 // let y: Option<u32> = Some(x());
972 // which would then cause this return type to become `u32`, not
974 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
975 let mut actual_return_ty = coercion.complete(&fcx);
976 if actual_return_ty.is_never() {
977 actual_return_ty = fcx.next_diverging_ty_var(
978 TypeVariableOrigin::DivergingFn(body.value.span));
980 fcx.demand_suptype(body.value.span, ret_ty, actual_return_ty);
985 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
988 let def_id = tcx.hir.local_def_id(id);
989 let def = tcx.adt_def(def_id);
990 def.destructor(tcx); // force the destructor to be evaluated
991 check_representable(tcx, span, def_id);
994 check_simd(tcx, span, def_id);
997 // if struct is packed and not aligned, check fields for alignment.
998 // Checks for combining packed and align attrs on single struct are done elsewhere.
999 if tcx.adt_def(def_id).repr.packed() && tcx.adt_def(def_id).repr.align == 0 {
1000 check_packed(tcx, span, def_id);
1004 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1007 let def_id = tcx.hir.local_def_id(id);
1008 let def = tcx.adt_def(def_id);
1009 def.destructor(tcx); // force the destructor to be evaluated
1010 check_representable(tcx, span, def_id);
1013 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1014 debug!("check_item_type(it.id={}, it.name={})",
1016 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1017 let _indenter = indenter();
1019 // Consts can play a role in type-checking, so they are included here.
1020 hir::ItemStatic(..) |
1021 hir::ItemConst(..) => {
1022 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1024 hir::ItemEnum(ref enum_definition, _) => {
1027 &enum_definition.variants,
1030 hir::ItemFn(..) => {} // entirely within check_item_body
1031 hir::ItemImpl(.., ref impl_item_refs) => {
1032 debug!("ItemImpl {} with id {}", it.name, it.id);
1033 let impl_def_id = tcx.hir.local_def_id(it.id);
1034 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1035 check_impl_items_against_trait(tcx,
1040 let trait_def_id = impl_trait_ref.def_id;
1041 check_on_unimplemented(tcx, trait_def_id, it);
1044 hir::ItemTrait(..) => {
1045 let def_id = tcx.hir.local_def_id(it.id);
1046 check_on_unimplemented(tcx, def_id, it);
1048 hir::ItemStruct(..) => {
1049 check_struct(tcx, it.id, it.span);
1051 hir::ItemUnion(..) => {
1052 check_union(tcx, it.id, it.span);
1054 hir::ItemTy(_, ref generics) => {
1055 let def_id = tcx.hir.local_def_id(it.id);
1056 let pty_ty = tcx.type_of(def_id);
1057 check_bounds_are_used(tcx, generics, pty_ty);
1059 hir::ItemForeignMod(ref m) => {
1060 check_abi(tcx, it.span, m.abi);
1062 if m.abi == Abi::RustIntrinsic {
1063 for item in &m.items {
1064 intrinsic::check_intrinsic_type(tcx, item);
1066 } else if m.abi == Abi::PlatformIntrinsic {
1067 for item in &m.items {
1068 intrinsic::check_platform_intrinsic_type(tcx, item);
1071 for item in &m.items {
1072 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1073 if !generics.types.is_empty() {
1074 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1075 "foreign items may not have type parameters");
1076 span_help!(&mut err, item.span,
1077 "consider using specialization instead of \
1082 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1083 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1088 _ => {/* nothing to do */ }
1092 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1095 let generics = tcx.generics_of(def_id);
1096 if let Some(ref attr) = item.attrs.iter().find(|a| {
1097 a.check_name("rustc_on_unimplemented")
1099 if let Some(istring) = attr.value_str() {
1100 let istring = istring.as_str();
1101 let parser = Parser::new(&istring);
1102 let types = &generics.types;
1103 for token in parser {
1105 Piece::String(_) => (), // Normal string, no need to check it
1106 Piece::NextArgument(a) => match a.position {
1107 // `{Self}` is allowed
1108 Position::ArgumentNamed(s) if s == "Self" => (),
1109 // So is `{A}` if A is a type parameter
1110 Position::ArgumentNamed(s) => match types.iter().find(|t| {
1115 let name = tcx.item_name(def_id);
1116 span_err!(tcx.sess, attr.span, E0230,
1117 "there is no type parameter \
1122 // `{:1}` and `{}` are not to be used
1123 Position::ArgumentIs(_) => {
1124 span_err!(tcx.sess, attr.span, E0231,
1125 "only named substitution \
1126 parameters are allowed");
1133 tcx.sess, attr.span, E0232,
1134 "this attribute must have a value")
1135 .span_label(attr.span, &format!("attribute requires a value"))
1136 .note(&format!("eg `#[rustc_on_unimplemented = \"foo\"]`"))
1142 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1143 impl_item: &hir::ImplItem,
1146 let mut err = struct_span_err!(
1147 tcx.sess, impl_item.span, E0520,
1148 "`{}` specializes an item from a parent `impl`, but \
1149 that item is not marked `default`",
1151 err.span_label(impl_item.span, &format!("cannot specialize default item `{}`",
1154 match tcx.span_of_impl(parent_impl) {
1156 err.span_label(span, &"parent `impl` is here");
1157 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1161 err.note(&format!("parent implementation is in crate `{}`", cname));
1168 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1169 trait_def: &ty::TraitDef,
1171 impl_item: &hir::ImplItem)
1173 let ancestors = trait_def.ancestors(impl_id);
1175 let kind = match impl_item.node {
1176 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1177 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1178 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1180 let parent = ancestors.defs(tcx, impl_item.name, kind).skip(1).next()
1181 .map(|node_item| node_item.map(|parent| parent.defaultness));
1183 if let Some(parent) = parent {
1184 if tcx.impl_item_is_final(&parent) {
1185 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1191 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1194 impl_trait_ref: ty::TraitRef<'tcx>,
1195 impl_item_refs: &[hir::ImplItemRef]) {
1196 // If the trait reference itself is erroneous (so the compilation is going
1197 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1198 // isn't populated for such impls.
1199 if impl_trait_ref.references_error() { return; }
1201 // Locate trait definition and items
1202 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1203 let mut overridden_associated_type = None;
1205 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1207 // Check existing impl methods to see if they are both present in trait
1208 // and compatible with trait signature
1209 for impl_item in impl_items() {
1210 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1211 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1212 .find(|ac| ac.name == ty_impl_item.name);
1214 // Check that impl definition matches trait definition
1215 if let Some(ty_trait_item) = ty_trait_item {
1216 match impl_item.node {
1217 hir::ImplItemKind::Const(..) => {
1218 // Find associated const definition.
1219 if ty_trait_item.kind == ty::AssociatedKind::Const {
1220 compare_const_impl(tcx,
1226 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1227 "item `{}` is an associated const, \
1228 which doesn't match its trait `{}`",
1231 err.span_label(impl_item.span, &format!("does not match trait"));
1232 // We can only get the spans from local trait definition
1233 // Same for E0324 and E0325
1234 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1235 err.span_label(trait_span, &format!("item in trait"));
1240 hir::ImplItemKind::Method(..) => {
1241 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1242 if ty_trait_item.kind == ty::AssociatedKind::Method {
1243 let err_count = tcx.sess.err_count();
1244 compare_impl_method(tcx,
1250 true); // start with old-broken-mode
1251 if err_count == tcx.sess.err_count() {
1252 // old broken mode did not report an error. Try with the new mode.
1253 compare_impl_method(tcx,
1259 false); // use the new mode
1262 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1263 "item `{}` is an associated method, \
1264 which doesn't match its trait `{}`",
1267 err.span_label(impl_item.span, &format!("does not match trait"));
1268 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1269 err.span_label(trait_span, &format!("item in trait"));
1274 hir::ImplItemKind::Type(_) => {
1275 if ty_trait_item.kind == ty::AssociatedKind::Type {
1276 if ty_trait_item.defaultness.has_value() {
1277 overridden_associated_type = Some(impl_item);
1280 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1281 "item `{}` is an associated type, \
1282 which doesn't match its trait `{}`",
1285 err.span_label(impl_item.span, &format!("does not match trait"));
1286 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1287 err.span_label(trait_span, &format!("item in trait"));
1295 check_specialization_validity(tcx, trait_def, impl_id, impl_item);
1298 // Check for missing items from trait
1299 let mut missing_items = Vec::new();
1300 let mut invalidated_items = Vec::new();
1301 let associated_type_overridden = overridden_associated_type.is_some();
1302 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1303 let is_implemented = trait_def.ancestors(impl_id)
1304 .defs(tcx, trait_item.name, trait_item.kind)
1306 .map(|node_item| !node_item.node.is_from_trait())
1309 if !is_implemented {
1310 if !trait_item.defaultness.has_value() {
1311 missing_items.push(trait_item);
1312 } else if associated_type_overridden {
1313 invalidated_items.push(trait_item.name);
1318 let signature = |item: &ty::AssociatedItem| {
1320 ty::AssociatedKind::Method => {
1321 format!("{}", tcx.type_of(item.def_id).fn_sig().0)
1323 ty::AssociatedKind::Type => format!("type {};", item.name.to_string()),
1324 ty::AssociatedKind::Const => {
1325 format!("const {}: {:?};", item.name.to_string(), tcx.type_of(item.def_id))
1330 if !missing_items.is_empty() {
1331 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1332 "not all trait items implemented, missing: `{}`",
1333 missing_items.iter()
1334 .map(|trait_item| trait_item.name.to_string())
1335 .collect::<Vec<_>>().join("`, `"));
1336 err.span_label(impl_span, &format!("missing `{}` in implementation",
1337 missing_items.iter()
1338 .map(|trait_item| trait_item.name.to_string())
1339 .collect::<Vec<_>>().join("`, `")));
1340 for trait_item in missing_items {
1341 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1342 err.span_label(span, &format!("`{}` from trait", trait_item.name));
1344 err.note(&format!("`{}` from trait: `{}`",
1346 signature(&trait_item)));
1352 if !invalidated_items.is_empty() {
1353 let invalidator = overridden_associated_type.unwrap();
1354 span_err!(tcx.sess, invalidator.span, E0399,
1355 "the following trait items need to be reimplemented \
1356 as `{}` was overridden: `{}`",
1358 invalidated_items.iter()
1359 .map(|name| name.to_string())
1360 .collect::<Vec<_>>().join("`, `"))
1364 /// Checks whether a type can be represented in memory. In particular, it
1365 /// identifies types that contain themselves without indirection through a
1366 /// pointer, which would mean their size is unbounded.
1367 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1371 let rty = tcx.type_of(item_def_id);
1373 // Check that it is possible to represent this type. This call identifies
1374 // (1) types that contain themselves and (2) types that contain a different
1375 // recursive type. It is only necessary to throw an error on those that
1376 // contain themselves. For case 2, there must be an inner type that will be
1377 // caught by case 1.
1378 match rty.is_representable(tcx, sp) {
1379 Representability::SelfRecursive => {
1380 tcx.recursive_type_with_infinite_size_error(item_def_id).emit();
1383 Representability::Representable | Representability::ContainsRecursive => (),
1388 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1389 let t = tcx.type_of(def_id);
1391 ty::TyAdt(def, substs) if def.is_struct() => {
1392 let fields = &def.struct_variant().fields;
1393 if fields.is_empty() {
1394 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1397 let e = fields[0].ty(tcx, substs);
1398 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1399 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1400 .span_label(sp, &format!("SIMD elements must have the same type"))
1405 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1406 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1408 span_err!(tcx.sess, sp, E0077,
1409 "SIMD vector element type should be machine type");
1418 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1419 if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1420 struct_span_err!(tcx.sess, sp, E0588,
1421 "packed struct cannot transitively contain a `[repr(align)]` struct").emit();
1425 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1427 stack: &mut Vec<DefId>) -> bool {
1428 let t = tcx.type_of(def_id);
1429 if stack.contains(&def_id) {
1430 debug!("check_packed_inner: {:?} is recursive", t);
1434 ty::TyAdt(def, substs) if def.is_struct() => {
1435 if tcx.adt_def(def.did).repr.align > 0 {
1438 // push struct def_id before checking fields
1440 for field in &def.struct_variant().fields {
1441 let f = field.ty(tcx, substs);
1443 ty::TyAdt(def, _) => {
1444 if check_packed_inner(tcx, def.did, stack) {
1451 // only need to pop if not early out
1459 #[allow(trivial_numeric_casts)]
1460 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1462 vs: &'tcx [hir::Variant],
1464 let def_id = tcx.hir.local_def_id(id);
1465 let def = tcx.adt_def(def_id);
1466 def.destructor(tcx); // force the destructor to be evaluated
1468 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1470 tcx.sess, sp, E0084,
1471 "unsupported representation for zero-variant enum")
1472 .span_label(sp, &format!("unsupported enum representation"))
1476 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1477 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1478 if !tcx.sess.features.borrow().i128_type {
1479 emit_feature_err(&tcx.sess.parse_sess,
1480 "i128_type", sp, GateIssue::Language, "128-bit type is unstable");
1485 if let Some(e) = v.node.disr_expr {
1486 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1490 let mut disr_vals: Vec<ConstInt> = Vec::new();
1491 for (discr, v) in def.discriminants(tcx).zip(vs) {
1492 // Check for duplicate discriminant values
1493 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1494 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1495 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1496 let i_span = match variant_i.node.disr_expr {
1497 Some(expr) => tcx.hir.span(expr.node_id),
1498 None => tcx.hir.span(variant_i_node_id)
1500 let span = match v.node.disr_expr {
1501 Some(expr) => tcx.hir.span(expr.node_id),
1504 struct_span_err!(tcx.sess, span, E0081,
1505 "discriminant value `{}` already exists", disr_vals[i])
1506 .span_label(i_span, &format!("first use of `{}`", disr_vals[i]))
1507 .span_label(span , &format!("enum already has `{}`", disr_vals[i]))
1510 disr_vals.push(discr);
1513 check_representable(tcx, sp, def_id);
1516 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1517 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1519 fn ast_ty_to_ty_cache(&self) -> &RefCell<NodeMap<Ty<'tcx>>> {
1520 &self.ast_ty_to_ty_cache
1523 fn get_free_substs(&self) -> Option<&Substs<'tcx>> {
1524 Some(&self.parameter_environment.free_substs)
1527 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1528 -> ty::GenericPredicates<'tcx>
1531 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1532 let item_id = tcx.hir.ty_param_owner(node_id);
1533 let item_def_id = tcx.hir.local_def_id(item_id);
1534 let generics = tcx.generics_of(item_def_id);
1535 let index = generics.type_param_to_index[&def_id.index];
1536 ty::GenericPredicates {
1538 predicates: self.parameter_environment.caller_bounds.iter().filter(|predicate| {
1540 ty::Predicate::Trait(ref data) => {
1541 data.0.self_ty().is_param(index)
1545 }).cloned().collect()
1549 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1550 -> Option<ty::Region<'tcx>> {
1552 Some(def) => infer::EarlyBoundRegion(span, def.name, def.issue_32330),
1553 None => infer::MiscVariable(span)
1555 Some(self.next_region_var(v))
1558 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1559 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1562 fn ty_infer_for_def(&self,
1563 ty_param_def: &ty::TypeParameterDef,
1564 substs: &[Kind<'tcx>],
1565 span: Span) -> Ty<'tcx> {
1566 self.type_var_for_def(span, ty_param_def, substs)
1569 fn projected_ty_from_poly_trait_ref(&self,
1571 poly_trait_ref: ty::PolyTraitRef<'tcx>,
1572 item_name: ast::Name)
1575 let (trait_ref, _) =
1576 self.replace_late_bound_regions_with_fresh_var(
1578 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_name),
1581 self.tcx().mk_projection(trait_ref, item_name)
1584 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1585 if ty.has_escaping_regions() {
1586 ty // FIXME: normalization and escaping regions
1588 self.normalize_associated_types_in(span, &ty)
1592 fn set_tainted_by_errors(&self) {
1593 self.infcx.set_tainted_by_errors()
1597 /// Controls whether the arguments are tupled. This is used for the call
1600 /// Tupling means that all call-side arguments are packed into a tuple and
1601 /// passed as a single parameter. For example, if tupling is enabled, this
1604 /// fn f(x: (isize, isize))
1606 /// Can be called as:
1613 #[derive(Clone, Eq, PartialEq)]
1614 enum TupleArgumentsFlag {
1619 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1620 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1621 body_id: ast::NodeId)
1622 -> FnCtxt<'a, 'gcx, 'tcx> {
1624 ast_ty_to_ty_cache: RefCell::new(NodeMap()),
1626 err_count_on_creation: inh.tcx.sess.err_count(),
1628 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1629 ast::CRATE_NODE_ID)),
1630 diverges: Cell::new(Diverges::Maybe),
1631 has_errors: Cell::new(false),
1632 enclosing_breakables: RefCell::new(EnclosingBreakables {
1640 pub fn sess(&self) -> &Session {
1644 pub fn err_count_since_creation(&self) -> usize {
1645 self.tcx.sess.err_count() - self.err_count_on_creation
1648 /// Produce warning on the given node, if the current point in the
1649 /// function is unreachable, and there hasn't been another warning.
1650 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1651 if self.diverges.get() == Diverges::Always {
1652 self.diverges.set(Diverges::WarnedAlways);
1654 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1656 self.tables.borrow_mut().lints.add_lint(
1657 lint::builtin::UNREACHABLE_CODE,
1659 format!("unreachable {}", kind));
1665 code: ObligationCauseCode<'tcx>)
1666 -> ObligationCause<'tcx> {
1667 ObligationCause::new(span, self.body_id, code)
1670 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1671 self.cause(span, ObligationCauseCode::MiscObligation)
1674 /// Resolves type variables in `ty` if possible. Unlike the infcx
1675 /// version (resolve_type_vars_if_possible), this version will
1676 /// also select obligations if it seems useful, in an effort
1677 /// to get more type information.
1678 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1679 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1681 // No TyInfer()? Nothing needs doing.
1682 if !ty.has_infer_types() {
1683 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1687 // If `ty` is a type variable, see whether we already know what it is.
1688 ty = self.resolve_type_vars_if_possible(&ty);
1689 if !ty.has_infer_types() {
1690 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1694 // If not, try resolving pending obligations as much as
1695 // possible. This can help substantially when there are
1696 // indirect dependencies that don't seem worth tracking
1698 self.select_obligations_where_possible();
1699 ty = self.resolve_type_vars_if_possible(&ty);
1701 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1705 fn record_deferred_call_resolution(&self,
1706 closure_def_id: DefId,
1707 r: DeferredCallResolutionHandler<'gcx, 'tcx>) {
1708 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1709 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1712 fn remove_deferred_call_resolutions(&self,
1713 closure_def_id: DefId)
1714 -> Vec<DeferredCallResolutionHandler<'gcx, 'tcx>>
1716 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1717 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(Vec::new())
1720 pub fn tag(&self) -> String {
1721 let self_ptr: *const FnCtxt = self;
1722 format!("{:?}", self_ptr)
1725 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1726 match self.locals.borrow().get(&nid) {
1729 span_bug!(span, "no type for local variable {}",
1730 self.tcx.hir.node_to_string(nid));
1736 pub fn write_ty(&self, node_id: ast::NodeId, ty: Ty<'tcx>) {
1737 debug!("write_ty({}, {:?}) in fcx {}",
1738 node_id, self.resolve_type_vars_if_possible(&ty), self.tag());
1739 self.tables.borrow_mut().node_types.insert(node_id, ty);
1741 if ty.references_error() {
1742 self.has_errors.set(true);
1743 self.set_tainted_by_errors();
1747 pub fn write_substs(&self, node_id: ast::NodeId, substs: ty::ItemSubsts<'tcx>) {
1748 if !substs.substs.is_noop() {
1749 debug!("write_substs({}, {:?}) in fcx {}",
1754 self.tables.borrow_mut().item_substs.insert(node_id, substs);
1758 pub fn apply_autoderef_adjustment(&self,
1759 node_id: ast::NodeId,
1761 adjusted_ty: Ty<'tcx>) {
1762 self.apply_adjustment(node_id, Adjustment {
1763 kind: Adjust::DerefRef {
1772 pub fn apply_adjustment(&self, node_id: ast::NodeId, adj: Adjustment<'tcx>) {
1773 debug!("apply_adjustment(node_id={}, adj={:?})", node_id, adj);
1775 if adj.is_identity() {
1779 match self.tables.borrow_mut().adjustments.entry(node_id) {
1780 Entry::Vacant(entry) => { entry.insert(adj); },
1781 Entry::Occupied(mut entry) => {
1782 debug!(" - composing on top of {:?}", entry.get());
1783 let composed_kind = match (entry.get().kind, adj.kind) {
1784 // Applying any adjustment on top of a NeverToAny
1785 // is a valid NeverToAny adjustment, because it can't
1787 (Adjust::NeverToAny, _) => Adjust::NeverToAny,
1790 autoref: Some(AutoBorrow::Ref(..)),
1792 }, Adjust::DerefRef { autoderefs, .. }) if autoderefs > 0 => {
1793 // A reborrow has no effect before a dereference.
1796 // FIXME: currently we never try to compose autoderefs
1797 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1799 bug!("while adjusting {}, can't compose {:?} and {:?}",
1800 node_id, entry.get(), adj)
1802 *entry.get_mut() = Adjustment {
1803 kind: composed_kind,
1810 /// Basically whenever we are converting from a type scheme into
1811 /// the fn body space, we always want to normalize associated
1812 /// types as well. This function combines the two.
1813 fn instantiate_type_scheme<T>(&self,
1815 substs: &Substs<'tcx>,
1818 where T : TypeFoldable<'tcx>
1820 let value = value.subst(self.tcx, substs);
1821 let result = self.normalize_associated_types_in(span, &value);
1822 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1829 /// As `instantiate_type_scheme`, but for the bounds found in a
1830 /// generic type scheme.
1831 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1832 -> ty::InstantiatedPredicates<'tcx> {
1833 let bounds = self.tcx.predicates_of(def_id);
1834 let result = bounds.instantiate(self.tcx, substs);
1835 let result = self.normalize_associated_types_in(span, &result);
1836 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1843 /// Replace all anonymized types with fresh inference variables
1844 /// and record them for writeback.
1845 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1846 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1847 if let ty::TyAnon(def_id, substs) = ty.sty {
1848 // Use the same type variable if the exact same TyAnon appears more
1849 // than once in the return type (e.g. if it's pased to a type alias).
1850 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1851 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1854 let span = self.tcx.def_span(def_id);
1855 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1856 self.anon_types.borrow_mut().insert(id, ty_var);
1858 let predicates_of = self.tcx.predicates_of(def_id);
1859 let bounds = predicates_of.instantiate(self.tcx, substs);
1861 for predicate in bounds.predicates {
1862 // Change the predicate to refer to the type variable,
1863 // which will be the concrete type, instead of the TyAnon.
1864 // This also instantiates nested `impl Trait`.
1865 let predicate = self.instantiate_anon_types(&predicate);
1867 // Require that the predicate holds for the concrete type.
1868 let cause = traits::ObligationCause::new(span, self.body_id,
1869 traits::ReturnType);
1870 self.register_predicate(traits::Obligation::new(cause, predicate));
1880 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1881 where T : TypeFoldable<'tcx>
1883 let ok = self.normalize_associated_types_in_as_infer_ok(span, value);
1884 self.register_infer_ok_obligations(ok)
1887 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1889 where T : TypeFoldable<'tcx>
1891 self.inh.normalize_associated_types_in_as_infer_ok(span, self.body_id, value)
1894 pub fn write_nil(&self, node_id: ast::NodeId) {
1895 self.write_ty(node_id, self.tcx.mk_nil());
1898 pub fn write_error(&self, node_id: ast::NodeId) {
1899 self.write_ty(node_id, self.tcx.types.err);
1902 pub fn require_type_meets(&self,
1905 code: traits::ObligationCauseCode<'tcx>,
1908 self.register_bound(
1911 traits::ObligationCause::new(span, self.body_id, code));
1914 pub fn require_type_is_sized(&self,
1917 code: traits::ObligationCauseCode<'tcx>)
1919 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
1920 self.require_type_meets(ty, span, code, lang_item);
1923 pub fn register_bound(&self,
1926 cause: traits::ObligationCause<'tcx>)
1928 self.fulfillment_cx.borrow_mut()
1929 .register_bound(self, ty, def_id, cause);
1932 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
1933 let t = AstConv::ast_ty_to_ty(self, ast_t);
1934 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
1938 pub fn node_ty(&self, id: ast::NodeId) -> Ty<'tcx> {
1939 match self.tables.borrow().node_types.get(&id) {
1941 None if self.err_count_since_creation() != 0 => self.tcx.types.err,
1943 bug!("no type for node {}: {} in fcx {}",
1944 id, self.tcx.hir.node_to_string(id),
1950 pub fn opt_node_ty_substs<F>(&self,
1953 F: FnOnce(&ty::ItemSubsts<'tcx>),
1955 if let Some(s) = self.tables.borrow().item_substs.get(&id) {
1960 /// Registers an obligation for checking later, during regionck, that the type `ty` must
1961 /// outlive the region `r`.
1962 pub fn register_region_obligation(&self,
1964 region: ty::Region<'tcx>,
1965 cause: traits::ObligationCause<'tcx>)
1967 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
1968 fulfillment_cx.register_region_obligation(ty, region, cause);
1971 /// Registers an obligation for checking later, during regionck, that the type `ty` must
1972 /// outlive the region `r`.
1973 pub fn register_wf_obligation(&self,
1976 code: traits::ObligationCauseCode<'tcx>)
1978 // WF obligations never themselves fail, so no real need to give a detailed cause:
1979 let cause = traits::ObligationCause::new(span, self.body_id, code);
1980 self.register_predicate(traits::Obligation::new(cause, ty::Predicate::WellFormed(ty)));
1983 pub fn register_old_wf_obligation(&self,
1986 code: traits::ObligationCauseCode<'tcx>)
1988 // Registers an "old-style" WF obligation that uses the
1989 // implicator code. This is basically a buggy version of
1990 // `register_wf_obligation` that is being kept around
1991 // temporarily just to help with phasing in the newer rules.
1993 // FIXME(#27579) all uses of this should be migrated to register_wf_obligation eventually
1994 let cause = traits::ObligationCause::new(span, self.body_id, code);
1995 self.register_region_obligation(ty, self.tcx.types.re_empty, cause);
1998 /// Registers obligations that all types appearing in `substs` are well-formed.
1999 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2001 for ty in substs.types() {
2002 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2006 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2007 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2008 /// trait/region obligations.
2010 /// For example, if there is a function:
2013 /// fn foo<'a,T:'a>(...)
2016 /// and a reference:
2022 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2023 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2024 pub fn add_obligations_for_parameters(&self,
2025 cause: traits::ObligationCause<'tcx>,
2026 predicates: &ty::InstantiatedPredicates<'tcx>)
2028 assert!(!predicates.has_escaping_regions());
2030 debug!("add_obligations_for_parameters(predicates={:?})",
2033 for obligation in traits::predicates_for_generics(cause, predicates) {
2034 self.register_predicate(obligation);
2038 // FIXME(arielb1): use this instead of field.ty everywhere
2039 // Only for fields! Returns <none> for methods>
2040 // Indifferent to privacy flags
2041 pub fn field_ty(&self,
2043 field: &'tcx ty::FieldDef,
2044 substs: &Substs<'tcx>)
2047 self.normalize_associated_types_in(span,
2048 &field.ty(self.tcx, substs))
2051 fn check_casts(&self) {
2052 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2053 for cast in deferred_cast_checks.drain(..) {
2058 /// Apply "fallbacks" to some types
2059 /// unconstrained types get replaced with ! or () (depending on whether
2060 /// feature(never_type) is enabled), unconstrained ints with i32, and
2061 /// unconstrained floats with f64.
2062 fn default_type_parameters(&self) {
2063 use rustc::ty::error::UnconstrainedNumeric::Neither;
2064 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2066 // Defaulting inference variables becomes very dubious if we have
2067 // encountered type-checking errors. Therefore, if we think we saw
2068 // some errors in this function, just resolve all uninstanted type
2069 // varibles to TyError.
2070 if self.is_tainted_by_errors() {
2071 for ty in &self.unsolved_variables() {
2072 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2073 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2074 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2080 for ty in &self.unsolved_variables() {
2081 let resolved = self.resolve_type_vars_if_possible(ty);
2082 if self.type_var_diverges(resolved) {
2083 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2085 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2086 self.tcx.mk_diverging_default());
2088 match self.type_is_unconstrained_numeric(resolved) {
2089 UnconstrainedInt => {
2090 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2092 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2094 UnconstrainedFloat => {
2095 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2097 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2105 // Implements type inference fallback algorithm
2106 fn select_all_obligations_and_apply_defaults(&self) {
2107 self.select_obligations_where_possible();
2108 self.default_type_parameters();
2109 self.select_obligations_where_possible();
2112 fn select_all_obligations_or_error(&self) {
2113 debug!("select_all_obligations_or_error");
2115 // upvar inference should have ensured that all deferred call
2116 // resolutions are handled by now.
2117 assert!(self.deferred_call_resolutions.borrow().is_empty());
2119 self.select_all_obligations_and_apply_defaults();
2121 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2123 match fulfillment_cx.select_all_or_error(self) {
2125 Err(errors) => { self.report_fulfillment_errors(&errors); }
2129 /// Select as many obligations as we can at present.
2130 fn select_obligations_where_possible(&self) {
2131 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2133 Err(errors) => { self.report_fulfillment_errors(&errors); }
2137 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2138 /// returns a type of `&T`, but the actual type we assign to the
2139 /// *expression* is `T`. So this function just peels off the return
2140 /// type by one layer to yield `T`.
2141 fn make_overloaded_lvalue_return_type(&self,
2142 method: MethodCallee<'tcx>)
2143 -> ty::TypeAndMut<'tcx>
2145 // extract method return type, which will be &T;
2146 // all LB regions should have been instantiated during method lookup
2147 let ret_ty = method.ty.fn_ret();
2148 let ret_ty = self.tcx.no_late_bound_regions(&ret_ty).unwrap();
2150 // method returns &T, but the type as visible to user is T, so deref
2151 ret_ty.builtin_deref(true, NoPreference).unwrap()
2154 fn lookup_indexing(&self,
2156 base_expr: &'gcx hir::Expr,
2159 lvalue_pref: LvaluePreference)
2160 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2162 // FIXME(#18741) -- this is almost but not quite the same as the
2163 // autoderef that normal method probing does. They could likely be
2166 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2168 while let Some((adj_ty, autoderefs)) = autoderef.next() {
2169 if let Some(final_mt) = self.try_index_step(
2170 MethodCall::expr(expr.id), expr, Some(AdjustedRcvr {
2171 rcvr_expr: base_expr,
2174 }), base_expr.span, adj_ty, lvalue_pref, idx_ty)
2176 autoderef.finalize(lvalue_pref, base_expr);
2177 return Some(final_mt);
2180 if let ty::TyArray(element_ty, _) = adj_ty.sty {
2181 autoderef.finalize(lvalue_pref, base_expr);
2182 let adj_ty = self.tcx.mk_slice(element_ty);
2183 return self.try_index_step(
2184 MethodCall::expr(expr.id), expr, Some(AdjustedRcvr {
2185 rcvr_expr: base_expr,
2188 }), base_expr.span, adj_ty, lvalue_pref, idx_ty)
2191 autoderef.unambiguous_final_ty();
2195 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2196 /// (and otherwise adjust) `base_expr`, looking for a type which either
2197 /// supports builtin indexing or overloaded indexing.
2198 /// This loop implements one step in that search; the autoderef loop
2199 /// is implemented by `lookup_indexing`.
2200 fn try_index_step(&self,
2201 method_call: MethodCall,
2203 base_expr: Option<AdjustedRcvr>,
2205 adjusted_ty: Ty<'tcx>,
2206 lvalue_pref: LvaluePreference,
2208 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2211 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2218 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_span));
2220 // First, try built-in indexing.
2221 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2222 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2223 debug!("try_index_step: success, using built-in indexing");
2224 // If we had `[T; N]`, we should've caught it before unsizing to `[T]`.
2225 if let Some(base_expr) = base_expr {
2226 assert!(!base_expr.unsize);
2227 self.apply_autoderef_adjustment(
2228 base_expr.rcvr_expr.id, base_expr.autoderefs, adjusted_ty);
2230 return Some((tcx.types.usize, ty));
2235 // If some lookup succeeds, write callee into table and extract index/element
2236 // type from the method signature.
2237 // If some lookup succeeded, install method in table
2238 let method = self.try_overloaded_lvalue_op(
2239 expr.span, base_expr, adjusted_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2242 debug!("try_index_step: success, using overloaded indexing");
2243 let method = self.register_infer_ok_obligations(ok);
2244 self.tables.borrow_mut().method_map.insert(method_call, method);
2245 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2249 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2250 let (tr, name) = match (op, is_mut) {
2251 (LvalueOp::Deref, false) =>
2252 (self.tcx.lang_items.deref_trait(), "deref"),
2253 (LvalueOp::Deref, true) =>
2254 (self.tcx.lang_items.deref_mut_trait(), "deref_mut"),
2255 (LvalueOp::Index, false) =>
2256 (self.tcx.lang_items.index_trait(), "index"),
2257 (LvalueOp::Index, true) =>
2258 (self.tcx.lang_items.index_mut_trait(), "index_mut"),
2260 (tr, Symbol::intern(name))
2263 fn try_overloaded_lvalue_op(&self,
2265 base_expr: Option<AdjustedRcvr>,
2267 arg_tys: &[Ty<'tcx>],
2268 lvalue_pref: LvaluePreference,
2270 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2272 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?},{:?})",
2279 // Try Mut first, if preferred.
2280 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2281 let method = match (lvalue_pref, mut_tr) {
2282 (PreferMutLvalue, Some(trait_did)) => {
2283 self.lookup_method_in_trait_adjusted(span,
2288 Some(arg_tys.to_owned()))
2293 // Otherwise, fall back to the immutable version.
2294 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2295 let method = match (method, imm_tr) {
2296 (None, Some(trait_did)) => {
2297 self.lookup_method_in_trait_adjusted(span,
2302 Some(arg_tys.to_owned()))
2304 (method, _) => method,
2310 fn check_method_argument_types(&self,
2312 method_fn_ty: Ty<'tcx>,
2313 callee_expr: &'gcx hir::Expr,
2314 args_no_rcvr: &'gcx [hir::Expr],
2315 tuple_arguments: TupleArgumentsFlag,
2316 expected: Expectation<'tcx>)
2318 if method_fn_ty.references_error() {
2319 let err_inputs = self.err_args(args_no_rcvr.len());
2321 let err_inputs = match tuple_arguments {
2322 DontTupleArguments => err_inputs,
2323 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2326 self.check_argument_types(sp, &err_inputs[..], &[], args_no_rcvr,
2327 false, tuple_arguments, None);
2330 match method_fn_ty.sty {
2331 ty::TyFnDef(def_id, .., ref fty) => {
2332 // HACK(eddyb) ignore self in the definition (see above).
2333 let expected_arg_tys = self.expected_inputs_for_expected_output(
2337 &fty.0.inputs()[1..]
2339 self.check_argument_types(sp, &fty.0.inputs()[1..], &expected_arg_tys[..],
2340 args_no_rcvr, fty.0.variadic, tuple_arguments,
2341 self.tcx.hir.span_if_local(def_id));
2345 span_bug!(callee_expr.span, "method without bare fn type");
2351 /// Generic function that factors out common logic from function calls,
2352 /// method calls and overloaded operators.
2353 fn check_argument_types(&self,
2355 fn_inputs: &[Ty<'tcx>],
2356 expected_arg_tys: &[Ty<'tcx>],
2357 args: &'gcx [hir::Expr],
2359 tuple_arguments: TupleArgumentsFlag,
2360 def_span: Option<Span>) {
2363 // Grab the argument types, supplying fresh type variables
2364 // if the wrong number of arguments were supplied
2365 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2371 // All the input types from the fn signature must outlive the call
2372 // so as to validate implied bounds.
2373 for &fn_input_ty in fn_inputs {
2374 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2377 let mut expected_arg_tys = expected_arg_tys;
2378 let expected_arg_count = fn_inputs.len();
2380 let sp_args = if args.len() > 0 {
2381 let (first, args) = args.split_at(1);
2382 let mut sp_tmp = first[0].span;
2384 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2385 if ! sp_opt.is_some() {
2388 sp_tmp = sp_opt.unwrap();
2395 fn parameter_count_error<'tcx>(sess: &Session, sp: Span, expected_count: usize,
2396 arg_count: usize, error_code: &str, variadic: bool,
2397 def_span: Option<Span>) {
2398 let mut err = sess.struct_span_err_with_code(sp,
2399 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2400 if variadic {"at least "} else {""},
2402 if expected_count == 1 {""} else {"s"},
2404 if arg_count == 1 {" was"} else {"s were"}),
2407 err.span_label(sp, &format!("expected {}{} parameter{}",
2408 if variadic {"at least "} else {""},
2410 if expected_count == 1 {""} else {"s"}));
2411 if let Some(def_s) = def_span {
2412 err.span_label(def_s, &format!("defined here"));
2417 let formal_tys = if tuple_arguments == TupleArguments {
2418 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2419 match tuple_type.sty {
2420 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2421 parameter_count_error(tcx.sess, sp_args, arg_types.len(), args.len(),
2422 "E0057", false, def_span);
2423 expected_arg_tys = &[];
2424 self.err_args(args.len())
2426 ty::TyTuple(arg_types, _) => {
2427 expected_arg_tys = match expected_arg_tys.get(0) {
2428 Some(&ty) => match ty.sty {
2429 ty::TyTuple(ref tys, _) => &tys,
2437 span_err!(tcx.sess, sp, E0059,
2438 "cannot use call notation; the first type parameter \
2439 for the function trait is neither a tuple nor unit");
2440 expected_arg_tys = &[];
2441 self.err_args(args.len())
2444 } else if expected_arg_count == supplied_arg_count {
2446 } else if variadic {
2447 if supplied_arg_count >= expected_arg_count {
2450 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2451 supplied_arg_count, "E0060", true, def_span);
2452 expected_arg_tys = &[];
2453 self.err_args(supplied_arg_count)
2456 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2457 supplied_arg_count, "E0061", false, def_span);
2458 expected_arg_tys = &[];
2459 self.err_args(supplied_arg_count)
2462 debug!("check_argument_types: formal_tys={:?}",
2463 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2465 // Check the arguments.
2466 // We do this in a pretty awful way: first we typecheck any arguments
2467 // that are not closures, then we typecheck the closures. This is so
2468 // that we have more information about the types of arguments when we
2469 // typecheck the functions. This isn't really the right way to do this.
2470 for &check_closures in &[false, true] {
2471 debug!("check_closures={}", check_closures);
2473 // More awful hacks: before we check argument types, try to do
2474 // an "opportunistic" vtable resolution of any trait bounds on
2475 // the call. This helps coercions.
2477 self.select_obligations_where_possible();
2480 // For variadic functions, we don't have a declared type for all of
2481 // the arguments hence we only do our usual type checking with
2482 // the arguments who's types we do know.
2483 let t = if variadic {
2485 } else if tuple_arguments == TupleArguments {
2490 for (i, arg) in args.iter().take(t).enumerate() {
2491 // Warn only for the first loop (the "no closures" one).
2492 // Closure arguments themselves can't be diverging, but
2493 // a previous argument can, e.g. `foo(panic!(), || {})`.
2494 if !check_closures {
2495 self.warn_if_unreachable(arg.id, arg.span, "expression");
2498 let is_closure = match arg.node {
2499 hir::ExprClosure(..) => true,
2503 if is_closure != check_closures {
2507 debug!("checking the argument");
2508 let formal_ty = formal_tys[i];
2510 // The special-cased logic below has three functions:
2511 // 1. Provide as good of an expected type as possible.
2512 let expected = expected_arg_tys.get(i).map(|&ty| {
2513 Expectation::rvalue_hint(self, ty)
2516 let checked_ty = self.check_expr_with_expectation(
2518 expected.unwrap_or(ExpectHasType(formal_ty)));
2520 // 2. Coerce to the most detailed type that could be coerced
2521 // to, which is `expected_ty` if `rvalue_hint` returns an
2522 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2523 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2524 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2526 // 3. Relate the expected type and the formal one,
2527 // if the expected type was used for the coercion.
2528 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2532 // We also need to make sure we at least write the ty of the other
2533 // arguments which we skipped above.
2535 for arg in args.iter().skip(expected_arg_count) {
2536 let arg_ty = self.check_expr(&arg);
2538 // There are a few types which get autopromoted when passed via varargs
2539 // in C but we just error out instead and require explicit casts.
2540 let arg_ty = self.structurally_resolved_type(arg.span,
2543 ty::TyFloat(ast::FloatTy::F32) => {
2544 self.type_error_message(arg.span, |t| {
2545 format!("can't pass an `{}` to variadic \
2546 function, cast to `c_double`", t)
2549 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2550 self.type_error_message(arg.span, |t| {
2551 format!("can't pass `{}` to variadic \
2552 function, cast to `c_int`",
2556 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2557 self.type_error_message(arg.span, |t| {
2558 format!("can't pass `{}` to variadic \
2559 function, cast to `c_uint`",
2563 ty::TyFnDef(.., f) => {
2564 let ptr_ty = self.tcx.mk_fn_ptr(f);
2565 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2566 self.type_error_message(arg.span,
2568 format!("can't pass `{}` to variadic \
2569 function, cast to `{}`", t, ptr_ty)
2578 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2579 (0..len).map(|_| self.tcx.types.err).collect()
2582 // AST fragment checking
2585 expected: Expectation<'tcx>)
2591 ast::LitKind::Str(..) => tcx.mk_static_str(),
2592 ast::LitKind::ByteStr(ref v) => {
2593 tcx.mk_imm_ref(tcx.types.re_static,
2594 tcx.mk_array(tcx.types.u8, v.len()))
2596 ast::LitKind::Byte(_) => tcx.types.u8,
2597 ast::LitKind::Char(_) => tcx.types.char,
2598 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2599 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2600 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2601 let opt_ty = expected.to_option(self).and_then(|ty| {
2603 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2604 ty::TyChar => Some(tcx.types.u8),
2605 ty::TyRawPtr(..) => Some(tcx.types.usize),
2606 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2610 opt_ty.unwrap_or_else(
2611 || tcx.mk_int_var(self.next_int_var_id()))
2613 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2614 ast::LitKind::FloatUnsuffixed(_) => {
2615 let opt_ty = expected.to_option(self).and_then(|ty| {
2617 ty::TyFloat(_) => Some(ty),
2621 opt_ty.unwrap_or_else(
2622 || tcx.mk_float_var(self.next_float_var_id()))
2624 ast::LitKind::Bool(_) => tcx.types.bool
2628 fn check_expr_eq_type(&self,
2629 expr: &'gcx hir::Expr,
2630 expected: Ty<'tcx>) {
2631 let ty = self.check_expr_with_hint(expr, expected);
2632 self.demand_eqtype(expr.span, expected, ty);
2635 pub fn check_expr_has_type(&self,
2636 expr: &'gcx hir::Expr,
2637 expected: Ty<'tcx>) -> Ty<'tcx> {
2638 let mut ty = self.check_expr_with_hint(expr, expected);
2640 // While we don't allow *arbitrary* coercions here, we *do* allow
2641 // coercions from ! to `expected`.
2643 assert!(!self.tables.borrow().adjustments.contains_key(&expr.id),
2644 "expression with never type wound up being adjusted");
2645 let adj_ty = self.next_diverging_ty_var(
2646 TypeVariableOrigin::AdjustmentType(expr.span));
2647 self.apply_adjustment(expr.id, Adjustment {
2648 kind: Adjust::NeverToAny,
2654 self.demand_suptype(expr.span, expected, ty);
2658 fn check_expr_coercable_to_type(&self,
2659 expr: &'gcx hir::Expr,
2660 expected: Ty<'tcx>) -> Ty<'tcx> {
2661 let ty = self.check_expr_with_hint(expr, expected);
2662 self.demand_coerce(expr, ty, expected);
2666 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2667 expected: Ty<'tcx>) -> Ty<'tcx> {
2668 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2671 fn check_expr_with_expectation(&self,
2672 expr: &'gcx hir::Expr,
2673 expected: Expectation<'tcx>) -> Ty<'tcx> {
2674 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2677 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2678 self.check_expr_with_expectation(expr, NoExpectation)
2681 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2682 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2683 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2686 // determine the `self` type, using fresh variables for all variables
2687 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2688 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2690 pub fn impl_self_ty(&self,
2691 span: Span, // (potential) receiver for this impl
2693 -> TypeAndSubsts<'tcx> {
2694 let ity = self.tcx.type_of(did);
2695 debug!("impl_self_ty: ity={:?}", ity);
2697 let substs = self.fresh_substs_for_item(span, did);
2698 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2700 TypeAndSubsts { substs: substs, ty: substd_ty }
2703 /// Unifies the output type with the expected type early, for more coercions
2704 /// and forward type information on the input expressions.
2705 fn expected_inputs_for_expected_output(&self,
2707 expected_ret: Expectation<'tcx>,
2708 formal_ret: Ty<'tcx>,
2709 formal_args: &[Ty<'tcx>])
2711 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2712 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2713 // Attempt to apply a subtyping relationship between the formal
2714 // return type (likely containing type variables if the function
2715 // is polymorphic) and the expected return type.
2716 // No argument expectations are produced if unification fails.
2717 let origin = self.misc(call_span);
2718 let ures = self.sub_types(false, &origin, formal_ret, ret_ty);
2720 // FIXME(#15760) can't use try! here, FromError doesn't default
2721 // to identity so the resulting type is not constrained.
2724 // Process any obligations locally as much as
2725 // we can. We don't care if some things turn
2726 // out unconstrained or ambiguous, as we're
2727 // just trying to get hints here.
2728 let result = self.save_and_restore_in_snapshot_flag(|_| {
2729 let mut fulfill = FulfillmentContext::new();
2730 let ok = ok; // FIXME(#30046)
2731 for obligation in ok.obligations {
2732 fulfill.register_predicate_obligation(self, obligation);
2734 fulfill.select_where_possible(self)
2739 Err(_) => return Err(()),
2742 Err(_) => return Err(()),
2745 // Record all the argument types, with the substitutions
2746 // produced from the above subtyping unification.
2747 Ok(formal_args.iter().map(|ty| {
2748 self.resolve_type_vars_if_possible(ty)
2751 }).unwrap_or(vec![]);
2752 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2753 formal_args, formal_ret,
2754 expected_args, expected_ret);
2758 // Checks a method call.
2759 fn check_method_call(&self,
2760 expr: &'gcx hir::Expr,
2761 method_name: Spanned<ast::Name>,
2762 args: &'gcx [hir::Expr],
2764 expected: Expectation<'tcx>,
2765 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2766 let rcvr = &args[0];
2767 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2769 // no need to check for bot/err -- callee does that
2770 let expr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2772 let tps = tps.iter().map(|ast_ty| self.to_ty(&ast_ty)).collect::<Vec<_>>();
2773 let fn_ty = match self.lookup_method(method_name.span,
2780 let method_ty = method.ty;
2781 let method_call = MethodCall::expr(expr.id);
2782 self.tables.borrow_mut().method_map.insert(method_call, method);
2786 if method_name.node != keywords::Invalid.name() {
2787 self.report_method_error(method_name.span,
2794 self.write_error(expr.id);
2799 // Call the generic checker.
2800 let ret_ty = self.check_method_argument_types(method_name.span, fn_ty,
2808 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2812 .unwrap_or_else(|| span_bug!(return_expr.span,
2813 "check_return_expr called outside fn body"));
2815 let ret_ty = ret_coercion.borrow().expected_ty();
2816 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty);
2817 ret_coercion.borrow_mut()
2819 &self.misc(return_expr.span),
2822 self.diverges.get());
2826 // A generic function for checking the then and else in an if
2828 fn check_then_else(&self,
2829 cond_expr: &'gcx hir::Expr,
2830 then_expr: &'gcx hir::Expr,
2831 opt_else_expr: Option<&'gcx hir::Expr>,
2833 expected: Expectation<'tcx>) -> Ty<'tcx> {
2834 let cond_ty = self.check_expr_has_type(cond_expr, self.tcx.types.bool);
2835 let cond_diverges = self.diverges.get();
2836 self.diverges.set(Diverges::Maybe);
2838 let expected = expected.adjust_for_branches(self);
2839 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2840 let then_diverges = self.diverges.get();
2841 self.diverges.set(Diverges::Maybe);
2843 // We've already taken the expected type's preferences
2844 // into account when typing the `then` branch. To figure
2845 // out the initial shot at a LUB, we thus only consider
2846 // `expected` if it represents a *hard* constraint
2847 // (`only_has_type`); otherwise, we just go with a
2848 // fresh type variable.
2849 let coerce_to_ty = expected.coercion_target_type(self, sp);
2850 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2852 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2853 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2855 if let Some(else_expr) = opt_else_expr {
2856 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2857 let else_diverges = self.diverges.get();
2859 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2861 // We won't diverge unless both branches do (or the condition does).
2862 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2864 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2865 coerce.coerce_forced_unit(self, &else_cause, &mut |_| ());
2867 // If the condition is false we can't diverge.
2868 self.diverges.set(cond_diverges);
2871 let result_ty = coerce.complete(self);
2872 if cond_ty.references_error() {
2879 // Check field access expressions
2880 fn check_field(&self,
2881 expr: &'gcx hir::Expr,
2882 lvalue_pref: LvaluePreference,
2883 base: &'gcx hir::Expr,
2884 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2885 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2886 let expr_t = self.structurally_resolved_type(expr.span,
2888 let mut private_candidate = None;
2889 let mut autoderef = self.autoderef(expr.span, expr_t);
2890 while let Some((base_t, autoderefs)) = autoderef.next() {
2892 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2893 debug!("struct named {:?}", base_t);
2894 if let Some(field) = base_def.struct_variant().find_field_named(field.node) {
2895 let field_ty = self.field_ty(expr.span, field, substs);
2896 if self.tcx.vis_is_accessible_from(field.vis, self.body_id) {
2897 autoderef.finalize(lvalue_pref, base);
2898 self.apply_autoderef_adjustment(base.id, autoderefs, base_t);
2900 self.tcx.check_stability(field.did, expr.id, expr.span);
2904 private_candidate = Some((base_def.did, field_ty));
2910 autoderef.unambiguous_final_ty();
2912 if let Some((did, field_ty)) = private_candidate {
2913 let struct_path = self.tcx().item_path_str(did);
2914 let msg = format!("field `{}` of struct `{}` is private", field.node, struct_path);
2915 let mut err = self.tcx().sess.struct_span_err(expr.span, &msg);
2916 // Also check if an accessible method exists, which is often what is meant.
2917 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
2918 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
2923 } else if field.node == keywords::Invalid.name() {
2924 self.tcx().types.err
2925 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
2926 self.type_error_struct(field.span, |actual| {
2927 format!("attempted to take value of method `{}` on type \
2928 `{}`", field.node, actual)
2930 .help("maybe a `()` to call it is missing? \
2931 If not, try an anonymous function")
2933 self.tcx().types.err
2935 let mut err = self.type_error_struct(field.span, |actual| {
2936 format!("no field `{}` on type `{}`",
2940 ty::TyAdt(def, _) if !def.is_enum() => {
2941 if let Some(suggested_field_name) =
2942 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
2943 err.span_label(field.span,
2944 &format!("did you mean `{}`?", suggested_field_name));
2946 err.span_label(field.span,
2947 &format!("unknown field"));
2950 ty::TyRawPtr(..) => {
2951 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref with \
2953 self.tcx.hir.node_to_pretty_string(base.id),
2959 self.tcx().types.err
2963 // Return an hint about the closest match in field names
2964 fn suggest_field_name(variant: &'tcx ty::VariantDef,
2965 field: &Spanned<ast::Name>,
2966 skip : Vec<InternedString>)
2968 let name = field.node.as_str();
2969 let names = variant.fields.iter().filter_map(|field| {
2970 // ignore already set fields and private fields from non-local crates
2971 if skip.iter().any(|x| *x == field.name.as_str()) ||
2972 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
2979 // only find fits with at least one matching letter
2980 find_best_match_for_name(names, &name, Some(name.len()))
2983 // Check tuple index expressions
2984 fn check_tup_field(&self,
2985 expr: &'gcx hir::Expr,
2986 lvalue_pref: LvaluePreference,
2987 base: &'gcx hir::Expr,
2988 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
2989 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2990 let expr_t = self.structurally_resolved_type(expr.span,
2992 let mut private_candidate = None;
2993 let mut tuple_like = false;
2994 let mut autoderef = self.autoderef(expr.span, expr_t);
2995 while let Some((base_t, autoderefs)) = autoderef.next() {
2996 let field = match base_t.sty {
2997 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
2998 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
2999 if !tuple_like { continue }
3001 debug!("tuple struct named {:?}", base_t);
3002 base_def.struct_variant().fields.get(idx.node).and_then(|field| {
3003 let field_ty = self.field_ty(expr.span, field, substs);
3004 private_candidate = Some((base_def.did, field_ty));
3005 if self.tcx.vis_is_accessible_from(field.vis, self.body_id) {
3006 self.tcx.check_stability(field.did, expr.id, expr.span);
3013 ty::TyTuple(ref v, _) => {
3015 v.get(idx.node).cloned()
3020 if let Some(field_ty) = field {
3021 autoderef.finalize(lvalue_pref, base);
3022 self.apply_autoderef_adjustment(base.id, autoderefs, base_t);
3026 autoderef.unambiguous_final_ty();
3028 if let Some((did, field_ty)) = private_candidate {
3029 let struct_path = self.tcx().item_path_str(did);
3030 let msg = format!("field `{}` of struct `{}` is private", idx.node, struct_path);
3031 self.tcx().sess.span_err(expr.span, &msg);
3035 self.type_error_message(
3039 format!("attempted out-of-bounds tuple index `{}` on \
3044 format!("attempted tuple index `{}` on type `{}`, but the \
3045 type was not a tuple or tuple struct",
3052 self.tcx().types.err
3055 fn report_unknown_field(&self,
3057 variant: &'tcx ty::VariantDef,
3059 skip_fields: &[hir::Field],
3061 let mut err = self.type_error_struct_with_diag(
3063 |actual| match ty.sty {
3064 ty::TyAdt(adt, ..) if adt.is_enum() => {
3065 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3066 "{} `{}::{}` has no field named `{}`",
3067 kind_name, actual, variant.name, field.name.node)
3070 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3071 "{} `{}` has no field named `{}`",
3072 kind_name, actual, field.name.node)
3076 // prevent all specified fields from being suggested
3077 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3078 if let Some(field_name) = Self::suggest_field_name(variant,
3080 skip_fields.collect()) {
3081 err.span_label(field.name.span,
3082 &format!("field does not exist - did you mean `{}`?", field_name));
3085 ty::TyAdt(adt, ..) if adt.is_enum() => {
3086 err.span_label(field.name.span, &format!("`{}::{}` does not have this field",
3090 err.span_label(field.name.span, &format!("`{}` does not have this field", ty));
3097 fn check_expr_struct_fields(&self,
3099 expected: Expectation<'tcx>,
3100 expr_id: ast::NodeId,
3102 variant: &'tcx ty::VariantDef,
3103 ast_fields: &'gcx [hir::Field],
3104 check_completeness: bool) {
3108 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3109 .get(0).cloned().unwrap_or(adt_ty);
3111 let (substs, hint_substs, adt_kind, kind_name) = match (&adt_ty.sty, &adt_ty_hint.sty) {
3112 (&ty::TyAdt(adt, substs), &ty::TyAdt(_, hint_substs)) => {
3113 (substs, hint_substs, adt.adt_kind(), adt.variant_descr())
3115 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3118 let mut remaining_fields = FxHashMap();
3119 for field in &variant.fields {
3120 remaining_fields.insert(field.name, field);
3123 let mut seen_fields = FxHashMap();
3125 let mut error_happened = false;
3127 // Typecheck each field.
3128 for field in ast_fields {
3129 let final_field_type;
3130 let field_type_hint;
3132 if let Some(v_field) = remaining_fields.remove(&field.name.node) {
3133 final_field_type = self.field_ty(field.span, v_field, substs);
3134 field_type_hint = self.field_ty(field.span, v_field, hint_substs);
3136 seen_fields.insert(field.name.node, field.span);
3138 // we don't look at stability attributes on
3139 // struct-like enums (yet...), but it's definitely not
3140 // a bug to have construct one.
3141 if adt_kind != ty::AdtKind::Enum {
3142 tcx.check_stability(v_field.did, expr_id, field.span);
3145 error_happened = true;
3146 final_field_type = tcx.types.err;
3147 field_type_hint = tcx.types.err;
3148 if let Some(_) = variant.find_field_named(field.name.node) {
3149 let mut err = struct_span_err!(self.tcx.sess,
3152 "field `{}` specified more than once",
3155 err.span_label(field.name.span, &format!("used more than once"));
3157 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3158 err.span_label(*prev_span, &format!("first use of `{}`", field.name.node));
3163 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3167 // Make sure to give a type to the field even if there's
3168 // an error, so we can continue typechecking
3169 let ty = self.check_expr_with_hint(&field.expr, field_type_hint);
3170 self.demand_coerce(&field.expr, ty, final_field_type);
3173 // Make sure the programmer specified correct number of fields.
3174 if kind_name == "union" {
3175 if ast_fields.len() != 1 {
3176 tcx.sess.span_err(span, "union expressions should have exactly one field");
3178 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3179 let len = remaining_fields.len();
3181 let mut displayable_field_names = remaining_fields
3183 .map(|x| x.as_str())
3184 .collect::<Vec<_>>();
3186 displayable_field_names.sort();
3188 let truncated_fields_error = if len <= 3 {
3191 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3194 let remaining_fields_names = displayable_field_names.iter().take(3)
3195 .map(|n| format!("`{}`", n))
3196 .collect::<Vec<_>>()
3199 struct_span_err!(tcx.sess, span, E0063,
3200 "missing field{} {}{} in initializer of `{}`",
3201 if remaining_fields.len() == 1 {""} else {"s"},
3202 remaining_fields_names,
3203 truncated_fields_error,
3205 .span_label(span, &format!("missing {}{}",
3206 remaining_fields_names,
3207 truncated_fields_error))
3212 fn check_struct_fields_on_error(&self,
3213 fields: &'gcx [hir::Field],
3214 base_expr: &'gcx Option<P<hir::Expr>>) {
3215 for field in fields {
3216 self.check_expr(&field.expr);
3220 self.check_expr(&base);
3226 pub fn check_struct_path(&self,
3228 node_id: ast::NodeId)
3229 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3230 let path_span = match *qpath {
3231 hir::QPath::Resolved(_, ref path) => path.span,
3232 hir::QPath::TypeRelative(ref qself, _) => qself.span
3234 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3235 let variant = match def {
3237 self.set_tainted_by_errors();
3240 Def::Variant(..) => {
3242 ty::TyAdt(adt, substs) => {
3243 Some((adt.variant_of_def(def), adt.did, substs))
3245 _ => bug!("unexpected type: {:?}", ty.sty)
3248 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3249 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3251 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3252 Some((adt.struct_variant(), adt.did, substs))
3257 _ => bug!("unexpected definition: {:?}", def)
3260 if let Some((variant, did, substs)) = variant {
3261 // Check bounds on type arguments used in the path.
3262 let bounds = self.instantiate_bounds(path_span, did, substs);
3263 let cause = traits::ObligationCause::new(path_span, self.body_id,
3264 traits::ItemObligation(did));
3265 self.add_obligations_for_parameters(cause, &bounds);
3269 struct_span_err!(self.tcx.sess, path_span, E0071,
3270 "expected struct, variant or union type, found {}",
3271 ty.sort_string(self.tcx))
3272 .span_label(path_span, &format!("not a struct"))
3278 fn check_expr_struct(&self,
3280 expected: Expectation<'tcx>,
3282 fields: &'gcx [hir::Field],
3283 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3285 // Find the relevant variant
3286 let (variant, struct_ty) =
3287 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3290 self.check_struct_fields_on_error(fields, base_expr);
3291 return self.tcx.types.err;
3294 let path_span = match *qpath {
3295 hir::QPath::Resolved(_, ref path) => path.span,
3296 hir::QPath::TypeRelative(ref qself, _) => qself.span
3299 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3300 base_expr.is_none());
3301 if let &Some(ref base_expr) = base_expr {
3302 self.check_expr_has_type(base_expr, struct_ty);
3303 match struct_ty.sty {
3304 ty::TyAdt(adt, substs) if adt.is_struct() => {
3305 self.tables.borrow_mut().fru_field_types.insert(
3307 adt.struct_variant().fields.iter().map(|f| {
3308 self.normalize_associated_types_in(
3309 expr.span, &f.ty(self.tcx, substs)
3315 span_err!(self.tcx.sess, base_expr.span, E0436,
3316 "functional record update syntax requires a struct");
3320 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3326 /// If an expression has any sub-expressions that result in a type error,
3327 /// inspecting that expression's type with `ty.references_error()` will return
3328 /// true. Likewise, if an expression is known to diverge, inspecting its
3329 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3330 /// strict, _|_ can appear in the type of an expression that does not,
3331 /// itself, diverge: for example, fn() -> _|_.)
3332 /// Note that inspecting a type's structure *directly* may expose the fact
3333 /// that there are actually multiple representations for `TyError`, so avoid
3334 /// that when err needs to be handled differently.
3335 fn check_expr_with_expectation_and_lvalue_pref(&self,
3336 expr: &'gcx hir::Expr,
3337 expected: Expectation<'tcx>,
3338 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3339 debug!(">> typechecking: expr={:?} expected={:?}",
3342 // Warn for expressions after diverging siblings.
3343 self.warn_if_unreachable(expr.id, expr.span, "expression");
3345 // Hide the outer diverging and has_errors flags.
3346 let old_diverges = self.diverges.get();
3347 let old_has_errors = self.has_errors.get();
3348 self.diverges.set(Diverges::Maybe);
3349 self.has_errors.set(false);
3351 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3353 // Warn for non-block expressions with diverging children.
3356 hir::ExprLoop(..) | hir::ExprWhile(..) |
3357 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3359 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3362 // Any expression that produces a value of type `!` must have diverged
3364 self.diverges.set(self.diverges.get() | Diverges::Always);
3367 // Record the type, which applies it effects.
3368 // We need to do this after the warning above, so that
3369 // we don't warn for the diverging expression itself.
3370 self.write_ty(expr.id, ty);
3372 // Combine the diverging and has_error flags.
3373 self.diverges.set(self.diverges.get() | old_diverges);
3374 self.has_errors.set(self.has_errors.get() | old_has_errors);
3376 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3377 debug!("... {:?}, expected is {:?}", ty, expected);
3382 fn check_expr_kind(&self,
3383 expr: &'gcx hir::Expr,
3384 expected: Expectation<'tcx>,
3385 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3389 hir::ExprBox(ref subexpr) => {
3390 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3392 ty::TyAdt(def, _) if def.is_box()
3393 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3397 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3398 tcx.mk_box(referent_ty)
3401 hir::ExprLit(ref lit) => {
3402 self.check_lit(&lit, expected)
3404 hir::ExprBinary(op, ref lhs, ref rhs) => {
3405 self.check_binop(expr, op, lhs, rhs)
3407 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3408 self.check_binop_assign(expr, op, lhs, rhs)
3410 hir::ExprUnary(unop, ref oprnd) => {
3411 let expected_inner = match unop {
3412 hir::UnNot | hir::UnNeg => {
3419 let lvalue_pref = match unop {
3420 hir::UnDeref => lvalue_pref,
3423 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3427 if !oprnd_t.references_error() {
3430 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3432 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3434 } else if let Some(ok) = self.try_overloaded_deref(
3435 expr.span, Some(&oprnd), oprnd_t, lvalue_pref) {
3436 let method = self.register_infer_ok_obligations(ok);
3437 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3438 self.tables.borrow_mut().method_map.insert(MethodCall::expr(expr.id),
3441 self.type_error_message(expr.span, |actual| {
3442 format!("type `{}` cannot be \
3443 dereferenced", actual)
3445 oprnd_t = tcx.types.err;
3449 oprnd_t = self.structurally_resolved_type(oprnd.span,
3451 let result = self.check_user_unop("!", "not",
3452 tcx.lang_items.not_trait(),
3453 expr, &oprnd, oprnd_t, unop);
3454 // If it's builtin, we can reuse the type, this helps inference.
3455 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3460 oprnd_t = self.structurally_resolved_type(oprnd.span,
3462 let result = self.check_user_unop("-", "neg",
3463 tcx.lang_items.neg_trait(),
3464 expr, &oprnd, oprnd_t, unop);
3465 // If it's builtin, we can reuse the type, this helps inference.
3466 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3474 hir::ExprAddrOf(mutbl, ref oprnd) => {
3475 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3477 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3478 if self.tcx.expr_is_lval(&oprnd) {
3479 // Lvalues may legitimately have unsized types.
3480 // For example, dereferences of a fat pointer and
3481 // the last field of a struct can be unsized.
3482 ExpectHasType(mt.ty)
3484 Expectation::rvalue_hint(self, mt.ty)
3490 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3491 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3493 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3494 if tm.ty.references_error() {
3497 // Note: at this point, we cannot say what the best lifetime
3498 // is to use for resulting pointer. We want to use the
3499 // shortest lifetime possible so as to avoid spurious borrowck
3500 // errors. Moreover, the longest lifetime will depend on the
3501 // precise details of the value whose address is being taken
3502 // (and how long it is valid), which we don't know yet until type
3503 // inference is complete.
3505 // Therefore, here we simply generate a region variable. The
3506 // region inferencer will then select the ultimate value.
3507 // Finally, borrowck is charged with guaranteeing that the
3508 // value whose address was taken can actually be made to live
3509 // as long as it needs to live.
3510 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3511 tcx.mk_ref(region, tm)
3514 hir::ExprPath(ref qpath) => {
3515 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3516 expr.id, expr.span);
3517 let ty = if def != Def::Err {
3518 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3520 self.set_tainted_by_errors();
3524 // We always require that the type provided as the value for
3525 // a type parameter outlives the moment of instantiation.
3526 self.opt_node_ty_substs(expr.id, |item_substs| {
3527 self.add_wf_bounds(&item_substs.substs, expr);
3532 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3533 for output in outputs {
3534 self.check_expr(output);
3536 for input in inputs {
3537 self.check_expr(input);
3541 hir::ExprBreak(destination, ref expr_opt) => {
3542 if let Some(target_id) = destination.target_id.opt_id() {
3543 let (e_ty, e_diverges, cause);
3544 if let Some(ref e) = *expr_opt {
3545 // If this is a break with a value, we need to type-check
3546 // the expression. Get an expected type from the loop context.
3547 let opt_coerce_to = {
3548 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3549 enclosing_breakables.find_breakable(target_id)
3552 .map(|coerce| coerce.expected_ty())
3555 // If the loop context is not a `loop { }`, then break with
3556 // a value is illegal, and `opt_coerce_to` will be `None`.
3557 // Just set expectation to error in that case.
3558 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3560 // Recurse without `enclosing_breakables` borrowed.
3561 e_ty = self.check_expr_with_hint(e, coerce_to);
3562 e_diverges = self.diverges.get();
3563 cause = self.misc(e.span);
3565 // Otherwise, this is a break *without* a value. That's
3566 // always legal, and is equivalent to `break ()`.
3567 e_ty = tcx.mk_nil();
3568 e_diverges = Diverges::Maybe;
3569 cause = self.misc(expr.span);
3572 // Now that we have type-checked `expr_opt`, borrow
3573 // the `enclosing_loops` field and let's coerce the
3574 // type of `expr_opt` into what is expected.
3575 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3576 let ctxt = enclosing_breakables.find_breakable(target_id);
3577 if let Some(ref mut coerce) = ctxt.coerce {
3578 if let Some(ref e) = *expr_opt {
3579 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3581 assert!(e_ty.is_nil());
3582 coerce.coerce_forced_unit(self, &cause, &mut |_| ());
3585 // If `ctxt.coerce` is `None`, we can just ignore
3586 // the type of the expresison. This is because
3587 // either this was a break *without* a value, in
3588 // which case it is always a legal type (`()`), or
3589 // else an error would have been flagged by the
3590 // `loops` pass for using break with an expression
3591 // where you are not supposed to.
3592 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3595 ctxt.may_break = true;
3597 // Otherwise, we failed to find the enclosing loop;
3598 // this can only happen if the `break` was not
3599 // inside a loop at all, which is caught by the
3600 // loop-checking pass.
3601 assert!(self.tcx.sess.err_count() > 0);
3604 // the type of a `break` is always `!`, since it diverges
3607 hir::ExprAgain(_) => { tcx.types.never }
3608 hir::ExprRet(ref expr_opt) => {
3609 if self.ret_coercion.is_none() {
3610 struct_span_err!(self.tcx.sess, expr.span, E0572,
3611 "return statement outside of function body").emit();
3612 } else if let Some(ref e) = *expr_opt {
3613 self.check_return_expr(e);
3615 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3616 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3617 coercion.coerce_forced_unit(self, &cause, &mut |_| ());
3621 hir::ExprAssign(ref lhs, ref rhs) => {
3622 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3625 if !tcx.expr_is_lval(&lhs) {
3627 tcx.sess, expr.span, E0070,
3628 "invalid left-hand side expression")
3631 &format!("left-hand of expression not valid"))
3635 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3637 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3639 if lhs_ty.references_error() || rhs_ty.references_error() {
3645 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3646 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3647 expr.span, expected)
3649 hir::ExprWhile(ref cond, ref body, _) => {
3650 let ctxt = BreakableCtxt {
3651 // cannot use break with a value from a while loop
3656 self.with_breakable_ctxt(expr.id, ctxt, || {
3657 self.check_expr_has_type(&cond, tcx.types.bool);
3658 let cond_diverging = self.diverges.get();
3659 self.check_block_no_value(&body);
3661 // We may never reach the body so it diverging means nothing.
3662 self.diverges.set(cond_diverging);
3667 hir::ExprLoop(ref body, _, source) => {
3668 let coerce = match source {
3669 // you can only use break with a value from a normal `loop { }`
3670 hir::LoopSource::Loop => {
3671 let coerce_to = expected.coercion_target_type(self, body.span);
3672 Some(CoerceMany::new(coerce_to))
3675 hir::LoopSource::WhileLet |
3676 hir::LoopSource::ForLoop => {
3681 let ctxt = BreakableCtxt {
3683 may_break: false, // will get updated if/when we find a `break`
3686 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3687 self.check_block_no_value(&body);
3691 // No way to know whether it's diverging because
3692 // of a `break` or an outer `break` or `return.
3693 self.diverges.set(Diverges::Maybe);
3696 // If we permit break with a value, then result type is
3697 // the LUB of the breaks (possibly ! if none); else, it
3698 // is nil. This makes sense because infinite loops
3699 // (which would have type !) are only possible iff we
3700 // permit break with a value [1].
3701 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3702 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3704 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3705 self.check_match(expr, &discrim, arms, expected, match_src)
3707 hir::ExprClosure(capture, ref decl, body_id, _) => {
3708 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3710 hir::ExprBlock(ref body) => {
3711 self.check_block_with_expected(&body, expected)
3713 hir::ExprCall(ref callee, ref args) => {
3714 self.check_call(expr, &callee, args, expected)
3716 hir::ExprMethodCall(name, ref tps, ref args) => {
3717 self.check_method_call(expr, name, args, &tps[..], expected, lvalue_pref)
3719 hir::ExprCast(ref e, ref t) => {
3720 // Find the type of `e`. Supply hints based on the type we are casting to,
3722 let t_cast = self.to_ty(t);
3723 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3724 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3725 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3726 let diverges = self.diverges.get();
3728 // Eagerly check for some obvious errors.
3729 if t_expr.references_error() || t_cast.references_error() {
3732 // Defer other checks until we're done type checking.
3733 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3734 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3736 deferred_cast_checks.push(cast_check);
3739 Err(ErrorReported) => {
3745 hir::ExprType(ref e, ref t) => {
3746 let typ = self.to_ty(&t);
3747 self.check_expr_eq_type(&e, typ);
3750 hir::ExprArray(ref args) => {
3751 let uty = expected.to_option(self).and_then(|uty| {
3753 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3758 let element_ty = if !args.is_empty() {
3759 let coerce_to = uty.unwrap_or_else(
3760 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3761 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3762 assert_eq!(self.diverges.get(), Diverges::Maybe);
3764 let e_ty = self.check_expr_with_hint(e, coerce_to);
3765 let cause = self.misc(e.span);
3766 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3768 coerce.complete(self)
3770 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3772 tcx.mk_array(element_ty, args.len())
3774 hir::ExprRepeat(ref element, count) => {
3775 let count = eval_length(self.tcx, count, "repeat count")
3778 let uty = match expected {
3779 ExpectHasType(uty) => {
3781 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3788 let (element_ty, t) = match uty {
3790 self.check_expr_coercable_to_type(&element, uty);
3794 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3795 let element_ty = self.check_expr_has_type(&element, t);
3801 // For [foo, ..n] where n > 1, `foo` must have
3803 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3804 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3807 if element_ty.references_error() {
3810 tcx.mk_array(t, count)
3813 hir::ExprTup(ref elts) => {
3814 let flds = expected.only_has_type(self).and_then(|ty| {
3816 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3821 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3822 let t = match flds {
3823 Some(ref fs) if i < fs.len() => {
3825 self.check_expr_coercable_to_type(&e, ety);
3829 self.check_expr_with_expectation(&e, NoExpectation)
3834 let tuple = tcx.mk_tup(elt_ts_iter, false);
3835 if tuple.references_error() {
3841 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
3842 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
3844 hir::ExprField(ref base, ref field) => {
3845 self.check_field(expr, lvalue_pref, &base, field)
3847 hir::ExprTupField(ref base, idx) => {
3848 self.check_tup_field(expr, lvalue_pref, &base, idx)
3850 hir::ExprIndex(ref base, ref idx) => {
3851 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
3852 let idx_t = self.check_expr(&idx);
3854 if base_t.references_error() {
3856 } else if idx_t.references_error() {
3859 let base_t = self.structurally_resolved_type(expr.span, base_t);
3860 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
3861 Some((index_ty, element_ty)) => {
3862 self.demand_coerce(idx, idx_t, index_ty);
3866 let mut err = self.type_error_struct(
3869 format!("cannot index a value of type `{}`",
3873 // Try to give some advice about indexing tuples.
3874 if let ty::TyTuple(..) = base_t.sty {
3875 let mut needs_note = true;
3876 // If the index is an integer, we can show the actual
3877 // fixed expression:
3878 if let hir::ExprLit(ref lit) = idx.node {
3879 if let ast::LitKind::Int(i,
3880 ast::LitIntType::Unsuffixed) = lit.node {
3881 let snip = tcx.sess.codemap().span_to_snippet(base.span);
3882 if let Ok(snip) = snip {
3883 err.span_suggestion(expr.span,
3884 "to access tuple elements, \
3885 use tuple indexing syntax \
3887 format!("{}.{}", snip, i));
3893 err.help("to access tuple elements, use tuple indexing \
3894 syntax (e.g. `tuple.0`)");
3906 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3907 // The newly resolved definition is written into `type_relative_path_defs`.
3908 fn finish_resolving_struct_path(&self,
3911 node_id: ast::NodeId)
3915 hir::QPath::Resolved(ref maybe_qself, ref path) => {
3916 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3917 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
3920 hir::QPath::TypeRelative(ref qself, ref segment) => {
3921 let ty = self.to_ty(qself);
3923 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
3928 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
3931 // Write back the new resolution.
3932 self.tables.borrow_mut().type_relative_path_defs.insert(node_id, def);
3939 // Resolve associated value path into a base type and associated constant or method definition.
3940 // The newly resolved definition is written into `type_relative_path_defs`.
3941 pub fn resolve_ty_and_def_ufcs<'b>(&self,
3942 qpath: &'b hir::QPath,
3943 node_id: ast::NodeId,
3945 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3947 let (ty, item_segment) = match *qpath {
3948 hir::QPath::Resolved(ref opt_qself, ref path) => {
3950 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3951 &path.segments[..]);
3953 hir::QPath::TypeRelative(ref qself, ref segment) => {
3954 (self.to_ty(qself), segment)
3957 let item_name = item_segment.name;
3958 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
3961 let def = match error {
3962 method::MethodError::PrivateMatch(def) => def,
3965 if item_name != keywords::Invalid.name() {
3966 self.report_method_error(span, ty, item_name, None, error, None);
3972 // Write back the new resolution.
3973 self.tables.borrow_mut().type_relative_path_defs.insert(node_id, def);
3974 (def, Some(ty), slice::ref_slice(&**item_segment))
3977 pub fn check_decl_initializer(&self,
3978 local: &'gcx hir::Local,
3979 init: &'gcx hir::Expr) -> Ty<'tcx>
3981 let ref_bindings = local.pat.contains_ref_binding();
3983 let local_ty = self.local_ty(init.span, local.id);
3984 if let Some(m) = ref_bindings {
3985 // Somewhat subtle: if we have a `ref` binding in the pattern,
3986 // we want to avoid introducing coercions for the RHS. This is
3987 // both because it helps preserve sanity and, in the case of
3988 // ref mut, for soundness (issue #23116). In particular, in
3989 // the latter case, we need to be clear that the type of the
3990 // referent for the reference that results is *equal to* the
3991 // type of the lvalue it is referencing, and not some
3992 // supertype thereof.
3993 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
3994 self.demand_eqtype(init.span, init_ty, local_ty);
3997 self.check_expr_coercable_to_type(init, local_ty)
4001 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4002 let t = self.local_ty(local.span, local.id);
4003 self.write_ty(local.id, t);
4005 if let Some(ref init) = local.init {
4006 let init_ty = self.check_decl_initializer(local, &init);
4007 if init_ty.references_error() {
4008 self.write_ty(local.id, init_ty);
4012 self.check_pat(&local.pat, t);
4013 let pat_ty = self.node_ty(local.pat.id);
4014 if pat_ty.references_error() {
4015 self.write_ty(local.id, pat_ty);
4019 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4020 // Don't do all the complex logic below for DeclItem.
4022 hir::StmtDecl(ref decl, id) => {
4024 hir::DeclLocal(_) => {}
4025 hir::DeclItem(_) => {
4031 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4034 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4036 // Hide the outer diverging and has_errors flags.
4037 let old_diverges = self.diverges.get();
4038 let old_has_errors = self.has_errors.get();
4039 self.diverges.set(Diverges::Maybe);
4040 self.has_errors.set(false);
4042 let (node_id, _span) = match stmt.node {
4043 hir::StmtDecl(ref decl, id) => {
4044 let span = match decl.node {
4045 hir::DeclLocal(ref l) => {
4046 self.check_decl_local(&l);
4049 hir::DeclItem(_) => {/* ignore for now */
4055 hir::StmtExpr(ref expr, id) => {
4056 // Check with expected type of ()
4057 self.check_expr_has_type(&expr, self.tcx.mk_nil());
4060 hir::StmtSemi(ref expr, id) => {
4061 self.check_expr(&expr);
4066 if self.has_errors.get() {
4067 self.write_error(node_id);
4069 self.write_nil(node_id);
4072 // Combine the diverging and has_error flags.
4073 self.diverges.set(self.diverges.get() | old_diverges);
4074 self.has_errors.set(self.has_errors.get() | old_has_errors);
4077 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4078 let unit = self.tcx.mk_nil();
4079 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4081 // if the block produces a `!` value, that can always be
4082 // (effectively) coerced to unit.
4084 self.demand_suptype(blk.span, unit, ty);
4088 fn check_block_with_expected(&self,
4089 blk: &'gcx hir::Block,
4090 expected: Expectation<'tcx>) -> Ty<'tcx> {
4092 let mut fcx_ps = self.ps.borrow_mut();
4093 let unsafety_state = fcx_ps.recurse(blk);
4094 replace(&mut *fcx_ps, unsafety_state)
4097 // In some cases, blocks have just one exit, but other blocks
4098 // can be targeted by multiple breaks. This cannot happen in
4099 // normal Rust syntax today, but it can happen when we desugar
4100 // a `do catch { ... }` expression.
4104 // 'a: { if true { break 'a Err(()); } Ok(()) }
4106 // Here we would wind up with two coercions, one from
4107 // `Err(())` and the other from the tail expression
4108 // `Ok(())`. If the tail expression is omitted, that's a
4109 // "forced unit" -- unless the block diverges, in which
4110 // case we can ignore the tail expression (e.g., `'a: {
4111 // break 'a 22; }` would not force the type of the block
4113 let tail_expr = blk.expr.as_ref();
4114 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4115 let coerce = if blk.targeted_by_break {
4116 CoerceMany::new(coerce_to_ty)
4118 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4119 Some(e) => ref_slice(e),
4122 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4125 let ctxt = BreakableCtxt {
4126 coerce: Some(coerce),
4130 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4131 for s in &blk.stmts {
4135 // check the tail expression **without** holding the
4136 // `enclosing_breakables` lock below.
4137 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4139 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4140 let mut ctxt = enclosing_breakables.find_breakable(blk.id);
4141 let mut coerce = ctxt.coerce.as_mut().unwrap();
4142 if let Some(tail_expr_ty) = tail_expr_ty {
4143 let tail_expr = tail_expr.unwrap();
4145 &self.misc(tail_expr.span),
4148 self.diverges.get());
4150 // Subtle: if there is no explicit tail expression,
4151 // that is typically equivalent to a tail expression
4152 // of `()` -- except if the block diverges. In that
4153 // case, there is no value supplied from the tail
4154 // expression (assuming there are no other breaks,
4155 // this implies that the type of the block will be
4157 if !self.diverges.get().always() {
4158 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4159 if let Some(expected_ty) = expected.only_has_type(self) {
4160 self.consider_hint_about_removing_semicolon(blk,
4169 let mut ty = ctxt.coerce.unwrap().complete(self);
4171 if self.has_errors.get() || ty.references_error() {
4172 ty = self.tcx.types.err
4175 self.write_ty(blk.id, ty);
4177 *self.ps.borrow_mut() = prev;
4181 /// A common error is to add an extra semicolon:
4184 /// fn foo() -> usize {
4189 /// This routine checks if the final statement in a block is an
4190 /// expression with an explicit semicolon whose type is compatible
4191 /// with `expected_ty`. If so, it suggests removing the semicolon.
4192 fn consider_hint_about_removing_semicolon(&self,
4193 blk: &'gcx hir::Block,
4194 expected_ty: Ty<'tcx>,
4195 err: &mut DiagnosticBuilder) {
4196 // Be helpful when the user wrote `{... expr;}` and
4197 // taking the `;` off is enough to fix the error.
4198 let last_stmt = match blk.stmts.last() {
4202 let last_expr = match last_stmt.node {
4203 hir::StmtSemi(ref e, _) => e,
4206 let last_expr_ty = self.expr_ty(last_expr);
4207 if self.can_sub_types(last_expr_ty, expected_ty).is_err() {
4210 let original_span = original_sp(last_stmt.span, blk.span);
4211 let span_semi = Span {
4212 lo: original_span.hi - BytePos(1),
4213 hi: original_span.hi,
4214 ctxt: original_span.ctxt,
4216 err.span_help(span_semi, "consider removing this semicolon:");
4219 // Instantiates the given path, which must refer to an item with the given
4220 // number of type parameters and type.
4221 pub fn instantiate_value_path(&self,
4222 segments: &[hir::PathSegment],
4223 opt_self_ty: Option<Ty<'tcx>>,
4226 node_id: ast::NodeId)
4228 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4233 // We need to extract the type parameters supplied by the user in
4234 // the path `path`. Due to the current setup, this is a bit of a
4235 // tricky-process; the problem is that resolve only tells us the
4236 // end-point of the path resolution, and not the intermediate steps.
4237 // Luckily, we can (at least for now) deduce the intermediate steps
4238 // just from the end-point.
4240 // There are basically four cases to consider:
4242 // 1. Reference to a constructor of enum variant or struct:
4244 // struct Foo<T>(...)
4245 // enum E<T> { Foo(...) }
4247 // In these cases, the parameters are declared in the type
4250 // 2. Reference to a fn item or a free constant:
4254 // In this case, the path will again always have the form
4255 // `a::b::foo::<T>` where only the final segment should have
4256 // type parameters. However, in this case, those parameters are
4257 // declared on a value, and hence are in the `FnSpace`.
4259 // 3. Reference to a method or an associated constant:
4261 // impl<A> SomeStruct<A> {
4265 // Here we can have a path like
4266 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4267 // may appear in two places. The penultimate segment,
4268 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4269 // final segment, `foo::<B>` contains parameters in fn space.
4271 // 4. Reference to a local variable
4273 // Local variables can't have any type parameters.
4275 // The first step then is to categorize the segments appropriately.
4277 assert!(!segments.is_empty());
4279 let mut ufcs_associated = None;
4280 let mut type_segment = None;
4281 let mut fn_segment = None;
4283 // Case 1. Reference to a struct/variant constructor.
4284 Def::StructCtor(def_id, ..) |
4285 Def::VariantCtor(def_id, ..) => {
4286 // Everything but the final segment should have no
4287 // parameters at all.
4288 let mut generics = self.tcx.generics_of(def_id);
4289 if let Some(def_id) = generics.parent {
4290 // Variant and struct constructors use the
4291 // generics of their parent type definition.
4292 generics = self.tcx.generics_of(def_id);
4294 type_segment = Some((segments.last().unwrap(), generics));
4297 // Case 2. Reference to a top-level value.
4299 Def::Const(def_id) |
4300 Def::Static(def_id, _) => {
4301 fn_segment = Some((segments.last().unwrap(),
4302 self.tcx.generics_of(def_id)));
4305 // Case 3. Reference to a method or associated const.
4306 Def::Method(def_id) |
4307 Def::AssociatedConst(def_id) => {
4308 let container = self.tcx.associated_item(def_id).container;
4310 ty::TraitContainer(trait_did) => {
4311 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4313 ty::ImplContainer(_) => {}
4316 let generics = self.tcx.generics_of(def_id);
4317 if segments.len() >= 2 {
4318 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4319 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4321 // `<T>::assoc` will end up here, and so can `T::assoc`.
4322 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4323 ufcs_associated = Some((container, self_ty));
4325 fn_segment = Some((segments.last().unwrap(), generics));
4328 // Case 4. Local variable, no generics.
4329 Def::Local(..) | Def::Upvar(..) => {}
4331 _ => bug!("unexpected definition: {:?}", def),
4334 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4336 // Now that we have categorized what space the parameters for each
4337 // segment belong to, let's sort out the parameters that the user
4338 // provided (if any) into their appropriate spaces. We'll also report
4339 // errors if type parameters are provided in an inappropriate place.
4340 let poly_segments = type_segment.is_some() as usize +
4341 fn_segment.is_some() as usize;
4342 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4345 Def::Local(def_id) | Def::Upvar(def_id, ..) => {
4346 let nid = self.tcx.hir.as_local_node_id(def_id).unwrap();
4347 let ty = self.local_ty(span, nid);
4348 let ty = self.normalize_associated_types_in(span, &ty);
4349 self.write_ty(node_id, ty);
4350 self.write_substs(node_id, ty::ItemSubsts {
4351 substs: self.tcx.intern_substs(&[])
4358 // Now we have to compare the types that the user *actually*
4359 // provided against the types that were *expected*. If the user
4360 // did not provide any types, then we want to substitute inference
4361 // variables. If the user provided some types, we may still need
4362 // to add defaults. If the user provided *too many* types, that's
4364 self.check_path_parameter_count(span, &mut type_segment);
4365 self.check_path_parameter_count(span, &mut fn_segment);
4367 let (fn_start, has_self) = match (type_segment, fn_segment) {
4368 (_, Some((_, generics))) => {
4369 (generics.parent_count(), generics.has_self)
4371 (Some((_, generics)), None) => {
4372 (generics.own_count(), generics.has_self)
4374 (None, None) => (0, false)
4376 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4377 let mut i = def.index as usize;
4379 let segment = if i < fn_start {
4380 i -= has_self as usize;
4386 let lifetimes = match segment.map(|(s, _)| &s.parameters) {
4387 Some(&hir::AngleBracketedParameters(ref data)) => &data.lifetimes[..],
4388 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4392 if let Some(lifetime) = lifetimes.get(i) {
4393 AstConv::ast_region_to_region(self, lifetime, Some(def))
4395 self.re_infer(span, Some(def)).unwrap()
4398 let mut i = def.index as usize;
4400 let segment = if i < fn_start {
4401 // Handle Self first, so we can adjust the index to match the AST.
4402 if has_self && i == 0 {
4403 return opt_self_ty.unwrap_or_else(|| {
4404 self.type_var_for_def(span, def, substs)
4407 i -= has_self as usize;
4413 let (types, infer_types) = match segment.map(|(s, _)| &s.parameters) {
4414 Some(&hir::AngleBracketedParameters(ref data)) => {
4415 (&data.types[..], data.infer_types)
4417 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4418 None => (&[][..], true)
4421 // Skip over the lifetimes in the same segment.
4422 if let Some((_, generics)) = segment {
4423 i -= generics.regions.len();
4426 if let Some(ast_ty) = types.get(i) {
4427 // A provided type parameter.
4429 } else if !infer_types && def.has_default {
4430 // No type parameter provided, but a default exists.
4431 let default = self.tcx.type_of(def.def_id);
4434 default.subst_spanned(self.tcx, substs, Some(span))
4437 // No type parameters were provided, we can infer all.
4438 // This can also be reached in some error cases:
4439 // We prefer to use inference variables instead of
4440 // TyError to let type inference recover somewhat.
4441 self.type_var_for_def(span, def, substs)
4445 // The things we are substituting into the type should not contain
4446 // escaping late-bound regions, and nor should the base type scheme.
4447 let ty = self.tcx.type_of(def.def_id());
4448 assert!(!substs.has_escaping_regions());
4449 assert!(!ty.has_escaping_regions());
4451 // Add all the obligations that are required, substituting and
4452 // normalized appropriately.
4453 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4454 self.add_obligations_for_parameters(
4455 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4458 // Substitute the values for the type parameters into the type of
4459 // the referenced item.
4460 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4462 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4463 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4464 // is inherent, there is no `Self` parameter, instead, the impl needs
4465 // type parameters, which we can infer by unifying the provided `Self`
4466 // with the substituted impl type.
4467 let ty = self.tcx.type_of(impl_def_id);
4469 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4470 match self.sub_types(false, &self.misc(span), self_ty, impl_ty) {
4471 Ok(ok) => self.register_infer_ok_obligations(ok),
4474 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4481 debug!("instantiate_value_path: type of {:?} is {:?}",
4484 self.write_substs(node_id, ty::ItemSubsts {
4490 /// Report errors if the provided parameters are too few or too many.
4491 fn check_path_parameter_count(&self,
4493 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
4494 let (lifetimes, types, infer_types, bindings) = {
4495 match segment.map(|(s, _)| &s.parameters) {
4496 Some(&hir::AngleBracketedParameters(ref data)) => {
4497 (&data.lifetimes[..], &data.types[..], data.infer_types, &data.bindings[..])
4499 Some(&hir::ParenthesizedParameters(_)) => {
4500 span_bug!(span, "parenthesized parameters cannot appear in ExprPath");
4502 None => (&[][..], &[][..], true, &[][..])
4506 let count_lifetime_params = |n| {
4507 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4509 let count_type_params = |n| {
4510 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4513 // Check provided lifetime parameters.
4514 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4515 if lifetimes.len() > lifetime_defs.len() {
4516 let expected_text = count_lifetime_params(lifetime_defs.len());
4517 let actual_text = count_lifetime_params(lifetimes.len());
4518 struct_span_err!(self.tcx.sess, span, E0088,
4519 "too many lifetime parameters provided: \
4520 expected at most {}, found {}",
4521 expected_text, actual_text)
4522 .span_label(span, &format!("expected {}", expected_text))
4524 } else if lifetimes.len() > 0 && lifetimes.len() < lifetime_defs.len() {
4525 let expected_text = count_lifetime_params(lifetime_defs.len());
4526 let actual_text = count_lifetime_params(lifetimes.len());
4527 struct_span_err!(self.tcx.sess, span, E0090,
4528 "too few lifetime parameters provided: \
4529 expected {}, found {}",
4530 expected_text, actual_text)
4531 .span_label(span, &format!("expected {}", expected_text))
4535 // The case where there is not enough lifetime parameters is not checked,
4536 // because this is not possible - a function never takes lifetime parameters.
4537 // See discussion for Pull Request 36208.
4539 // Check provided type parameters.
4540 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4541 if generics.parent.is_none() {
4542 &generics.types[generics.has_self as usize..]
4547 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4548 if types.len() > type_defs.len() {
4549 let span = types[type_defs.len()].span;
4550 let expected_text = count_type_params(type_defs.len());
4551 let actual_text = count_type_params(types.len());
4552 struct_span_err!(self.tcx.sess, span, E0087,
4553 "too many type parameters provided: \
4554 expected at most {}, found {}",
4555 expected_text, actual_text)
4556 .span_label(span, &format!("expected {}", expected_text))
4559 // To prevent derived errors to accumulate due to extra
4560 // type parameters, we force instantiate_value_path to
4561 // use inference variables instead of the provided types.
4563 } else if !infer_types && types.len() < required_len {
4564 let expected_text = count_type_params(required_len);
4565 let actual_text = count_type_params(types.len());
4566 struct_span_err!(self.tcx.sess, span, E0089,
4567 "too few type parameters provided: \
4568 expected {}, found {}",
4569 expected_text, actual_text)
4570 .span_label(span, &format!("expected {}", expected_text))
4574 if !bindings.is_empty() {
4575 span_err!(self.tcx.sess, bindings[0].span, E0182,
4576 "unexpected binding of associated item in expression path \
4577 (only allowed in type paths)");
4581 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4583 where F: Fn() -> Ty<'tcx>
4585 let mut ty = self.resolve_type_vars_with_obligations(ty);
4588 let alternative = f();
4591 if alternative.is_ty_var() || alternative.references_error() {
4592 if !self.is_tainted_by_errors() {
4593 self.type_error_message(sp, |_actual| {
4594 "the type of this value must be known in this context".to_string()
4597 self.demand_suptype(sp, self.tcx.types.err, ty);
4598 ty = self.tcx.types.err;
4600 self.demand_suptype(sp, alternative, ty);
4608 // Resolves `typ` by a single level if `typ` is a type variable. If no
4609 // resolution is possible, then an error is reported.
4610 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4611 self.structurally_resolve_type_or_else(sp, ty, || {
4616 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4617 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4618 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4621 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4622 index = enclosing_breakables.stack.len();
4623 enclosing_breakables.by_id.insert(id, index);
4624 enclosing_breakables.stack.push(ctxt);
4628 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4629 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4630 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4631 enclosing_breakables.stack.pop().expect("missing breakable context")
4637 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
4638 generics: &hir::Generics,
4640 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
4641 generics.ty_params.len(), ty);
4643 // make a vector of booleans initially false, set to true when used
4644 if generics.ty_params.is_empty() { return; }
4645 let mut tps_used = vec![false; generics.ty_params.len()];
4647 for leaf_ty in ty.walk() {
4648 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
4649 debug!("Found use of ty param num {}", idx);
4650 tps_used[idx as usize - generics.lifetimes.len()] = true;
4654 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
4656 struct_span_err!(tcx.sess, param.span, E0091,
4657 "type parameter `{}` is unused",
4659 .span_label(param.span, &format!("unused type parameter"))