1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 n.b.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
92 use namespace::Namespace;
93 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
94 use rustc::infer::anon_types::AnonTypeDecl;
95 use rustc::infer::type_variable::{TypeVariableOrigin};
96 use rustc::middle::region;
97 use rustc::mir::interpret::{GlobalId};
98 use rustc::ty::subst::{UnpackedKind, Subst, Substs};
99 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
100 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
101 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
102 use rustc::ty::fold::TypeFoldable;
103 use rustc::ty::query::Providers;
104 use rustc::ty::util::{Representability, IntTypeExt, Discr};
105 use errors::{DiagnosticBuilder, DiagnosticId};
106 use rustc_data_structures::accumulate_vec::AccumulateVec;
107 use rustc_data_structures::array_vec::ArrayVec;
109 use require_c_abi_if_variadic;
110 use session::{CompileIncomplete, config, Session};
113 use util::common::{ErrorReported, indenter};
114 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
116 use std::cell::{Cell, RefCell, Ref, RefMut};
117 use rustc_data_structures::sync::Lrc;
118 use std::collections::{hash_map::Entry, HashSet};
120 use std::fmt::Display;
122 use std::mem::replace;
123 use std::ops::{self, Deref};
124 use rustc_target::spec::abi::Abi;
127 use syntax::codemap::original_sp;
128 use syntax::feature_gate::{GateIssue, emit_feature_err};
130 use syntax::symbol::{Symbol, LocalInternedString, keywords};
131 use syntax::util::lev_distance::find_best_match_for_name;
132 use syntax_pos::{self, BytePos, Span, MultiSpan};
134 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
135 use rustc::hir::itemlikevisit::ItemLikeVisitor;
136 use rustc::hir::map::Node;
137 use rustc::hir::{self, PatKind, ItemKind};
138 use rustc::middle::lang_items;
154 mod generator_interior;
158 /// A wrapper for InferCtxt's `in_progress_tables` field.
159 #[derive(Copy, Clone)]
160 struct MaybeInProgressTables<'a, 'tcx: 'a> {
161 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
164 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
165 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
166 match self.maybe_tables {
167 Some(tables) => tables.borrow(),
169 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
174 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
175 match self.maybe_tables {
176 Some(tables) => tables.borrow_mut(),
178 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
185 /// closures defined within the function. For example:
188 /// bar(move|| { ... })
191 /// Here, the function `foo()` and the closure passed to
192 /// `bar()` will each have their own `FnCtxt`, but they will
193 /// share the inherited fields.
194 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
195 infcx: InferCtxt<'a, 'gcx, 'tcx>,
197 tables: MaybeInProgressTables<'a, 'tcx>,
199 locals: RefCell<NodeMap<Ty<'tcx>>>,
201 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
203 // When we process a call like `c()` where `c` is a closure type,
204 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
205 // `FnOnce` closure. In that case, we defer full resolution of the
206 // call until upvar inference can kick in and make the
207 // decision. We keep these deferred resolutions grouped by the
208 // def-id of the closure, so that once we decide, we can easily go
209 // back and process them.
210 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
212 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
214 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
216 // Anonymized types found in explicit return types and their
217 // associated fresh inference variable. Writeback resolves these
218 // variables to get the concrete type, which can be used to
219 // deanonymize TyAnon, after typeck is done with all functions.
220 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
222 /// Each type parameter has an implicit region bound that
223 /// indicates it must outlive at least the function body (the user
224 /// may specify stronger requirements). This field indicates the
225 /// region of the callee. If it is `None`, then the parameter
226 /// environment is for an item or something where the "callee" is
228 implicit_region_bound: Option<ty::Region<'tcx>>,
230 body_id: Option<hir::BodyId>,
233 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
234 type Target = InferCtxt<'a, 'gcx, 'tcx>;
235 fn deref(&self) -> &Self::Target {
240 /// When type-checking an expression, we propagate downward
241 /// whatever type hint we are able in the form of an `Expectation`.
242 #[derive(Copy, Clone, Debug)]
243 pub enum Expectation<'tcx> {
244 /// We know nothing about what type this expression should have.
247 /// This expression is an `if` condition, it must resolve to `bool`.
250 /// This expression should have the type given (or some subtype)
251 ExpectHasType(Ty<'tcx>),
253 /// This expression will be cast to the `Ty`
254 ExpectCastableToType(Ty<'tcx>),
256 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
257 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
258 ExpectRvalueLikeUnsized(Ty<'tcx>),
261 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
262 // Disregard "castable to" expectations because they
263 // can lead us astray. Consider for example `if cond
264 // {22} else {c} as u8` -- if we propagate the
265 // "castable to u8" constraint to 22, it will pick the
266 // type 22u8, which is overly constrained (c might not
267 // be a u8). In effect, the problem is that the
268 // "castable to" expectation is not the tightest thing
269 // we can say, so we want to drop it in this case.
270 // The tightest thing we can say is "must unify with
271 // else branch". Note that in the case of a "has type"
272 // constraint, this limitation does not hold.
274 // If the expected type is just a type variable, then don't use
275 // an expected type. Otherwise, we might write parts of the type
276 // when checking the 'then' block which are incompatible with the
278 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
280 ExpectHasType(ety) => {
281 let ety = fcx.shallow_resolve(ety);
282 if !ety.is_ty_var() {
288 ExpectRvalueLikeUnsized(ety) => {
289 ExpectRvalueLikeUnsized(ety)
295 /// Provide an expectation for an rvalue expression given an *optional*
296 /// hint, which is not required for type safety (the resulting type might
297 /// be checked higher up, as is the case with `&expr` and `box expr`), but
298 /// is useful in determining the concrete type.
300 /// The primary use case is where the expected type is a fat pointer,
301 /// like `&[isize]`. For example, consider the following statement:
303 /// let x: &[isize] = &[1, 2, 3];
305 /// In this case, the expected type for the `&[1, 2, 3]` expression is
306 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
307 /// expectation `ExpectHasType([isize])`, that would be too strong --
308 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
309 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
310 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
311 /// which still is useful, because it informs integer literals and the like.
312 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
313 /// for examples of where this comes up,.
314 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
315 match fcx.tcx.struct_tail(ty).sty {
316 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
317 ExpectRvalueLikeUnsized(ty)
319 _ => ExpectHasType(ty)
323 // Resolves `expected` by a single level if it is a variable. If
324 // there is no expected type or resolution is not possible (e.g.,
325 // no constraints yet present), just returns `None`.
326 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
328 NoExpectation => NoExpectation,
329 ExpectIfCondition => ExpectIfCondition,
330 ExpectCastableToType(t) => {
331 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
333 ExpectHasType(t) => {
334 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
336 ExpectRvalueLikeUnsized(t) => {
337 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
342 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
343 match self.resolve(fcx) {
344 NoExpectation => None,
345 ExpectIfCondition => Some(fcx.tcx.types.bool),
346 ExpectCastableToType(ty) |
348 ExpectRvalueLikeUnsized(ty) => Some(ty),
352 /// It sometimes happens that we want to turn an expectation into
353 /// a **hard constraint** (i.e., something that must be satisfied
354 /// for the program to type-check). `only_has_type` will return
355 /// such a constraint, if it exists.
356 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
357 match self.resolve(fcx) {
358 ExpectHasType(ty) => Some(ty),
359 ExpectIfCondition => Some(fcx.tcx.types.bool),
360 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
364 /// Like `only_has_type`, but instead of returning `None` if no
365 /// hard constraint exists, creates a fresh type variable.
366 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
367 self.only_has_type(fcx)
368 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
372 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
379 fn maybe_mut_place(m: hir::Mutability) -> Self {
381 hir::MutMutable => Needs::MutPlace,
382 hir::MutImmutable => Needs::None,
387 #[derive(Copy, Clone)]
388 pub struct UnsafetyState {
389 pub def: ast::NodeId,
390 pub unsafety: hir::Unsafety,
391 pub unsafe_push_count: u32,
396 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
397 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
400 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
401 match self.unsafety {
402 // If this unsafe, then if the outer function was already marked as
403 // unsafe we shouldn't attribute the unsafe'ness to the block. This
404 // way the block can be warned about instead of ignoring this
405 // extraneous block (functions are never warned about).
406 hir::Unsafety::Unsafe if self.from_fn => *self,
409 let (unsafety, def, count) = match blk.rules {
410 hir::PushUnsafeBlock(..) =>
411 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
412 hir::PopUnsafeBlock(..) =>
413 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
414 hir::UnsafeBlock(..) =>
415 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
417 (unsafety, self.def, self.unsafe_push_count),
421 unsafe_push_count: count,
428 #[derive(Debug, Copy, Clone)]
434 /// Tracks whether executing a node may exit normally (versus
435 /// return/break/panic, which "diverge", leaving dead code in their
436 /// wake). Tracked semi-automatically (through type variables marked
437 /// as diverging), with some manual adjustments for control-flow
438 /// primitives (approximating a CFG).
439 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
441 /// Potentially unknown, some cases converge,
442 /// others require a CFG to determine them.
445 /// Definitely known to diverge and therefore
446 /// not reach the next sibling or its parent.
449 /// Same as `Always` but with a reachability
450 /// warning already emitted
454 // Convenience impls for combinig `Diverges`.
456 impl ops::BitAnd for Diverges {
458 fn bitand(self, other: Self) -> Self {
459 cmp::min(self, other)
463 impl ops::BitOr for Diverges {
465 fn bitor(self, other: Self) -> Self {
466 cmp::max(self, other)
470 impl ops::BitAndAssign for Diverges {
471 fn bitand_assign(&mut self, other: Self) {
472 *self = *self & other;
476 impl ops::BitOrAssign for Diverges {
477 fn bitor_assign(&mut self, other: Self) {
478 *self = *self | other;
483 fn always(self) -> bool {
484 self >= Diverges::Always
488 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
491 // this is `null` for loops where break with a value is illegal,
492 // such as `while`, `for`, and `while let`
493 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
496 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
497 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
498 by_id: NodeMap<usize>,
501 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
502 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
503 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
504 bug!("could not find enclosing breakable with id {}", target_id);
511 struct PathSeg(DefId, usize);
513 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
514 body_id: ast::NodeId,
516 /// The parameter environment used for proving trait obligations
517 /// in this function. This can change when we descend into
518 /// closures (as they bring new things into scope), hence it is
519 /// not part of `Inherited` (as of the time of this writing,
520 /// closures do not yet change the environment, but they will
522 param_env: ty::ParamEnv<'tcx>,
524 // Number of errors that had been reported when we started
525 // checking this function. On exit, if we find that *more* errors
526 // have been reported, we will skip regionck and other work that
527 // expects the types within the function to be consistent.
528 err_count_on_creation: usize,
530 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
532 yield_ty: Option<Ty<'tcx>>,
534 ps: RefCell<UnsafetyState>,
536 /// Whether the last checked node generates a divergence (e.g.,
537 /// `return` will set this to Always). In general, when entering
538 /// an expression or other node in the tree, the initial value
539 /// indicates whether prior parts of the containing expression may
540 /// have diverged. It is then typically set to `Maybe` (and the
541 /// old value remembered) for processing the subparts of the
542 /// current expression. As each subpart is processed, they may set
543 /// the flag to `Always` etc. Finally, at the end, we take the
544 /// result and "union" it with the original value, so that when we
545 /// return the flag indicates if any subpart of the the parent
546 /// expression (up to and including this part) has diverged. So,
547 /// if you read it after evaluating a subexpression `X`, the value
548 /// you get indicates whether any subexpression that was
549 /// evaluating up to and including `X` diverged.
551 /// We currently use this flag only for diagnostic purposes:
553 /// - To warn about unreachable code: if, after processing a
554 /// sub-expression but before we have applied the effects of the
555 /// current node, we see that the flag is set to `Always`, we
556 /// can issue a warning. This corresponds to something like
557 /// `foo(return)`; we warn on the `foo()` expression. (We then
558 /// update the flag to `WarnedAlways` to suppress duplicate
559 /// reports.) Similarly, if we traverse to a fresh statement (or
560 /// tail expression) from a `Always` setting, we will issue a
561 /// warning. This corresponds to something like `{return;
562 /// foo();}` or `{return; 22}`, where we would warn on the
565 /// An expression represents dead-code if, after checking it,
566 /// the diverges flag is set to something other than `Maybe`.
567 diverges: Cell<Diverges>,
569 /// Whether any child nodes have any type errors.
570 has_errors: Cell<bool>,
572 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
574 inh: &'a Inherited<'a, 'gcx, 'tcx>,
577 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
578 type Target = Inherited<'a, 'gcx, 'tcx>;
579 fn deref(&self) -> &Self::Target {
584 /// Helper type of a temporary returned by Inherited::build(...).
585 /// Necessary because we can't write the following bound:
586 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
587 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
588 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
592 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
593 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
594 -> InheritedBuilder<'a, 'gcx, 'tcx> {
595 let hir_id_root = if def_id.is_local() {
596 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
597 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
598 DefId::local(hir_id.owner)
604 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
610 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
611 fn enter<F, R>(&'tcx mut self, f: F) -> R
612 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
614 let def_id = self.def_id;
615 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
619 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
620 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
622 let item_id = tcx.hir.as_local_node_id(def_id);
623 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
624 let implicit_region_bound = body_id.map(|body_id| {
625 let body = tcx.hir.body(body_id);
626 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
630 tables: MaybeInProgressTables {
631 maybe_tables: infcx.in_progress_tables,
634 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
635 locals: RefCell::new(NodeMap()),
636 deferred_call_resolutions: RefCell::new(DefIdMap()),
637 deferred_cast_checks: RefCell::new(Vec::new()),
638 deferred_generator_interiors: RefCell::new(Vec::new()),
639 anon_types: RefCell::new(DefIdMap()),
640 implicit_region_bound,
645 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
646 debug!("register_predicate({:?})", obligation);
647 if obligation.has_escaping_regions() {
648 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
653 .register_predicate_obligation(self, obligation);
656 fn register_predicates<I>(&self, obligations: I)
657 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
658 for obligation in obligations {
659 self.register_predicate(obligation);
663 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
664 self.register_predicates(infer_ok.obligations);
668 fn normalize_associated_types_in<T>(&self,
670 body_id: ast::NodeId,
671 param_env: ty::ParamEnv<'tcx>,
673 where T : TypeFoldable<'tcx>
675 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
676 self.register_infer_ok_obligations(ok)
680 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
682 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
683 fn visit_item(&mut self, i: &'tcx hir::Item) {
684 check_item_type(self.tcx, i);
686 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
687 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
690 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
691 tcx.sess.track_errors(|| {
692 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
693 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
697 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
698 tcx.sess.track_errors(|| {
699 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
703 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
704 tcx.typeck_item_bodies(LOCAL_CRATE)
707 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
708 -> Result<(), CompileIncomplete>
710 debug_assert!(crate_num == LOCAL_CRATE);
711 Ok(tcx.sess.track_errors(|| {
712 tcx.par_body_owners(|body_owner_def_id| {
713 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
718 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
719 wfcheck::check_item_well_formed(tcx, def_id);
722 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
723 wfcheck::check_trait_item(tcx, def_id);
726 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
727 wfcheck::check_impl_item(tcx, def_id);
730 pub fn provide(providers: &mut Providers) {
731 method::provide(providers);
732 *providers = Providers {
738 check_item_well_formed,
739 check_trait_item_well_formed,
740 check_impl_item_well_formed,
745 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
747 -> Option<ty::Destructor> {
748 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
751 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
752 /// with information about it's body-id and fn-decl (if any). Otherwise,
755 /// If this function returns "some", then `typeck_tables(def_id)` will
756 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
757 /// may not succeed. In some cases where this function returns `None`
758 /// (notably closures), `typeck_tables(def_id)` would wind up
759 /// redirecting to the owning function.
760 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
762 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
764 match tcx.hir.get(id) {
765 hir::map::NodeItem(item) => {
767 hir::ItemKind::Const(_, body) |
768 hir::ItemKind::Static(_, _, body) =>
770 hir::ItemKind::Fn(ref decl, .., body) =>
771 Some((body, Some(decl))),
776 hir::map::NodeTraitItem(item) => {
778 hir::TraitItemKind::Const(_, Some(body)) =>
780 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
781 Some((body, Some(&sig.decl))),
786 hir::map::NodeImplItem(item) => {
788 hir::ImplItemKind::Const(_, body) =>
790 hir::ImplItemKind::Method(ref sig, body) =>
791 Some((body, Some(&sig.decl))),
796 hir::map::NodeAnonConst(constant) => Some((constant.body, None)),
801 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
804 // Closures' tables come from their outermost function,
805 // as they are part of the same "inference environment".
806 let outer_def_id = tcx.closure_base_def_id(def_id);
807 if outer_def_id != def_id {
808 return tcx.has_typeck_tables(outer_def_id);
811 let id = tcx.hir.as_local_node_id(def_id).unwrap();
812 primary_body_of(tcx, id).is_some()
815 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
818 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
821 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
823 -> &'tcx ty::TypeckTables<'tcx> {
824 // Closures' tables come from their outermost function,
825 // as they are part of the same "inference environment".
826 let outer_def_id = tcx.closure_base_def_id(def_id);
827 if outer_def_id != def_id {
828 return tcx.typeck_tables_of(outer_def_id);
831 let id = tcx.hir.as_local_node_id(def_id).unwrap();
832 let span = tcx.hir.span(id);
834 // Figure out what primary body this item has.
835 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
836 span_bug!(span, "can't type-check body of {:?}", def_id);
838 let body = tcx.hir.body(body_id);
840 let tables = Inherited::build(tcx, def_id).enter(|inh| {
841 let param_env = tcx.param_env(def_id);
842 let fcx = if let Some(decl) = fn_decl {
843 let fn_sig = tcx.fn_sig(def_id);
845 check_abi(tcx, span, fn_sig.abi());
847 // Compute the fty from point of view of inside fn.
849 tcx.liberate_late_bound_regions(def_id, &fn_sig);
851 inh.normalize_associated_types_in(body.value.span,
856 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
859 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
860 let expected_type = tcx.type_of(def_id);
861 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
862 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
864 // Gather locals in statics (because of block expressions).
865 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
867 fcx.check_expr_coercable_to_type(&body.value, expected_type);
872 // All type checking constraints were added, try to fallback unsolved variables.
873 fcx.select_obligations_where_possible(false);
874 let mut fallback_has_occurred = false;
875 for ty in &fcx.unsolved_variables() {
876 fallback_has_occurred |= fcx.fallback_if_possible(ty);
878 fcx.select_obligations_where_possible(fallback_has_occurred);
880 // Even though coercion casts provide type hints, we check casts after fallback for
881 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
884 // Closure and generater analysis may run after fallback
885 // because they don't constrain other type variables.
886 fcx.closure_analyze(body);
887 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
888 fcx.resolve_generator_interiors(def_id);
889 fcx.select_all_obligations_or_error();
891 if fn_decl.is_some() {
892 fcx.regionck_fn(id, body);
894 fcx.regionck_expr(body);
897 fcx.resolve_type_vars_in_body(body)
900 // Consistency check our TypeckTables instance can hold all ItemLocalIds
901 // it will need to hold.
902 assert_eq!(tables.local_id_root,
903 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
907 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
908 if !tcx.sess.target.target.is_abi_supported(abi) {
909 struct_span_err!(tcx.sess, span, E0570,
910 "The ABI `{}` is not supported for the current target", abi).emit()
914 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
915 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
918 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
919 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
922 // infer the variable's type
923 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
924 self.fcx.locals.borrow_mut().insert(nid, var_ty);
928 // take type that the user specified
929 self.fcx.locals.borrow_mut().insert(nid, typ);
936 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
937 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
938 NestedVisitorMap::None
941 // Add explicitly-declared locals.
942 fn visit_local(&mut self, local: &'gcx hir::Local) {
943 let o_ty = match local.ty {
945 let o_ty = self.fcx.to_ty(&ty);
947 let c_ty = self.fcx.inh.infcx.canonicalize_response(&o_ty);
948 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
949 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
955 self.assign(local.span, local.id, o_ty);
957 debug!("Local variable {:?} is assigned type {}",
959 self.fcx.ty_to_string(
960 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
961 intravisit::walk_local(self, local);
964 // Add pattern bindings.
965 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
966 if let PatKind::Binding(_, _, ident, _) = p.node {
967 let var_ty = self.assign(p.span, p.id, None);
969 if !self.fcx.tcx.features().unsized_locals {
970 self.fcx.require_type_is_sized(var_ty, p.span,
971 traits::VariableType(p.id));
974 debug!("Pattern binding {} is assigned to {} with type {:?}",
976 self.fcx.ty_to_string(
977 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
980 intravisit::walk_pat(self, p);
983 // Don't descend into the bodies of nested closures
984 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
985 _: hir::BodyId, _: Span, _: ast::NodeId) { }
988 /// When `check_fn` is invoked on a generator (i.e., a body that
989 /// includes yield), it returns back some information about the yield
991 struct GeneratorTypes<'tcx> {
992 /// Type of value that is yielded.
993 yield_ty: ty::Ty<'tcx>,
995 /// Types that are captured (see `GeneratorInterior` for more).
996 interior: ty::Ty<'tcx>,
998 /// Indicates if the generator is movable or static (immovable)
999 movability: hir::GeneratorMovability,
1002 /// Helper used for fns and closures. Does the grungy work of checking a function
1003 /// body and returns the function context used for that purpose, since in the case of a fn item
1004 /// there is still a bit more to do.
1007 /// * inherited: other fields inherited from the enclosing fn (if any)
1008 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1009 param_env: ty::ParamEnv<'tcx>,
1010 fn_sig: ty::FnSig<'tcx>,
1011 decl: &'gcx hir::FnDecl,
1013 body: &'gcx hir::Body,
1014 can_be_generator: Option<hir::GeneratorMovability>)
1015 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1017 let mut fn_sig = fn_sig.clone();
1019 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1021 // Create the function context. This is either derived from scratch or,
1022 // in the case of closures, based on the outer context.
1023 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1024 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1026 let declared_ret_ty = fn_sig.output();
1027 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1028 let revealed_ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &declared_ret_ty);
1029 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1030 fn_sig = fcx.tcx.mk_fn_sig(
1031 fn_sig.inputs().iter().cloned(),
1038 let span = body.value.span;
1040 if body.is_generator && can_be_generator.is_some() {
1041 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1042 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1043 fcx.yield_ty = Some(yield_ty);
1046 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1048 // Add formal parameters.
1049 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1050 // Check the pattern.
1051 fcx.check_pat_walk(&arg.pat, arg_ty,
1052 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1054 // Check that argument is Sized.
1055 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1056 // for simple cases like `fn foo(x: Trait)`,
1057 // where we would error once on the parameter as a whole, and once on the binding `x`.
1058 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1059 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1062 fcx.write_ty(arg.hir_id, arg_ty);
1065 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1066 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1068 fcx.check_return_expr(&body.value);
1070 // We insert the deferred_generator_interiors entry after visiting the body.
1071 // This ensures that all nested generators appear before the entry of this generator.
1072 // resolve_generator_interiors relies on this property.
1073 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1074 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1075 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1076 Some(GeneratorTypes {
1077 yield_ty: fcx.yield_ty.unwrap(),
1079 movability: can_be_generator.unwrap(),
1085 // Finalize the return check by taking the LUB of the return types
1086 // we saw and assigning it to the expected return type. This isn't
1087 // really expected to fail, since the coercions would have failed
1088 // earlier when trying to find a LUB.
1090 // However, the behavior around `!` is sort of complex. In the
1091 // event that the `actual_return_ty` comes back as `!`, that
1092 // indicates that the fn either does not return or "returns" only
1093 // values of type `!`. In this case, if there is an expected
1094 // return type that is *not* `!`, that should be ok. But if the
1095 // return type is being inferred, we want to "fallback" to `!`:
1097 // let x = move || panic!();
1099 // To allow for that, I am creating a type variable with diverging
1100 // fallback. This was deemed ever so slightly better than unifying
1101 // the return value with `!` because it allows for the caller to
1102 // make more assumptions about the return type (e.g., they could do
1104 // let y: Option<u32> = Some(x());
1106 // which would then cause this return type to become `u32`, not
1108 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1109 let mut actual_return_ty = coercion.complete(&fcx);
1110 if actual_return_ty.is_never() {
1111 actual_return_ty = fcx.next_diverging_ty_var(
1112 TypeVariableOrigin::DivergingFn(span));
1114 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1116 // Check that the main return type implements the termination trait.
1117 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1118 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1121 config::EntryFnType::Main => {
1122 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1123 let trait_ref = ty::TraitRef::new(term_id, substs);
1124 let return_ty_span = decl.output.span();
1125 let cause = traits::ObligationCause::new(
1126 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1128 inherited.register_predicate(
1129 traits::Obligation::new(
1130 cause, param_env, trait_ref.to_predicate()));
1132 config::EntryFnType::Start => {},
1138 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1139 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1140 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1141 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1142 if declared_ret_ty.sty != ty::TyNever {
1143 fcx.tcx.sess.span_err(
1145 "return type should be `!`",
1149 let inputs = fn_sig.inputs();
1150 let span = fcx.tcx.hir.span(fn_id);
1151 if inputs.len() == 1 {
1152 let arg_is_panic_info = match inputs[0].sty {
1153 ty::TyRef(region, ty, mutbl) => match ty.sty {
1154 ty::TyAdt(ref adt, _) => {
1155 adt.did == panic_info_did &&
1156 mutbl == hir::Mutability::MutImmutable &&
1157 *region != RegionKind::ReStatic
1164 if !arg_is_panic_info {
1165 fcx.tcx.sess.span_err(
1166 decl.inputs[0].span,
1167 "argument should be `&PanicInfo`",
1171 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1172 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1173 if !generics.params.is_empty() {
1174 fcx.tcx.sess.span_err(
1176 "`#[panic_implementation]` function should have no type \
1183 fcx.tcx.sess.span_err(span, "function should have one argument");
1186 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1191 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1192 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1193 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1194 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1195 if declared_ret_ty.sty != ty::TyNever {
1196 fcx.tcx.sess.span_err(
1198 "return type should be `!`",
1202 let inputs = fn_sig.inputs();
1203 let span = fcx.tcx.hir.span(fn_id);
1204 if inputs.len() == 1 {
1205 let arg_is_alloc_layout = match inputs[0].sty {
1206 ty::TyAdt(ref adt, _) => {
1207 adt.did == alloc_layout_did
1212 if !arg_is_alloc_layout {
1213 fcx.tcx.sess.span_err(
1214 decl.inputs[0].span,
1215 "argument should be `Layout`",
1219 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1220 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1221 if !generics.params.is_empty() {
1222 fcx.tcx.sess.span_err(
1224 "`#[alloc_error_handler]` function should have no type \
1231 fcx.tcx.sess.span_err(span, "function should have one argument");
1234 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1242 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1245 let def_id = tcx.hir.local_def_id(id);
1246 let def = tcx.adt_def(def_id);
1247 def.destructor(tcx); // force the destructor to be evaluated
1248 check_representable(tcx, span, def_id);
1250 if def.repr.simd() {
1251 check_simd(tcx, span, def_id);
1254 check_transparent(tcx, span, def_id);
1255 check_packed(tcx, span, def_id);
1258 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1261 let def_id = tcx.hir.local_def_id(id);
1262 let def = tcx.adt_def(def_id);
1263 def.destructor(tcx); // force the destructor to be evaluated
1264 check_representable(tcx, span, def_id);
1266 check_packed(tcx, span, def_id);
1269 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1270 debug!("check_item_type(it.id={}, it.name={})",
1272 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1273 let _indenter = indenter();
1275 // Consts can play a role in type-checking, so they are included here.
1276 hir::ItemKind::Static(..) => {
1277 let def_id = tcx.hir.local_def_id(it.id);
1278 tcx.typeck_tables_of(def_id);
1279 maybe_check_static_with_link_section(tcx, def_id, it.span);
1281 hir::ItemKind::Const(..) => {
1282 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1284 hir::ItemKind::Enum(ref enum_definition, _) => {
1287 &enum_definition.variants,
1290 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1291 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1292 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1293 let impl_def_id = tcx.hir.local_def_id(it.id);
1294 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1295 check_impl_items_against_trait(tcx,
1300 let trait_def_id = impl_trait_ref.def_id;
1301 check_on_unimplemented(tcx, trait_def_id, it);
1304 hir::ItemKind::Trait(..) => {
1305 let def_id = tcx.hir.local_def_id(it.id);
1306 check_on_unimplemented(tcx, def_id, it);
1308 hir::ItemKind::Struct(..) => {
1309 check_struct(tcx, it.id, it.span);
1311 hir::ItemKind::Union(..) => {
1312 check_union(tcx, it.id, it.span);
1314 hir::ItemKind::Existential(..) |
1315 hir::ItemKind::Ty(..) => {
1316 let def_id = tcx.hir.local_def_id(it.id);
1317 let pty_ty = tcx.type_of(def_id);
1318 let generics = tcx.generics_of(def_id);
1319 check_bounds_are_used(tcx, &generics, pty_ty);
1321 hir::ItemKind::ForeignMod(ref m) => {
1322 check_abi(tcx, it.span, m.abi);
1324 if m.abi == Abi::RustIntrinsic {
1325 for item in &m.items {
1326 intrinsic::check_intrinsic_type(tcx, item);
1328 } else if m.abi == Abi::PlatformIntrinsic {
1329 for item in &m.items {
1330 intrinsic::check_platform_intrinsic_type(tcx, item);
1333 for item in &m.items {
1334 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1335 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1336 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1337 "foreign items may not have type parameters");
1338 err.span_label(item.span, "can't have type parameters");
1339 // FIXME: once we start storing spans for type arguments, turn this into a
1341 err.help("use specialization instead of type parameters by replacing them \
1342 with concrete types like `u32`");
1346 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1347 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1352 _ => {/* nothing to do */ }
1356 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1357 // Only restricted on wasm32 target for now
1358 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1362 // If `#[link_section]` is missing, then nothing to verify
1363 let attrs = tcx.codegen_fn_attrs(id);
1364 if attrs.link_section.is_none() {
1368 // For the wasm32 target statics with #[link_section] are placed into custom
1369 // sections of the final output file, but this isn't link custom sections of
1370 // other executable formats. Namely we can only embed a list of bytes,
1371 // nothing with pointers to anything else or relocations. If any relocation
1372 // show up, reject them here.
1373 let instance = ty::Instance::mono(tcx, id);
1374 let cid = GlobalId {
1378 let param_env = ty::ParamEnv::reveal_all();
1379 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1380 let alloc = tcx.const_value_to_allocation(static_);
1381 if alloc.relocations.len() != 0 {
1382 let msg = "statics with a custom `#[link_section]` must be a \
1383 simple list of bytes on the wasm target with no \
1384 extra levels of indirection such as references";
1385 tcx.sess.span_err(span, msg);
1390 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1391 trait_def_id: DefId,
1393 let item_def_id = tcx.hir.local_def_id(item.id);
1394 // an error would be reported if this fails.
1395 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1398 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1399 impl_item: &hir::ImplItem,
1402 let mut err = struct_span_err!(
1403 tcx.sess, impl_item.span, E0520,
1404 "`{}` specializes an item from a parent `impl`, but \
1405 that item is not marked `default`",
1407 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1410 match tcx.span_of_impl(parent_impl) {
1412 err.span_label(span, "parent `impl` is here");
1413 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1417 err.note(&format!("parent implementation is in crate `{}`", cname));
1424 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1425 trait_def: &ty::TraitDef,
1426 trait_item: &ty::AssociatedItem,
1428 impl_item: &hir::ImplItem)
1430 let ancestors = trait_def.ancestors(tcx, impl_id);
1432 let kind = match impl_item.node {
1433 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1434 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1435 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1436 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1439 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).skip(1).next()
1440 .map(|node_item| node_item.map(|parent| parent.defaultness));
1442 if let Some(parent) = parent {
1443 if tcx.impl_item_is_final(&parent) {
1444 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1450 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1453 impl_trait_ref: ty::TraitRef<'tcx>,
1454 impl_item_refs: &[hir::ImplItemRef]) {
1455 let impl_span = tcx.sess.codemap().def_span(impl_span);
1457 // If the trait reference itself is erroneous (so the compilation is going
1458 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1459 // isn't populated for such impls.
1460 if impl_trait_ref.references_error() { return; }
1462 // Locate trait definition and items
1463 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1464 let mut overridden_associated_type = None;
1466 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1468 // Check existing impl methods to see if they are both present in trait
1469 // and compatible with trait signature
1470 for impl_item in impl_items() {
1471 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1472 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1473 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1474 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1476 // Not compatible, but needed for the error message
1477 tcx.associated_items(impl_trait_ref.def_id)
1478 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1481 // Check that impl definition matches trait definition
1482 if let Some(ty_trait_item) = ty_trait_item {
1483 match impl_item.node {
1484 hir::ImplItemKind::Const(..) => {
1485 // Find associated const definition.
1486 if ty_trait_item.kind == ty::AssociatedKind::Const {
1487 compare_const_impl(tcx,
1493 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1494 "item `{}` is an associated const, \
1495 which doesn't match its trait `{}`",
1498 err.span_label(impl_item.span, "does not match trait");
1499 // We can only get the spans from local trait definition
1500 // Same for E0324 and E0325
1501 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1502 err.span_label(trait_span, "item in trait");
1507 hir::ImplItemKind::Method(..) => {
1508 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1509 if ty_trait_item.kind == ty::AssociatedKind::Method {
1510 compare_impl_method(tcx,
1517 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1518 "item `{}` is an associated method, \
1519 which doesn't match its trait `{}`",
1522 err.span_label(impl_item.span, "does not match trait");
1523 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1524 err.span_label(trait_span, "item in trait");
1529 hir::ImplItemKind::Existential(..) |
1530 hir::ImplItemKind::Type(_) => {
1531 if ty_trait_item.kind == ty::AssociatedKind::Type {
1532 if ty_trait_item.defaultness.has_value() {
1533 overridden_associated_type = Some(impl_item);
1536 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1537 "item `{}` is an associated type, \
1538 which doesn't match its trait `{}`",
1541 err.span_label(impl_item.span, "does not match trait");
1542 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1543 err.span_label(trait_span, "item in trait");
1550 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1554 // Check for missing items from trait
1555 let mut missing_items = Vec::new();
1556 let mut invalidated_items = Vec::new();
1557 let associated_type_overridden = overridden_associated_type.is_some();
1558 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1559 let is_implemented = trait_def.ancestors(tcx, impl_id)
1560 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1562 .map(|node_item| !node_item.node.is_from_trait())
1565 if !is_implemented && !tcx.impl_is_default(impl_id) {
1566 if !trait_item.defaultness.has_value() {
1567 missing_items.push(trait_item);
1568 } else if associated_type_overridden {
1569 invalidated_items.push(trait_item.ident);
1574 if !missing_items.is_empty() {
1575 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1576 "not all trait items implemented, missing: `{}`",
1577 missing_items.iter()
1578 .map(|trait_item| trait_item.ident.to_string())
1579 .collect::<Vec<_>>().join("`, `"));
1580 err.span_label(impl_span, format!("missing `{}` in implementation",
1581 missing_items.iter()
1582 .map(|trait_item| trait_item.ident.to_string())
1583 .collect::<Vec<_>>().join("`, `")));
1584 for trait_item in missing_items {
1585 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1586 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1588 err.note_trait_signature(trait_item.ident.to_string(),
1589 trait_item.signature(&tcx));
1595 if !invalidated_items.is_empty() {
1596 let invalidator = overridden_associated_type.unwrap();
1597 span_err!(tcx.sess, invalidator.span, E0399,
1598 "the following trait items need to be reimplemented \
1599 as `{}` was overridden: `{}`",
1601 invalidated_items.iter()
1602 .map(|name| name.to_string())
1603 .collect::<Vec<_>>().join("`, `"))
1607 /// Checks whether a type can be represented in memory. In particular, it
1608 /// identifies types that contain themselves without indirection through a
1609 /// pointer, which would mean their size is unbounded.
1610 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1614 let rty = tcx.type_of(item_def_id);
1616 // Check that it is possible to represent this type. This call identifies
1617 // (1) types that contain themselves and (2) types that contain a different
1618 // recursive type. It is only necessary to throw an error on those that
1619 // contain themselves. For case 2, there must be an inner type that will be
1620 // caught by case 1.
1621 match rty.is_representable(tcx, sp) {
1622 Representability::SelfRecursive(spans) => {
1623 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1625 err.span_label(span, "recursive without indirection");
1630 Representability::Representable | Representability::ContainsRecursive => (),
1635 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1636 let t = tcx.type_of(def_id);
1638 ty::TyAdt(def, substs) if def.is_struct() => {
1639 let fields = &def.non_enum_variant().fields;
1640 if fields.is_empty() {
1641 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1644 let e = fields[0].ty(tcx, substs);
1645 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1646 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1647 .span_label(sp, "SIMD elements must have the same type")
1652 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1653 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1655 span_err!(tcx.sess, sp, E0077,
1656 "SIMD vector element type should be machine type");
1665 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1666 let repr = tcx.adt_def(def_id).repr;
1668 for attr in tcx.get_attrs(def_id).iter() {
1669 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1670 if let attr::ReprPacked(pack) = r {
1671 if pack != repr.pack {
1672 struct_span_err!(tcx.sess, sp, E0634,
1673 "type has conflicting packed representation hints").emit();
1679 struct_span_err!(tcx.sess, sp, E0587,
1680 "type has conflicting packed and align representation hints").emit();
1682 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1683 struct_span_err!(tcx.sess, sp, E0588,
1684 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1689 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1691 stack: &mut Vec<DefId>) -> bool {
1692 let t = tcx.type_of(def_id);
1693 if stack.contains(&def_id) {
1694 debug!("check_packed_inner: {:?} is recursive", t);
1698 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1699 if tcx.adt_def(def.did).repr.align > 0 {
1702 // push struct def_id before checking fields
1704 for field in &def.non_enum_variant().fields {
1705 let f = field.ty(tcx, substs);
1707 ty::TyAdt(def, _) => {
1708 if check_packed_inner(tcx, def.did, stack) {
1715 // only need to pop if not early out
1723 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1724 let adt = tcx.adt_def(def_id);
1725 if !adt.repr.transparent() {
1729 // For each field, figure out if it's known to be a ZST and align(1)
1730 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1731 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1732 let param_env = tcx.param_env(field.did);
1733 let layout = tcx.layout_of(param_env.and(ty));
1734 // We are currently checking the type this field came from, so it must be local
1735 let span = tcx.hir.span_if_local(field.did).unwrap();
1736 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1737 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1741 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1742 let non_zst_count = non_zst_fields.clone().count();
1743 if non_zst_count != 1 {
1744 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1745 struct_span_err!(tcx.sess, sp, E0690,
1746 "transparent struct needs exactly one non-zero-sized field, but has {}",
1748 .span_note(field_spans, "non-zero-sized field")
1751 for &(span, zst, align1) in &field_infos {
1753 span_err!(tcx.sess, span, E0691,
1754 "zero-sized field in transparent struct has alignment larger than 1");
1759 #[allow(trivial_numeric_casts)]
1760 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1762 vs: &'tcx [hir::Variant],
1764 let def_id = tcx.hir.local_def_id(id);
1765 let def = tcx.adt_def(def_id);
1766 def.destructor(tcx); // force the destructor to be evaluated
1769 let attributes = tcx.get_attrs(def_id);
1770 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1772 tcx.sess, attr.span, E0084,
1773 "unsupported representation for zero-variant enum")
1774 .span_label(sp, "zero-variant enum")
1779 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1780 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1781 if !tcx.features().repr128 {
1782 emit_feature_err(&tcx.sess.parse_sess,
1785 GateIssue::Language,
1786 "repr with 128-bit type is unstable");
1791 if let Some(ref e) = v.node.disr_expr {
1792 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1796 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1797 for (discr, v) in def.discriminants(tcx).zip(vs) {
1798 // Check for duplicate discriminant values
1799 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1800 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1801 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1802 let i_span = match variant_i.node.disr_expr {
1803 Some(ref expr) => tcx.hir.span(expr.id),
1804 None => tcx.hir.span(variant_i_node_id)
1806 let span = match v.node.disr_expr {
1807 Some(ref expr) => tcx.hir.span(expr.id),
1810 struct_span_err!(tcx.sess, span, E0081,
1811 "discriminant value `{}` already exists", disr_vals[i])
1812 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1813 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1816 disr_vals.push(discr);
1819 check_representable(tcx, sp, def_id);
1822 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1823 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1825 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1826 -> ty::GenericPredicates<'tcx>
1829 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1830 let item_id = tcx.hir.ty_param_owner(node_id);
1831 let item_def_id = tcx.hir.local_def_id(item_id);
1832 let generics = tcx.generics_of(item_def_id);
1833 let index = generics.param_def_id_to_index[&def_id];
1834 ty::GenericPredicates {
1836 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1838 ty::Predicate::Trait(ref data) => {
1839 data.skip_binder().self_ty().is_param(index)
1843 }).cloned().collect()
1847 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1848 -> Option<ty::Region<'tcx>> {
1850 Some(def) => infer::EarlyBoundRegion(span, def.name),
1851 None => infer::MiscVariable(span)
1853 Some(self.next_region_var(v))
1856 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1857 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1860 fn ty_infer_for_def(&self,
1861 ty_param_def: &ty::GenericParamDef,
1862 span: Span) -> Ty<'tcx> {
1863 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1869 fn projected_ty_from_poly_trait_ref(&self,
1872 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1875 let (trait_ref, _) =
1876 self.replace_late_bound_regions_with_fresh_var(
1878 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1881 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1884 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1885 if ty.has_escaping_regions() {
1886 ty // FIXME: normalization and escaping regions
1888 self.normalize_associated_types_in(span, &ty)
1892 fn set_tainted_by_errors(&self) {
1893 self.infcx.set_tainted_by_errors()
1896 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1897 self.write_ty(hir_id, ty)
1901 /// Controls whether the arguments are tupled. This is used for the call
1904 /// Tupling means that all call-side arguments are packed into a tuple and
1905 /// passed as a single parameter. For example, if tupling is enabled, this
1908 /// fn f(x: (isize, isize))
1910 /// Can be called as:
1917 #[derive(Clone, Eq, PartialEq)]
1918 enum TupleArgumentsFlag {
1923 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1924 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1925 param_env: ty::ParamEnv<'tcx>,
1926 body_id: ast::NodeId)
1927 -> FnCtxt<'a, 'gcx, 'tcx> {
1931 err_count_on_creation: inh.tcx.sess.err_count(),
1934 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1935 ast::CRATE_NODE_ID)),
1936 diverges: Cell::new(Diverges::Maybe),
1937 has_errors: Cell::new(false),
1938 enclosing_breakables: RefCell::new(EnclosingBreakables {
1946 pub fn sess(&self) -> &Session {
1950 pub fn err_count_since_creation(&self) -> usize {
1951 self.tcx.sess.err_count() - self.err_count_on_creation
1954 /// Produce warning on the given node, if the current point in the
1955 /// function is unreachable, and there hasn't been another warning.
1956 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1957 if self.diverges.get() == Diverges::Always {
1958 self.diverges.set(Diverges::WarnedAlways);
1960 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1962 self.tcx().lint_node(
1963 lint::builtin::UNREACHABLE_CODE,
1965 &format!("unreachable {}", kind));
1971 code: ObligationCauseCode<'tcx>)
1972 -> ObligationCause<'tcx> {
1973 ObligationCause::new(span, self.body_id, code)
1976 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1977 self.cause(span, ObligationCauseCode::MiscObligation)
1980 /// Resolves type variables in `ty` if possible. Unlike the infcx
1981 /// version (resolve_type_vars_if_possible), this version will
1982 /// also select obligations if it seems useful, in an effort
1983 /// to get more type information.
1984 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1985 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1987 // No TyInfer()? Nothing needs doing.
1988 if !ty.has_infer_types() {
1989 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1993 // If `ty` is a type variable, see whether we already know what it is.
1994 ty = self.resolve_type_vars_if_possible(&ty);
1995 if !ty.has_infer_types() {
1996 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2000 // If not, try resolving pending obligations as much as
2001 // possible. This can help substantially when there are
2002 // indirect dependencies that don't seem worth tracking
2004 self.select_obligations_where_possible(false);
2005 ty = self.resolve_type_vars_if_possible(&ty);
2007 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2011 fn record_deferred_call_resolution(&self,
2012 closure_def_id: DefId,
2013 r: DeferredCallResolution<'gcx, 'tcx>) {
2014 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2015 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2018 fn remove_deferred_call_resolutions(&self,
2019 closure_def_id: DefId)
2020 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2022 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2023 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2026 pub fn tag(&self) -> String {
2027 let self_ptr: *const FnCtxt = self;
2028 format!("{:?}", self_ptr)
2031 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
2032 match self.locals.borrow().get(&nid) {
2035 span_bug!(span, "no type for local variable {}",
2036 self.tcx.hir.node_to_string(nid));
2042 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2043 debug!("write_ty({:?}, {:?}) in fcx {}",
2044 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2045 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2047 if ty.references_error() {
2048 self.has_errors.set(true);
2049 self.set_tainted_by_errors();
2053 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2054 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2055 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2058 // The NodeId and the ItemLocalId must identify the same item. We just pass
2059 // both of them for consistency checking.
2060 pub fn write_method_call(&self,
2062 method: MethodCallee<'tcx>) {
2065 .type_dependent_defs_mut()
2066 .insert(hir_id, Def::Method(method.def_id));
2067 self.write_substs(hir_id, method.substs);
2070 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2071 if !substs.is_noop() {
2072 debug!("write_substs({:?}, {:?}) in fcx {}",
2077 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2081 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2082 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2088 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2089 Entry::Vacant(entry) => { entry.insert(adj); },
2090 Entry::Occupied(mut entry) => {
2091 debug!(" - composing on top of {:?}", entry.get());
2092 match (&entry.get()[..], &adj[..]) {
2093 // Applying any adjustment on top of a NeverToAny
2094 // is a valid NeverToAny adjustment, because it can't
2096 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2098 Adjustment { kind: Adjust::Deref(_), .. },
2099 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2101 Adjustment { kind: Adjust::Deref(_), .. },
2102 .. // Any following adjustments are allowed.
2104 // A reborrow has no effect before a dereference.
2106 // FIXME: currently we never try to compose autoderefs
2107 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2109 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2110 expr, entry.get(), adj)
2112 *entry.get_mut() = adj;
2117 /// Basically whenever we are converting from a type scheme into
2118 /// the fn body space, we always want to normalize associated
2119 /// types as well. This function combines the two.
2120 fn instantiate_type_scheme<T>(&self,
2122 substs: &Substs<'tcx>,
2125 where T : TypeFoldable<'tcx>
2127 let value = value.subst(self.tcx, substs);
2128 let result = self.normalize_associated_types_in(span, &value);
2129 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2136 /// As `instantiate_type_scheme`, but for the bounds found in a
2137 /// generic type scheme.
2138 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2139 -> ty::InstantiatedPredicates<'tcx> {
2140 let bounds = self.tcx.predicates_of(def_id);
2141 let result = bounds.instantiate(self.tcx, substs);
2142 let result = self.normalize_associated_types_in(span, &result);
2143 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2150 /// Replace the anonymized types from the return value of the
2151 /// function with type variables and records the `AnonTypeMap` for
2152 /// later use during writeback. See
2153 /// `InferCtxt::instantiate_anon_types` for more details.
2154 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2159 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2161 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2166 let (value, anon_type_map) = self.register_infer_ok_obligations(
2167 self.instantiate_anon_types(
2175 let mut anon_types = self.anon_types.borrow_mut();
2176 for (ty, decl) in anon_type_map {
2177 let old_value = anon_types.insert(ty, decl);
2178 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2184 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2185 where T : TypeFoldable<'tcx>
2187 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2190 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2192 where T : TypeFoldable<'tcx>
2194 self.inh.partially_normalize_associated_types_in(span,
2200 pub fn require_type_meets(&self,
2203 code: traits::ObligationCauseCode<'tcx>,
2206 self.register_bound(
2209 traits::ObligationCause::new(span, self.body_id, code));
2212 pub fn require_type_is_sized(&self,
2215 code: traits::ObligationCauseCode<'tcx>)
2217 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2218 self.require_type_meets(ty, span, code, lang_item);
2221 pub fn register_bound(&self,
2224 cause: traits::ObligationCause<'tcx>)
2226 self.fulfillment_cx.borrow_mut()
2227 .register_bound(self, self.param_env, ty, def_id, cause);
2230 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2231 let t = AstConv::ast_ty_to_ty(self, ast_t);
2232 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2236 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2237 match self.tables.borrow().node_types().get(id) {
2239 None if self.is_tainted_by_errors() => self.tcx.types.err,
2241 let node_id = self.tcx.hir.hir_to_node_id(id);
2242 bug!("no type for node {}: {} in fcx {}",
2243 node_id, self.tcx.hir.node_to_string(node_id),
2249 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2250 /// outlive the region `r`.
2251 pub fn register_wf_obligation(&self,
2254 code: traits::ObligationCauseCode<'tcx>)
2256 // WF obligations never themselves fail, so no real need to give a detailed cause:
2257 let cause = traits::ObligationCause::new(span, self.body_id, code);
2258 self.register_predicate(traits::Obligation::new(cause,
2260 ty::Predicate::WellFormed(ty)));
2263 /// Registers obligations that all types appearing in `substs` are well-formed.
2264 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2266 for ty in substs.types() {
2267 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2271 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2272 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2273 /// trait/region obligations.
2275 /// For example, if there is a function:
2278 /// fn foo<'a,T:'a>(...)
2281 /// and a reference:
2287 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2288 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2289 pub fn add_obligations_for_parameters(&self,
2290 cause: traits::ObligationCause<'tcx>,
2291 predicates: &ty::InstantiatedPredicates<'tcx>)
2293 assert!(!predicates.has_escaping_regions());
2295 debug!("add_obligations_for_parameters(predicates={:?})",
2298 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2299 self.register_predicate(obligation);
2303 // FIXME(arielb1): use this instead of field.ty everywhere
2304 // Only for fields! Returns <none> for methods>
2305 // Indifferent to privacy flags
2306 pub fn field_ty(&self,
2308 field: &'tcx ty::FieldDef,
2309 substs: &Substs<'tcx>)
2312 self.normalize_associated_types_in(span,
2313 &field.ty(self.tcx, substs))
2316 fn check_casts(&self) {
2317 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2318 for cast in deferred_cast_checks.drain(..) {
2323 fn resolve_generator_interiors(&self, def_id: DefId) {
2324 let mut generators = self.deferred_generator_interiors.borrow_mut();
2325 for (body_id, interior) in generators.drain(..) {
2326 self.select_obligations_where_possible(false);
2327 generator_interior::resolve_interior(self, def_id, body_id, interior);
2331 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2332 // Non-numerics get replaced with ! or () (depending on whether
2333 // feature(never_type) is enabled, unconstrained ints with i32,
2334 // unconstrained floats with f64.
2335 // Fallback becomes very dubious if we have encountered type-checking errors.
2336 // In that case, fallback to TyError.
2337 // The return value indicates whether fallback has occured.
2338 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2339 use rustc::ty::error::UnconstrainedNumeric::Neither;
2340 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2342 assert!(ty.is_ty_infer());
2343 let fallback = match self.type_is_unconstrained_numeric(ty) {
2344 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2345 UnconstrainedInt => self.tcx.types.i32,
2346 UnconstrainedFloat => self.tcx.types.f64,
2347 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2348 Neither => return false,
2350 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2351 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2355 fn select_all_obligations_or_error(&self) {
2356 debug!("select_all_obligations_or_error");
2357 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2358 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2362 /// Select as many obligations as we can at present.
2363 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2364 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2367 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2372 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2374 hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
2376 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2381 hir::ExprKind::Type(ref e, _) => {
2382 self.is_place_expr(e)
2385 hir::ExprKind::Unary(hir::UnDeref, _) |
2386 hir::ExprKind::Field(..) |
2387 hir::ExprKind::Index(..) => {
2391 // Partially qualified paths in expressions can only legally
2392 // refer to associated items which are always rvalues.
2393 hir::ExprKind::Path(hir::QPath::TypeRelative(..)) |
2395 hir::ExprKind::Call(..) |
2396 hir::ExprKind::MethodCall(..) |
2397 hir::ExprKind::Struct(..) |
2398 hir::ExprKind::Tup(..) |
2399 hir::ExprKind::If(..) |
2400 hir::ExprKind::Match(..) |
2401 hir::ExprKind::Closure(..) |
2402 hir::ExprKind::Block(..) |
2403 hir::ExprKind::Repeat(..) |
2404 hir::ExprKind::Array(..) |
2405 hir::ExprKind::Break(..) |
2406 hir::ExprKind::Continue(..) |
2407 hir::ExprKind::Ret(..) |
2408 hir::ExprKind::While(..) |
2409 hir::ExprKind::Loop(..) |
2410 hir::ExprKind::Assign(..) |
2411 hir::ExprKind::InlineAsm(..) |
2412 hir::ExprKind::AssignOp(..) |
2413 hir::ExprKind::Lit(_) |
2414 hir::ExprKind::Unary(..) |
2415 hir::ExprKind::Box(..) |
2416 hir::ExprKind::AddrOf(..) |
2417 hir::ExprKind::Binary(..) |
2418 hir::ExprKind::Yield(..) |
2419 hir::ExprKind::Cast(..) => {
2425 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2426 /// returns a type of `&T`, but the actual type we assign to the
2427 /// *expression* is `T`. So this function just peels off the return
2428 /// type by one layer to yield `T`.
2429 fn make_overloaded_place_return_type(&self,
2430 method: MethodCallee<'tcx>)
2431 -> ty::TypeAndMut<'tcx>
2433 // extract method return type, which will be &T;
2434 let ret_ty = method.sig.output();
2436 // method returns &T, but the type as visible to user is T, so deref
2437 ret_ty.builtin_deref(true).unwrap()
2440 fn lookup_indexing(&self,
2442 base_expr: &'gcx hir::Expr,
2446 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2448 // FIXME(#18741) -- this is almost but not quite the same as the
2449 // autoderef that normal method probing does. They could likely be
2452 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2453 let mut result = None;
2454 while result.is_none() && autoderef.next().is_some() {
2455 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2457 autoderef.finalize();
2461 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2462 /// (and otherwise adjust) `base_expr`, looking for a type which either
2463 /// supports builtin indexing or overloaded indexing.
2464 /// This loop implements one step in that search; the autoderef loop
2465 /// is implemented by `lookup_indexing`.
2466 fn try_index_step(&self,
2468 base_expr: &hir::Expr,
2469 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2472 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2474 let adjusted_ty = autoderef.unambiguous_final_ty();
2475 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2482 for &unsize in &[false, true] {
2483 let mut self_ty = adjusted_ty;
2485 // We only unsize arrays here.
2486 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2487 self_ty = self.tcx.mk_slice(element_ty);
2493 // If some lookup succeeds, write callee into table and extract index/element
2494 // type from the method signature.
2495 // If some lookup succeeded, install method in table
2496 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2497 let method = self.try_overloaded_place_op(
2498 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2500 let result = method.map(|ok| {
2501 debug!("try_index_step: success, using overloaded indexing");
2502 let method = self.register_infer_ok_obligations(ok);
2504 let mut adjustments = autoderef.adjust_steps(needs);
2505 if let ty::TyRef(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2506 let mutbl = match r_mutbl {
2507 hir::MutImmutable => AutoBorrowMutability::Immutable,
2508 hir::MutMutable => AutoBorrowMutability::Mutable {
2509 // Indexing can be desugared to a method call,
2510 // so maybe we could use two-phase here.
2511 // See the documentation of AllowTwoPhase for why that's
2512 // not the case today.
2513 allow_two_phase_borrow: AllowTwoPhase::No,
2516 adjustments.push(Adjustment {
2517 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2518 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2525 adjustments.push(Adjustment {
2526 kind: Adjust::Unsize,
2527 target: method.sig.inputs()[0]
2530 self.apply_adjustments(base_expr, adjustments);
2532 self.write_method_call(expr.hir_id, method);
2533 (input_ty, self.make_overloaded_place_return_type(method).ty)
2535 if result.is_some() {
2543 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2544 let (tr, name) = match (op, is_mut) {
2545 (PlaceOp::Deref, false) =>
2546 (self.tcx.lang_items().deref_trait(), "deref"),
2547 (PlaceOp::Deref, true) =>
2548 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2549 (PlaceOp::Index, false) =>
2550 (self.tcx.lang_items().index_trait(), "index"),
2551 (PlaceOp::Index, true) =>
2552 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2554 (tr, ast::Ident::from_str(name))
2557 fn try_overloaded_place_op(&self,
2560 arg_tys: &[Ty<'tcx>],
2563 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2565 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2571 // Try Mut first, if needed.
2572 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2573 let method = match (needs, mut_tr) {
2574 (Needs::MutPlace, Some(trait_did)) => {
2575 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2580 // Otherwise, fall back to the immutable version.
2581 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2582 let method = match (method, imm_tr) {
2583 (None, Some(trait_did)) => {
2584 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2586 (method, _) => method,
2592 fn check_method_argument_types(&self,
2595 method: Result<MethodCallee<'tcx>, ()>,
2596 args_no_rcvr: &'gcx [hir::Expr],
2597 tuple_arguments: TupleArgumentsFlag,
2598 expected: Expectation<'tcx>)
2600 let has_error = match method {
2602 method.substs.references_error() || method.sig.references_error()
2607 let err_inputs = self.err_args(args_no_rcvr.len());
2609 let err_inputs = match tuple_arguments {
2610 DontTupleArguments => err_inputs,
2611 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2614 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2615 false, tuple_arguments, None);
2616 return self.tcx.types.err;
2619 let method = method.unwrap();
2620 // HACK(eddyb) ignore self in the definition (see above).
2621 let expected_arg_tys = self.expected_inputs_for_expected_output(
2624 method.sig.output(),
2625 &method.sig.inputs()[1..]
2627 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2628 args_no_rcvr, method.sig.variadic, tuple_arguments,
2629 self.tcx.hir.span_if_local(method.def_id));
2633 /// Generic function that factors out common logic from function calls,
2634 /// method calls and overloaded operators.
2635 fn check_argument_types(&self,
2638 fn_inputs: &[Ty<'tcx>],
2639 mut expected_arg_tys: &[Ty<'tcx>],
2640 args: &'gcx [hir::Expr],
2642 tuple_arguments: TupleArgumentsFlag,
2643 def_span: Option<Span>) {
2646 // Grab the argument types, supplying fresh type variables
2647 // if the wrong number of arguments were supplied
2648 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2654 // All the input types from the fn signature must outlive the call
2655 // so as to validate implied bounds.
2656 for &fn_input_ty in fn_inputs {
2657 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2660 let expected_arg_count = fn_inputs.len();
2662 let param_count_error = |expected_count: usize,
2667 let mut err = tcx.sess.struct_span_err_with_code(sp,
2668 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2669 if variadic {"at least "} else {""},
2671 if expected_count == 1 {""} else {"s"},
2673 if arg_count == 1 {" was"} else {"s were"}),
2674 DiagnosticId::Error(error_code.to_owned()));
2676 if let Some(def_s) = def_span.map(|sp| tcx.sess.codemap().def_span(sp)) {
2677 err.span_label(def_s, "defined here");
2680 let sugg_span = tcx.sess.codemap().end_point(expr_sp);
2681 // remove closing `)` from the span
2682 let sugg_span = sugg_span.shrink_to_lo();
2683 err.span_suggestion(
2685 "expected the unit value `()`; create it with empty parentheses",
2686 String::from("()"));
2688 err.span_label(sp, format!("expected {}{} parameter{}",
2689 if variadic {"at least "} else {""},
2691 if expected_count == 1 {""} else {"s"}));
2696 let formal_tys = if tuple_arguments == TupleArguments {
2697 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2698 match tuple_type.sty {
2699 ty::TyTuple(arg_types) if arg_types.len() != args.len() => {
2700 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2701 expected_arg_tys = &[];
2702 self.err_args(args.len())
2704 ty::TyTuple(arg_types) => {
2705 expected_arg_tys = match expected_arg_tys.get(0) {
2706 Some(&ty) => match ty.sty {
2707 ty::TyTuple(ref tys) => &tys,
2715 span_err!(tcx.sess, sp, E0059,
2716 "cannot use call notation; the first type parameter \
2717 for the function trait is neither a tuple nor unit");
2718 expected_arg_tys = &[];
2719 self.err_args(args.len())
2722 } else if expected_arg_count == supplied_arg_count {
2724 } else if variadic {
2725 if supplied_arg_count >= expected_arg_count {
2728 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2729 expected_arg_tys = &[];
2730 self.err_args(supplied_arg_count)
2733 // is the missing argument of type `()`?
2734 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2735 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2736 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2737 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2741 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2743 expected_arg_tys = &[];
2744 self.err_args(supplied_arg_count)
2746 // If there is no expectation, expect formal_tys.
2747 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2753 debug!("check_argument_types: formal_tys={:?}",
2754 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2756 // Check the arguments.
2757 // We do this in a pretty awful way: first we typecheck any arguments
2758 // that are not closures, then we typecheck the closures. This is so
2759 // that we have more information about the types of arguments when we
2760 // typecheck the functions. This isn't really the right way to do this.
2761 for &check_closures in &[false, true] {
2762 debug!("check_closures={}", check_closures);
2764 // More awful hacks: before we check argument types, try to do
2765 // an "opportunistic" vtable resolution of any trait bounds on
2766 // the call. This helps coercions.
2768 self.select_obligations_where_possible(false);
2771 // For variadic functions, we don't have a declared type for all of
2772 // the arguments hence we only do our usual type checking with
2773 // the arguments who's types we do know.
2774 let t = if variadic {
2776 } else if tuple_arguments == TupleArguments {
2781 for (i, arg) in args.iter().take(t).enumerate() {
2782 // Warn only for the first loop (the "no closures" one).
2783 // Closure arguments themselves can't be diverging, but
2784 // a previous argument can, e.g. `foo(panic!(), || {})`.
2785 if !check_closures {
2786 self.warn_if_unreachable(arg.id, arg.span, "expression");
2789 let is_closure = match arg.node {
2790 hir::ExprKind::Closure(..) => true,
2794 if is_closure != check_closures {
2798 debug!("checking the argument");
2799 let formal_ty = formal_tys[i];
2801 // The special-cased logic below has three functions:
2802 // 1. Provide as good of an expected type as possible.
2803 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2805 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2807 // 2. Coerce to the most detailed type that could be coerced
2808 // to, which is `expected_ty` if `rvalue_hint` returns an
2809 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2810 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2811 // We're processing function arguments so we definitely want to use
2812 // two-phase borrows.
2813 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2815 // 3. Relate the expected type and the formal one,
2816 // if the expected type was used for the coercion.
2817 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2821 // We also need to make sure we at least write the ty of the other
2822 // arguments which we skipped above.
2824 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2825 use structured_errors::{VariadicError, StructuredDiagnostic};
2826 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2829 for arg in args.iter().skip(expected_arg_count) {
2830 let arg_ty = self.check_expr(&arg);
2832 // There are a few types which get autopromoted when passed via varargs
2833 // in C but we just error out instead and require explicit casts.
2834 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2836 ty::TyFloat(ast::FloatTy::F32) => {
2837 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2839 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2840 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2842 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2843 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2845 ty::TyFnDef(..) => {
2846 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2847 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2848 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2856 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2857 (0..len).map(|_| self.tcx.types.err).collect()
2860 // AST fragment checking
2863 expected: Expectation<'tcx>)
2869 ast::LitKind::Str(..) => tcx.mk_static_str(),
2870 ast::LitKind::ByteStr(ref v) => {
2871 tcx.mk_imm_ref(tcx.types.re_static,
2872 tcx.mk_array(tcx.types.u8, v.len() as u64))
2874 ast::LitKind::Byte(_) => tcx.types.u8,
2875 ast::LitKind::Char(_) => tcx.types.char,
2876 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2877 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2878 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2879 let opt_ty = expected.to_option(self).and_then(|ty| {
2881 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2882 ty::TyChar => Some(tcx.types.u8),
2883 ty::TyRawPtr(..) => Some(tcx.types.usize),
2884 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2888 opt_ty.unwrap_or_else(
2889 || tcx.mk_int_var(self.next_int_var_id()))
2891 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2892 ast::LitKind::FloatUnsuffixed(_) => {
2893 let opt_ty = expected.to_option(self).and_then(|ty| {
2895 ty::TyFloat(_) => Some(ty),
2899 opt_ty.unwrap_or_else(
2900 || tcx.mk_float_var(self.next_float_var_id()))
2902 ast::LitKind::Bool(_) => tcx.types.bool
2906 fn check_expr_eq_type(&self,
2907 expr: &'gcx hir::Expr,
2908 expected: Ty<'tcx>) {
2909 let ty = self.check_expr_with_hint(expr, expected);
2910 self.demand_eqtype(expr.span, expected, ty);
2913 pub fn check_expr_has_type_or_error(&self,
2914 expr: &'gcx hir::Expr,
2915 expected: Ty<'tcx>) -> Ty<'tcx> {
2916 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2919 fn check_expr_meets_expectation_or_error(&self,
2920 expr: &'gcx hir::Expr,
2921 expected: Expectation<'tcx>) -> Ty<'tcx> {
2922 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2923 let mut ty = self.check_expr_with_expectation(expr, expected);
2925 // While we don't allow *arbitrary* coercions here, we *do* allow
2926 // coercions from ! to `expected`.
2928 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2929 "expression with never type wound up being adjusted");
2930 let adj_ty = self.next_diverging_ty_var(
2931 TypeVariableOrigin::AdjustmentType(expr.span));
2932 self.apply_adjustments(expr, vec![Adjustment {
2933 kind: Adjust::NeverToAny,
2939 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2940 // Add help to type error if this is an `if` condition with an assignment
2941 match (expected, &expr.node) {
2942 (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs)) => {
2943 let msg = "try comparing for equality";
2944 if let (Ok(left), Ok(right)) = (
2945 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2946 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2948 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2960 fn check_expr_coercable_to_type(&self,
2961 expr: &'gcx hir::Expr,
2962 expected: Ty<'tcx>) -> Ty<'tcx> {
2963 let ty = self.check_expr_with_hint(expr, expected);
2964 // checks don't need two phase
2965 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2968 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2969 expected: Ty<'tcx>) -> Ty<'tcx> {
2970 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2973 fn check_expr_with_expectation(&self,
2974 expr: &'gcx hir::Expr,
2975 expected: Expectation<'tcx>) -> Ty<'tcx> {
2976 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2979 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2980 self.check_expr_with_expectation(expr, NoExpectation)
2983 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2984 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2987 // determine the `self` type, using fresh variables for all variables
2988 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2989 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2991 pub fn impl_self_ty(&self,
2992 span: Span, // (potential) receiver for this impl
2994 -> TypeAndSubsts<'tcx> {
2995 let ity = self.tcx.type_of(did);
2996 debug!("impl_self_ty: ity={:?}", ity);
2998 let substs = self.fresh_substs_for_item(span, did);
2999 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3001 TypeAndSubsts { substs: substs, ty: substd_ty }
3004 /// Unifies the output type with the expected type early, for more coercions
3005 /// and forward type information on the input expressions.
3006 fn expected_inputs_for_expected_output(&self,
3008 expected_ret: Expectation<'tcx>,
3009 formal_ret: Ty<'tcx>,
3010 formal_args: &[Ty<'tcx>])
3012 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3013 let ret_ty = match expected_ret.only_has_type(self) {
3015 None => return Vec::new()
3017 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3018 // Attempt to apply a subtyping relationship between the formal
3019 // return type (likely containing type variables if the function
3020 // is polymorphic) and the expected return type.
3021 // No argument expectations are produced if unification fails.
3022 let origin = self.misc(call_span);
3023 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3025 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3026 // to identity so the resulting type is not constrained.
3029 // Process any obligations locally as much as
3030 // we can. We don't care if some things turn
3031 // out unconstrained or ambiguous, as we're
3032 // just trying to get hints here.
3033 self.save_and_restore_in_snapshot_flag(|_| {
3034 let mut fulfill = TraitEngine::new(self.tcx);
3035 for obligation in ok.obligations {
3036 fulfill.register_predicate_obligation(self, obligation);
3038 fulfill.select_where_possible(self)
3039 }).map_err(|_| ())?;
3041 Err(_) => return Err(()),
3044 // Record all the argument types, with the substitutions
3045 // produced from the above subtyping unification.
3046 Ok(formal_args.iter().map(|ty| {
3047 self.resolve_type_vars_if_possible(ty)
3049 }).unwrap_or(Vec::new());
3050 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3051 formal_args, formal_ret,
3052 expect_args, expected_ret);
3056 // Checks a method call.
3057 fn check_method_call(&self,
3058 expr: &'gcx hir::Expr,
3059 segment: &hir::PathSegment,
3061 args: &'gcx [hir::Expr],
3062 expected: Expectation<'tcx>,
3063 needs: Needs) -> Ty<'tcx> {
3064 let rcvr = &args[0];
3065 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3066 // no need to check for bot/err -- callee does that
3067 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3069 let method = match self.lookup_method(rcvr_t,
3075 self.write_method_call(expr.hir_id, method);
3079 if segment.ident.name != keywords::Invalid.name() {
3080 self.report_method_error(span,
3091 // Call the generic checker.
3092 self.check_method_argument_types(span,
3100 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3104 .unwrap_or_else(|| span_bug!(return_expr.span,
3105 "check_return_expr called outside fn body"));
3107 let ret_ty = ret_coercion.borrow().expected_ty();
3108 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3109 ret_coercion.borrow_mut()
3111 &self.cause(return_expr.span,
3112 ObligationCauseCode::ReturnType(return_expr.id)),
3118 // A generic function for checking the then and else in an if
3120 fn check_then_else(&self,
3121 cond_expr: &'gcx hir::Expr,
3122 then_expr: &'gcx hir::Expr,
3123 opt_else_expr: Option<&'gcx hir::Expr>,
3125 expected: Expectation<'tcx>) -> Ty<'tcx> {
3126 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3127 let cond_diverges = self.diverges.get();
3128 self.diverges.set(Diverges::Maybe);
3130 let expected = expected.adjust_for_branches(self);
3131 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3132 let then_diverges = self.diverges.get();
3133 self.diverges.set(Diverges::Maybe);
3135 // We've already taken the expected type's preferences
3136 // into account when typing the `then` branch. To figure
3137 // out the initial shot at a LUB, we thus only consider
3138 // `expected` if it represents a *hard* constraint
3139 // (`only_has_type`); otherwise, we just go with a
3140 // fresh type variable.
3141 let coerce_to_ty = expected.coercion_target_type(self, sp);
3142 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3144 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3145 coerce.coerce(self, &if_cause, then_expr, then_ty);
3147 if let Some(else_expr) = opt_else_expr {
3148 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3149 let else_diverges = self.diverges.get();
3151 coerce.coerce(self, &if_cause, else_expr, else_ty);
3153 // We won't diverge unless both branches do (or the condition does).
3154 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3156 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3157 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3159 // If the condition is false we can't diverge.
3160 self.diverges.set(cond_diverges);
3163 let result_ty = coerce.complete(self);
3164 if cond_ty.references_error() {
3171 // Check field access expressions
3172 fn check_field(&self,
3173 expr: &'gcx hir::Expr,
3175 base: &'gcx hir::Expr,
3176 field: ast::Ident) -> Ty<'tcx> {
3177 let expr_t = self.check_expr_with_needs(base, needs);
3178 let expr_t = self.structurally_resolved_type(base.span,
3180 let mut private_candidate = None;
3181 let mut autoderef = self.autoderef(expr.span, expr_t);
3182 while let Some((base_t, _)) = autoderef.next() {
3184 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3185 debug!("struct named {:?}", base_t);
3186 let (ident, def_scope) =
3187 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3188 let fields = &base_def.non_enum_variant().fields;
3189 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3190 let field = &fields[index];
3191 let field_ty = self.field_ty(expr.span, field, substs);
3192 // Save the index of all fields regardless of their visibility in case
3193 // of error recovery.
3194 self.write_field_index(expr.id, index);
3195 if field.vis.is_accessible_from(def_scope, self.tcx) {
3196 let adjustments = autoderef.adjust_steps(needs);
3197 self.apply_adjustments(base, adjustments);
3198 autoderef.finalize();
3200 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3203 private_candidate = Some((base_def.did, field_ty));
3206 ty::TyTuple(ref tys) => {
3207 let fstr = field.as_str();
3208 if let Ok(index) = fstr.parse::<usize>() {
3209 if fstr == index.to_string() {
3210 if let Some(field_ty) = tys.get(index) {
3211 let adjustments = autoderef.adjust_steps(needs);
3212 self.apply_adjustments(base, adjustments);
3213 autoderef.finalize();
3215 self.write_field_index(expr.id, index);
3224 autoderef.unambiguous_final_ty();
3226 if let Some((did, field_ty)) = private_candidate {
3227 let struct_path = self.tcx().item_path_str(did);
3228 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3229 "field `{}` of struct `{}` is private",
3230 field, struct_path);
3231 // Also check if an accessible method exists, which is often what is meant.
3232 if self.method_exists(field, expr_t, expr.id, false) {
3233 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3237 } else if field.name == keywords::Invalid.name() {
3238 self.tcx().types.err
3239 } else if self.method_exists(field, expr_t, expr.id, true) {
3240 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3241 "attempted to take value of method `{}` on type `{}`",
3243 .help("maybe a `()` to call it is missing?")
3245 self.tcx().types.err
3247 if !expr_t.is_primitive_ty() {
3248 let mut err = self.no_such_field_err(field.span, field, expr_t);
3251 ty::TyAdt(def, _) if !def.is_enum() => {
3252 if let Some(suggested_field_name) =
3253 Self::suggest_field_name(def.non_enum_variant(),
3254 &field.as_str(), vec![]) {
3255 err.span_label(field.span,
3256 format!("did you mean `{}`?", suggested_field_name));
3258 err.span_label(field.span, "unknown field");
3259 let struct_variant_def = def.non_enum_variant();
3260 let field_names = self.available_field_names(struct_variant_def);
3261 if !field_names.is_empty() {
3262 err.note(&format!("available fields are: {}",
3263 self.name_series_display(field_names)));
3267 ty::TyRawPtr(..) => {
3268 let base = self.tcx.hir.node_to_pretty_string(base.id);
3269 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3270 let suggestion = format!("(*{}).{}", base, field);
3271 err.span_suggestion(field.span, &msg, suggestion);
3277 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3278 "`{}` is a primitive type and therefore doesn't have fields",
3281 self.tcx().types.err
3285 // Return an hint about the closest match in field names
3286 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3288 skip: Vec<LocalInternedString>)
3290 let names = variant.fields.iter().filter_map(|field| {
3291 // ignore already set fields and private fields from non-local crates
3292 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3293 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3296 Some(&field.ident.name)
3300 find_best_match_for_name(names, field, None)
3303 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3304 let mut available = Vec::new();
3305 for field in variant.fields.iter() {
3306 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3307 if field.vis.is_accessible_from(def_scope, self.tcx) {
3308 available.push(field.ident.name);
3314 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3315 // dynamic limit, to never omit just one field
3316 let limit = if names.len() == 6 { 6 } else { 5 };
3317 let mut display = names.iter().take(limit)
3318 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3319 if names.len() > limit {
3320 display = format!("{} ... and {} others", display, names.len() - limit);
3325 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3326 -> DiagnosticBuilder {
3327 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3328 "no field `{}` on type `{}`",
3332 fn report_unknown_field(&self,
3334 variant: &'tcx ty::VariantDef,
3336 skip_fields: &[hir::Field],
3338 let mut err = self.type_error_struct_with_diag(
3340 |actual| match ty.sty {
3341 ty::TyAdt(adt, ..) if adt.is_enum() => {
3342 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3343 "{} `{}::{}` has no field named `{}`",
3344 kind_name, actual, variant.name, field.ident)
3347 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3348 "{} `{}` has no field named `{}`",
3349 kind_name, actual, field.ident)
3353 // prevent all specified fields from being suggested
3354 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3355 if let Some(field_name) = Self::suggest_field_name(variant,
3356 &field.ident.as_str(),
3357 skip_fields.collect()) {
3358 err.span_label(field.ident.span,
3359 format!("field does not exist - did you mean `{}`?", field_name));
3362 ty::TyAdt(adt, ..) => {
3364 err.span_label(field.ident.span,
3365 format!("`{}::{}` does not have this field",
3368 err.span_label(field.ident.span,
3369 format!("`{}` does not have this field", ty));
3371 let available_field_names = self.available_field_names(variant);
3372 if !available_field_names.is_empty() {
3373 err.note(&format!("available fields are: {}",
3374 self.name_series_display(available_field_names)));
3377 _ => bug!("non-ADT passed to report_unknown_field")
3383 fn check_expr_struct_fields(&self,
3385 expected: Expectation<'tcx>,
3386 expr_id: ast::NodeId,
3388 variant: &'tcx ty::VariantDef,
3389 ast_fields: &'gcx [hir::Field],
3390 check_completeness: bool) -> bool {
3394 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3395 .get(0).cloned().unwrap_or(adt_ty);
3396 // re-link the regions that EIfEO can erase.
3397 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3399 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3400 &ty::TyAdt(adt, substs) => {
3401 (substs, adt.adt_kind(), adt.variant_descr())
3403 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3406 let mut remaining_fields = FxHashMap();
3407 for (i, field) in variant.fields.iter().enumerate() {
3408 remaining_fields.insert(field.ident.modern(), (i, field));
3411 let mut seen_fields = FxHashMap();
3413 let mut error_happened = false;
3415 // Typecheck each field.
3416 for field in ast_fields {
3417 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3418 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3419 seen_fields.insert(ident, field.span);
3420 self.write_field_index(field.id, i);
3422 // we don't look at stability attributes on
3423 // struct-like enums (yet...), but it's definitely not
3424 // a bug to have construct one.
3425 if adt_kind != ty::AdtKind::Enum {
3426 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3429 self.field_ty(field.span, v_field, substs)
3431 error_happened = true;
3432 if let Some(prev_span) = seen_fields.get(&ident) {
3433 let mut err = struct_span_err!(self.tcx.sess,
3436 "field `{}` specified more than once",
3439 err.span_label(field.ident.span, "used more than once");
3440 err.span_label(*prev_span, format!("first use of `{}`", ident));
3444 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3450 // Make sure to give a type to the field even if there's
3451 // an error, so we can continue typechecking
3452 self.check_expr_coercable_to_type(&field.expr, field_type);
3455 // Make sure the programmer specified correct number of fields.
3456 if kind_name == "union" {
3457 if ast_fields.len() != 1 {
3458 tcx.sess.span_err(span, "union expressions should have exactly one field");
3460 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3461 let len = remaining_fields.len();
3463 let mut displayable_field_names = remaining_fields
3465 .map(|ident| ident.as_str())
3466 .collect::<Vec<_>>();
3468 displayable_field_names.sort();
3470 let truncated_fields_error = if len <= 3 {
3473 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3476 let remaining_fields_names = displayable_field_names.iter().take(3)
3477 .map(|n| format!("`{}`", n))
3478 .collect::<Vec<_>>()
3481 struct_span_err!(tcx.sess, span, E0063,
3482 "missing field{} {}{} in initializer of `{}`",
3483 if remaining_fields.len() == 1 { "" } else { "s" },
3484 remaining_fields_names,
3485 truncated_fields_error,
3487 .span_label(span, format!("missing {}{}",
3488 remaining_fields_names,
3489 truncated_fields_error))
3495 fn check_struct_fields_on_error(&self,
3496 fields: &'gcx [hir::Field],
3497 base_expr: &'gcx Option<P<hir::Expr>>) {
3498 for field in fields {
3499 self.check_expr(&field.expr);
3503 self.check_expr(&base);
3509 pub fn check_struct_path(&self,
3511 node_id: ast::NodeId)
3512 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3513 let path_span = match *qpath {
3514 hir::QPath::Resolved(_, ref path) => path.span,
3515 hir::QPath::TypeRelative(ref qself, _) => qself.span
3517 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3518 let variant = match def {
3520 self.set_tainted_by_errors();
3523 Def::Variant(..) => {
3525 ty::TyAdt(adt, substs) => {
3526 Some((adt.variant_of_def(def), adt.did, substs))
3528 _ => bug!("unexpected type: {:?}", ty.sty)
3531 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3532 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3534 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3535 Some((adt.non_enum_variant(), adt.did, substs))
3540 _ => bug!("unexpected definition: {:?}", def)
3543 if let Some((variant, did, substs)) = variant {
3544 // Check bounds on type arguments used in the path.
3545 let bounds = self.instantiate_bounds(path_span, did, substs);
3546 let cause = traits::ObligationCause::new(path_span, self.body_id,
3547 traits::ItemObligation(did));
3548 self.add_obligations_for_parameters(cause, &bounds);
3552 struct_span_err!(self.tcx.sess, path_span, E0071,
3553 "expected struct, variant or union type, found {}",
3554 ty.sort_string(self.tcx))
3555 .span_label(path_span, "not a struct")
3561 fn check_expr_struct(&self,
3563 expected: Expectation<'tcx>,
3565 fields: &'gcx [hir::Field],
3566 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3568 // Find the relevant variant
3569 let (variant, struct_ty) =
3570 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3573 self.check_struct_fields_on_error(fields, base_expr);
3574 return self.tcx.types.err;
3577 let path_span = match *qpath {
3578 hir::QPath::Resolved(_, ref path) => path.span,
3579 hir::QPath::TypeRelative(ref qself, _) => qself.span
3582 // Prohibit struct expressions when non exhaustive flag is set.
3583 if let ty::TyAdt(adt, _) = struct_ty.sty {
3584 if !adt.did.is_local() && adt.is_non_exhaustive() {
3585 span_err!(self.tcx.sess, expr.span, E0639,
3586 "cannot create non-exhaustive {} using struct expression",
3587 adt.variant_descr());
3591 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3592 variant, fields, base_expr.is_none());
3593 if let &Some(ref base_expr) = base_expr {
3594 // If check_expr_struct_fields hit an error, do not attempt to populate
3595 // the fields with the base_expr. This could cause us to hit errors later
3596 // when certain fields are assumed to exist that in fact do not.
3597 if !error_happened {
3598 self.check_expr_has_type_or_error(base_expr, struct_ty);
3599 match struct_ty.sty {
3600 ty::TyAdt(adt, substs) if adt.is_struct() => {
3601 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3602 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3607 .fru_field_types_mut()
3608 .insert(expr.hir_id, fru_field_types);
3611 span_err!(self.tcx.sess, base_expr.span, E0436,
3612 "functional record update syntax requires a struct");
3617 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3623 /// If an expression has any sub-expressions that result in a type error,
3624 /// inspecting that expression's type with `ty.references_error()` will return
3625 /// true. Likewise, if an expression is known to diverge, inspecting its
3626 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3627 /// strict, _|_ can appear in the type of an expression that does not,
3628 /// itself, diverge: for example, fn() -> _|_.)
3629 /// Note that inspecting a type's structure *directly* may expose the fact
3630 /// that there are actually multiple representations for `TyError`, so avoid
3631 /// that when err needs to be handled differently.
3632 fn check_expr_with_expectation_and_needs(&self,
3633 expr: &'gcx hir::Expr,
3634 expected: Expectation<'tcx>,
3635 needs: Needs) -> Ty<'tcx> {
3636 debug!(">> typechecking: expr={:?} expected={:?}",
3639 // Warn for expressions after diverging siblings.
3640 self.warn_if_unreachable(expr.id, expr.span, "expression");
3642 // Hide the outer diverging and has_errors flags.
3643 let old_diverges = self.diverges.get();
3644 let old_has_errors = self.has_errors.get();
3645 self.diverges.set(Diverges::Maybe);
3646 self.has_errors.set(false);
3648 let ty = self.check_expr_kind(expr, expected, needs);
3650 // Warn for non-block expressions with diverging children.
3652 hir::ExprKind::Block(..) |
3653 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3654 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3656 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3659 // Any expression that produces a value of type `!` must have diverged
3661 self.diverges.set(self.diverges.get() | Diverges::Always);
3664 // Record the type, which applies it effects.
3665 // We need to do this after the warning above, so that
3666 // we don't warn for the diverging expression itself.
3667 self.write_ty(expr.hir_id, ty);
3669 // Combine the diverging and has_error flags.
3670 self.diverges.set(self.diverges.get() | old_diverges);
3671 self.has_errors.set(self.has_errors.get() | old_has_errors);
3673 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3674 debug!("... {:?}, expected is {:?}", ty, expected);
3679 fn check_expr_kind(&self,
3680 expr: &'gcx hir::Expr,
3681 expected: Expectation<'tcx>,
3682 needs: Needs) -> Ty<'tcx> {
3686 hir::ExprKind::Box(ref subexpr) => {
3687 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3689 ty::TyAdt(def, _) if def.is_box()
3690 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3694 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3695 tcx.mk_box(referent_ty)
3698 hir::ExprKind::Lit(ref lit) => {
3699 self.check_lit(&lit, expected)
3701 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3702 self.check_binop(expr, op, lhs, rhs)
3704 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3705 self.check_binop_assign(expr, op, lhs, rhs)
3707 hir::ExprKind::Unary(unop, ref oprnd) => {
3708 let expected_inner = match unop {
3709 hir::UnNot | hir::UnNeg => {
3716 let needs = match unop {
3717 hir::UnDeref => needs,
3720 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3724 if !oprnd_t.references_error() {
3725 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3728 if let Some(mt) = oprnd_t.builtin_deref(true) {
3730 } else if let Some(ok) = self.try_overloaded_deref(
3731 expr.span, oprnd_t, needs) {
3732 let method = self.register_infer_ok_obligations(ok);
3733 if let ty::TyRef(region, _, mutbl) = method.sig.inputs()[0].sty {
3734 let mutbl = match mutbl {
3735 hir::MutImmutable => AutoBorrowMutability::Immutable,
3736 hir::MutMutable => AutoBorrowMutability::Mutable {
3737 // (It shouldn't actually matter for unary ops whether
3738 // we enable two-phase borrows or not, since a unary
3739 // op has no additional operands.)
3740 allow_two_phase_borrow: AllowTwoPhase::No,
3743 self.apply_adjustments(oprnd, vec![Adjustment {
3744 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3745 target: method.sig.inputs()[0]
3748 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3749 self.write_method_call(expr.hir_id, method);
3751 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3752 "type `{}` cannot be dereferenced",
3754 oprnd_t = tcx.types.err;
3758 let result = self.check_user_unop(expr, oprnd_t, unop);
3759 // If it's builtin, we can reuse the type, this helps inference.
3760 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3765 let result = self.check_user_unop(expr, oprnd_t, unop);
3766 // If it's builtin, we can reuse the type, this helps inference.
3767 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3775 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3776 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3778 ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
3779 if self.is_place_expr(&oprnd) {
3780 // Places may legitimately have unsized types.
3781 // For example, dereferences of a fat pointer and
3782 // the last field of a struct can be unsized.
3785 Expectation::rvalue_hint(self, ty)
3791 let needs = Needs::maybe_mut_place(mutbl);
3792 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3794 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3795 if tm.ty.references_error() {
3798 // Note: at this point, we cannot say what the best lifetime
3799 // is to use for resulting pointer. We want to use the
3800 // shortest lifetime possible so as to avoid spurious borrowck
3801 // errors. Moreover, the longest lifetime will depend on the
3802 // precise details of the value whose address is being taken
3803 // (and how long it is valid), which we don't know yet until type
3804 // inference is complete.
3806 // Therefore, here we simply generate a region variable. The
3807 // region inferencer will then select the ultimate value.
3808 // Finally, borrowck is charged with guaranteeing that the
3809 // value whose address was taken can actually be made to live
3810 // as long as it needs to live.
3811 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3812 tcx.mk_ref(region, tm)
3815 hir::ExprKind::Path(ref qpath) => {
3816 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3817 let ty = if def != Def::Err {
3818 self.instantiate_value_path(segs, opt_ty, def, expr.span, id)
3820 self.set_tainted_by_errors();
3824 // We always require that the type provided as the value for
3825 // a type parameter outlives the moment of instantiation.
3826 let substs = self.tables.borrow().node_substs(expr.hir_id);
3827 self.add_wf_bounds(substs, expr);
3831 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3832 for output in outputs {
3833 self.check_expr(output);
3835 for input in inputs {
3836 self.check_expr(input);
3840 hir::ExprKind::Break(destination, ref expr_opt) => {
3841 if let Ok(target_id) = destination.target_id {
3843 if let Some(ref e) = *expr_opt {
3844 // If this is a break with a value, we need to type-check
3845 // the expression. Get an expected type from the loop context.
3846 let opt_coerce_to = {
3847 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3848 enclosing_breakables.find_breakable(target_id)
3851 .map(|coerce| coerce.expected_ty())
3854 // If the loop context is not a `loop { }`, then break with
3855 // a value is illegal, and `opt_coerce_to` will be `None`.
3856 // Just set expectation to error in that case.
3857 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3859 // Recurse without `enclosing_breakables` borrowed.
3860 e_ty = self.check_expr_with_hint(e, coerce_to);
3861 cause = self.misc(e.span);
3863 // Otherwise, this is a break *without* a value. That's
3864 // always legal, and is equivalent to `break ()`.
3865 e_ty = tcx.mk_nil();
3866 cause = self.misc(expr.span);
3869 // Now that we have type-checked `expr_opt`, borrow
3870 // the `enclosing_loops` field and let's coerce the
3871 // type of `expr_opt` into what is expected.
3872 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3873 let ctxt = enclosing_breakables.find_breakable(target_id);
3874 if let Some(ref mut coerce) = ctxt.coerce {
3875 if let Some(ref e) = *expr_opt {
3876 coerce.coerce(self, &cause, e, e_ty);
3878 assert!(e_ty.is_nil());
3879 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3882 // If `ctxt.coerce` is `None`, we can just ignore
3883 // the type of the expresison. This is because
3884 // either this was a break *without* a value, in
3885 // which case it is always a legal type (`()`), or
3886 // else an error would have been flagged by the
3887 // `loops` pass for using break with an expression
3888 // where you are not supposed to.
3889 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3892 ctxt.may_break = true;
3894 // the type of a `break` is always `!`, since it diverges
3897 // Otherwise, we failed to find the enclosing loop;
3898 // this can only happen if the `break` was not
3899 // inside a loop at all, which is caught by the
3900 // loop-checking pass.
3901 if self.tcx.sess.err_count() == 0 {
3902 self.tcx.sess.delay_span_bug(expr.span,
3903 "break was outside loop, but no error was emitted");
3906 // We still need to assign a type to the inner expression to
3907 // prevent the ICE in #43162.
3908 if let Some(ref e) = *expr_opt {
3909 self.check_expr_with_hint(e, tcx.types.err);
3911 // ... except when we try to 'break rust;'.
3912 // ICE this expression in particular (see #43162).
3913 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
3914 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3915 fatally_break_rust(self.tcx.sess);
3919 // There was an error, make typecheck fail
3924 hir::ExprKind::Continue(destination) => {
3925 if destination.target_id.is_ok() {
3928 // There was an error, make typecheck fail
3932 hir::ExprKind::Ret(ref expr_opt) => {
3933 if self.ret_coercion.is_none() {
3934 struct_span_err!(self.tcx.sess, expr.span, E0572,
3935 "return statement outside of function body").emit();
3936 } else if let Some(ref e) = *expr_opt {
3937 self.check_return_expr(e);
3939 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3940 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3941 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3945 hir::ExprKind::Assign(ref lhs, ref rhs) => {
3946 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3948 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3951 ExpectIfCondition => {
3952 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3953 expected error elsehwere");
3956 // Only check this if not in an `if` condition, as the
3957 // mistyped comparison help is more appropriate.
3958 if !self.is_place_expr(&lhs) {
3959 struct_span_err!(self.tcx.sess, expr.span, E0070,
3960 "invalid left-hand side expression")
3961 .span_label(expr.span, "left-hand of expression not valid")
3967 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3969 if lhs_ty.references_error() || rhs_ty.references_error() {
3975 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
3976 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3977 expr.span, expected)
3979 hir::ExprKind::While(ref cond, ref body, _) => {
3980 let ctxt = BreakableCtxt {
3981 // cannot use break with a value from a while loop
3983 may_break: false, // Will get updated if/when we find a `break`.
3986 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3987 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3988 let cond_diverging = self.diverges.get();
3989 self.check_block_no_value(&body);
3991 // We may never reach the body so it diverging means nothing.
3992 self.diverges.set(cond_diverging);
3996 // No way to know whether it's diverging because
3997 // of a `break` or an outer `break` or `return`.
3998 self.diverges.set(Diverges::Maybe);
4003 hir::ExprKind::Loop(ref body, _, source) => {
4004 let coerce = match source {
4005 // you can only use break with a value from a normal `loop { }`
4006 hir::LoopSource::Loop => {
4007 let coerce_to = expected.coercion_target_type(self, body.span);
4008 Some(CoerceMany::new(coerce_to))
4011 hir::LoopSource::WhileLet |
4012 hir::LoopSource::ForLoop => {
4017 let ctxt = BreakableCtxt {
4019 may_break: false, // Will get updated if/when we find a `break`.
4022 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4023 self.check_block_no_value(&body);
4027 // No way to know whether it's diverging because
4028 // of a `break` or an outer `break` or `return`.
4029 self.diverges.set(Diverges::Maybe);
4032 // If we permit break with a value, then result type is
4033 // the LUB of the breaks (possibly ! if none); else, it
4034 // is nil. This makes sense because infinite loops
4035 // (which would have type !) are only possible iff we
4036 // permit break with a value [1].
4037 if ctxt.coerce.is_none() && !ctxt.may_break {
4039 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4041 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
4043 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4044 self.check_match(expr, &discrim, arms, expected, match_src)
4046 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4047 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4049 hir::ExprKind::Block(ref body, _) => {
4050 self.check_block_with_expected(&body, expected)
4052 hir::ExprKind::Call(ref callee, ref args) => {
4053 self.check_call(expr, &callee, args, expected)
4055 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4056 self.check_method_call(expr, segment, span, args, expected, needs)
4058 hir::ExprKind::Cast(ref e, ref t) => {
4059 // Find the type of `e`. Supply hints based on the type we are casting to,
4061 let t_cast = self.to_ty(t);
4062 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4063 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4064 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4066 // Eagerly check for some obvious errors.
4067 if t_expr.references_error() || t_cast.references_error() {
4070 // Defer other checks until we're done type checking.
4071 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4072 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4074 deferred_cast_checks.push(cast_check);
4077 Err(ErrorReported) => {
4083 hir::ExprKind::Type(ref e, ref t) => {
4084 let ty = self.to_ty(&t);
4085 self.check_expr_eq_type(&e, ty);
4088 hir::ExprKind::Array(ref args) => {
4089 let uty = expected.to_option(self).and_then(|uty| {
4091 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4096 let element_ty = if !args.is_empty() {
4097 let coerce_to = uty.unwrap_or_else(
4098 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4099 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4100 assert_eq!(self.diverges.get(), Diverges::Maybe);
4102 let e_ty = self.check_expr_with_hint(e, coerce_to);
4103 let cause = self.misc(e.span);
4104 coerce.coerce(self, &cause, e, e_ty);
4106 coerce.complete(self)
4108 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4110 tcx.mk_array(element_ty, args.len() as u64)
4112 hir::ExprKind::Repeat(ref element, ref count) => {
4113 let count_def_id = tcx.hir.local_def_id(count.id);
4114 let param_env = ty::ParamEnv::empty();
4115 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4116 let instance = ty::Instance::resolve(
4122 let global_id = GlobalId {
4126 let count = tcx.const_eval(param_env.and(global_id));
4128 if let Err(ref err) = count {
4129 err.report_as_error(
4130 tcx.at(tcx.def_span(count_def_id)),
4131 "could not evaluate repeat length",
4135 let uty = match expected {
4136 ExpectHasType(uty) => {
4138 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4145 let (element_ty, t) = match uty {
4147 self.check_expr_coercable_to_type(&element, uty);
4151 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4152 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4157 if let Ok(count) = count {
4158 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4160 // For [foo, ..n] where n > 1, `foo` must have
4162 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4163 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4167 if element_ty.references_error() {
4169 } else if let Ok(count) = count {
4170 tcx.mk_ty(ty::TyArray(t, count))
4175 hir::ExprKind::Tup(ref elts) => {
4176 let flds = expected.only_has_type(self).and_then(|ty| {
4177 let ty = self.resolve_type_vars_with_obligations(ty);
4179 ty::TyTuple(ref flds) => Some(&flds[..]),
4184 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4185 let t = match flds {
4186 Some(ref fs) if i < fs.len() => {
4188 self.check_expr_coercable_to_type(&e, ety);
4192 self.check_expr_with_expectation(&e, NoExpectation)
4197 let tuple = tcx.mk_tup(elt_ts_iter);
4198 if tuple.references_error() {
4201 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4205 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4206 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4208 hir::ExprKind::Field(ref base, field) => {
4209 self.check_field(expr, needs, &base, field)
4211 hir::ExprKind::Index(ref base, ref idx) => {
4212 let base_t = self.check_expr_with_needs(&base, needs);
4213 let idx_t = self.check_expr(&idx);
4215 if base_t.references_error() {
4217 } else if idx_t.references_error() {
4220 let base_t = self.structurally_resolved_type(base.span, base_t);
4221 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4222 Some((index_ty, element_ty)) => {
4223 // two-phase not needed because index_ty is never mutable
4224 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4229 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4230 "cannot index into a value of type `{}`",
4232 // Try to give some advice about indexing tuples.
4233 if let ty::TyTuple(..) = base_t.sty {
4234 let mut needs_note = true;
4235 // If the index is an integer, we can show the actual
4236 // fixed expression:
4237 if let hir::ExprKind::Lit(ref lit) = idx.node {
4238 if let ast::LitKind::Int(i,
4239 ast::LitIntType::Unsuffixed) = lit.node {
4240 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4241 if let Ok(snip) = snip {
4242 err.span_suggestion(expr.span,
4243 "to access tuple elements, use",
4244 format!("{}.{}", snip, i));
4250 err.help("to access tuple elements, use tuple indexing \
4251 syntax (e.g. `tuple.0`)");
4260 hir::ExprKind::Yield(ref value) => {
4261 match self.yield_ty {
4263 self.check_expr_coercable_to_type(&value, ty);
4266 struct_span_err!(self.tcx.sess, expr.span, E0627,
4267 "yield statement outside of generator literal").emit();
4275 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4276 // The newly resolved definition is written into `type_dependent_defs`.
4277 fn finish_resolving_struct_path(&self,
4280 node_id: ast::NodeId)
4284 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4285 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4286 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4289 hir::QPath::TypeRelative(ref qself, ref segment) => {
4290 let ty = self.to_ty(qself);
4292 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4297 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4300 // Write back the new resolution.
4301 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4302 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4309 // Resolve associated value path into a base type and associated constant or method definition.
4310 // The newly resolved definition is written into `type_dependent_defs`.
4311 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4312 qpath: &'b hir::QPath,
4313 node_id: ast::NodeId,
4315 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4317 let (ty, item_segment) = match *qpath {
4318 hir::QPath::Resolved(ref opt_qself, ref path) => {
4320 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4321 &path.segments[..]);
4323 hir::QPath::TypeRelative(ref qself, ref segment) => {
4324 (self.to_ty(qself), segment)
4327 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4328 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4329 // Return directly on cache hit. This is useful to avoid doubly reporting
4330 // errors with default match binding modes. See #44614.
4331 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4333 let item_name = item_segment.ident;
4334 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4337 let def = match error {
4338 method::MethodError::PrivateMatch(def, _) => def,
4341 if item_name.name != keywords::Invalid.name() {
4342 self.report_method_error(span, ty, item_name, None, error, None);
4348 // Write back the new resolution.
4349 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4350 (def, Some(ty), slice::from_ref(&**item_segment))
4353 pub fn check_decl_initializer(&self,
4354 local: &'gcx hir::Local,
4355 init: &'gcx hir::Expr) -> Ty<'tcx>
4357 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4358 // for #42640 (default match binding modes).
4361 let ref_bindings = local.pat.contains_explicit_ref_binding();
4363 let local_ty = self.local_ty(init.span, local.id);
4364 if let Some(m) = ref_bindings {
4365 // Somewhat subtle: if we have a `ref` binding in the pattern,
4366 // we want to avoid introducing coercions for the RHS. This is
4367 // both because it helps preserve sanity and, in the case of
4368 // ref mut, for soundness (issue #23116). In particular, in
4369 // the latter case, we need to be clear that the type of the
4370 // referent for the reference that results is *equal to* the
4371 // type of the place it is referencing, and not some
4372 // supertype thereof.
4373 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4374 self.demand_eqtype(init.span, local_ty, init_ty);
4377 self.check_expr_coercable_to_type(init, local_ty)
4381 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4382 let t = self.local_ty(local.span, local.id);
4383 self.write_ty(local.hir_id, t);
4385 if let Some(ref init) = local.init {
4386 let init_ty = self.check_decl_initializer(local, &init);
4387 if init_ty.references_error() {
4388 self.write_ty(local.hir_id, init_ty);
4392 self.check_pat_walk(&local.pat, t,
4393 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4395 let pat_ty = self.node_ty(local.pat.hir_id);
4396 if pat_ty.references_error() {
4397 self.write_ty(local.hir_id, pat_ty);
4401 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4402 // Don't do all the complex logic below for DeclItem.
4404 hir::StmtKind::Decl(ref decl, _) => {
4406 hir::DeclKind::Local(_) => {}
4407 hir::DeclKind::Item(_) => {
4412 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4415 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4417 // Hide the outer diverging and has_errors flags.
4418 let old_diverges = self.diverges.get();
4419 let old_has_errors = self.has_errors.get();
4420 self.diverges.set(Diverges::Maybe);
4421 self.has_errors.set(false);
4424 hir::StmtKind::Decl(ref decl, _) => {
4426 hir::DeclKind::Local(ref l) => {
4427 self.check_decl_local(&l);
4429 hir::DeclKind::Item(_) => {/* ignore for now */}
4432 hir::StmtKind::Expr(ref expr, _) => {
4433 // Check with expected type of ()
4434 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4436 hir::StmtKind::Semi(ref expr, _) => {
4437 self.check_expr(&expr);
4441 // Combine the diverging and has_error flags.
4442 self.diverges.set(self.diverges.get() | old_diverges);
4443 self.has_errors.set(self.has_errors.get() | old_has_errors);
4446 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4447 let unit = self.tcx.mk_nil();
4448 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4450 // if the block produces a `!` value, that can always be
4451 // (effectively) coerced to unit.
4453 self.demand_suptype(blk.span, unit, ty);
4457 fn check_block_with_expected(&self,
4458 blk: &'gcx hir::Block,
4459 expected: Expectation<'tcx>) -> Ty<'tcx> {
4461 let mut fcx_ps = self.ps.borrow_mut();
4462 let unsafety_state = fcx_ps.recurse(blk);
4463 replace(&mut *fcx_ps, unsafety_state)
4466 // In some cases, blocks have just one exit, but other blocks
4467 // can be targeted by multiple breaks. This can happen both
4468 // with labeled blocks as well as when we desugar
4469 // a `do catch { ... }` expression.
4473 // 'a: { if true { break 'a Err(()); } Ok(()) }
4475 // Here we would wind up with two coercions, one from
4476 // `Err(())` and the other from the tail expression
4477 // `Ok(())`. If the tail expression is omitted, that's a
4478 // "forced unit" -- unless the block diverges, in which
4479 // case we can ignore the tail expression (e.g., `'a: {
4480 // break 'a 22; }` would not force the type of the block
4482 let tail_expr = blk.expr.as_ref();
4483 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4484 let coerce = if blk.targeted_by_break {
4485 CoerceMany::new(coerce_to_ty)
4487 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4488 Some(e) => slice::from_ref(e),
4491 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4494 let prev_diverges = self.diverges.get();
4495 let ctxt = BreakableCtxt {
4496 coerce: Some(coerce),
4500 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4501 for s in &blk.stmts {
4505 // check the tail expression **without** holding the
4506 // `enclosing_breakables` lock below.
4507 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4509 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4510 let ctxt = enclosing_breakables.find_breakable(blk.id);
4511 let coerce = ctxt.coerce.as_mut().unwrap();
4512 if let Some(tail_expr_ty) = tail_expr_ty {
4513 let tail_expr = tail_expr.unwrap();
4514 let cause = self.cause(tail_expr.span,
4515 ObligationCauseCode::BlockTailExpression(blk.id));
4521 // Subtle: if there is no explicit tail expression,
4522 // that is typically equivalent to a tail expression
4523 // of `()` -- except if the block diverges. In that
4524 // case, there is no value supplied from the tail
4525 // expression (assuming there are no other breaks,
4526 // this implies that the type of the block will be
4529 // #41425 -- label the implicit `()` as being the
4530 // "found type" here, rather than the "expected type".
4532 // #44579 -- if the block was recovered during parsing,
4533 // the type would be nonsensical and it is not worth it
4534 // to perform the type check, so we avoid generating the
4535 // diagnostic output.
4536 if !self.diverges.get().always() && !blk.recovered {
4537 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4538 if let Some(expected_ty) = expected.only_has_type(self) {
4539 self.consider_hint_about_removing_semicolon(blk,
4549 // If we can break from the block, then the block's exit is always reachable
4550 // (... as long as the entry is reachable) - regardless of the tail of the block.
4551 self.diverges.set(prev_diverges);
4554 let mut ty = ctxt.coerce.unwrap().complete(self);
4556 if self.has_errors.get() || ty.references_error() {
4557 ty = self.tcx.types.err
4560 self.write_ty(blk.hir_id, ty);
4562 *self.ps.borrow_mut() = prev;
4566 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4567 /// suggestion can be made, `None` otherwise.
4568 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4569 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4570 // `while` before reaching it, as block tail returns are not available in them.
4571 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4572 let parent = self.tcx.hir.get(fn_id);
4574 if let Node::NodeItem(&hir::Item {
4575 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4577 decl.clone().and_then(|decl| {
4578 // This is less than ideal, it will not suggest a return type span on any
4579 // method called `main`, regardless of whether it is actually the entry point,
4580 // but it will still present it as the reason for the expected type.
4581 Some((decl, name != Symbol::intern("main")))
4583 } else if let Node::NodeTraitItem(&hir::TraitItem {
4584 node: hir::TraitItemKind::Method(hir::MethodSig {
4588 decl.clone().and_then(|decl| {
4591 } else if let Node::NodeImplItem(&hir::ImplItem {
4592 node: hir::ImplItemKind::Method(hir::MethodSig {
4596 decl.clone().and_then(|decl| {
4607 /// On implicit return expressions with mismatched types, provide the following suggestions:
4609 /// - Point out the method's return type as the reason for the expected type
4610 /// - Possible missing semicolon
4611 /// - Possible missing return type if the return type is the default, and not `fn main()`
4612 pub fn suggest_mismatched_types_on_tail(&self,
4613 err: &mut DiagnosticBuilder<'tcx>,
4614 expression: &'gcx hir::Expr,
4618 blk_id: ast::NodeId) {
4619 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4620 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4621 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4623 self.suggest_ref_or_into(err, expression, expected, found);
4626 pub fn suggest_ref_or_into(
4628 err: &mut DiagnosticBuilder<'tcx>,
4633 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4634 err.span_suggestion(sp, msg, suggestion);
4635 } else if !self.check_for_cast(err, expr, found, expected) {
4636 let methods = self.get_conversion_methods(expr.span, expected, found);
4637 if let Ok(expr_text) = self.sess().codemap().span_to_snippet(expr.span) {
4638 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4639 .filter_map(|(receiver, method)| {
4640 let method_call = format!(".{}()", method.ident);
4641 if receiver.ends_with(&method_call) {
4642 None // do not suggest code that is already there (#53348)
4644 Some(format!("{}{}", receiver, method_call))
4646 }) .collect::<Vec<_>>();
4647 if !suggestions.is_empty() {
4648 err.span_suggestions(expr.span, "try using a conversion method", suggestions);
4654 /// A common error is to forget to add a semicolon at the end of a block:
4658 /// bar_that_returns_u32()
4662 /// This routine checks if the return expression in a block would make sense on its own as a
4663 /// statement and the return type has been left as default or has been specified as `()`. If so,
4664 /// it suggests adding a semicolon.
4665 fn suggest_missing_semicolon(&self,
4666 err: &mut DiagnosticBuilder<'tcx>,
4667 expression: &'gcx hir::Expr,
4670 if expected.is_nil() {
4671 // `BlockTailExpression` only relevant if the tail expr would be
4672 // useful on its own.
4673 match expression.node {
4674 hir::ExprKind::Call(..) |
4675 hir::ExprKind::MethodCall(..) |
4676 hir::ExprKind::If(..) |
4677 hir::ExprKind::While(..) |
4678 hir::ExprKind::Loop(..) |
4679 hir::ExprKind::Match(..) |
4680 hir::ExprKind::Block(..) => {
4681 let sp = self.tcx.sess.codemap().next_point(cause_span);
4682 err.span_suggestion(sp,
4683 "try adding a semicolon",
4692 /// A possible error is to forget to add a return type that is needed:
4696 /// bar_that_returns_u32()
4700 /// This routine checks if the return type is left as default, the method is not part of an
4701 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4703 fn suggest_missing_return_type(&self,
4704 err: &mut DiagnosticBuilder<'tcx>,
4705 fn_decl: &hir::FnDecl,
4708 can_suggest: bool) {
4709 // Only suggest changing the return type for methods that
4710 // haven't set a return type at all (and aren't `fn main()` or an impl).
4711 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_nil()) {
4712 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4713 err.span_suggestion(span,
4714 "try adding a return type",
4716 self.resolve_type_vars_with_obligations(found)));
4718 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4719 err.span_label(span, "possibly return type missing here?");
4721 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4722 // `fn main()` must return `()`, do not suggest changing return type
4723 err.span_label(span, "expected `()` because of default return type");
4725 // expectation was caused by something else, not the default return
4726 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4727 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4728 // Only point to return type if the expected type is the return type, as if they
4729 // are not, the expectation must have been caused by something else.
4730 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4732 let ty = AstConv::ast_ty_to_ty(self, ty);
4733 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4734 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4735 if ty.sty == expected.sty {
4736 err.span_label(sp, format!("expected `{}` because of return type",
4744 /// A common error is to add an extra semicolon:
4747 /// fn foo() -> usize {
4752 /// This routine checks if the final statement in a block is an
4753 /// expression with an explicit semicolon whose type is compatible
4754 /// with `expected_ty`. If so, it suggests removing the semicolon.
4755 fn consider_hint_about_removing_semicolon(&self,
4756 blk: &'gcx hir::Block,
4757 expected_ty: Ty<'tcx>,
4758 err: &mut DiagnosticBuilder) {
4759 // Be helpful when the user wrote `{... expr;}` and
4760 // taking the `;` off is enough to fix the error.
4761 let last_stmt = match blk.stmts.last() {
4765 let last_expr = match last_stmt.node {
4766 hir::StmtKind::Semi(ref e, _) => e,
4769 let last_expr_ty = self.node_ty(last_expr.hir_id);
4770 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4773 let original_span = original_sp(last_stmt.span, blk.span);
4774 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4775 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4778 fn def_ids_for_path_segments(&self,
4779 segments: &[hir::PathSegment],
4782 // We need to extract the type parameters supplied by the user in
4783 // the path `path`. Due to the current setup, this is a bit of a
4784 // tricky-process; the problem is that resolve only tells us the
4785 // end-point of the path resolution, and not the intermediate steps.
4786 // Luckily, we can (at least for now) deduce the intermediate steps
4787 // just from the end-point.
4789 // There are basically four cases to consider:
4791 // 1. Reference to a constructor of enum variant or struct:
4793 // struct Foo<T>(...)
4794 // enum E<T> { Foo(...) }
4796 // In these cases, the parameters are declared in the type
4799 // 2. Reference to a fn item or a free constant:
4803 // In this case, the path will again always have the form
4804 // `a::b::foo::<T>` where only the final segment should have
4805 // type parameters. However, in this case, those parameters are
4806 // declared on a value, and hence are in the `FnSpace`.
4808 // 3. Reference to a method or an associated constant:
4810 // impl<A> SomeStruct<A> {
4814 // Here we can have a path like
4815 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4816 // may appear in two places. The penultimate segment,
4817 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4818 // final segment, `foo::<B>` contains parameters in fn space.
4820 // 4. Reference to a local variable
4822 // Local variables can't have any type parameters.
4824 // The first step then is to categorize the segments appropriately.
4826 assert!(!segments.is_empty());
4827 let last = segments.len() - 1;
4829 let mut path_segs = vec![];
4832 // Case 1. Reference to a struct/variant constructor.
4833 Def::StructCtor(def_id, ..) |
4834 Def::VariantCtor(def_id, ..) => {
4835 // Everything but the final segment should have no
4836 // parameters at all.
4837 let mut generics = self.tcx.generics_of(def_id);
4838 // Variant and struct constructors use the
4839 // generics of their parent type definition.
4840 let generics_def_id = generics.parent.unwrap_or(def_id);
4841 path_segs.push(PathSeg(generics_def_id, last));
4844 // Case 2. Reference to a top-level value.
4846 Def::Const(def_id) |
4847 Def::Static(def_id, _) => {
4848 path_segs.push(PathSeg(def_id, last));
4851 // Case 3. Reference to a method or associated const.
4852 Def::Method(def_id) |
4853 Def::AssociatedConst(def_id) => {
4854 if segments.len() >= 2 {
4855 let generics = self.tcx.generics_of(def_id);
4856 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
4858 path_segs.push(PathSeg(def_id, last));
4861 // Case 4. Local variable, no generics.
4862 Def::Local(..) | Def::Upvar(..) => {}
4864 _ => bug!("unexpected definition: {:?}", def),
4867 debug!("path_segs = {:?}", path_segs);
4872 // Instantiates the given path, which must refer to an item with the given
4873 // number of type parameters and type.
4874 pub fn instantiate_value_path(&self,
4875 segments: &[hir::PathSegment],
4876 opt_self_ty: Option<Ty<'tcx>>,
4879 node_id: ast::NodeId)
4881 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4886 let path_segs = self.def_ids_for_path_segments(segments, def);
4888 let mut ufcs_associated = None;
4890 Def::Method(def_id) |
4891 Def::AssociatedConst(def_id) => {
4892 let container = self.tcx.associated_item(def_id).container;
4894 ty::TraitContainer(trait_did) => {
4895 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4897 ty::ImplContainer(_) => {}
4899 if segments.len() == 1 {
4900 // `<T>::assoc` will end up here, and so can `T::assoc`.
4901 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4902 ufcs_associated = Some((container, self_ty));
4908 // Now that we have categorized what space the parameters for each
4909 // segment belong to, let's sort out the parameters that the user
4910 // provided (if any) into their appropriate spaces. We'll also report
4911 // errors if type parameters are provided in an inappropriate place.
4912 let mut generic_segs = HashSet::new();
4913 for PathSeg(_, index) in &path_segs {
4914 generic_segs.insert(index);
4916 let segs: Vec<_> = segments
4919 .filter_map(|(index, seg)| {
4920 if !generic_segs.contains(&index) {
4928 AstConv::prohibit_generics(self, &segs);
4931 Def::Local(nid) | Def::Upvar(nid, ..) => {
4932 let ty = self.local_ty(span, nid);
4933 let ty = self.normalize_associated_types_in(span, &ty);
4934 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4940 // Now we have to compare the types that the user *actually*
4941 // provided against the types that were *expected*. If the user
4942 // did not provide any types, then we want to substitute inference
4943 // variables. If the user provided some types, we may still need
4944 // to add defaults. If the user provided *too many* types, that's
4946 let mut infer_lifetimes = FxHashMap();
4947 for &PathSeg(def_id, index) in &path_segs {
4948 let seg = &segments[index];
4949 let generics = self.tcx.generics_of(def_id);
4950 let supress_mismatch = self.check_impl_trait(span, seg, &generics);
4951 self.check_generic_arg_count(span, seg, &generics, false, supress_mismatch);
4952 infer_lifetimes.insert(index, if let Some(ref data) = seg.args {
4953 !data.args.iter().any(|arg| match arg {
4954 GenericArg::Lifetime(_) => true,
4962 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4963 self.tcx.generics_of(*def_id).has_self
4964 }).unwrap_or(false);
4966 let def_id = def.def_id();
4967 let mut parent_defs = self.tcx.generics_of(def_id);
4968 let count = parent_defs.count();
4969 let mut substs = if count <= 8 {
4970 AccumulateVec::Array(ArrayVec::new())
4972 AccumulateVec::Heap(Vec::with_capacity(count))
4974 let mut stack = vec![(def_id, parent_defs)];
4975 while let Some(def_id) = parent_defs.parent {
4976 parent_defs = self.tcx.generics_of(def_id);
4977 stack.push((def_id, parent_defs));
4979 while let Some((def_id, defs)) = stack.pop() {
4980 Substs::fill_single(&mut substs, defs, &mut |param: &ty::GenericParamDef, substs| {
4981 if param.index == 0 && has_self {
4982 if let GenericParamDefKind::Type { .. } = param.kind {
4983 // Handle Self first, so we can adjust the index to match the AST.
4984 return opt_self_ty.map(|ty| ty.into()).unwrap_or_else(|| {
4985 self.var_for_def(span, param)
4990 let infer_types = if let Some(&PathSeg(_, index)) = path_segs
4992 .find(|&PathSeg(did, _)| *did == def_id) {
4994 if let Some(ref data) = segments[index].args {
4995 let lifetime_offset = if infer_lifetimes[&index] {
4996 defs.own_counts().lifetimes
5000 let param_idx = param.index as usize - has_self as usize - lifetime_offset;
5001 if let Some(arg) = data.args.get(param_idx) {
5002 return match param.kind {
5003 GenericParamDefKind::Lifetime => match arg {
5004 GenericArg::Lifetime(lt) => {
5005 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5007 _ => bug!("expected a lifetime arg"),
5009 GenericParamDefKind::Type { .. } => match arg {
5010 GenericArg::Type(ty) => self.to_ty(ty).into(),
5011 _ => bug!("expected a type arg"),
5017 segments[index].infer_types
5023 GenericParamDefKind::Lifetime => {
5024 self.re_infer(span, Some(param)).unwrap().into()
5026 GenericParamDefKind::Type { has_default, .. } => {
5027 if !infer_types && has_default {
5028 // No type parameter provided, but a default exists.
5029 let default = self.tcx.type_of(param.def_id);
5032 default.subst_spanned(self.tcx, substs, Some(span))
5035 // No type parameters were provided, we can infer all.
5036 // This can also be reached in some error cases:
5037 // We prefer to use inference variables instead of
5038 // TyError to let type inference recover somewhat.
5039 self.var_for_def(span, param)
5045 let substs = self.tcx.intern_substs(&substs);
5047 // The things we are substituting into the type should not contain
5048 // escaping late-bound regions, and nor should the base type scheme.
5049 let ty = self.tcx.type_of(def_id);
5050 assert!(!substs.has_escaping_regions());
5051 assert!(!ty.has_escaping_regions());
5053 // Add all the obligations that are required, substituting and
5054 // normalized appropriately.
5055 let bounds = self.instantiate_bounds(span, def_id, &substs);
5056 self.add_obligations_for_parameters(
5057 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5060 // Substitute the values for the type parameters into the type of
5061 // the referenced item.
5062 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5064 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
5065 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5066 // is inherent, there is no `Self` parameter, instead, the impl needs
5067 // type parameters, which we can infer by unifying the provided `Self`
5068 // with the substituted impl type.
5069 let ty = self.tcx.type_of(impl_def_id);
5071 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5072 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5073 Ok(ok) => self.register_infer_ok_obligations(ok),
5076 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5083 self.check_rustc_args_require_const(def_id, node_id, span);
5085 debug!("instantiate_value_path: type of {:?} is {:?}",
5088 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
5092 fn check_rustc_args_require_const(&self,
5094 node_id: ast::NodeId,
5096 // We're only interested in functions tagged with
5097 // #[rustc_args_required_const], so ignore anything that's not.
5098 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5102 // If our calling expression is indeed the function itself, we're good!
5103 // If not, generate an error that this can only be called directly.
5104 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5105 Node::NodeExpr(expr) => {
5107 hir::ExprKind::Call(ref callee, ..) => {
5108 if callee.id == node_id {
5118 self.tcx.sess.span_err(span, "this function can only be invoked \
5119 directly, not through a function pointer");
5122 /// Report errors if the provided parameters are too few or too many.
5123 fn check_generic_arg_count(&self,
5125 segment: &hir::PathSegment,
5126 generics: &ty::Generics,
5127 is_method_call: bool,
5128 supress_mismatch_error: bool) {
5129 let (mut lifetimes, mut types) = (vec![], vec![]);
5130 let infer_types = segment.infer_types;
5131 let mut bindings = vec![];
5132 if let Some(ref data) = segment.args {
5133 data.args.iter().for_each(|arg| match arg {
5134 GenericArg::Lifetime(lt) => lifetimes.push(lt.clone()),
5135 GenericArg::Type(ty) => types.push(ty.clone()),
5137 bindings = data.bindings.clone().to_vec();
5145 let mut lt_accepted = 0;
5146 let mut ty_params = ParamRange { required: 0, accepted: 0 };
5147 for param in &generics.params {
5149 GenericParamDefKind::Lifetime => lt_accepted += 1,
5150 GenericParamDefKind::Type { has_default, .. } => {
5151 ty_params.accepted += 1;
5153 ty_params.required += 1;
5158 if generics.parent.is_none() && generics.has_self {
5159 ty_params.required -= 1;
5160 ty_params.accepted -= 1;
5162 let ty_accepted = ty_params.accepted;
5163 let ty_required = ty_params.required;
5165 let count_ty_params = |n| format!("{} type parameter{}", n, if n == 1 { "" } else { "s" });
5166 let expected_text = count_ty_params(ty_accepted);
5167 let actual_text = count_ty_params(types.len());
5168 if let Some((mut err, span)) = if types.len() > ty_accepted {
5169 // To prevent derived errors to accumulate due to extra
5170 // type parameters, we force instantiate_value_path to
5171 // use inference variables instead of the provided types.
5174 let span = types[ty_accepted].span;
5175 Some((struct_span_err!(self.tcx.sess, span, E0087,
5176 "too many type parameters provided: \
5177 expected at most {}, found {}",
5178 expected_text, actual_text), span))
5179 } else if types.len() < ty_required && !infer_types && !supress_mismatch_error {
5180 Some((struct_span_err!(self.tcx.sess, span, E0089,
5181 "too few type parameters provided: \
5182 expected {}, found {}",
5183 expected_text, actual_text), span))
5187 self.set_tainted_by_errors(); // #53251
5188 err.span_label(span, format!("expected {}", expected_text)).emit();
5191 if !bindings.is_empty() {
5192 AstConv::prohibit_projection(self, bindings[0].span);
5195 let infer_lifetimes = lifetimes.len() == 0;
5196 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
5197 let has_late_bound_lifetime_defs = generics.has_late_bound_regions;
5198 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
5199 // Report this as a lint only if no error was reported previously.
5200 let primary_msg = "cannot specify lifetime arguments explicitly \
5201 if late bound lifetime parameters are present";
5202 let note_msg = "the late bound lifetime parameter is introduced here";
5203 if !is_method_call && (lifetimes.len() > lt_accepted ||
5204 lifetimes.len() < lt_accepted && !infer_lifetimes) {
5205 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
5206 err.span_note(span_late, note_msg);
5211 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
5212 multispan.push_span_label(span_late, note_msg.to_string());
5213 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
5214 lifetimes[0].id, multispan, primary_msg);
5219 let count_lifetime_params = |n| {
5220 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
5222 let expected_text = count_lifetime_params(lt_accepted);
5223 let actual_text = count_lifetime_params(lifetimes.len());
5224 if let Some((mut err, span)) = if lifetimes.len() > lt_accepted {
5225 let span = lifetimes[lt_accepted].span;
5226 Some((struct_span_err!(self.tcx.sess, span, E0088,
5227 "too many lifetime parameters provided: \
5228 expected at most {}, found {}",
5229 expected_text, actual_text), span))
5230 } else if lifetimes.len() < lt_accepted && !infer_lifetimes {
5231 Some((struct_span_err!(self.tcx.sess, span, E0090,
5232 "too few lifetime parameters provided: \
5233 expected {}, found {}",
5234 expected_text, actual_text), span))
5238 err.span_label(span, format!("expected {}", expected_text)).emit();
5242 /// Report error if there is an explicit type parameter when using `impl Trait`.
5243 fn check_impl_trait(&self,
5245 seg: &hir::PathSegment,
5246 generics: &ty::Generics)
5248 let explicit = !seg.infer_types;
5249 let impl_trait = generics.params.iter().any(|param| match param.kind {
5250 ty::GenericParamDefKind::Type {
5251 synthetic: Some(hir::SyntheticTyParamKind::ImplTrait), ..
5256 if explicit && impl_trait {
5257 let mut err = struct_span_err! {
5261 "cannot provide explicit type parameters when `impl Trait` is \
5262 used in argument position."
5271 // Resolves `typ` by a single level if `typ` is a type variable.
5272 // If no resolution is possible, then an error is reported.
5273 // Numeric inference variables may be left unresolved.
5274 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5275 let ty = self.resolve_type_vars_with_obligations(ty);
5276 if !ty.is_ty_var() {
5279 if !self.is_tainted_by_errors() {
5280 self.need_type_info_err((**self).body_id, sp, ty)
5281 .note("type must be known at this point")
5284 self.demand_suptype(sp, self.tcx.types.err, ty);
5289 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5290 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5291 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5294 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5295 index = enclosing_breakables.stack.len();
5296 enclosing_breakables.by_id.insert(id, index);
5297 enclosing_breakables.stack.push(ctxt);
5301 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5302 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5303 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5304 enclosing_breakables.stack.pop().expect("missing breakable context")
5310 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5311 generics: &ty::Generics,
5313 let own_counts = generics.own_counts();
5314 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5316 if own_counts.types == 0 {
5319 // Make a vector of booleans initially false, set to true when used.
5320 let mut types_used = vec![false; own_counts.types];
5322 for leaf_ty in ty.walk() {
5323 if let ty::TyParam(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5324 debug!("Found use of ty param num {}", idx);
5325 types_used[idx as usize - own_counts.lifetimes] = true;
5326 } else if let ty::TyError = leaf_ty.sty {
5327 // If there is already another error, do not emit
5328 // an error for not using a type Parameter.
5329 assert!(tcx.sess.err_count() > 0);
5334 let types = generics.params.iter().filter(|param| match param.kind {
5335 ty::GenericParamDefKind::Type { .. } => true,
5338 for (&used, param) in types_used.iter().zip(types) {
5340 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5341 let span = tcx.hir.span(id);
5342 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5343 .span_label(span, "unused type parameter")
5349 fn fatally_break_rust(sess: &Session) {
5350 let handler = sess.diagnostic();
5351 handler.span_bug_no_panic(
5353 "It looks like you're trying to break rust; would you like some ICE?",
5355 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5356 handler.note_without_error(
5357 "we would appreciate a joke overview: \
5358 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5360 handler.note_without_error(&format!("rustc {} running on {}",
5361 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5362 ::session::config::host_triple(),