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::{ConstValue, GlobalId};
98 use rustc::ty::subst::{CanonicalSubsts, 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::{Applicability, DiagnosticBuilder, DiagnosticId};
107 use require_c_abi_if_variadic;
108 use session::{CompileIncomplete, config, Session};
111 use util::common::{ErrorReported, indenter};
112 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
114 use std::cell::{Cell, RefCell, Ref, RefMut};
115 use rustc_data_structures::sync::Lrc;
116 use std::collections::hash_map::Entry;
118 use std::fmt::Display;
120 use std::mem::replace;
121 use std::ops::{self, Deref};
122 use rustc_target::spec::abi::Abi;
125 use syntax::source_map::DUMMY_SP;
126 use syntax::source_map::original_sp;
127 use syntax::feature_gate::{GateIssue, emit_feature_err};
129 use syntax::symbol::{Symbol, LocalInternedString, keywords};
130 use syntax::util::lev_distance::find_best_match_for_name;
131 use syntax_pos::{self, BytePos, Span, MultiSpan};
133 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
134 use rustc::hir::itemlikevisit::ItemLikeVisitor;
135 use rustc::hir::Node;
136 use rustc::hir::{self, PatKind, ItemKind};
137 use rustc::middle::lang_items;
153 mod generator_interior;
157 /// A wrapper for InferCtxt's `in_progress_tables` field.
158 #[derive(Copy, Clone)]
159 struct MaybeInProgressTables<'a, 'tcx: 'a> {
160 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
163 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
164 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
165 match self.maybe_tables {
166 Some(tables) => tables.borrow(),
168 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
173 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
174 match self.maybe_tables {
175 Some(tables) => tables.borrow_mut(),
177 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
184 /// closures defined within the function. For example:
187 /// bar(move|| { ... })
190 /// Here, the function `foo()` and the closure passed to
191 /// `bar()` will each have their own `FnCtxt`, but they will
192 /// share the inherited fields.
193 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
194 infcx: InferCtxt<'a, 'gcx, 'tcx>,
196 tables: MaybeInProgressTables<'a, 'tcx>,
198 locals: RefCell<NodeMap<Ty<'tcx>>>,
200 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
202 // When we process a call like `c()` where `c` is a closure type,
203 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
204 // `FnOnce` closure. In that case, we defer full resolution of the
205 // call until upvar inference can kick in and make the
206 // decision. We keep these deferred resolutions grouped by the
207 // def-id of the closure, so that once we decide, we can easily go
208 // back and process them.
209 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
211 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
213 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
215 // Anonymized types found in explicit return types and their
216 // associated fresh inference variable. Writeback resolves these
217 // variables to get the concrete type, which can be used to
218 // deanonymize Anon, after typeck is done with all functions.
219 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
221 /// Each type parameter has an implicit region bound that
222 /// indicates it must outlive at least the function body (the user
223 /// may specify stronger requirements). This field indicates the
224 /// region of the callee. If it is `None`, then the parameter
225 /// environment is for an item or something where the "callee" is
227 implicit_region_bound: Option<ty::Region<'tcx>>,
229 body_id: Option<hir::BodyId>,
232 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
233 type Target = InferCtxt<'a, 'gcx, 'tcx>;
234 fn deref(&self) -> &Self::Target {
239 /// When type-checking an expression, we propagate downward
240 /// whatever type hint we are able in the form of an `Expectation`.
241 #[derive(Copy, Clone, Debug)]
242 pub enum Expectation<'tcx> {
243 /// We know nothing about what type this expression should have.
246 /// This expression is an `if` condition, it must resolve to `bool`.
249 /// This expression should have the type given (or some subtype)
250 ExpectHasType(Ty<'tcx>),
252 /// This expression will be cast to the `Ty`
253 ExpectCastableToType(Ty<'tcx>),
255 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
256 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
257 ExpectRvalueLikeUnsized(Ty<'tcx>),
260 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
261 // Disregard "castable to" expectations because they
262 // can lead us astray. Consider for example `if cond
263 // {22} else {c} as u8` -- if we propagate the
264 // "castable to u8" constraint to 22, it will pick the
265 // type 22u8, which is overly constrained (c might not
266 // be a u8). In effect, the problem is that the
267 // "castable to" expectation is not the tightest thing
268 // we can say, so we want to drop it in this case.
269 // The tightest thing we can say is "must unify with
270 // else branch". Note that in the case of a "has type"
271 // constraint, this limitation does not hold.
273 // If the expected type is just a type variable, then don't use
274 // an expected type. Otherwise, we might write parts of the type
275 // when checking the 'then' block which are incompatible with the
277 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
279 ExpectHasType(ety) => {
280 let ety = fcx.shallow_resolve(ety);
281 if !ety.is_ty_var() {
287 ExpectRvalueLikeUnsized(ety) => {
288 ExpectRvalueLikeUnsized(ety)
294 /// Provide an expectation for an rvalue expression given an *optional*
295 /// hint, which is not required for type safety (the resulting type might
296 /// be checked higher up, as is the case with `&expr` and `box expr`), but
297 /// is useful in determining the concrete type.
299 /// The primary use case is where the expected type is a fat pointer,
300 /// like `&[isize]`. For example, consider the following statement:
302 /// let x: &[isize] = &[1, 2, 3];
304 /// In this case, the expected type for the `&[1, 2, 3]` expression is
305 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
306 /// expectation `ExpectHasType([isize])`, that would be too strong --
307 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
308 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
309 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
310 /// which still is useful, because it informs integer literals and the like.
311 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
312 /// for examples of where this comes up,.
313 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
314 match fcx.tcx.struct_tail(ty).sty {
315 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
316 ExpectRvalueLikeUnsized(ty)
318 _ => ExpectHasType(ty)
322 // Resolves `expected` by a single level if it is a variable. If
323 // there is no expected type or resolution is not possible (e.g.,
324 // no constraints yet present), just returns `None`.
325 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
327 NoExpectation => NoExpectation,
328 ExpectIfCondition => ExpectIfCondition,
329 ExpectCastableToType(t) => {
330 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
332 ExpectHasType(t) => {
333 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
335 ExpectRvalueLikeUnsized(t) => {
336 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
341 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
342 match self.resolve(fcx) {
343 NoExpectation => None,
344 ExpectIfCondition => Some(fcx.tcx.types.bool),
345 ExpectCastableToType(ty) |
347 ExpectRvalueLikeUnsized(ty) => Some(ty),
351 /// It sometimes happens that we want to turn an expectation into
352 /// a **hard constraint** (i.e., something that must be satisfied
353 /// for the program to type-check). `only_has_type` will return
354 /// such a constraint, if it exists.
355 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
356 match self.resolve(fcx) {
357 ExpectHasType(ty) => Some(ty),
358 ExpectIfCondition => Some(fcx.tcx.types.bool),
359 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
363 /// Like `only_has_type`, but instead of returning `None` if no
364 /// hard constraint exists, creates a fresh type variable.
365 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
366 self.only_has_type(fcx)
367 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
371 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
378 fn maybe_mut_place(m: hir::Mutability) -> Self {
380 hir::MutMutable => Needs::MutPlace,
381 hir::MutImmutable => Needs::None,
386 #[derive(Copy, Clone)]
387 pub struct UnsafetyState {
388 pub def: ast::NodeId,
389 pub unsafety: hir::Unsafety,
390 pub unsafe_push_count: u32,
395 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
396 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
399 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
400 match self.unsafety {
401 // If this unsafe, then if the outer function was already marked as
402 // unsafe we shouldn't attribute the unsafe'ness to the block. This
403 // way the block can be warned about instead of ignoring this
404 // extraneous block (functions are never warned about).
405 hir::Unsafety::Unsafe if self.from_fn => *self,
408 let (unsafety, def, count) = match blk.rules {
409 hir::PushUnsafeBlock(..) =>
410 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
411 hir::PopUnsafeBlock(..) =>
412 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
413 hir::UnsafeBlock(..) =>
414 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
416 (unsafety, self.def, self.unsafe_push_count),
420 unsafe_push_count: count,
427 #[derive(Debug, Copy, Clone)]
433 /// Tracks whether executing a node may exit normally (versus
434 /// return/break/panic, which "diverge", leaving dead code in their
435 /// wake). Tracked semi-automatically (through type variables marked
436 /// as diverging), with some manual adjustments for control-flow
437 /// primitives (approximating a CFG).
438 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
440 /// Potentially unknown, some cases converge,
441 /// others require a CFG to determine them.
444 /// Definitely known to diverge and therefore
445 /// not reach the next sibling or its parent.
448 /// Same as `Always` but with a reachability
449 /// warning already emitted
453 // Convenience impls for combinig `Diverges`.
455 impl ops::BitAnd for Diverges {
457 fn bitand(self, other: Self) -> Self {
458 cmp::min(self, other)
462 impl ops::BitOr for Diverges {
464 fn bitor(self, other: Self) -> Self {
465 cmp::max(self, other)
469 impl ops::BitAndAssign for Diverges {
470 fn bitand_assign(&mut self, other: Self) {
471 *self = *self & other;
475 impl ops::BitOrAssign for Diverges {
476 fn bitor_assign(&mut self, other: Self) {
477 *self = *self | other;
482 fn always(self) -> bool {
483 self >= Diverges::Always
487 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
490 // this is `null` for loops where break with a value is illegal,
491 // such as `while`, `for`, and `while let`
492 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
495 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
496 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
497 by_id: NodeMap<usize>,
500 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
501 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
502 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
503 bug!("could not find enclosing breakable with id {}", target_id);
510 struct PathSeg(DefId, usize);
512 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
513 body_id: ast::NodeId,
515 /// The parameter environment used for proving trait obligations
516 /// in this function. This can change when we descend into
517 /// closures (as they bring new things into scope), hence it is
518 /// not part of `Inherited` (as of the time of this writing,
519 /// closures do not yet change the environment, but they will
521 param_env: ty::ParamEnv<'tcx>,
523 // Number of errors that had been reported when we started
524 // checking this function. On exit, if we find that *more* errors
525 // have been reported, we will skip regionck and other work that
526 // expects the types within the function to be consistent.
527 err_count_on_creation: usize,
529 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
531 yield_ty: Option<Ty<'tcx>>,
533 ps: RefCell<UnsafetyState>,
535 /// Whether the last checked node generates a divergence (e.g.,
536 /// `return` will set this to Always). In general, when entering
537 /// an expression or other node in the tree, the initial value
538 /// indicates whether prior parts of the containing expression may
539 /// have diverged. It is then typically set to `Maybe` (and the
540 /// old value remembered) for processing the subparts of the
541 /// current expression. As each subpart is processed, they may set
542 /// the flag to `Always` etc. Finally, at the end, we take the
543 /// result and "union" it with the original value, so that when we
544 /// return the flag indicates if any subpart of the the parent
545 /// expression (up to and including this part) has diverged. So,
546 /// if you read it after evaluating a subexpression `X`, the value
547 /// you get indicates whether any subexpression that was
548 /// evaluating up to and including `X` diverged.
550 /// We currently use this flag only for diagnostic purposes:
552 /// - To warn about unreachable code: if, after processing a
553 /// sub-expression but before we have applied the effects of the
554 /// current node, we see that the flag is set to `Always`, we
555 /// can issue a warning. This corresponds to something like
556 /// `foo(return)`; we warn on the `foo()` expression. (We then
557 /// update the flag to `WarnedAlways` to suppress duplicate
558 /// reports.) Similarly, if we traverse to a fresh statement (or
559 /// tail expression) from a `Always` setting, we will issue a
560 /// warning. This corresponds to something like `{return;
561 /// foo();}` or `{return; 22}`, where we would warn on the
564 /// An expression represents dead-code if, after checking it,
565 /// the diverges flag is set to something other than `Maybe`.
566 diverges: Cell<Diverges>,
568 /// Whether any child nodes have any type errors.
569 has_errors: Cell<bool>,
571 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
573 inh: &'a Inherited<'a, 'gcx, 'tcx>,
576 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
577 type Target = Inherited<'a, 'gcx, 'tcx>;
578 fn deref(&self) -> &Self::Target {
583 /// Helper type of a temporary returned by Inherited::build(...).
584 /// Necessary because we can't write the following bound:
585 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
586 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
587 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
591 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
592 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
593 -> InheritedBuilder<'a, 'gcx, 'tcx> {
594 let hir_id_root = if def_id.is_local() {
595 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
596 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
597 DefId::local(hir_id.owner)
603 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
609 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
610 fn enter<F, R>(&'tcx mut self, f: F) -> R
611 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
613 let def_id = self.def_id;
614 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
618 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
619 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
621 let item_id = tcx.hir.as_local_node_id(def_id);
622 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
623 let implicit_region_bound = body_id.map(|body_id| {
624 let body = tcx.hir.body(body_id);
625 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
629 tables: MaybeInProgressTables {
630 maybe_tables: infcx.in_progress_tables,
633 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
634 locals: RefCell::new(NodeMap()),
635 deferred_call_resolutions: RefCell::new(DefIdMap()),
636 deferred_cast_checks: RefCell::new(Vec::new()),
637 deferred_generator_interiors: RefCell::new(Vec::new()),
638 anon_types: RefCell::new(DefIdMap()),
639 implicit_region_bound,
644 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
645 debug!("register_predicate({:?})", obligation);
646 if obligation.has_escaping_regions() {
647 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
652 .register_predicate_obligation(self, obligation);
655 fn register_predicates<I>(&self, obligations: I)
656 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
657 for obligation in obligations {
658 self.register_predicate(obligation);
662 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
663 self.register_predicates(infer_ok.obligations);
667 fn normalize_associated_types_in<T>(&self,
669 body_id: ast::NodeId,
670 param_env: ty::ParamEnv<'tcx>,
672 where T : TypeFoldable<'tcx>
674 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
675 self.register_infer_ok_obligations(ok)
679 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
681 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
682 fn visit_item(&mut self, i: &'tcx hir::Item) {
683 check_item_type(self.tcx, i);
685 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
686 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
689 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
690 tcx.sess.track_errors(|| {
691 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
692 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
696 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
697 tcx.sess.track_errors(|| {
698 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
702 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
703 tcx.typeck_item_bodies(LOCAL_CRATE)
706 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
707 -> Result<(), CompileIncomplete>
709 debug_assert!(crate_num == LOCAL_CRATE);
710 Ok(tcx.sess.track_errors(|| {
711 tcx.par_body_owners(|body_owner_def_id| {
712 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
717 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
718 wfcheck::check_item_well_formed(tcx, def_id);
721 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
722 wfcheck::check_trait_item(tcx, def_id);
725 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
726 wfcheck::check_impl_item(tcx, def_id);
729 pub fn provide(providers: &mut Providers) {
730 method::provide(providers);
731 *providers = Providers {
737 check_item_well_formed,
738 check_trait_item_well_formed,
739 check_impl_item_well_formed,
744 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
746 -> Option<ty::Destructor> {
747 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
750 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
751 /// with information about it's body-id and fn-decl (if any). Otherwise,
754 /// If this function returns "some", then `typeck_tables(def_id)` will
755 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
756 /// may not succeed. In some cases where this function returns `None`
757 /// (notably closures), `typeck_tables(def_id)` would wind up
758 /// redirecting to the owning function.
759 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
761 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
763 match tcx.hir.get(id) {
764 Node::Item(item) => {
766 hir::ItemKind::Const(_, body) |
767 hir::ItemKind::Static(_, _, body) =>
769 hir::ItemKind::Fn(ref decl, .., body) =>
770 Some((body, Some(decl))),
775 Node::TraitItem(item) => {
777 hir::TraitItemKind::Const(_, Some(body)) =>
779 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
780 Some((body, Some(&sig.decl))),
785 Node::ImplItem(item) => {
787 hir::ImplItemKind::Const(_, body) =>
789 hir::ImplItemKind::Method(ref sig, body) =>
790 Some((body, Some(&sig.decl))),
795 Node::AnonConst(constant) => Some((constant.body, None)),
800 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
803 // Closures' tables come from their outermost function,
804 // as they are part of the same "inference environment".
805 let outer_def_id = tcx.closure_base_def_id(def_id);
806 if outer_def_id != def_id {
807 return tcx.has_typeck_tables(outer_def_id);
810 let id = tcx.hir.as_local_node_id(def_id).unwrap();
811 primary_body_of(tcx, id).is_some()
814 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
817 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
820 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
822 -> &'tcx ty::TypeckTables<'tcx> {
823 // Closures' tables come from their outermost function,
824 // as they are part of the same "inference environment".
825 let outer_def_id = tcx.closure_base_def_id(def_id);
826 if outer_def_id != def_id {
827 return tcx.typeck_tables_of(outer_def_id);
830 let id = tcx.hir.as_local_node_id(def_id).unwrap();
831 let span = tcx.hir.span(id);
833 // Figure out what primary body this item has.
834 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
835 span_bug!(span, "can't type-check body of {:?}", def_id);
837 let body = tcx.hir.body(body_id);
839 let tables = Inherited::build(tcx, def_id).enter(|inh| {
840 let param_env = tcx.param_env(def_id);
841 let fcx = if let Some(decl) = fn_decl {
842 let fn_sig = tcx.fn_sig(def_id);
844 check_abi(tcx, span, fn_sig.abi());
846 // Compute the fty from point of view of inside fn.
848 tcx.liberate_late_bound_regions(def_id, &fn_sig);
850 inh.normalize_associated_types_in(body.value.span,
855 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
858 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
859 let expected_type = tcx.type_of(def_id);
860 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
861 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
863 // Gather locals in statics (because of block expressions).
864 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
866 fcx.check_expr_coercable_to_type(&body.value, expected_type);
871 // All type checking constraints were added, try to fallback unsolved variables.
872 fcx.select_obligations_where_possible(false);
873 let mut fallback_has_occurred = false;
874 for ty in &fcx.unsolved_variables() {
875 fallback_has_occurred |= fcx.fallback_if_possible(ty);
877 fcx.select_obligations_where_possible(fallback_has_occurred);
879 // Even though coercion casts provide type hints, we check casts after fallback for
880 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
883 // Closure and generator analysis may run after fallback
884 // because they don't constrain other type variables.
885 fcx.closure_analyze(body);
886 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
887 fcx.resolve_generator_interiors(def_id);
888 fcx.select_all_obligations_or_error();
890 if fn_decl.is_some() {
891 fcx.regionck_fn(id, body);
893 fcx.regionck_expr(body);
896 fcx.resolve_type_vars_in_body(body)
899 // Consistency check our TypeckTables instance can hold all ItemLocalIds
900 // it will need to hold.
901 assert_eq!(tables.local_id_root,
902 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
906 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
907 if !tcx.sess.target.target.is_abi_supported(abi) {
908 struct_span_err!(tcx.sess, span, E0570,
909 "The ABI `{}` is not supported for the current target", abi).emit()
913 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
914 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
917 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
918 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
921 // infer the variable's type
922 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
923 self.fcx.locals.borrow_mut().insert(nid, var_ty);
927 // take type that the user specified
928 self.fcx.locals.borrow_mut().insert(nid, typ);
935 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
936 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
937 NestedVisitorMap::None
940 // Add explicitly-declared locals.
941 fn visit_local(&mut self, local: &'gcx hir::Local) {
942 let o_ty = match local.ty {
944 let o_ty = self.fcx.to_ty(&ty);
946 let c_ty = self.fcx.inh.infcx.canonicalize_response(&o_ty);
947 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
948 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
954 self.assign(local.span, local.id, o_ty);
956 debug!("Local variable {:?} is assigned type {}",
958 self.fcx.ty_to_string(
959 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
960 intravisit::walk_local(self, local);
963 // Add pattern bindings.
964 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
965 if let PatKind::Binding(_, _, ident, _) = p.node {
966 let var_ty = self.assign(p.span, p.id, None);
968 if !self.fcx.tcx.features().unsized_locals {
969 self.fcx.require_type_is_sized(var_ty, p.span,
970 traits::VariableType(p.id));
973 debug!("Pattern binding {} is assigned to {} with type {:?}",
975 self.fcx.ty_to_string(
976 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
979 intravisit::walk_pat(self, p);
982 // Don't descend into the bodies of nested closures
983 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
984 _: hir::BodyId, _: Span, _: ast::NodeId) { }
987 /// When `check_fn` is invoked on a generator (i.e., a body that
988 /// includes yield), it returns back some information about the yield
990 struct GeneratorTypes<'tcx> {
991 /// Type of value that is yielded.
992 yield_ty: ty::Ty<'tcx>,
994 /// Types that are captured (see `GeneratorInterior` for more).
995 interior: ty::Ty<'tcx>,
997 /// Indicates if the generator is movable or static (immovable)
998 movability: hir::GeneratorMovability,
1001 /// Helper used for fns and closures. Does the grungy work of checking a function
1002 /// body and returns the function context used for that purpose, since in the case of a fn item
1003 /// there is still a bit more to do.
1006 /// * inherited: other fields inherited from the enclosing fn (if any)
1007 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1008 param_env: ty::ParamEnv<'tcx>,
1009 fn_sig: ty::FnSig<'tcx>,
1010 decl: &'gcx hir::FnDecl,
1012 body: &'gcx hir::Body,
1013 can_be_generator: Option<hir::GeneratorMovability>)
1014 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1016 let mut fn_sig = fn_sig.clone();
1018 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1020 // Create the function context. This is either derived from scratch or,
1021 // in the case of closures, based on the outer context.
1022 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1023 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1025 let declared_ret_ty = fn_sig.output();
1026 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1027 let revealed_ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &declared_ret_ty);
1028 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1029 fn_sig = fcx.tcx.mk_fn_sig(
1030 fn_sig.inputs().iter().cloned(),
1037 let span = body.value.span;
1039 if body.is_generator && can_be_generator.is_some() {
1040 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1041 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1042 fcx.yield_ty = Some(yield_ty);
1045 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1047 // Add formal parameters.
1048 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1049 // Check the pattern.
1050 fcx.check_pat_walk(&arg.pat, arg_ty,
1051 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1053 // Check that argument is Sized.
1054 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1055 // for simple cases like `fn foo(x: Trait)`,
1056 // where we would error once on the parameter as a whole, and once on the binding `x`.
1057 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1058 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1061 fcx.write_ty(arg.hir_id, arg_ty);
1064 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1065 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1067 fcx.check_return_expr(&body.value);
1069 // We insert the deferred_generator_interiors entry after visiting the body.
1070 // This ensures that all nested generators appear before the entry of this generator.
1071 // resolve_generator_interiors relies on this property.
1072 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1073 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1074 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1075 Some(GeneratorTypes {
1076 yield_ty: fcx.yield_ty.unwrap(),
1078 movability: can_be_generator.unwrap(),
1084 // Finalize the return check by taking the LUB of the return types
1085 // we saw and assigning it to the expected return type. This isn't
1086 // really expected to fail, since the coercions would have failed
1087 // earlier when trying to find a LUB.
1089 // However, the behavior around `!` is sort of complex. In the
1090 // event that the `actual_return_ty` comes back as `!`, that
1091 // indicates that the fn either does not return or "returns" only
1092 // values of type `!`. In this case, if there is an expected
1093 // return type that is *not* `!`, that should be ok. But if the
1094 // return type is being inferred, we want to "fallback" to `!`:
1096 // let x = move || panic!();
1098 // To allow for that, I am creating a type variable with diverging
1099 // fallback. This was deemed ever so slightly better than unifying
1100 // the return value with `!` because it allows for the caller to
1101 // make more assumptions about the return type (e.g., they could do
1103 // let y: Option<u32> = Some(x());
1105 // which would then cause this return type to become `u32`, not
1107 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1108 let mut actual_return_ty = coercion.complete(&fcx);
1109 if actual_return_ty.is_never() {
1110 actual_return_ty = fcx.next_diverging_ty_var(
1111 TypeVariableOrigin::DivergingFn(span));
1113 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1115 // Check that the main return type implements the termination trait.
1116 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1117 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1120 config::EntryFnType::Main => {
1121 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1122 let trait_ref = ty::TraitRef::new(term_id, substs);
1123 let return_ty_span = decl.output.span();
1124 let cause = traits::ObligationCause::new(
1125 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1127 inherited.register_predicate(
1128 traits::Obligation::new(
1129 cause, param_env, trait_ref.to_predicate()));
1131 config::EntryFnType::Start => {},
1137 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1138 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1139 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1140 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1141 if declared_ret_ty.sty != ty::Never {
1142 fcx.tcx.sess.span_err(
1144 "return type should be `!`",
1148 let inputs = fn_sig.inputs();
1149 let span = fcx.tcx.hir.span(fn_id);
1150 if inputs.len() == 1 {
1151 let arg_is_panic_info = match inputs[0].sty {
1152 ty::Ref(region, ty, mutbl) => match ty.sty {
1153 ty::Adt(ref adt, _) => {
1154 adt.did == panic_info_did &&
1155 mutbl == hir::Mutability::MutImmutable &&
1156 *region != RegionKind::ReStatic
1163 if !arg_is_panic_info {
1164 fcx.tcx.sess.span_err(
1165 decl.inputs[0].span,
1166 "argument should be `&PanicInfo`",
1170 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1171 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1172 if !generics.params.is_empty() {
1173 fcx.tcx.sess.span_err(
1175 "should have no type parameters",
1181 let span = fcx.tcx.sess.source_map().def_span(span);
1182 fcx.tcx.sess.span_err(span, "function should have one argument");
1185 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1190 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1191 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1192 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1193 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1194 if declared_ret_ty.sty != ty::Never {
1195 fcx.tcx.sess.span_err(
1197 "return type should be `!`",
1201 let inputs = fn_sig.inputs();
1202 let span = fcx.tcx.hir.span(fn_id);
1203 if inputs.len() == 1 {
1204 let arg_is_alloc_layout = match inputs[0].sty {
1205 ty::Adt(ref adt, _) => {
1206 adt.did == alloc_layout_did
1211 if !arg_is_alloc_layout {
1212 fcx.tcx.sess.span_err(
1213 decl.inputs[0].span,
1214 "argument should be `Layout`",
1218 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1219 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1220 if !generics.params.is_empty() {
1221 fcx.tcx.sess.span_err(
1223 "`#[alloc_error_handler]` function should have no type \
1230 let span = fcx.tcx.sess.source_map().def_span(span);
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 = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1383 bug!("Matching on non-ByRef static")
1385 if alloc.relocations.len() != 0 {
1386 let msg = "statics with a custom `#[link_section]` must be a \
1387 simple list of bytes on the wasm target with no \
1388 extra levels of indirection such as references";
1389 tcx.sess.span_err(span, msg);
1394 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1395 trait_def_id: DefId,
1397 let item_def_id = tcx.hir.local_def_id(item.id);
1398 // an error would be reported if this fails.
1399 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1402 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1403 impl_item: &hir::ImplItem,
1406 let mut err = struct_span_err!(
1407 tcx.sess, impl_item.span, E0520,
1408 "`{}` specializes an item from a parent `impl`, but \
1409 that item is not marked `default`",
1411 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1414 match tcx.span_of_impl(parent_impl) {
1416 err.span_label(span, "parent `impl` is here");
1417 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1421 err.note(&format!("parent implementation is in crate `{}`", cname));
1428 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1429 trait_def: &ty::TraitDef,
1430 trait_item: &ty::AssociatedItem,
1432 impl_item: &hir::ImplItem)
1434 let ancestors = trait_def.ancestors(tcx, impl_id);
1436 let kind = match impl_item.node {
1437 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1438 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1439 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1440 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1443 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1444 .map(|node_item| node_item.map(|parent| parent.defaultness));
1446 if let Some(parent) = parent {
1447 if tcx.impl_item_is_final(&parent) {
1448 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1454 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1457 impl_trait_ref: ty::TraitRef<'tcx>,
1458 impl_item_refs: &[hir::ImplItemRef]) {
1459 let impl_span = tcx.sess.source_map().def_span(impl_span);
1461 // If the trait reference itself is erroneous (so the compilation is going
1462 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1463 // isn't populated for such impls.
1464 if impl_trait_ref.references_error() { return; }
1466 // Locate trait definition and items
1467 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1468 let mut overridden_associated_type = None;
1470 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1472 // Check existing impl methods to see if they are both present in trait
1473 // and compatible with trait signature
1474 for impl_item in impl_items() {
1475 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1476 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1477 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1478 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1480 // Not compatible, but needed for the error message
1481 tcx.associated_items(impl_trait_ref.def_id)
1482 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1485 // Check that impl definition matches trait definition
1486 if let Some(ty_trait_item) = ty_trait_item {
1487 match impl_item.node {
1488 hir::ImplItemKind::Const(..) => {
1489 // Find associated const definition.
1490 if ty_trait_item.kind == ty::AssociatedKind::Const {
1491 compare_const_impl(tcx,
1497 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1498 "item `{}` is an associated const, \
1499 which doesn't match its trait `{}`",
1502 err.span_label(impl_item.span, "does not match trait");
1503 // We can only get the spans from local trait definition
1504 // Same for E0324 and E0325
1505 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1506 err.span_label(trait_span, "item in trait");
1511 hir::ImplItemKind::Method(..) => {
1512 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1513 if ty_trait_item.kind == ty::AssociatedKind::Method {
1514 compare_impl_method(tcx,
1521 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1522 "item `{}` is an associated method, \
1523 which doesn't match its trait `{}`",
1526 err.span_label(impl_item.span, "does not match trait");
1527 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1528 err.span_label(trait_span, "item in trait");
1533 hir::ImplItemKind::Existential(..) |
1534 hir::ImplItemKind::Type(_) => {
1535 if ty_trait_item.kind == ty::AssociatedKind::Type {
1536 if ty_trait_item.defaultness.has_value() {
1537 overridden_associated_type = Some(impl_item);
1540 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1541 "item `{}` is an associated type, \
1542 which doesn't match its trait `{}`",
1545 err.span_label(impl_item.span, "does not match trait");
1546 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1547 err.span_label(trait_span, "item in trait");
1554 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1558 // Check for missing items from trait
1559 let mut missing_items = Vec::new();
1560 let mut invalidated_items = Vec::new();
1561 let associated_type_overridden = overridden_associated_type.is_some();
1562 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1563 let is_implemented = trait_def.ancestors(tcx, impl_id)
1564 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1566 .map(|node_item| !node_item.node.is_from_trait())
1569 if !is_implemented && !tcx.impl_is_default(impl_id) {
1570 if !trait_item.defaultness.has_value() {
1571 missing_items.push(trait_item);
1572 } else if associated_type_overridden {
1573 invalidated_items.push(trait_item.ident);
1578 if !missing_items.is_empty() {
1579 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1580 "not all trait items implemented, missing: `{}`",
1581 missing_items.iter()
1582 .map(|trait_item| trait_item.ident.to_string())
1583 .collect::<Vec<_>>().join("`, `"));
1584 err.span_label(impl_span, format!("missing `{}` in implementation",
1585 missing_items.iter()
1586 .map(|trait_item| trait_item.ident.to_string())
1587 .collect::<Vec<_>>().join("`, `")));
1588 for trait_item in missing_items {
1589 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1590 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1592 err.note_trait_signature(trait_item.ident.to_string(),
1593 trait_item.signature(&tcx));
1599 if !invalidated_items.is_empty() {
1600 let invalidator = overridden_associated_type.unwrap();
1601 span_err!(tcx.sess, invalidator.span, E0399,
1602 "the following trait items need to be reimplemented \
1603 as `{}` was overridden: `{}`",
1605 invalidated_items.iter()
1606 .map(|name| name.to_string())
1607 .collect::<Vec<_>>().join("`, `"))
1611 /// Checks whether a type can be represented in memory. In particular, it
1612 /// identifies types that contain themselves without indirection through a
1613 /// pointer, which would mean their size is unbounded.
1614 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1618 let rty = tcx.type_of(item_def_id);
1620 // Check that it is possible to represent this type. This call identifies
1621 // (1) types that contain themselves and (2) types that contain a different
1622 // recursive type. It is only necessary to throw an error on those that
1623 // contain themselves. For case 2, there must be an inner type that will be
1624 // caught by case 1.
1625 match rty.is_representable(tcx, sp) {
1626 Representability::SelfRecursive(spans) => {
1627 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1629 err.span_label(span, "recursive without indirection");
1634 Representability::Representable | Representability::ContainsRecursive => (),
1639 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1640 let t = tcx.type_of(def_id);
1642 ty::Adt(def, substs) if def.is_struct() => {
1643 let fields = &def.non_enum_variant().fields;
1644 if fields.is_empty() {
1645 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1648 let e = fields[0].ty(tcx, substs);
1649 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1650 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1651 .span_label(sp, "SIMD elements must have the same type")
1656 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1657 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1659 span_err!(tcx.sess, sp, E0077,
1660 "SIMD vector element type should be machine type");
1669 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1670 let repr = tcx.adt_def(def_id).repr;
1672 for attr in tcx.get_attrs(def_id).iter() {
1673 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1674 if let attr::ReprPacked(pack) = r {
1675 if pack != repr.pack {
1676 struct_span_err!(tcx.sess, sp, E0634,
1677 "type has conflicting packed representation hints").emit();
1683 struct_span_err!(tcx.sess, sp, E0587,
1684 "type has conflicting packed and align representation hints").emit();
1686 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1687 struct_span_err!(tcx.sess, sp, E0588,
1688 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1693 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1695 stack: &mut Vec<DefId>) -> bool {
1696 let t = tcx.type_of(def_id);
1697 if stack.contains(&def_id) {
1698 debug!("check_packed_inner: {:?} is recursive", t);
1702 ty::Adt(def, substs) if def.is_struct() || def.is_union() => {
1703 if tcx.adt_def(def.did).repr.align > 0 {
1706 // push struct def_id before checking fields
1708 for field in &def.non_enum_variant().fields {
1709 let f = field.ty(tcx, substs);
1711 ty::Adt(def, _) => {
1712 if check_packed_inner(tcx, def.did, stack) {
1719 // only need to pop if not early out
1727 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1728 let adt = tcx.adt_def(def_id);
1729 if !adt.repr.transparent() {
1733 // For each field, figure out if it's known to be a ZST and align(1)
1734 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1735 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1736 let param_env = tcx.param_env(field.did);
1737 let layout = tcx.layout_of(param_env.and(ty));
1738 // We are currently checking the type this field came from, so it must be local
1739 let span = tcx.hir.span_if_local(field.did).unwrap();
1740 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1741 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1745 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1746 let non_zst_count = non_zst_fields.clone().count();
1747 if non_zst_count != 1 {
1748 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1749 struct_span_err!(tcx.sess, sp, E0690,
1750 "transparent struct needs exactly one non-zero-sized field, but has {}",
1752 .span_note(field_spans, "non-zero-sized field")
1755 for &(span, zst, align1) in &field_infos {
1757 span_err!(tcx.sess, span, E0691,
1758 "zero-sized field in transparent struct has alignment larger than 1");
1763 #[allow(trivial_numeric_casts)]
1764 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1766 vs: &'tcx [hir::Variant],
1768 let def_id = tcx.hir.local_def_id(id);
1769 let def = tcx.adt_def(def_id);
1770 def.destructor(tcx); // force the destructor to be evaluated
1773 let attributes = tcx.get_attrs(def_id);
1774 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1776 tcx.sess, attr.span, E0084,
1777 "unsupported representation for zero-variant enum")
1778 .span_label(sp, "zero-variant enum")
1783 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1784 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1785 if !tcx.features().repr128 {
1786 emit_feature_err(&tcx.sess.parse_sess,
1789 GateIssue::Language,
1790 "repr with 128-bit type is unstable");
1795 if let Some(ref e) = v.node.disr_expr {
1796 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1800 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1801 for (discr, v) in def.discriminants(tcx).zip(vs) {
1802 // Check for duplicate discriminant values
1803 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1804 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1805 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1806 let i_span = match variant_i.node.disr_expr {
1807 Some(ref expr) => tcx.hir.span(expr.id),
1808 None => tcx.hir.span(variant_i_node_id)
1810 let span = match v.node.disr_expr {
1811 Some(ref expr) => tcx.hir.span(expr.id),
1814 struct_span_err!(tcx.sess, span, E0081,
1815 "discriminant value `{}` already exists", disr_vals[i])
1816 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1817 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1820 disr_vals.push(discr);
1823 check_representable(tcx, sp, def_id);
1826 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1827 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1829 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1830 -> ty::GenericPredicates<'tcx>
1833 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1834 let item_id = tcx.hir.ty_param_owner(node_id);
1835 let item_def_id = tcx.hir.local_def_id(item_id);
1836 let generics = tcx.generics_of(item_def_id);
1837 let index = generics.param_def_id_to_index[&def_id];
1838 ty::GenericPredicates {
1840 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1842 ty::Predicate::Trait(ref data) => {
1843 data.skip_binder().self_ty().is_param(index)
1847 }).cloned().collect()
1851 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1852 -> Option<ty::Region<'tcx>> {
1854 Some(def) => infer::EarlyBoundRegion(span, def.name),
1855 None => infer::MiscVariable(span)
1857 Some(self.next_region_var(v))
1860 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1861 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1864 fn ty_infer_for_def(&self,
1865 ty_param_def: &ty::GenericParamDef,
1866 span: Span) -> Ty<'tcx> {
1867 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1873 fn projected_ty_from_poly_trait_ref(&self,
1876 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1879 let (trait_ref, _) =
1880 self.replace_late_bound_regions_with_fresh_var(
1882 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1885 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1888 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1889 if ty.has_escaping_regions() {
1890 ty // FIXME: normalization and escaping regions
1892 self.normalize_associated_types_in(span, &ty)
1896 fn set_tainted_by_errors(&self) {
1897 self.infcx.set_tainted_by_errors()
1900 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1901 self.write_ty(hir_id, ty)
1905 /// Controls whether the arguments are tupled. This is used for the call
1908 /// Tupling means that all call-side arguments are packed into a tuple and
1909 /// passed as a single parameter. For example, if tupling is enabled, this
1912 /// fn f(x: (isize, isize))
1914 /// Can be called as:
1921 #[derive(Clone, Eq, PartialEq)]
1922 enum TupleArgumentsFlag {
1927 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1928 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1929 param_env: ty::ParamEnv<'tcx>,
1930 body_id: ast::NodeId)
1931 -> FnCtxt<'a, 'gcx, 'tcx> {
1935 err_count_on_creation: inh.tcx.sess.err_count(),
1938 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1939 ast::CRATE_NODE_ID)),
1940 diverges: Cell::new(Diverges::Maybe),
1941 has_errors: Cell::new(false),
1942 enclosing_breakables: RefCell::new(EnclosingBreakables {
1950 pub fn sess(&self) -> &Session {
1954 pub fn err_count_since_creation(&self) -> usize {
1955 self.tcx.sess.err_count() - self.err_count_on_creation
1958 /// Produce warning on the given node, if the current point in the
1959 /// function is unreachable, and there hasn't been another warning.
1960 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1961 if self.diverges.get() == Diverges::Always {
1962 self.diverges.set(Diverges::WarnedAlways);
1964 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1966 self.tcx().lint_node(
1967 lint::builtin::UNREACHABLE_CODE,
1969 &format!("unreachable {}", kind));
1975 code: ObligationCauseCode<'tcx>)
1976 -> ObligationCause<'tcx> {
1977 ObligationCause::new(span, self.body_id, code)
1980 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1981 self.cause(span, ObligationCauseCode::MiscObligation)
1984 /// Resolves type variables in `ty` if possible. Unlike the infcx
1985 /// version (resolve_type_vars_if_possible), this version will
1986 /// also select obligations if it seems useful, in an effort
1987 /// to get more type information.
1988 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1989 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1991 // No Infer()? Nothing needs doing.
1992 if !ty.has_infer_types() {
1993 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1997 // If `ty` is a type variable, see whether we already know what it is.
1998 ty = self.resolve_type_vars_if_possible(&ty);
1999 if !ty.has_infer_types() {
2000 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2004 // If not, try resolving pending obligations as much as
2005 // possible. This can help substantially when there are
2006 // indirect dependencies that don't seem worth tracking
2008 self.select_obligations_where_possible(false);
2009 ty = self.resolve_type_vars_if_possible(&ty);
2011 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2015 fn record_deferred_call_resolution(&self,
2016 closure_def_id: DefId,
2017 r: DeferredCallResolution<'gcx, 'tcx>) {
2018 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2019 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2022 fn remove_deferred_call_resolutions(&self,
2023 closure_def_id: DefId)
2024 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2026 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2027 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2030 pub fn tag(&self) -> String {
2031 let self_ptr: *const FnCtxt = self;
2032 format!("{:?}", self_ptr)
2035 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
2036 match self.locals.borrow().get(&nid) {
2039 span_bug!(span, "no type for local variable {}",
2040 self.tcx.hir.node_to_string(nid));
2046 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2047 debug!("write_ty({:?}, {:?}) in fcx {}",
2048 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2049 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2051 if ty.references_error() {
2052 self.has_errors.set(true);
2053 self.set_tainted_by_errors();
2057 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2058 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2059 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2062 // The NodeId and the ItemLocalId must identify the same item. We just pass
2063 // both of them for consistency checking.
2064 pub fn write_method_call(&self,
2066 method: MethodCallee<'tcx>) {
2067 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2070 .type_dependent_defs_mut()
2071 .insert(hir_id, Def::Method(method.def_id));
2073 self.write_substs(hir_id, method.substs);
2075 // When the method is confirmed, the `method.substs` includes
2076 // parameters from not just the method, but also the impl of
2077 // the method -- in particular, the `Self` type will be fully
2078 // resolved. However, those are not something that the "user
2079 // specified" -- i.e., those types come from the inferred type
2080 // of the receiver, not something the user wrote. So when we
2081 // create the user-substs, we want to replace those earlier
2082 // types with just the types that the user actually wrote --
2083 // that is, those that appear on the *method itself*.
2085 // As an example, if the user wrote something like
2086 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2087 // type of `foo` (possibly adjusted), but we don't want to
2088 // include that. We want just the `[_, u32]` part.
2089 if !method.substs.is_noop() {
2090 let method_generics = self.tcx.generics_of(method.def_id);
2091 if !method_generics.params.is_empty() {
2092 let user_substs = self.infcx.probe(|_| {
2093 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2094 let i = param.index as usize;
2095 if i < method_generics.parent_count {
2096 self.infcx.var_for_def(DUMMY_SP, param)
2101 self.infcx.canonicalize_response(&just_method_substs)
2104 debug!("write_method_call: user_substs = {:?}", user_substs);
2105 self.write_user_substs(hir_id, user_substs);
2110 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2111 if !substs.is_noop() {
2112 debug!("write_substs({:?}, {:?}) in fcx {}",
2117 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2121 /// Given the substs that we just converted from the HIR, try to
2122 /// canonicalize them and store them as user-given substitutions
2123 /// (i.e., substitutions that must be respected by the NLL check).
2125 /// This should be invoked **before any unifications have
2126 /// occurred**, so that annotations like `Vec<_>` are preserved
2128 pub fn write_user_substs_from_substs(&self, hir_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2129 if !substs.is_noop() {
2130 let user_substs = self.infcx.canonicalize_response(&substs);
2131 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2132 self.write_user_substs(hir_id, user_substs);
2136 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalSubsts<'tcx>) {
2138 "write_user_substs({:?}, {:?}) in fcx {}",
2144 if !substs.is_identity() {
2145 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2147 debug!("write_user_substs: skipping identity substs");
2151 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2152 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2158 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2159 Entry::Vacant(entry) => { entry.insert(adj); },
2160 Entry::Occupied(mut entry) => {
2161 debug!(" - composing on top of {:?}", entry.get());
2162 match (&entry.get()[..], &adj[..]) {
2163 // Applying any adjustment on top of a NeverToAny
2164 // is a valid NeverToAny adjustment, because it can't
2166 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2168 Adjustment { kind: Adjust::Deref(_), .. },
2169 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2171 Adjustment { kind: Adjust::Deref(_), .. },
2172 .. // Any following adjustments are allowed.
2174 // A reborrow has no effect before a dereference.
2176 // FIXME: currently we never try to compose autoderefs
2177 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2179 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2180 expr, entry.get(), adj)
2182 *entry.get_mut() = adj;
2187 /// Basically whenever we are converting from a type scheme into
2188 /// the fn body space, we always want to normalize associated
2189 /// types as well. This function combines the two.
2190 fn instantiate_type_scheme<T>(&self,
2192 substs: &Substs<'tcx>,
2195 where T : TypeFoldable<'tcx>
2197 let value = value.subst(self.tcx, substs);
2198 let result = self.normalize_associated_types_in(span, &value);
2199 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2206 /// As `instantiate_type_scheme`, but for the bounds found in a
2207 /// generic type scheme.
2208 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2209 -> ty::InstantiatedPredicates<'tcx> {
2210 let bounds = self.tcx.predicates_of(def_id);
2211 let result = bounds.instantiate(self.tcx, substs);
2212 let result = self.normalize_associated_types_in(span, &result);
2213 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2220 /// Replace the anonymized types from the return value of the
2221 /// function with type variables and records the `AnonTypeMap` for
2222 /// later use during writeback. See
2223 /// `InferCtxt::instantiate_anon_types` for more details.
2224 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2229 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2231 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2236 let (value, anon_type_map) = self.register_infer_ok_obligations(
2237 self.instantiate_anon_types(
2245 let mut anon_types = self.anon_types.borrow_mut();
2246 for (ty, decl) in anon_type_map {
2247 let old_value = anon_types.insert(ty, decl);
2248 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2254 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2255 where T : TypeFoldable<'tcx>
2257 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2260 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2262 where T : TypeFoldable<'tcx>
2264 self.inh.partially_normalize_associated_types_in(span,
2270 pub fn require_type_meets(&self,
2273 code: traits::ObligationCauseCode<'tcx>,
2276 self.register_bound(
2279 traits::ObligationCause::new(span, self.body_id, code));
2282 pub fn require_type_is_sized(&self,
2285 code: traits::ObligationCauseCode<'tcx>)
2287 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2288 self.require_type_meets(ty, span, code, lang_item);
2291 pub fn register_bound(&self,
2294 cause: traits::ObligationCause<'tcx>)
2296 self.fulfillment_cx.borrow_mut()
2297 .register_bound(self, self.param_env, ty, def_id, cause);
2300 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2301 let t = AstConv::ast_ty_to_ty(self, ast_t);
2302 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2306 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2307 match self.tables.borrow().node_types().get(id) {
2309 None if self.is_tainted_by_errors() => self.tcx.types.err,
2311 let node_id = self.tcx.hir.hir_to_node_id(id);
2312 bug!("no type for node {}: {} in fcx {}",
2313 node_id, self.tcx.hir.node_to_string(node_id),
2319 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2320 /// outlive the region `r`.
2321 pub fn register_wf_obligation(&self,
2324 code: traits::ObligationCauseCode<'tcx>)
2326 // WF obligations never themselves fail, so no real need to give a detailed cause:
2327 let cause = traits::ObligationCause::new(span, self.body_id, code);
2328 self.register_predicate(traits::Obligation::new(cause,
2330 ty::Predicate::WellFormed(ty)));
2333 /// Registers obligations that all types appearing in `substs` are well-formed.
2334 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2336 for ty in substs.types() {
2337 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2341 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2342 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2343 /// trait/region obligations.
2345 /// For example, if there is a function:
2348 /// fn foo<'a,T:'a>(...)
2351 /// and a reference:
2357 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2358 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2359 pub fn add_obligations_for_parameters(&self,
2360 cause: traits::ObligationCause<'tcx>,
2361 predicates: &ty::InstantiatedPredicates<'tcx>)
2363 assert!(!predicates.has_escaping_regions());
2365 debug!("add_obligations_for_parameters(predicates={:?})",
2368 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2369 self.register_predicate(obligation);
2373 // FIXME(arielb1): use this instead of field.ty everywhere
2374 // Only for fields! Returns <none> for methods>
2375 // Indifferent to privacy flags
2376 pub fn field_ty(&self,
2378 field: &'tcx ty::FieldDef,
2379 substs: &Substs<'tcx>)
2382 self.normalize_associated_types_in(span,
2383 &field.ty(self.tcx, substs))
2386 fn check_casts(&self) {
2387 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2388 for cast in deferred_cast_checks.drain(..) {
2393 fn resolve_generator_interiors(&self, def_id: DefId) {
2394 let mut generators = self.deferred_generator_interiors.borrow_mut();
2395 for (body_id, interior) in generators.drain(..) {
2396 self.select_obligations_where_possible(false);
2397 generator_interior::resolve_interior(self, def_id, body_id, interior);
2401 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2402 // Non-numerics get replaced with ! or () (depending on whether
2403 // feature(never_type) is enabled, unconstrained ints with i32,
2404 // unconstrained floats with f64.
2405 // Fallback becomes very dubious if we have encountered type-checking errors.
2406 // In that case, fallback to Error.
2407 // The return value indicates whether fallback has occurred.
2408 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2409 use rustc::ty::error::UnconstrainedNumeric::Neither;
2410 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2412 assert!(ty.is_ty_infer());
2413 let fallback = match self.type_is_unconstrained_numeric(ty) {
2414 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2415 UnconstrainedInt => self.tcx.types.i32,
2416 UnconstrainedFloat => self.tcx.types.f64,
2417 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2418 Neither => return false,
2420 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2421 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2425 fn select_all_obligations_or_error(&self) {
2426 debug!("select_all_obligations_or_error");
2427 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2428 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2432 /// Select as many obligations as we can at present.
2433 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2434 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2437 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2442 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2444 hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
2446 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2451 hir::ExprKind::Type(ref e, _) => {
2452 self.is_place_expr(e)
2455 hir::ExprKind::Unary(hir::UnDeref, _) |
2456 hir::ExprKind::Field(..) |
2457 hir::ExprKind::Index(..) => {
2461 // Partially qualified paths in expressions can only legally
2462 // refer to associated items which are always rvalues.
2463 hir::ExprKind::Path(hir::QPath::TypeRelative(..)) |
2465 hir::ExprKind::Call(..) |
2466 hir::ExprKind::MethodCall(..) |
2467 hir::ExprKind::Struct(..) |
2468 hir::ExprKind::Tup(..) |
2469 hir::ExprKind::If(..) |
2470 hir::ExprKind::Match(..) |
2471 hir::ExprKind::Closure(..) |
2472 hir::ExprKind::Block(..) |
2473 hir::ExprKind::Repeat(..) |
2474 hir::ExprKind::Array(..) |
2475 hir::ExprKind::Break(..) |
2476 hir::ExprKind::Continue(..) |
2477 hir::ExprKind::Ret(..) |
2478 hir::ExprKind::While(..) |
2479 hir::ExprKind::Loop(..) |
2480 hir::ExprKind::Assign(..) |
2481 hir::ExprKind::InlineAsm(..) |
2482 hir::ExprKind::AssignOp(..) |
2483 hir::ExprKind::Lit(_) |
2484 hir::ExprKind::Unary(..) |
2485 hir::ExprKind::Box(..) |
2486 hir::ExprKind::AddrOf(..) |
2487 hir::ExprKind::Binary(..) |
2488 hir::ExprKind::Yield(..) |
2489 hir::ExprKind::Cast(..) => {
2495 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2496 /// returns a type of `&T`, but the actual type we assign to the
2497 /// *expression* is `T`. So this function just peels off the return
2498 /// type by one layer to yield `T`.
2499 fn make_overloaded_place_return_type(&self,
2500 method: MethodCallee<'tcx>)
2501 -> ty::TypeAndMut<'tcx>
2503 // extract method return type, which will be &T;
2504 let ret_ty = method.sig.output();
2506 // method returns &T, but the type as visible to user is T, so deref
2507 ret_ty.builtin_deref(true).unwrap()
2510 fn lookup_indexing(&self,
2512 base_expr: &'gcx hir::Expr,
2516 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2518 // FIXME(#18741) -- this is almost but not quite the same as the
2519 // autoderef that normal method probing does. They could likely be
2522 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2523 let mut result = None;
2524 while result.is_none() && autoderef.next().is_some() {
2525 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2527 autoderef.finalize();
2531 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2532 /// (and otherwise adjust) `base_expr`, looking for a type which either
2533 /// supports builtin indexing or overloaded indexing.
2534 /// This loop implements one step in that search; the autoderef loop
2535 /// is implemented by `lookup_indexing`.
2536 fn try_index_step(&self,
2538 base_expr: &hir::Expr,
2539 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2542 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2544 let adjusted_ty = autoderef.unambiguous_final_ty();
2545 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2552 for &unsize in &[false, true] {
2553 let mut self_ty = adjusted_ty;
2555 // We only unsize arrays here.
2556 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2557 self_ty = self.tcx.mk_slice(element_ty);
2563 // If some lookup succeeds, write callee into table and extract index/element
2564 // type from the method signature.
2565 // If some lookup succeeded, install method in table
2566 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2567 let method = self.try_overloaded_place_op(
2568 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2570 let result = method.map(|ok| {
2571 debug!("try_index_step: success, using overloaded indexing");
2572 let method = self.register_infer_ok_obligations(ok);
2574 let mut adjustments = autoderef.adjust_steps(needs);
2575 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2576 let mutbl = match r_mutbl {
2577 hir::MutImmutable => AutoBorrowMutability::Immutable,
2578 hir::MutMutable => AutoBorrowMutability::Mutable {
2579 // Indexing can be desugared to a method call,
2580 // so maybe we could use two-phase here.
2581 // See the documentation of AllowTwoPhase for why that's
2582 // not the case today.
2583 allow_two_phase_borrow: AllowTwoPhase::No,
2586 adjustments.push(Adjustment {
2587 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2588 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2595 adjustments.push(Adjustment {
2596 kind: Adjust::Unsize,
2597 target: method.sig.inputs()[0]
2600 self.apply_adjustments(base_expr, adjustments);
2602 self.write_method_call(expr.hir_id, method);
2603 (input_ty, self.make_overloaded_place_return_type(method).ty)
2605 if result.is_some() {
2613 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2614 let (tr, name) = match (op, is_mut) {
2615 (PlaceOp::Deref, false) =>
2616 (self.tcx.lang_items().deref_trait(), "deref"),
2617 (PlaceOp::Deref, true) =>
2618 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2619 (PlaceOp::Index, false) =>
2620 (self.tcx.lang_items().index_trait(), "index"),
2621 (PlaceOp::Index, true) =>
2622 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2624 (tr, ast::Ident::from_str(name))
2627 fn try_overloaded_place_op(&self,
2630 arg_tys: &[Ty<'tcx>],
2633 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2635 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2641 // Try Mut first, if needed.
2642 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2643 let method = match (needs, mut_tr) {
2644 (Needs::MutPlace, Some(trait_did)) => {
2645 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2650 // Otherwise, fall back to the immutable version.
2651 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2652 let method = match (method, imm_tr) {
2653 (None, Some(trait_did)) => {
2654 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2656 (method, _) => method,
2662 fn check_method_argument_types(&self,
2665 method: Result<MethodCallee<'tcx>, ()>,
2666 args_no_rcvr: &'gcx [hir::Expr],
2667 tuple_arguments: TupleArgumentsFlag,
2668 expected: Expectation<'tcx>)
2670 let has_error = match method {
2672 method.substs.references_error() || method.sig.references_error()
2677 let err_inputs = self.err_args(args_no_rcvr.len());
2679 let err_inputs = match tuple_arguments {
2680 DontTupleArguments => err_inputs,
2681 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2684 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2685 false, tuple_arguments, None);
2686 return self.tcx.types.err;
2689 let method = method.unwrap();
2690 // HACK(eddyb) ignore self in the definition (see above).
2691 let expected_arg_tys = self.expected_inputs_for_expected_output(
2694 method.sig.output(),
2695 &method.sig.inputs()[1..]
2697 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2698 args_no_rcvr, method.sig.variadic, tuple_arguments,
2699 self.tcx.hir.span_if_local(method.def_id));
2703 /// Generic function that factors out common logic from function calls,
2704 /// method calls and overloaded operators.
2705 fn check_argument_types(&self,
2708 fn_inputs: &[Ty<'tcx>],
2709 mut expected_arg_tys: &[Ty<'tcx>],
2710 args: &'gcx [hir::Expr],
2712 tuple_arguments: TupleArgumentsFlag,
2713 def_span: Option<Span>) {
2716 // Grab the argument types, supplying fresh type variables
2717 // if the wrong number of arguments were supplied
2718 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2724 // All the input types from the fn signature must outlive the call
2725 // so as to validate implied bounds.
2726 for &fn_input_ty in fn_inputs {
2727 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2730 let expected_arg_count = fn_inputs.len();
2732 let param_count_error = |expected_count: usize,
2737 let mut err = tcx.sess.struct_span_err_with_code(sp,
2738 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2739 if variadic {"at least "} else {""},
2741 if expected_count == 1 {""} else {"s"},
2743 if arg_count == 1 {" was"} else {"s were"}),
2744 DiagnosticId::Error(error_code.to_owned()));
2746 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2747 err.span_label(def_s, "defined here");
2750 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2751 // remove closing `)` from the span
2752 let sugg_span = sugg_span.shrink_to_lo();
2753 err.span_suggestion_with_applicability(
2755 "expected the unit value `()`; create it with empty parentheses",
2757 Applicability::MachineApplicable);
2759 err.span_label(sp, format!("expected {}{} parameter{}",
2760 if variadic {"at least "} else {""},
2762 if expected_count == 1 {""} else {"s"}));
2767 let formal_tys = if tuple_arguments == TupleArguments {
2768 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2769 match tuple_type.sty {
2770 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2771 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2772 expected_arg_tys = &[];
2773 self.err_args(args.len())
2775 ty::Tuple(arg_types) => {
2776 expected_arg_tys = match expected_arg_tys.get(0) {
2777 Some(&ty) => match ty.sty {
2778 ty::Tuple(ref tys) => &tys,
2786 span_err!(tcx.sess, sp, E0059,
2787 "cannot use call notation; the first type parameter \
2788 for the function trait is neither a tuple nor unit");
2789 expected_arg_tys = &[];
2790 self.err_args(args.len())
2793 } else if expected_arg_count == supplied_arg_count {
2795 } else if variadic {
2796 if supplied_arg_count >= expected_arg_count {
2799 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2800 expected_arg_tys = &[];
2801 self.err_args(supplied_arg_count)
2804 // is the missing argument of type `()`?
2805 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2806 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2807 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2808 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2812 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2814 expected_arg_tys = &[];
2815 self.err_args(supplied_arg_count)
2817 // If there is no expectation, expect formal_tys.
2818 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2824 debug!("check_argument_types: formal_tys={:?}",
2825 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2827 // Check the arguments.
2828 // We do this in a pretty awful way: first we typecheck any arguments
2829 // that are not closures, then we typecheck the closures. This is so
2830 // that we have more information about the types of arguments when we
2831 // typecheck the functions. This isn't really the right way to do this.
2832 for &check_closures in &[false, true] {
2833 debug!("check_closures={}", check_closures);
2835 // More awful hacks: before we check argument types, try to do
2836 // an "opportunistic" vtable resolution of any trait bounds on
2837 // the call. This helps coercions.
2839 self.select_obligations_where_possible(false);
2842 // For variadic functions, we don't have a declared type for all of
2843 // the arguments hence we only do our usual type checking with
2844 // the arguments who's types we do know.
2845 let t = if variadic {
2847 } else if tuple_arguments == TupleArguments {
2852 for (i, arg) in args.iter().take(t).enumerate() {
2853 // Warn only for the first loop (the "no closures" one).
2854 // Closure arguments themselves can't be diverging, but
2855 // a previous argument can, e.g. `foo(panic!(), || {})`.
2856 if !check_closures {
2857 self.warn_if_unreachable(arg.id, arg.span, "expression");
2860 let is_closure = match arg.node {
2861 hir::ExprKind::Closure(..) => true,
2865 if is_closure != check_closures {
2869 debug!("checking the argument");
2870 let formal_ty = formal_tys[i];
2872 // The special-cased logic below has three functions:
2873 // 1. Provide as good of an expected type as possible.
2874 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2876 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2878 // 2. Coerce to the most detailed type that could be coerced
2879 // to, which is `expected_ty` if `rvalue_hint` returns an
2880 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2881 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2882 // We're processing function arguments so we definitely want to use
2883 // two-phase borrows.
2884 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2886 // 3. Relate the expected type and the formal one,
2887 // if the expected type was used for the coercion.
2888 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2892 // We also need to make sure we at least write the ty of the other
2893 // arguments which we skipped above.
2895 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2896 use structured_errors::{VariadicError, StructuredDiagnostic};
2897 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2900 for arg in args.iter().skip(expected_arg_count) {
2901 let arg_ty = self.check_expr(&arg);
2903 // There are a few types which get autopromoted when passed via varargs
2904 // in C but we just error out instead and require explicit casts.
2905 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2907 ty::Float(ast::FloatTy::F32) => {
2908 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2910 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2911 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2913 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2914 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2917 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2918 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2919 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2927 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2928 (0..len).map(|_| self.tcx.types.err).collect()
2931 // AST fragment checking
2934 expected: Expectation<'tcx>)
2940 ast::LitKind::Str(..) => tcx.mk_static_str(),
2941 ast::LitKind::ByteStr(ref v) => {
2942 tcx.mk_imm_ref(tcx.types.re_static,
2943 tcx.mk_array(tcx.types.u8, v.len() as u64))
2945 ast::LitKind::Byte(_) => tcx.types.u8,
2946 ast::LitKind::Char(_) => tcx.types.char,
2947 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2948 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2949 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2950 let opt_ty = expected.to_option(self).and_then(|ty| {
2952 ty::Int(_) | ty::Uint(_) => Some(ty),
2953 ty::Char => Some(tcx.types.u8),
2954 ty::RawPtr(..) => Some(tcx.types.usize),
2955 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2959 opt_ty.unwrap_or_else(
2960 || tcx.mk_int_var(self.next_int_var_id()))
2962 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2963 ast::LitKind::FloatUnsuffixed(_) => {
2964 let opt_ty = expected.to_option(self).and_then(|ty| {
2966 ty::Float(_) => Some(ty),
2970 opt_ty.unwrap_or_else(
2971 || tcx.mk_float_var(self.next_float_var_id()))
2973 ast::LitKind::Bool(_) => tcx.types.bool
2977 fn check_expr_eq_type(&self,
2978 expr: &'gcx hir::Expr,
2979 expected: Ty<'tcx>) {
2980 let ty = self.check_expr_with_hint(expr, expected);
2981 self.demand_eqtype(expr.span, expected, ty);
2984 pub fn check_expr_has_type_or_error(&self,
2985 expr: &'gcx hir::Expr,
2986 expected: Ty<'tcx>) -> Ty<'tcx> {
2987 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2990 fn check_expr_meets_expectation_or_error(&self,
2991 expr: &'gcx hir::Expr,
2992 expected: Expectation<'tcx>) -> Ty<'tcx> {
2993 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2994 let mut ty = self.check_expr_with_expectation(expr, expected);
2996 // While we don't allow *arbitrary* coercions here, we *do* allow
2997 // coercions from ! to `expected`.
2999 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3000 "expression with never type wound up being adjusted");
3001 let adj_ty = self.next_diverging_ty_var(
3002 TypeVariableOrigin::AdjustmentType(expr.span));
3003 self.apply_adjustments(expr, vec![Adjustment {
3004 kind: Adjust::NeverToAny,
3010 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3011 // Add help to type error if this is an `if` condition with an assignment
3012 match (expected, &expr.node) {
3013 (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs)) => {
3014 let msg = "try comparing for equality";
3015 if let (Ok(left), Ok(right)) = (
3016 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3017 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3019 err.span_suggestion_with_applicability(
3022 format!("{} == {}", left, right),
3023 Applicability::MaybeIncorrect);
3035 fn check_expr_coercable_to_type(&self,
3036 expr: &'gcx hir::Expr,
3037 expected: Ty<'tcx>) -> Ty<'tcx> {
3038 let ty = self.check_expr_with_hint(expr, expected);
3039 // checks don't need two phase
3040 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3043 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
3044 expected: Ty<'tcx>) -> Ty<'tcx> {
3045 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3048 fn check_expr_with_expectation(&self,
3049 expr: &'gcx hir::Expr,
3050 expected: Expectation<'tcx>) -> Ty<'tcx> {
3051 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3054 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3055 self.check_expr_with_expectation(expr, NoExpectation)
3058 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3059 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3062 // determine the `self` type, using fresh variables for all variables
3063 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3064 // would return ($0, $1) where $0 and $1 are freshly instantiated type
3066 pub fn impl_self_ty(&self,
3067 span: Span, // (potential) receiver for this impl
3069 -> TypeAndSubsts<'tcx> {
3070 let ity = self.tcx.type_of(did);
3071 debug!("impl_self_ty: ity={:?}", ity);
3073 let substs = self.fresh_substs_for_item(span, did);
3074 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3076 TypeAndSubsts { substs: substs, ty: substd_ty }
3079 /// Unifies the output type with the expected type early, for more coercions
3080 /// and forward type information on the input expressions.
3081 fn expected_inputs_for_expected_output(&self,
3083 expected_ret: Expectation<'tcx>,
3084 formal_ret: Ty<'tcx>,
3085 formal_args: &[Ty<'tcx>])
3087 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3088 let ret_ty = match expected_ret.only_has_type(self) {
3090 None => return Vec::new()
3092 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3093 // Attempt to apply a subtyping relationship between the formal
3094 // return type (likely containing type variables if the function
3095 // is polymorphic) and the expected return type.
3096 // No argument expectations are produced if unification fails.
3097 let origin = self.misc(call_span);
3098 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3100 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3101 // to identity so the resulting type is not constrained.
3104 // Process any obligations locally as much as
3105 // we can. We don't care if some things turn
3106 // out unconstrained or ambiguous, as we're
3107 // just trying to get hints here.
3108 self.save_and_restore_in_snapshot_flag(|_| {
3109 let mut fulfill = TraitEngine::new(self.tcx);
3110 for obligation in ok.obligations {
3111 fulfill.register_predicate_obligation(self, obligation);
3113 fulfill.select_where_possible(self)
3114 }).map_err(|_| ())?;
3116 Err(_) => return Err(()),
3119 // Record all the argument types, with the substitutions
3120 // produced from the above subtyping unification.
3121 Ok(formal_args.iter().map(|ty| {
3122 self.resolve_type_vars_if_possible(ty)
3124 }).unwrap_or(Vec::new());
3125 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3126 formal_args, formal_ret,
3127 expect_args, expected_ret);
3131 // Checks a method call.
3132 fn check_method_call(&self,
3133 expr: &'gcx hir::Expr,
3134 segment: &hir::PathSegment,
3136 args: &'gcx [hir::Expr],
3137 expected: Expectation<'tcx>,
3138 needs: Needs) -> Ty<'tcx> {
3139 let rcvr = &args[0];
3140 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3141 // no need to check for bot/err -- callee does that
3142 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3144 let method = match self.lookup_method(rcvr_t,
3150 self.write_method_call(expr.hir_id, method);
3154 if segment.ident.name != keywords::Invalid.name() {
3155 self.report_method_error(span,
3166 // Call the generic checker.
3167 self.check_method_argument_types(span,
3175 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3179 .unwrap_or_else(|| span_bug!(return_expr.span,
3180 "check_return_expr called outside fn body"));
3182 let ret_ty = ret_coercion.borrow().expected_ty();
3183 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3184 ret_coercion.borrow_mut()
3186 &self.cause(return_expr.span,
3187 ObligationCauseCode::ReturnType(return_expr.id)),
3193 // A generic function for checking the then and else in an if
3195 fn check_then_else(&self,
3196 cond_expr: &'gcx hir::Expr,
3197 then_expr: &'gcx hir::Expr,
3198 opt_else_expr: Option<&'gcx hir::Expr>,
3200 expected: Expectation<'tcx>) -> Ty<'tcx> {
3201 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3202 let cond_diverges = self.diverges.get();
3203 self.diverges.set(Diverges::Maybe);
3205 let expected = expected.adjust_for_branches(self);
3206 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3207 let then_diverges = self.diverges.get();
3208 self.diverges.set(Diverges::Maybe);
3210 // We've already taken the expected type's preferences
3211 // into account when typing the `then` branch. To figure
3212 // out the initial shot at a LUB, we thus only consider
3213 // `expected` if it represents a *hard* constraint
3214 // (`only_has_type`); otherwise, we just go with a
3215 // fresh type variable.
3216 let coerce_to_ty = expected.coercion_target_type(self, sp);
3217 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3219 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3220 coerce.coerce(self, &if_cause, then_expr, then_ty);
3222 if let Some(else_expr) = opt_else_expr {
3223 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3224 let else_diverges = self.diverges.get();
3226 coerce.coerce(self, &if_cause, else_expr, else_ty);
3228 // We won't diverge unless both branches do (or the condition does).
3229 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3231 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3232 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3234 // If the condition is false we can't diverge.
3235 self.diverges.set(cond_diverges);
3238 let result_ty = coerce.complete(self);
3239 if cond_ty.references_error() {
3246 // Check field access expressions
3247 fn check_field(&self,
3248 expr: &'gcx hir::Expr,
3250 base: &'gcx hir::Expr,
3251 field: ast::Ident) -> Ty<'tcx> {
3252 let expr_t = self.check_expr_with_needs(base, needs);
3253 let expr_t = self.structurally_resolved_type(base.span,
3255 let mut private_candidate = None;
3256 let mut autoderef = self.autoderef(expr.span, expr_t);
3257 while let Some((base_t, _)) = autoderef.next() {
3259 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3260 debug!("struct named {:?}", base_t);
3261 let (ident, def_scope) =
3262 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3263 let fields = &base_def.non_enum_variant().fields;
3264 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3265 let field = &fields[index];
3266 let field_ty = self.field_ty(expr.span, field, substs);
3267 // Save the index of all fields regardless of their visibility in case
3268 // of error recovery.
3269 self.write_field_index(expr.id, index);
3270 if field.vis.is_accessible_from(def_scope, self.tcx) {
3271 let adjustments = autoderef.adjust_steps(needs);
3272 self.apply_adjustments(base, adjustments);
3273 autoderef.finalize();
3275 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3278 private_candidate = Some((base_def.did, field_ty));
3281 ty::Tuple(ref tys) => {
3282 let fstr = field.as_str();
3283 if let Ok(index) = fstr.parse::<usize>() {
3284 if fstr == index.to_string() {
3285 if let Some(field_ty) = tys.get(index) {
3286 let adjustments = autoderef.adjust_steps(needs);
3287 self.apply_adjustments(base, adjustments);
3288 autoderef.finalize();
3290 self.write_field_index(expr.id, index);
3299 autoderef.unambiguous_final_ty();
3301 if let Some((did, field_ty)) = private_candidate {
3302 let struct_path = self.tcx().item_path_str(did);
3303 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3304 "field `{}` of struct `{}` is private",
3305 field, struct_path);
3306 // Also check if an accessible method exists, which is often what is meant.
3307 if self.method_exists(field, expr_t, expr.id, false) {
3308 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3312 } else if field.name == keywords::Invalid.name() {
3313 self.tcx().types.err
3314 } else if self.method_exists(field, expr_t, expr.id, true) {
3315 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3316 "attempted to take value of method `{}` on type `{}`",
3318 .help("maybe a `()` to call it is missing?")
3320 self.tcx().types.err
3322 if !expr_t.is_primitive_ty() {
3323 let mut err = self.no_such_field_err(field.span, field, expr_t);
3326 ty::Adt(def, _) if !def.is_enum() => {
3327 if let Some(suggested_field_name) =
3328 Self::suggest_field_name(def.non_enum_variant(),
3329 &field.as_str(), vec![]) {
3330 err.span_label(field.span,
3331 format!("did you mean `{}`?", suggested_field_name));
3333 err.span_label(field.span, "unknown field");
3334 let struct_variant_def = def.non_enum_variant();
3335 let field_names = self.available_field_names(struct_variant_def);
3336 if !field_names.is_empty() {
3337 err.note(&format!("available fields are: {}",
3338 self.name_series_display(field_names)));
3343 let base = self.tcx.hir.node_to_pretty_string(base.id);
3344 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3345 let suggestion = format!("(*{}).{}", base, field);
3346 err.span_suggestion(field.span, &msg, suggestion);
3352 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3353 "`{}` is a primitive type and therefore doesn't have fields",
3356 self.tcx().types.err
3360 // Return an hint about the closest match in field names
3361 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3363 skip: Vec<LocalInternedString>)
3365 let names = variant.fields.iter().filter_map(|field| {
3366 // ignore already set fields and private fields from non-local crates
3367 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3368 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3371 Some(&field.ident.name)
3375 find_best_match_for_name(names, field, None)
3378 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3379 let mut available = Vec::new();
3380 for field in variant.fields.iter() {
3381 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3382 if field.vis.is_accessible_from(def_scope, self.tcx) {
3383 available.push(field.ident.name);
3389 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3390 // dynamic limit, to never omit just one field
3391 let limit = if names.len() == 6 { 6 } else { 5 };
3392 let mut display = names.iter().take(limit)
3393 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3394 if names.len() > limit {
3395 display = format!("{} ... and {} others", display, names.len() - limit);
3400 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3401 -> DiagnosticBuilder {
3402 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3403 "no field `{}` on type `{}`",
3407 fn report_unknown_field(&self,
3409 variant: &'tcx ty::VariantDef,
3411 skip_fields: &[hir::Field],
3413 let mut err = self.type_error_struct_with_diag(
3415 |actual| match ty.sty {
3416 ty::Adt(adt, ..) if adt.is_enum() => {
3417 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3418 "{} `{}::{}` has no field named `{}`",
3419 kind_name, actual, variant.name, field.ident)
3422 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3423 "{} `{}` has no field named `{}`",
3424 kind_name, actual, field.ident)
3428 // prevent all specified fields from being suggested
3429 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3430 if let Some(field_name) = Self::suggest_field_name(variant,
3431 &field.ident.as_str(),
3432 skip_fields.collect()) {
3433 err.span_label(field.ident.span,
3434 format!("field does not exist - did you mean `{}`?", field_name));
3437 ty::Adt(adt, ..) => {
3439 err.span_label(field.ident.span,
3440 format!("`{}::{}` does not have this field",
3443 err.span_label(field.ident.span,
3444 format!("`{}` does not have this field", ty));
3446 let available_field_names = self.available_field_names(variant);
3447 if !available_field_names.is_empty() {
3448 err.note(&format!("available fields are: {}",
3449 self.name_series_display(available_field_names)));
3452 _ => bug!("non-ADT passed to report_unknown_field")
3458 fn check_expr_struct_fields(&self,
3460 expected: Expectation<'tcx>,
3461 expr_id: ast::NodeId,
3463 variant: &'tcx ty::VariantDef,
3464 ast_fields: &'gcx [hir::Field],
3465 check_completeness: bool) -> bool {
3469 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3470 .get(0).cloned().unwrap_or(adt_ty);
3471 // re-link the regions that EIfEO can erase.
3472 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3474 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3475 &ty::Adt(adt, substs) => {
3476 (substs, adt.adt_kind(), adt.variant_descr())
3478 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3481 let mut remaining_fields = FxHashMap();
3482 for (i, field) in variant.fields.iter().enumerate() {
3483 remaining_fields.insert(field.ident.modern(), (i, field));
3486 let mut seen_fields = FxHashMap();
3488 let mut error_happened = false;
3490 // Typecheck each field.
3491 for field in ast_fields {
3492 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3493 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3494 seen_fields.insert(ident, field.span);
3495 self.write_field_index(field.id, i);
3497 // we don't look at stability attributes on
3498 // struct-like enums (yet...), but it's definitely not
3499 // a bug to have construct one.
3500 if adt_kind != ty::AdtKind::Enum {
3501 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3504 self.field_ty(field.span, v_field, substs)
3506 error_happened = true;
3507 if let Some(prev_span) = seen_fields.get(&ident) {
3508 let mut err = struct_span_err!(self.tcx.sess,
3511 "field `{}` specified more than once",
3514 err.span_label(field.ident.span, "used more than once");
3515 err.span_label(*prev_span, format!("first use of `{}`", ident));
3519 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3525 // Make sure to give a type to the field even if there's
3526 // an error, so we can continue typechecking
3527 self.check_expr_coercable_to_type(&field.expr, field_type);
3530 // Make sure the programmer specified correct number of fields.
3531 if kind_name == "union" {
3532 if ast_fields.len() != 1 {
3533 tcx.sess.span_err(span, "union expressions should have exactly one field");
3535 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3536 let len = remaining_fields.len();
3538 let mut displayable_field_names = remaining_fields
3540 .map(|ident| ident.as_str())
3541 .collect::<Vec<_>>();
3543 displayable_field_names.sort();
3545 let truncated_fields_error = if len <= 3 {
3548 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3551 let remaining_fields_names = displayable_field_names.iter().take(3)
3552 .map(|n| format!("`{}`", n))
3553 .collect::<Vec<_>>()
3556 struct_span_err!(tcx.sess, span, E0063,
3557 "missing field{} {}{} in initializer of `{}`",
3558 if remaining_fields.len() == 1 { "" } else { "s" },
3559 remaining_fields_names,
3560 truncated_fields_error,
3562 .span_label(span, format!("missing {}{}",
3563 remaining_fields_names,
3564 truncated_fields_error))
3570 fn check_struct_fields_on_error(&self,
3571 fields: &'gcx [hir::Field],
3572 base_expr: &'gcx Option<P<hir::Expr>>) {
3573 for field in fields {
3574 self.check_expr(&field.expr);
3578 self.check_expr(&base);
3584 pub fn check_struct_path(&self,
3586 node_id: ast::NodeId)
3587 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3588 let path_span = match *qpath {
3589 hir::QPath::Resolved(_, ref path) => path.span,
3590 hir::QPath::TypeRelative(ref qself, _) => qself.span
3592 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3593 let variant = match def {
3595 self.set_tainted_by_errors();
3598 Def::Variant(..) => {
3600 ty::Adt(adt, substs) => {
3601 Some((adt.variant_of_def(def), adt.did, substs))
3603 _ => bug!("unexpected type: {:?}", ty.sty)
3606 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3607 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3609 ty::Adt(adt, substs) if !adt.is_enum() => {
3610 Some((adt.non_enum_variant(), adt.did, substs))
3615 _ => bug!("unexpected definition: {:?}", def)
3618 if let Some((variant, did, substs)) = variant {
3619 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3620 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
3621 self.write_user_substs_from_substs(hir_id, substs);
3623 // Check bounds on type arguments used in the path.
3624 let bounds = self.instantiate_bounds(path_span, did, substs);
3625 let cause = traits::ObligationCause::new(path_span, self.body_id,
3626 traits::ItemObligation(did));
3627 self.add_obligations_for_parameters(cause, &bounds);
3631 struct_span_err!(self.tcx.sess, path_span, E0071,
3632 "expected struct, variant or union type, found {}",
3633 ty.sort_string(self.tcx))
3634 .span_label(path_span, "not a struct")
3640 fn check_expr_struct(&self,
3642 expected: Expectation<'tcx>,
3644 fields: &'gcx [hir::Field],
3645 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3647 // Find the relevant variant
3648 let (variant, adt_ty) =
3649 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3652 self.check_struct_fields_on_error(fields, base_expr);
3653 return self.tcx.types.err;
3656 let path_span = match *qpath {
3657 hir::QPath::Resolved(_, ref path) => path.span,
3658 hir::QPath::TypeRelative(ref qself, _) => qself.span
3661 // Prohibit struct expressions when non exhaustive flag is set.
3662 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3663 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3664 span_err!(self.tcx.sess, expr.span, E0639,
3665 "cannot create non-exhaustive {} using struct expression",
3666 adt.variant_descr());
3669 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3670 variant, fields, base_expr.is_none());
3671 if let &Some(ref base_expr) = base_expr {
3672 // If check_expr_struct_fields hit an error, do not attempt to populate
3673 // the fields with the base_expr. This could cause us to hit errors later
3674 // when certain fields are assumed to exist that in fact do not.
3675 if !error_happened {
3676 self.check_expr_has_type_or_error(base_expr, adt_ty);
3678 ty::Adt(adt, substs) if adt.is_struct() => {
3679 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3680 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3685 .fru_field_types_mut()
3686 .insert(expr.hir_id, fru_field_types);
3689 span_err!(self.tcx.sess, base_expr.span, E0436,
3690 "functional record update syntax requires a struct");
3695 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3701 /// If an expression has any sub-expressions that result in a type error,
3702 /// inspecting that expression's type with `ty.references_error()` will return
3703 /// true. Likewise, if an expression is known to diverge, inspecting its
3704 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3705 /// strict, _|_ can appear in the type of an expression that does not,
3706 /// itself, diverge: for example, fn() -> _|_.)
3707 /// Note that inspecting a type's structure *directly* may expose the fact
3708 /// that there are actually multiple representations for `Error`, so avoid
3709 /// that when err needs to be handled differently.
3710 fn check_expr_with_expectation_and_needs(&self,
3711 expr: &'gcx hir::Expr,
3712 expected: Expectation<'tcx>,
3713 needs: Needs) -> Ty<'tcx> {
3714 debug!(">> typechecking: expr={:?} expected={:?}",
3717 // Warn for expressions after diverging siblings.
3718 self.warn_if_unreachable(expr.id, expr.span, "expression");
3720 // Hide the outer diverging and has_errors flags.
3721 let old_diverges = self.diverges.get();
3722 let old_has_errors = self.has_errors.get();
3723 self.diverges.set(Diverges::Maybe);
3724 self.has_errors.set(false);
3726 let ty = self.check_expr_kind(expr, expected, needs);
3728 // Warn for non-block expressions with diverging children.
3730 hir::ExprKind::Block(..) |
3731 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3732 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3734 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3737 // Any expression that produces a value of type `!` must have diverged
3739 self.diverges.set(self.diverges.get() | Diverges::Always);
3742 // Record the type, which applies it effects.
3743 // We need to do this after the warning above, so that
3744 // we don't warn for the diverging expression itself.
3745 self.write_ty(expr.hir_id, ty);
3747 // Combine the diverging and has_error flags.
3748 self.diverges.set(self.diverges.get() | old_diverges);
3749 self.has_errors.set(self.has_errors.get() | old_has_errors);
3751 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3752 debug!("... {:?}, expected is {:?}", ty, expected);
3757 fn check_expr_kind(&self,
3758 expr: &'gcx hir::Expr,
3759 expected: Expectation<'tcx>,
3760 needs: Needs) -> Ty<'tcx> {
3764 hir::ExprKind::Box(ref subexpr) => {
3765 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3767 ty::Adt(def, _) if def.is_box()
3768 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3772 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3773 tcx.mk_box(referent_ty)
3776 hir::ExprKind::Lit(ref lit) => {
3777 self.check_lit(&lit, expected)
3779 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3780 self.check_binop(expr, op, lhs, rhs)
3782 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3783 self.check_binop_assign(expr, op, lhs, rhs)
3785 hir::ExprKind::Unary(unop, ref oprnd) => {
3786 let expected_inner = match unop {
3787 hir::UnNot | hir::UnNeg => {
3794 let needs = match unop {
3795 hir::UnDeref => needs,
3798 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3802 if !oprnd_t.references_error() {
3803 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3806 if let Some(mt) = oprnd_t.builtin_deref(true) {
3808 } else if let Some(ok) = self.try_overloaded_deref(
3809 expr.span, oprnd_t, needs) {
3810 let method = self.register_infer_ok_obligations(ok);
3811 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3812 let mutbl = match mutbl {
3813 hir::MutImmutable => AutoBorrowMutability::Immutable,
3814 hir::MutMutable => AutoBorrowMutability::Mutable {
3815 // (It shouldn't actually matter for unary ops whether
3816 // we enable two-phase borrows or not, since a unary
3817 // op has no additional operands.)
3818 allow_two_phase_borrow: AllowTwoPhase::No,
3821 self.apply_adjustments(oprnd, vec![Adjustment {
3822 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3823 target: method.sig.inputs()[0]
3826 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3827 self.write_method_call(expr.hir_id, method);
3829 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3830 "type `{}` cannot be dereferenced",
3832 oprnd_t = tcx.types.err;
3836 let result = self.check_user_unop(expr, oprnd_t, unop);
3837 // If it's builtin, we can reuse the type, this helps inference.
3838 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3843 let result = self.check_user_unop(expr, oprnd_t, unop);
3844 // If it's builtin, we can reuse the type, this helps inference.
3845 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3853 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3854 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3856 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3857 if self.is_place_expr(&oprnd) {
3858 // Places may legitimately have unsized types.
3859 // For example, dereferences of a fat pointer and
3860 // the last field of a struct can be unsized.
3863 Expectation::rvalue_hint(self, ty)
3869 let needs = Needs::maybe_mut_place(mutbl);
3870 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3872 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3873 if tm.ty.references_error() {
3876 // Note: at this point, we cannot say what the best lifetime
3877 // is to use for resulting pointer. We want to use the
3878 // shortest lifetime possible so as to avoid spurious borrowck
3879 // errors. Moreover, the longest lifetime will depend on the
3880 // precise details of the value whose address is being taken
3881 // (and how long it is valid), which we don't know yet until type
3882 // inference is complete.
3884 // Therefore, here we simply generate a region variable. The
3885 // region inferencer will then select the ultimate value.
3886 // Finally, borrowck is charged with guaranteeing that the
3887 // value whose address was taken can actually be made to live
3888 // as long as it needs to live.
3889 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3890 tcx.mk_ref(region, tm)
3893 hir::ExprKind::Path(ref qpath) => {
3894 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3895 let ty = if def != Def::Err {
3896 self.instantiate_value_path(segs, opt_ty, def, expr.span, id)
3898 self.set_tainted_by_errors();
3902 // We always require that the type provided as the value for
3903 // a type parameter outlives the moment of instantiation.
3904 let substs = self.tables.borrow().node_substs(expr.hir_id);
3905 self.add_wf_bounds(substs, expr);
3909 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3910 for output in outputs {
3911 self.check_expr(output);
3913 for input in inputs {
3914 self.check_expr(input);
3918 hir::ExprKind::Break(destination, ref expr_opt) => {
3919 if let Ok(target_id) = destination.target_id {
3921 if let Some(ref e) = *expr_opt {
3922 // If this is a break with a value, we need to type-check
3923 // the expression. Get an expected type from the loop context.
3924 let opt_coerce_to = {
3925 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3926 enclosing_breakables.find_breakable(target_id)
3929 .map(|coerce| coerce.expected_ty())
3932 // If the loop context is not a `loop { }`, then break with
3933 // a value is illegal, and `opt_coerce_to` will be `None`.
3934 // Just set expectation to error in that case.
3935 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3937 // Recurse without `enclosing_breakables` borrowed.
3938 e_ty = self.check_expr_with_hint(e, coerce_to);
3939 cause = self.misc(e.span);
3941 // Otherwise, this is a break *without* a value. That's
3942 // always legal, and is equivalent to `break ()`.
3943 e_ty = tcx.mk_nil();
3944 cause = self.misc(expr.span);
3947 // Now that we have type-checked `expr_opt`, borrow
3948 // the `enclosing_loops` field and let's coerce the
3949 // type of `expr_opt` into what is expected.
3950 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3951 let ctxt = enclosing_breakables.find_breakable(target_id);
3952 if let Some(ref mut coerce) = ctxt.coerce {
3953 if let Some(ref e) = *expr_opt {
3954 coerce.coerce(self, &cause, e, e_ty);
3956 assert!(e_ty.is_nil());
3957 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3960 // If `ctxt.coerce` is `None`, we can just ignore
3961 // the type of the expresison. This is because
3962 // either this was a break *without* a value, in
3963 // which case it is always a legal type (`()`), or
3964 // else an error would have been flagged by the
3965 // `loops` pass for using break with an expression
3966 // where you are not supposed to.
3967 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3970 ctxt.may_break = true;
3972 // the type of a `break` is always `!`, since it diverges
3975 // Otherwise, we failed to find the enclosing loop;
3976 // this can only happen if the `break` was not
3977 // inside a loop at all, which is caught by the
3978 // loop-checking pass.
3979 if self.tcx.sess.err_count() == 0 {
3980 self.tcx.sess.delay_span_bug(expr.span,
3981 "break was outside loop, but no error was emitted");
3984 // We still need to assign a type to the inner expression to
3985 // prevent the ICE in #43162.
3986 if let Some(ref e) = *expr_opt {
3987 self.check_expr_with_hint(e, tcx.types.err);
3989 // ... except when we try to 'break rust;'.
3990 // ICE this expression in particular (see #43162).
3991 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
3992 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3993 fatally_break_rust(self.tcx.sess);
3997 // There was an error, make typecheck fail
4002 hir::ExprKind::Continue(destination) => {
4003 if destination.target_id.is_ok() {
4006 // There was an error, make typecheck fail
4010 hir::ExprKind::Ret(ref expr_opt) => {
4011 if self.ret_coercion.is_none() {
4012 struct_span_err!(self.tcx.sess, expr.span, E0572,
4013 "return statement outside of function body").emit();
4014 } else if let Some(ref e) = *expr_opt {
4015 self.check_return_expr(e);
4017 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4018 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4019 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4023 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4024 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4026 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4029 ExpectIfCondition => {
4030 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4031 expected error elsehwere");
4034 // Only check this if not in an `if` condition, as the
4035 // mistyped comparison help is more appropriate.
4036 if !self.is_place_expr(&lhs) {
4037 struct_span_err!(self.tcx.sess, expr.span, E0070,
4038 "invalid left-hand side expression")
4039 .span_label(expr.span, "left-hand of expression not valid")
4045 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4047 if lhs_ty.references_error() || rhs_ty.references_error() {
4053 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4054 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4055 expr.span, expected)
4057 hir::ExprKind::While(ref cond, ref body, _) => {
4058 let ctxt = BreakableCtxt {
4059 // cannot use break with a value from a while loop
4061 may_break: false, // Will get updated if/when we find a `break`.
4064 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4065 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4066 let cond_diverging = self.diverges.get();
4067 self.check_block_no_value(&body);
4069 // We may never reach the body so it diverging means nothing.
4070 self.diverges.set(cond_diverging);
4074 // No way to know whether it's diverging because
4075 // of a `break` or an outer `break` or `return`.
4076 self.diverges.set(Diverges::Maybe);
4081 hir::ExprKind::Loop(ref body, _, source) => {
4082 let coerce = match source {
4083 // you can only use break with a value from a normal `loop { }`
4084 hir::LoopSource::Loop => {
4085 let coerce_to = expected.coercion_target_type(self, body.span);
4086 Some(CoerceMany::new(coerce_to))
4089 hir::LoopSource::WhileLet |
4090 hir::LoopSource::ForLoop => {
4095 let ctxt = BreakableCtxt {
4097 may_break: false, // Will get updated if/when we find a `break`.
4100 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4101 self.check_block_no_value(&body);
4105 // No way to know whether it's diverging because
4106 // of a `break` or an outer `break` or `return`.
4107 self.diverges.set(Diverges::Maybe);
4110 // If we permit break with a value, then result type is
4111 // the LUB of the breaks (possibly ! if none); else, it
4112 // is nil. This makes sense because infinite loops
4113 // (which would have type !) are only possible iff we
4114 // permit break with a value [1].
4115 if ctxt.coerce.is_none() && !ctxt.may_break {
4117 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4119 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
4121 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4122 self.check_match(expr, &discrim, arms, expected, match_src)
4124 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4125 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4127 hir::ExprKind::Block(ref body, _) => {
4128 self.check_block_with_expected(&body, expected)
4130 hir::ExprKind::Call(ref callee, ref args) => {
4131 self.check_call(expr, &callee, args, expected)
4133 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4134 self.check_method_call(expr, segment, span, args, expected, needs)
4136 hir::ExprKind::Cast(ref e, ref t) => {
4137 // Find the type of `e`. Supply hints based on the type we are casting to,
4139 let t_cast = self.to_ty(t);
4140 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4141 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4142 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4144 // Eagerly check for some obvious errors.
4145 if t_expr.references_error() || t_cast.references_error() {
4148 // Defer other checks until we're done type checking.
4149 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4150 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4152 deferred_cast_checks.push(cast_check);
4155 Err(ErrorReported) => {
4161 hir::ExprKind::Type(ref e, ref t) => {
4162 let ty = self.to_ty(&t);
4163 self.check_expr_eq_type(&e, ty);
4166 hir::ExprKind::Array(ref args) => {
4167 let uty = expected.to_option(self).and_then(|uty| {
4169 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4174 let element_ty = if !args.is_empty() {
4175 let coerce_to = uty.unwrap_or_else(
4176 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4177 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4178 assert_eq!(self.diverges.get(), Diverges::Maybe);
4180 let e_ty = self.check_expr_with_hint(e, coerce_to);
4181 let cause = self.misc(e.span);
4182 coerce.coerce(self, &cause, e, e_ty);
4184 coerce.complete(self)
4186 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4188 tcx.mk_array(element_ty, args.len() as u64)
4190 hir::ExprKind::Repeat(ref element, ref count) => {
4191 let count_def_id = tcx.hir.local_def_id(count.id);
4192 let param_env = ty::ParamEnv::empty();
4193 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4194 let instance = ty::Instance::resolve(
4200 let global_id = GlobalId {
4204 let count = tcx.const_eval(param_env.and(global_id));
4206 if let Err(ref err) = count {
4207 err.report_as_error(
4208 tcx.at(tcx.def_span(count_def_id)),
4209 "could not evaluate repeat length",
4213 let uty = match expected {
4214 ExpectHasType(uty) => {
4216 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4223 let (element_ty, t) = match uty {
4225 self.check_expr_coercable_to_type(&element, uty);
4229 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4230 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4235 if let Ok(count) = count {
4236 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4238 // For [foo, ..n] where n > 1, `foo` must have
4240 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4241 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4245 if element_ty.references_error() {
4247 } else if let Ok(count) = count {
4248 tcx.mk_ty(ty::Array(t, count))
4253 hir::ExprKind::Tup(ref elts) => {
4254 let flds = expected.only_has_type(self).and_then(|ty| {
4255 let ty = self.resolve_type_vars_with_obligations(ty);
4257 ty::Tuple(ref flds) => Some(&flds[..]),
4262 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4263 let t = match flds {
4264 Some(ref fs) if i < fs.len() => {
4266 self.check_expr_coercable_to_type(&e, ety);
4270 self.check_expr_with_expectation(&e, NoExpectation)
4275 let tuple = tcx.mk_tup(elt_ts_iter);
4276 if tuple.references_error() {
4279 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4283 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4284 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4286 hir::ExprKind::Field(ref base, field) => {
4287 self.check_field(expr, needs, &base, field)
4289 hir::ExprKind::Index(ref base, ref idx) => {
4290 let base_t = self.check_expr_with_needs(&base, needs);
4291 let idx_t = self.check_expr(&idx);
4293 if base_t.references_error() {
4295 } else if idx_t.references_error() {
4298 let base_t = self.structurally_resolved_type(base.span, base_t);
4299 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4300 Some((index_ty, element_ty)) => {
4301 // two-phase not needed because index_ty is never mutable
4302 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4307 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4308 "cannot index into a value of type `{}`",
4310 // Try to give some advice about indexing tuples.
4311 if let ty::Tuple(..) = base_t.sty {
4312 let mut needs_note = true;
4313 // If the index is an integer, we can show the actual
4314 // fixed expression:
4315 if let hir::ExprKind::Lit(ref lit) = idx.node {
4316 if let ast::LitKind::Int(i,
4317 ast::LitIntType::Unsuffixed) = lit.node {
4318 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4319 if let Ok(snip) = snip {
4320 err.span_suggestion_with_applicability(
4322 "to access tuple elements, use",
4323 format!("{}.{}", snip, i),
4324 Applicability::MachineApplicable);
4330 err.help("to access tuple elements, use tuple indexing \
4331 syntax (e.g. `tuple.0`)");
4340 hir::ExprKind::Yield(ref value) => {
4341 match self.yield_ty {
4343 self.check_expr_coercable_to_type(&value, ty);
4346 struct_span_err!(self.tcx.sess, expr.span, E0627,
4347 "yield statement outside of generator literal").emit();
4355 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4356 // The newly resolved definition is written into `type_dependent_defs`.
4357 fn finish_resolving_struct_path(&self,
4360 node_id: ast::NodeId)
4364 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4365 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4366 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4369 hir::QPath::TypeRelative(ref qself, ref segment) => {
4370 let ty = self.to_ty(qself);
4372 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4377 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4380 // Write back the new resolution.
4381 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4382 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4389 // Resolve associated value path into a base type and associated constant or method definition.
4390 // The newly resolved definition is written into `type_dependent_defs`.
4391 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4392 qpath: &'b hir::QPath,
4393 node_id: ast::NodeId,
4395 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4397 let (ty, item_segment) = match *qpath {
4398 hir::QPath::Resolved(ref opt_qself, ref path) => {
4400 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4401 &path.segments[..]);
4403 hir::QPath::TypeRelative(ref qself, ref segment) => {
4404 (self.to_ty(qself), segment)
4407 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4408 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4409 // Return directly on cache hit. This is useful to avoid doubly reporting
4410 // errors with default match binding modes. See #44614.
4411 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4413 let item_name = item_segment.ident;
4414 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4417 let def = match error {
4418 method::MethodError::PrivateMatch(def, _) => def,
4421 if item_name.name != keywords::Invalid.name() {
4422 self.report_method_error(span, ty, item_name, None, error, None);
4428 // Write back the new resolution.
4429 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4430 (def, Some(ty), slice::from_ref(&**item_segment))
4433 pub fn check_decl_initializer(&self,
4434 local: &'gcx hir::Local,
4435 init: &'gcx hir::Expr) -> Ty<'tcx>
4437 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4438 // for #42640 (default match binding modes).
4441 let ref_bindings = local.pat.contains_explicit_ref_binding();
4443 let local_ty = self.local_ty(init.span, local.id);
4444 if let Some(m) = ref_bindings {
4445 // Somewhat subtle: if we have a `ref` binding in the pattern,
4446 // we want to avoid introducing coercions for the RHS. This is
4447 // both because it helps preserve sanity and, in the case of
4448 // ref mut, for soundness (issue #23116). In particular, in
4449 // the latter case, we need to be clear that the type of the
4450 // referent for the reference that results is *equal to* the
4451 // type of the place it is referencing, and not some
4452 // supertype thereof.
4453 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4454 self.demand_eqtype(init.span, local_ty, init_ty);
4457 self.check_expr_coercable_to_type(init, local_ty)
4461 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4462 let t = self.local_ty(local.span, local.id);
4463 self.write_ty(local.hir_id, t);
4465 if let Some(ref init) = local.init {
4466 let init_ty = self.check_decl_initializer(local, &init);
4467 if init_ty.references_error() {
4468 self.write_ty(local.hir_id, init_ty);
4472 self.check_pat_walk(&local.pat, t,
4473 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4475 let pat_ty = self.node_ty(local.pat.hir_id);
4476 if pat_ty.references_error() {
4477 self.write_ty(local.hir_id, pat_ty);
4481 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4482 // Don't do all the complex logic below for DeclItem.
4484 hir::StmtKind::Decl(ref decl, _) => {
4486 hir::DeclKind::Local(_) => {}
4487 hir::DeclKind::Item(_) => {
4492 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4495 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4497 // Hide the outer diverging and has_errors flags.
4498 let old_diverges = self.diverges.get();
4499 let old_has_errors = self.has_errors.get();
4500 self.diverges.set(Diverges::Maybe);
4501 self.has_errors.set(false);
4504 hir::StmtKind::Decl(ref decl, _) => {
4506 hir::DeclKind::Local(ref l) => {
4507 self.check_decl_local(&l);
4509 hir::DeclKind::Item(_) => {/* ignore for now */}
4512 hir::StmtKind::Expr(ref expr, _) => {
4513 // Check with expected type of ()
4514 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4516 hir::StmtKind::Semi(ref expr, _) => {
4517 self.check_expr(&expr);
4521 // Combine the diverging and has_error flags.
4522 self.diverges.set(self.diverges.get() | old_diverges);
4523 self.has_errors.set(self.has_errors.get() | old_has_errors);
4526 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4527 let unit = self.tcx.mk_nil();
4528 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4530 // if the block produces a `!` value, that can always be
4531 // (effectively) coerced to unit.
4533 self.demand_suptype(blk.span, unit, ty);
4537 fn check_block_with_expected(&self,
4538 blk: &'gcx hir::Block,
4539 expected: Expectation<'tcx>) -> Ty<'tcx> {
4541 let mut fcx_ps = self.ps.borrow_mut();
4542 let unsafety_state = fcx_ps.recurse(blk);
4543 replace(&mut *fcx_ps, unsafety_state)
4546 // In some cases, blocks have just one exit, but other blocks
4547 // can be targeted by multiple breaks. This can happen both
4548 // with labeled blocks as well as when we desugar
4549 // a `try { ... }` expression.
4553 // 'a: { if true { break 'a Err(()); } Ok(()) }
4555 // Here we would wind up with two coercions, one from
4556 // `Err(())` and the other from the tail expression
4557 // `Ok(())`. If the tail expression is omitted, that's a
4558 // "forced unit" -- unless the block diverges, in which
4559 // case we can ignore the tail expression (e.g., `'a: {
4560 // break 'a 22; }` would not force the type of the block
4562 let tail_expr = blk.expr.as_ref();
4563 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4564 let coerce = if blk.targeted_by_break {
4565 CoerceMany::new(coerce_to_ty)
4567 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4568 Some(e) => slice::from_ref(e),
4571 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4574 let prev_diverges = self.diverges.get();
4575 let ctxt = BreakableCtxt {
4576 coerce: Some(coerce),
4580 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4581 for s in &blk.stmts {
4585 // check the tail expression **without** holding the
4586 // `enclosing_breakables` lock below.
4587 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4589 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4590 let ctxt = enclosing_breakables.find_breakable(blk.id);
4591 let coerce = ctxt.coerce.as_mut().unwrap();
4592 if let Some(tail_expr_ty) = tail_expr_ty {
4593 let tail_expr = tail_expr.unwrap();
4594 let cause = self.cause(tail_expr.span,
4595 ObligationCauseCode::BlockTailExpression(blk.id));
4601 // Subtle: if there is no explicit tail expression,
4602 // that is typically equivalent to a tail expression
4603 // of `()` -- except if the block diverges. In that
4604 // case, there is no value supplied from the tail
4605 // expression (assuming there are no other breaks,
4606 // this implies that the type of the block will be
4609 // #41425 -- label the implicit `()` as being the
4610 // "found type" here, rather than the "expected type".
4612 // #44579 -- if the block was recovered during parsing,
4613 // the type would be nonsensical and it is not worth it
4614 // to perform the type check, so we avoid generating the
4615 // diagnostic output.
4616 if !self.diverges.get().always() && !blk.recovered {
4617 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4618 if let Some(expected_ty) = expected.only_has_type(self) {
4619 self.consider_hint_about_removing_semicolon(blk,
4629 // If we can break from the block, then the block's exit is always reachable
4630 // (... as long as the entry is reachable) - regardless of the tail of the block.
4631 self.diverges.set(prev_diverges);
4634 let mut ty = ctxt.coerce.unwrap().complete(self);
4636 if self.has_errors.get() || ty.references_error() {
4637 ty = self.tcx.types.err
4640 self.write_ty(blk.hir_id, ty);
4642 *self.ps.borrow_mut() = prev;
4646 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4647 /// suggestion can be made, `None` otherwise.
4648 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4649 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4650 // `while` before reaching it, as block tail returns are not available in them.
4651 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4652 let parent = self.tcx.hir.get(fn_id);
4654 if let Node::Item(&hir::Item {
4655 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4657 decl.clone().and_then(|decl| {
4658 // This is less than ideal, it will not suggest a return type span on any
4659 // method called `main`, regardless of whether it is actually the entry point,
4660 // but it will still present it as the reason for the expected type.
4661 Some((decl, name != Symbol::intern("main")))
4663 } else if let Node::TraitItem(&hir::TraitItem {
4664 node: hir::TraitItemKind::Method(hir::MethodSig {
4668 decl.clone().and_then(|decl| {
4671 } else if let Node::ImplItem(&hir::ImplItem {
4672 node: hir::ImplItemKind::Method(hir::MethodSig {
4676 decl.clone().and_then(|decl| {
4687 /// On implicit return expressions with mismatched types, provide the following suggestions:
4689 /// - Point out the method's return type as the reason for the expected type
4690 /// - Possible missing semicolon
4691 /// - Possible missing return type if the return type is the default, and not `fn main()`
4692 pub fn suggest_mismatched_types_on_tail(&self,
4693 err: &mut DiagnosticBuilder<'tcx>,
4694 expression: &'gcx hir::Expr,
4698 blk_id: ast::NodeId) {
4699 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4700 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4701 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4703 self.suggest_ref_or_into(err, expression, expected, found);
4706 pub fn suggest_ref_or_into(
4708 err: &mut DiagnosticBuilder<'tcx>,
4713 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4714 err.span_suggestion(sp, msg, suggestion);
4715 } else if !self.check_for_cast(err, expr, found, expected) {
4716 let methods = self.get_conversion_methods(expr.span, expected, found);
4717 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4718 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4719 .filter_map(|(receiver, method)| {
4720 let method_call = format!(".{}()", method.ident);
4721 if receiver.ends_with(&method_call) {
4722 None // do not suggest code that is already there (#53348)
4724 Some(format!("{}{}", receiver, method_call))
4726 }) .collect::<Vec<_>>();
4727 if !suggestions.is_empty() {
4728 err.span_suggestions(expr.span, "try using a conversion method", suggestions);
4734 /// A common error is to forget to add a semicolon at the end of a block:
4738 /// bar_that_returns_u32()
4742 /// This routine checks if the return expression in a block would make sense on its own as a
4743 /// statement and the return type has been left as default or has been specified as `()`. If so,
4744 /// it suggests adding a semicolon.
4745 fn suggest_missing_semicolon(&self,
4746 err: &mut DiagnosticBuilder<'tcx>,
4747 expression: &'gcx hir::Expr,
4750 if expected.is_nil() {
4751 // `BlockTailExpression` only relevant if the tail expr would be
4752 // useful on its own.
4753 match expression.node {
4754 hir::ExprKind::Call(..) |
4755 hir::ExprKind::MethodCall(..) |
4756 hir::ExprKind::If(..) |
4757 hir::ExprKind::While(..) |
4758 hir::ExprKind::Loop(..) |
4759 hir::ExprKind::Match(..) |
4760 hir::ExprKind::Block(..) => {
4761 let sp = self.tcx.sess.source_map().next_point(cause_span);
4762 err.span_suggestion_with_applicability(
4764 "try adding a semicolon",
4766 Applicability::MachineApplicable);
4774 /// A possible error is to forget to add a return type that is needed:
4778 /// bar_that_returns_u32()
4782 /// This routine checks if the return type is left as default, the method is not part of an
4783 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4785 fn suggest_missing_return_type(&self,
4786 err: &mut DiagnosticBuilder<'tcx>,
4787 fn_decl: &hir::FnDecl,
4790 can_suggest: bool) {
4791 // Only suggest changing the return type for methods that
4792 // haven't set a return type at all (and aren't `fn main()` or an impl).
4793 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_nil()) {
4794 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4795 err.span_suggestion_with_applicability(
4797 "try adding a return type",
4798 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4799 Applicability::MachineApplicable);
4801 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4802 err.span_label(span, "possibly return type missing here?");
4804 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4805 // `fn main()` must return `()`, do not suggest changing return type
4806 err.span_label(span, "expected `()` because of default return type");
4808 // expectation was caused by something else, not the default return
4809 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4810 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4811 // Only point to return type if the expected type is the return type, as if they
4812 // are not, the expectation must have been caused by something else.
4813 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4815 let ty = AstConv::ast_ty_to_ty(self, ty);
4816 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4817 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4818 if ty.sty == expected.sty {
4819 err.span_label(sp, format!("expected `{}` because of return type",
4827 /// A common error is to add an extra semicolon:
4830 /// fn foo() -> usize {
4835 /// This routine checks if the final statement in a block is an
4836 /// expression with an explicit semicolon whose type is compatible
4837 /// with `expected_ty`. If so, it suggests removing the semicolon.
4838 fn consider_hint_about_removing_semicolon(&self,
4839 blk: &'gcx hir::Block,
4840 expected_ty: Ty<'tcx>,
4841 err: &mut DiagnosticBuilder) {
4842 // Be helpful when the user wrote `{... expr;}` and
4843 // taking the `;` off is enough to fix the error.
4844 let last_stmt = match blk.stmts.last() {
4848 let last_expr = match last_stmt.node {
4849 hir::StmtKind::Semi(ref e, _) => e,
4852 let last_expr_ty = self.node_ty(last_expr.hir_id);
4853 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4856 let original_span = original_sp(last_stmt.span, blk.span);
4857 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4858 err.span_suggestion_with_applicability(
4860 "consider removing this semicolon",
4862 Applicability::MachineApplicable);
4865 fn def_ids_for_path_segments(&self,
4866 segments: &[hir::PathSegment],
4869 // We need to extract the type parameters supplied by the user in
4870 // the path `path`. Due to the current setup, this is a bit of a
4871 // tricky-process; the problem is that resolve only tells us the
4872 // end-point of the path resolution, and not the intermediate steps.
4873 // Luckily, we can (at least for now) deduce the intermediate steps
4874 // just from the end-point.
4876 // There are basically four cases to consider:
4878 // 1. Reference to a constructor of enum variant or struct:
4880 // struct Foo<T>(...)
4881 // enum E<T> { Foo(...) }
4883 // In these cases, the parameters are declared in the type
4886 // 2. Reference to a fn item or a free constant:
4890 // In this case, the path will again always have the form
4891 // `a::b::foo::<T>` where only the final segment should have
4892 // type parameters. However, in this case, those parameters are
4893 // declared on a value, and hence are in the `FnSpace`.
4895 // 3. Reference to a method or an associated constant:
4897 // impl<A> SomeStruct<A> {
4901 // Here we can have a path like
4902 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4903 // may appear in two places. The penultimate segment,
4904 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4905 // final segment, `foo::<B>` contains parameters in fn space.
4907 // 4. Reference to a local variable
4909 // Local variables can't have any type parameters.
4911 // The first step then is to categorize the segments appropriately.
4913 assert!(!segments.is_empty());
4914 let last = segments.len() - 1;
4916 let mut path_segs = vec![];
4919 // Case 1. Reference to a struct/variant constructor.
4920 Def::StructCtor(def_id, ..) |
4921 Def::VariantCtor(def_id, ..) => {
4922 // Everything but the final segment should have no
4923 // parameters at all.
4924 let generics = self.tcx.generics_of(def_id);
4925 // Variant and struct constructors use the
4926 // generics of their parent type definition.
4927 let generics_def_id = generics.parent.unwrap_or(def_id);
4928 path_segs.push(PathSeg(generics_def_id, last));
4931 // Case 2. Reference to a top-level value.
4933 Def::Const(def_id) |
4934 Def::Static(def_id, _) => {
4935 path_segs.push(PathSeg(def_id, last));
4938 // Case 3. Reference to a method or associated const.
4939 Def::Method(def_id) |
4940 Def::AssociatedConst(def_id) => {
4941 if segments.len() >= 2 {
4942 let generics = self.tcx.generics_of(def_id);
4943 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
4945 path_segs.push(PathSeg(def_id, last));
4948 // Case 4. Local variable, no generics.
4949 Def::Local(..) | Def::Upvar(..) => {}
4951 _ => bug!("unexpected definition: {:?}", def),
4954 debug!("path_segs = {:?}", path_segs);
4959 // Instantiates the given path, which must refer to an item with the given
4960 // number of type parameters and type.
4961 pub fn instantiate_value_path(&self,
4962 segments: &[hir::PathSegment],
4963 self_ty: Option<Ty<'tcx>>,
4966 node_id: ast::NodeId)
4968 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4973 let path_segs = self.def_ids_for_path_segments(segments, def);
4975 let mut ufcs_associated = None;
4977 Def::Method(def_id) |
4978 Def::AssociatedConst(def_id) => {
4979 let container = self.tcx.associated_item(def_id).container;
4981 ty::TraitContainer(trait_did) => {
4982 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4984 ty::ImplContainer(_) => {}
4986 if segments.len() == 1 {
4987 // `<T>::assoc` will end up here, and so can `T::assoc`.
4988 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4989 ufcs_associated = Some((container, self_ty));
4995 // Now that we have categorized what space the parameters for each
4996 // segment belong to, let's sort out the parameters that the user
4997 // provided (if any) into their appropriate spaces. We'll also report
4998 // errors if type parameters are provided in an inappropriate place.
5000 let mut generic_segs = FxHashSet::default();
5001 for PathSeg(_, index) in &path_segs {
5002 generic_segs.insert(index);
5004 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5005 if !generic_segs.contains(&index) {
5013 Def::Local(nid) | Def::Upvar(nid, ..) => {
5014 let ty = self.local_ty(span, nid);
5015 let ty = self.normalize_associated_types_in(span, &ty);
5016 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
5022 // Now we have to compare the types that the user *actually*
5023 // provided against the types that were *expected*. If the user
5024 // did not provide any types, then we want to substitute inference
5025 // variables. If the user provided some types, we may still need
5026 // to add defaults. If the user provided *too many* types, that's
5029 let mut infer_args_for_err = FxHashSet::default();
5030 for &PathSeg(def_id, index) in &path_segs {
5031 let seg = &segments[index];
5032 let generics = self.tcx.generics_of(def_id);
5033 // Argument-position `impl Trait` is treated as a normal generic
5034 // parameter internally, but we don't allow users to specify the
5035 // parameter's value explicitly, so we have to do some error-
5037 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5042 false, // `is_method_call`
5044 if suppress_errors {
5045 infer_args_for_err.insert(index);
5046 self.set_tainted_by_errors(); // See issue #53251.
5050 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5051 self.tcx.generics_of(*def_id).has_self
5052 }).unwrap_or(false);
5054 let def_id = def.def_id();
5056 let substs = AstConv::create_substs_for_generic_args(
5062 // Provide the generic args, and whether types should be inferred.
5064 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5067 // If we've encountered an `impl Trait`-related error, we're just
5068 // going to infer the arguments for better error messages.
5069 if !infer_args_for_err.contains(&index) {
5070 // Check whether the user has provided generic arguments.
5071 if let Some(ref data) = segments[index].args {
5072 return (Some(data), segments[index].infer_types);
5075 return (None, segments[index].infer_types);
5080 // Provide substitutions for parameters for which (valid) arguments have been provided.
5082 match (¶m.kind, arg) {
5083 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5084 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5086 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5087 self.to_ty(ty).into()
5089 _ => unreachable!(),
5092 // Provide substitutions for parameters for which arguments are inferred.
5093 |substs, param, infer_types| {
5095 GenericParamDefKind::Lifetime => {
5096 self.re_infer(span, Some(param)).unwrap().into()
5098 GenericParamDefKind::Type { has_default, .. } => {
5099 if !infer_types && has_default {
5100 // If we have a default, then we it doesn't matter that we're not
5101 // inferring the type arguments: we provide the default where any
5103 let default = self.tcx.type_of(param.def_id);
5106 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5109 // If no type arguments were provided, we have to infer them.
5110 // This case also occurs as a result of some malformed input, e.g.
5111 // a lifetime argument being given instead of a type paramter.
5112 // Using inference instead of `Error` gives better error messages.
5113 self.var_for_def(span, param)
5120 // The things we are substituting into the type should not contain
5121 // escaping late-bound regions, and nor should the base type scheme.
5122 let ty = self.tcx.type_of(def_id);
5123 assert!(!substs.has_escaping_regions());
5124 assert!(!ty.has_escaping_regions());
5126 // Add all the obligations that are required, substituting and
5127 // normalized appropriately.
5128 let bounds = self.instantiate_bounds(span, def_id, &substs);
5129 self.add_obligations_for_parameters(
5130 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5133 // Substitute the values for the type parameters into the type of
5134 // the referenced item.
5135 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5137 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
5138 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5139 // is inherent, there is no `Self` parameter, instead, the impl needs
5140 // type parameters, which we can infer by unifying the provided `Self`
5141 // with the substituted impl type.
5142 let ty = self.tcx.type_of(impl_def_id);
5144 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5145 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5146 Ok(ok) => self.register_infer_ok_obligations(ok),
5149 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5156 self.check_rustc_args_require_const(def_id, node_id, span);
5158 debug!("instantiate_value_path: type of {:?} is {:?}",
5161 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
5162 self.write_substs(hir_id, substs);
5164 self.write_user_substs_from_substs(hir_id, substs);
5169 fn check_rustc_args_require_const(&self,
5171 node_id: ast::NodeId,
5173 // We're only interested in functions tagged with
5174 // #[rustc_args_required_const], so ignore anything that's not.
5175 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5179 // If our calling expression is indeed the function itself, we're good!
5180 // If not, generate an error that this can only be called directly.
5181 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5182 Node::Expr(expr) => {
5184 hir::ExprKind::Call(ref callee, ..) => {
5185 if callee.id == node_id {
5195 self.tcx.sess.span_err(span, "this function can only be invoked \
5196 directly, not through a function pointer");
5199 // Resolves `typ` by a single level if `typ` is a type variable.
5200 // If no resolution is possible, then an error is reported.
5201 // Numeric inference variables may be left unresolved.
5202 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5203 let ty = self.resolve_type_vars_with_obligations(ty);
5204 if !ty.is_ty_var() {
5207 if !self.is_tainted_by_errors() {
5208 self.need_type_info_err((**self).body_id, sp, ty)
5209 .note("type must be known at this point")
5212 self.demand_suptype(sp, self.tcx.types.err, ty);
5217 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5218 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5219 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5222 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5223 index = enclosing_breakables.stack.len();
5224 enclosing_breakables.by_id.insert(id, index);
5225 enclosing_breakables.stack.push(ctxt);
5229 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5230 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5231 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5232 enclosing_breakables.stack.pop().expect("missing breakable context")
5238 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5239 generics: &ty::Generics,
5241 let own_counts = generics.own_counts();
5242 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5244 if own_counts.types == 0 {
5247 // Make a vector of booleans initially false, set to true when used.
5248 let mut types_used = vec![false; own_counts.types];
5250 for leaf_ty in ty.walk() {
5251 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5252 debug!("Found use of ty param num {}", idx);
5253 types_used[idx as usize - own_counts.lifetimes] = true;
5254 } else if let ty::Error = leaf_ty.sty {
5255 // If there is already another error, do not emit
5256 // an error for not using a type Parameter.
5257 assert!(tcx.sess.err_count() > 0);
5262 let types = generics.params.iter().filter(|param| match param.kind {
5263 ty::GenericParamDefKind::Type { .. } => true,
5266 for (&used, param) in types_used.iter().zip(types) {
5268 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5269 let span = tcx.hir.span(id);
5270 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5271 .span_label(span, "unused type parameter")
5277 fn fatally_break_rust(sess: &Session) {
5278 let handler = sess.diagnostic();
5279 handler.span_bug_no_panic(
5281 "It looks like you're trying to break rust; would you like some ICE?",
5283 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5284 handler.note_without_error(
5285 "we would appreciate a joke overview: \
5286 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5288 handler.note_without_error(&format!("rustc {} running on {}",
5289 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5290 ::session::config::host_triple(),