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::opaque_types::OpaqueTypeDecl;
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 // Opaque 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 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
219 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'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 opaque_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_opaque_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 // at this point we don't care if there are duplicate handlers or if the handler has
1142 // the wrong signature as this value we'll be used when writing metadata and that
1143 // only happens if compilation succeeded
1144 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1146 if declared_ret_ty.sty != ty::Never {
1147 fcx.tcx.sess.span_err(
1149 "return type should be `!`",
1153 let inputs = fn_sig.inputs();
1154 let span = fcx.tcx.hir.span(fn_id);
1155 if inputs.len() == 1 {
1156 let arg_is_panic_info = match inputs[0].sty {
1157 ty::Ref(region, ty, mutbl) => match ty.sty {
1158 ty::Adt(ref adt, _) => {
1159 adt.did == panic_info_did &&
1160 mutbl == hir::Mutability::MutImmutable &&
1161 *region != RegionKind::ReStatic
1168 if !arg_is_panic_info {
1169 fcx.tcx.sess.span_err(
1170 decl.inputs[0].span,
1171 "argument should be `&PanicInfo`",
1175 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1176 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1177 if !generics.params.is_empty() {
1178 fcx.tcx.sess.span_err(
1180 "should have no type parameters",
1186 let span = fcx.tcx.sess.source_map().def_span(span);
1187 fcx.tcx.sess.span_err(span, "function should have one argument");
1190 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1195 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1196 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1197 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1198 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1199 if declared_ret_ty.sty != ty::Never {
1200 fcx.tcx.sess.span_err(
1202 "return type should be `!`",
1206 let inputs = fn_sig.inputs();
1207 let span = fcx.tcx.hir.span(fn_id);
1208 if inputs.len() == 1 {
1209 let arg_is_alloc_layout = match inputs[0].sty {
1210 ty::Adt(ref adt, _) => {
1211 adt.did == alloc_layout_did
1216 if !arg_is_alloc_layout {
1217 fcx.tcx.sess.span_err(
1218 decl.inputs[0].span,
1219 "argument should be `Layout`",
1223 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1224 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1225 if !generics.params.is_empty() {
1226 fcx.tcx.sess.span_err(
1228 "`#[alloc_error_handler]` function should have no type \
1235 let span = fcx.tcx.sess.source_map().def_span(span);
1236 fcx.tcx.sess.span_err(span, "function should have one argument");
1239 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1247 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1250 let def_id = tcx.hir.local_def_id(id);
1251 let def = tcx.adt_def(def_id);
1252 def.destructor(tcx); // force the destructor to be evaluated
1253 check_representable(tcx, span, def_id);
1255 if def.repr.simd() {
1256 check_simd(tcx, span, def_id);
1259 check_transparent(tcx, span, def_id);
1260 check_packed(tcx, span, def_id);
1263 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1266 let def_id = tcx.hir.local_def_id(id);
1267 let def = tcx.adt_def(def_id);
1268 def.destructor(tcx); // force the destructor to be evaluated
1269 check_representable(tcx, span, def_id);
1271 check_packed(tcx, span, def_id);
1274 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1275 debug!("check_item_type(it.id={}, it.name={})",
1277 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1278 let _indenter = indenter();
1280 // Consts can play a role in type-checking, so they are included here.
1281 hir::ItemKind::Static(..) => {
1282 let def_id = tcx.hir.local_def_id(it.id);
1283 tcx.typeck_tables_of(def_id);
1284 maybe_check_static_with_link_section(tcx, def_id, it.span);
1286 hir::ItemKind::Const(..) => {
1287 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1289 hir::ItemKind::Enum(ref enum_definition, _) => {
1292 &enum_definition.variants,
1295 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1296 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1297 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1298 let impl_def_id = tcx.hir.local_def_id(it.id);
1299 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1300 check_impl_items_against_trait(tcx,
1305 let trait_def_id = impl_trait_ref.def_id;
1306 check_on_unimplemented(tcx, trait_def_id, it);
1309 hir::ItemKind::Trait(..) => {
1310 let def_id = tcx.hir.local_def_id(it.id);
1311 check_on_unimplemented(tcx, def_id, it);
1313 hir::ItemKind::Struct(..) => {
1314 check_struct(tcx, it.id, it.span);
1316 hir::ItemKind::Union(..) => {
1317 check_union(tcx, it.id, it.span);
1319 hir::ItemKind::Existential(..) |
1320 hir::ItemKind::Ty(..) => {
1321 let def_id = tcx.hir.local_def_id(it.id);
1322 let pty_ty = tcx.type_of(def_id);
1323 let generics = tcx.generics_of(def_id);
1324 check_bounds_are_used(tcx, &generics, pty_ty);
1326 hir::ItemKind::ForeignMod(ref m) => {
1327 check_abi(tcx, it.span, m.abi);
1329 if m.abi == Abi::RustIntrinsic {
1330 for item in &m.items {
1331 intrinsic::check_intrinsic_type(tcx, item);
1333 } else if m.abi == Abi::PlatformIntrinsic {
1334 for item in &m.items {
1335 intrinsic::check_platform_intrinsic_type(tcx, item);
1338 for item in &m.items {
1339 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1340 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1341 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1342 "foreign items may not have type parameters");
1343 err.span_label(item.span, "can't have type parameters");
1344 // FIXME: once we start storing spans for type arguments, turn this into a
1346 err.help("use specialization instead of type parameters by replacing them \
1347 with concrete types like `u32`");
1351 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1352 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1357 _ => {/* nothing to do */ }
1361 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1362 // Only restricted on wasm32 target for now
1363 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1367 // If `#[link_section]` is missing, then nothing to verify
1368 let attrs = tcx.codegen_fn_attrs(id);
1369 if attrs.link_section.is_none() {
1373 // For the wasm32 target statics with #[link_section] are placed into custom
1374 // sections of the final output file, but this isn't link custom sections of
1375 // other executable formats. Namely we can only embed a list of bytes,
1376 // nothing with pointers to anything else or relocations. If any relocation
1377 // show up, reject them here.
1378 let instance = ty::Instance::mono(tcx, id);
1379 let cid = GlobalId {
1383 let param_env = ty::ParamEnv::reveal_all();
1384 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1385 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1388 bug!("Matching on non-ByRef static")
1390 if alloc.relocations.len() != 0 {
1391 let msg = "statics with a custom `#[link_section]` must be a \
1392 simple list of bytes on the wasm target with no \
1393 extra levels of indirection such as references";
1394 tcx.sess.span_err(span, msg);
1399 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1400 trait_def_id: DefId,
1402 let item_def_id = tcx.hir.local_def_id(item.id);
1403 // an error would be reported if this fails.
1404 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1407 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1408 impl_item: &hir::ImplItem,
1411 let mut err = struct_span_err!(
1412 tcx.sess, impl_item.span, E0520,
1413 "`{}` specializes an item from a parent `impl`, but \
1414 that item is not marked `default`",
1416 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1419 match tcx.span_of_impl(parent_impl) {
1421 err.span_label(span, "parent `impl` is here");
1422 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1426 err.note(&format!("parent implementation is in crate `{}`", cname));
1433 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1434 trait_def: &ty::TraitDef,
1435 trait_item: &ty::AssociatedItem,
1437 impl_item: &hir::ImplItem)
1439 let ancestors = trait_def.ancestors(tcx, impl_id);
1441 let kind = match impl_item.node {
1442 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1443 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1444 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1445 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1448 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1449 .map(|node_item| node_item.map(|parent| parent.defaultness));
1451 if let Some(parent) = parent {
1452 if tcx.impl_item_is_final(&parent) {
1453 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1459 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1462 impl_trait_ref: ty::TraitRef<'tcx>,
1463 impl_item_refs: &[hir::ImplItemRef]) {
1464 let impl_span = tcx.sess.source_map().def_span(impl_span);
1466 // If the trait reference itself is erroneous (so the compilation is going
1467 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1468 // isn't populated for such impls.
1469 if impl_trait_ref.references_error() { return; }
1471 // Locate trait definition and items
1472 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1473 let mut overridden_associated_type = None;
1475 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1477 // Check existing impl methods to see if they are both present in trait
1478 // and compatible with trait signature
1479 for impl_item in impl_items() {
1480 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1481 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1482 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1483 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1485 // Not compatible, but needed for the error message
1486 tcx.associated_items(impl_trait_ref.def_id)
1487 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1490 // Check that impl definition matches trait definition
1491 if let Some(ty_trait_item) = ty_trait_item {
1492 match impl_item.node {
1493 hir::ImplItemKind::Const(..) => {
1494 // Find associated const definition.
1495 if ty_trait_item.kind == ty::AssociatedKind::Const {
1496 compare_const_impl(tcx,
1502 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1503 "item `{}` is an associated const, \
1504 which doesn't match its trait `{}`",
1507 err.span_label(impl_item.span, "does not match trait");
1508 // We can only get the spans from local trait definition
1509 // Same for E0324 and E0325
1510 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1511 err.span_label(trait_span, "item in trait");
1516 hir::ImplItemKind::Method(..) => {
1517 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1518 if ty_trait_item.kind == ty::AssociatedKind::Method {
1519 compare_impl_method(tcx,
1526 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1527 "item `{}` is an associated method, \
1528 which doesn't match its trait `{}`",
1531 err.span_label(impl_item.span, "does not match trait");
1532 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1533 err.span_label(trait_span, "item in trait");
1538 hir::ImplItemKind::Existential(..) |
1539 hir::ImplItemKind::Type(_) => {
1540 if ty_trait_item.kind == ty::AssociatedKind::Type {
1541 if ty_trait_item.defaultness.has_value() {
1542 overridden_associated_type = Some(impl_item);
1545 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1546 "item `{}` is an associated type, \
1547 which doesn't match its trait `{}`",
1550 err.span_label(impl_item.span, "does not match trait");
1551 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1552 err.span_label(trait_span, "item in trait");
1559 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1563 // Check for missing items from trait
1564 let mut missing_items = Vec::new();
1565 let mut invalidated_items = Vec::new();
1566 let associated_type_overridden = overridden_associated_type.is_some();
1567 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1568 let is_implemented = trait_def.ancestors(tcx, impl_id)
1569 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1571 .map(|node_item| !node_item.node.is_from_trait())
1574 if !is_implemented && !tcx.impl_is_default(impl_id) {
1575 if !trait_item.defaultness.has_value() {
1576 missing_items.push(trait_item);
1577 } else if associated_type_overridden {
1578 invalidated_items.push(trait_item.ident);
1583 if !missing_items.is_empty() {
1584 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1585 "not all trait items implemented, missing: `{}`",
1586 missing_items.iter()
1587 .map(|trait_item| trait_item.ident.to_string())
1588 .collect::<Vec<_>>().join("`, `"));
1589 err.span_label(impl_span, format!("missing `{}` in implementation",
1590 missing_items.iter()
1591 .map(|trait_item| trait_item.ident.to_string())
1592 .collect::<Vec<_>>().join("`, `")));
1593 for trait_item in missing_items {
1594 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1595 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1597 err.note_trait_signature(trait_item.ident.to_string(),
1598 trait_item.signature(&tcx));
1604 if !invalidated_items.is_empty() {
1605 let invalidator = overridden_associated_type.unwrap();
1606 span_err!(tcx.sess, invalidator.span, E0399,
1607 "the following trait items need to be reimplemented \
1608 as `{}` was overridden: `{}`",
1610 invalidated_items.iter()
1611 .map(|name| name.to_string())
1612 .collect::<Vec<_>>().join("`, `"))
1616 /// Checks whether a type can be represented in memory. In particular, it
1617 /// identifies types that contain themselves without indirection through a
1618 /// pointer, which would mean their size is unbounded.
1619 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1623 let rty = tcx.type_of(item_def_id);
1625 // Check that it is possible to represent this type. This call identifies
1626 // (1) types that contain themselves and (2) types that contain a different
1627 // recursive type. It is only necessary to throw an error on those that
1628 // contain themselves. For case 2, there must be an inner type that will be
1629 // caught by case 1.
1630 match rty.is_representable(tcx, sp) {
1631 Representability::SelfRecursive(spans) => {
1632 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1634 err.span_label(span, "recursive without indirection");
1639 Representability::Representable | Representability::ContainsRecursive => (),
1644 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1645 let t = tcx.type_of(def_id);
1647 ty::Adt(def, substs) if def.is_struct() => {
1648 let fields = &def.non_enum_variant().fields;
1649 if fields.is_empty() {
1650 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1653 let e = fields[0].ty(tcx, substs);
1654 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1655 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1656 .span_label(sp, "SIMD elements must have the same type")
1661 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1662 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1664 span_err!(tcx.sess, sp, E0077,
1665 "SIMD vector element type should be machine type");
1674 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1675 let repr = tcx.adt_def(def_id).repr;
1677 for attr in tcx.get_attrs(def_id).iter() {
1678 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1679 if let attr::ReprPacked(pack) = r {
1680 if pack != repr.pack {
1681 struct_span_err!(tcx.sess, sp, E0634,
1682 "type has conflicting packed representation hints").emit();
1688 struct_span_err!(tcx.sess, sp, E0587,
1689 "type has conflicting packed and align representation hints").emit();
1691 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1692 struct_span_err!(tcx.sess, sp, E0588,
1693 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1698 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1700 stack: &mut Vec<DefId>) -> bool {
1701 let t = tcx.type_of(def_id);
1702 if stack.contains(&def_id) {
1703 debug!("check_packed_inner: {:?} is recursive", t);
1707 ty::Adt(def, substs) if def.is_struct() || def.is_union() => {
1708 if tcx.adt_def(def.did).repr.align > 0 {
1711 // push struct def_id before checking fields
1713 for field in &def.non_enum_variant().fields {
1714 let f = field.ty(tcx, substs);
1716 ty::Adt(def, _) => {
1717 if check_packed_inner(tcx, def.did, stack) {
1724 // only need to pop if not early out
1732 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1733 let adt = tcx.adt_def(def_id);
1734 if !adt.repr.transparent() {
1738 // For each field, figure out if it's known to be a ZST and align(1)
1739 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1740 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1741 let param_env = tcx.param_env(field.did);
1742 let layout = tcx.layout_of(param_env.and(ty));
1743 // We are currently checking the type this field came from, so it must be local
1744 let span = tcx.hir.span_if_local(field.did).unwrap();
1745 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1746 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1750 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1751 let non_zst_count = non_zst_fields.clone().count();
1752 if non_zst_count != 1 {
1753 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1754 struct_span_err!(tcx.sess, sp, E0690,
1755 "transparent struct needs exactly one non-zero-sized field, but has {}",
1757 .span_note(field_spans, "non-zero-sized field")
1760 for &(span, zst, align1) in &field_infos {
1762 span_err!(tcx.sess, span, E0691,
1763 "zero-sized field in transparent struct has alignment larger than 1");
1768 #[allow(trivial_numeric_casts)]
1769 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1771 vs: &'tcx [hir::Variant],
1773 let def_id = tcx.hir.local_def_id(id);
1774 let def = tcx.adt_def(def_id);
1775 def.destructor(tcx); // force the destructor to be evaluated
1778 let attributes = tcx.get_attrs(def_id);
1779 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1781 tcx.sess, attr.span, E0084,
1782 "unsupported representation for zero-variant enum")
1783 .span_label(sp, "zero-variant enum")
1788 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1789 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1790 if !tcx.features().repr128 {
1791 emit_feature_err(&tcx.sess.parse_sess,
1794 GateIssue::Language,
1795 "repr with 128-bit type is unstable");
1800 if let Some(ref e) = v.node.disr_expr {
1801 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1805 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1806 for (discr, v) in def.discriminants(tcx).zip(vs) {
1807 // Check for duplicate discriminant values
1808 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1809 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1810 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1811 let i_span = match variant_i.node.disr_expr {
1812 Some(ref expr) => tcx.hir.span(expr.id),
1813 None => tcx.hir.span(variant_i_node_id)
1815 let span = match v.node.disr_expr {
1816 Some(ref expr) => tcx.hir.span(expr.id),
1819 struct_span_err!(tcx.sess, span, E0081,
1820 "discriminant value `{}` already exists", disr_vals[i])
1821 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1822 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1825 disr_vals.push(discr);
1828 check_representable(tcx, sp, def_id);
1831 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1832 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1834 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1835 -> ty::GenericPredicates<'tcx>
1838 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1839 let item_id = tcx.hir.ty_param_owner(node_id);
1840 let item_def_id = tcx.hir.local_def_id(item_id);
1841 let generics = tcx.generics_of(item_def_id);
1842 let index = generics.param_def_id_to_index[&def_id];
1843 ty::GenericPredicates {
1845 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1847 ty::Predicate::Trait(ref data) => {
1848 data.skip_binder().self_ty().is_param(index)
1852 }).cloned().collect()
1856 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1857 -> Option<ty::Region<'tcx>> {
1859 Some(def) => infer::EarlyBoundRegion(span, def.name),
1860 None => infer::MiscVariable(span)
1862 Some(self.next_region_var(v))
1865 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1866 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1869 fn ty_infer_for_def(&self,
1870 ty_param_def: &ty::GenericParamDef,
1871 span: Span) -> Ty<'tcx> {
1872 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1878 fn projected_ty_from_poly_trait_ref(&self,
1881 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1884 let (trait_ref, _) =
1885 self.replace_late_bound_regions_with_fresh_var(
1887 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1890 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1893 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1894 if ty.has_escaping_regions() {
1895 ty // FIXME: normalization and escaping regions
1897 self.normalize_associated_types_in(span, &ty)
1901 fn set_tainted_by_errors(&self) {
1902 self.infcx.set_tainted_by_errors()
1905 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1906 self.write_ty(hir_id, ty)
1910 /// Controls whether the arguments are tupled. This is used for the call
1913 /// Tupling means that all call-side arguments are packed into a tuple and
1914 /// passed as a single parameter. For example, if tupling is enabled, this
1917 /// fn f(x: (isize, isize))
1919 /// Can be called as:
1926 #[derive(Clone, Eq, PartialEq)]
1927 enum TupleArgumentsFlag {
1932 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1933 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1934 param_env: ty::ParamEnv<'tcx>,
1935 body_id: ast::NodeId)
1936 -> FnCtxt<'a, 'gcx, 'tcx> {
1940 err_count_on_creation: inh.tcx.sess.err_count(),
1943 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1944 ast::CRATE_NODE_ID)),
1945 diverges: Cell::new(Diverges::Maybe),
1946 has_errors: Cell::new(false),
1947 enclosing_breakables: RefCell::new(EnclosingBreakables {
1955 pub fn sess(&self) -> &Session {
1959 pub fn err_count_since_creation(&self) -> usize {
1960 self.tcx.sess.err_count() - self.err_count_on_creation
1963 /// Produce warning on the given node, if the current point in the
1964 /// function is unreachable, and there hasn't been another warning.
1965 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1966 if self.diverges.get() == Diverges::Always {
1967 self.diverges.set(Diverges::WarnedAlways);
1969 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1971 self.tcx().lint_node(
1972 lint::builtin::UNREACHABLE_CODE,
1974 &format!("unreachable {}", kind));
1980 code: ObligationCauseCode<'tcx>)
1981 -> ObligationCause<'tcx> {
1982 ObligationCause::new(span, self.body_id, code)
1985 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1986 self.cause(span, ObligationCauseCode::MiscObligation)
1989 /// Resolves type variables in `ty` if possible. Unlike the infcx
1990 /// version (resolve_type_vars_if_possible), this version will
1991 /// also select obligations if it seems useful, in an effort
1992 /// to get more type information.
1993 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1994 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1996 // No Infer()? Nothing needs doing.
1997 if !ty.has_infer_types() {
1998 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2002 // If `ty` is a type variable, see whether we already know what it is.
2003 ty = self.resolve_type_vars_if_possible(&ty);
2004 if !ty.has_infer_types() {
2005 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2009 // If not, try resolving pending obligations as much as
2010 // possible. This can help substantially when there are
2011 // indirect dependencies that don't seem worth tracking
2013 self.select_obligations_where_possible(false);
2014 ty = self.resolve_type_vars_if_possible(&ty);
2016 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2020 fn record_deferred_call_resolution(&self,
2021 closure_def_id: DefId,
2022 r: DeferredCallResolution<'gcx, 'tcx>) {
2023 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2024 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2027 fn remove_deferred_call_resolutions(&self,
2028 closure_def_id: DefId)
2029 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2031 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2032 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2035 pub fn tag(&self) -> String {
2036 let self_ptr: *const FnCtxt = self;
2037 format!("{:?}", self_ptr)
2040 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
2041 match self.locals.borrow().get(&nid) {
2044 span_bug!(span, "no type for local variable {}",
2045 self.tcx.hir.node_to_string(nid));
2051 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2052 debug!("write_ty({:?}, {:?}) in fcx {}",
2053 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2054 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2056 if ty.references_error() {
2057 self.has_errors.set(true);
2058 self.set_tainted_by_errors();
2062 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2063 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2064 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2067 // The NodeId and the ItemLocalId must identify the same item. We just pass
2068 // both of them for consistency checking.
2069 pub fn write_method_call(&self,
2071 method: MethodCallee<'tcx>) {
2072 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2075 .type_dependent_defs_mut()
2076 .insert(hir_id, Def::Method(method.def_id));
2078 self.write_substs(hir_id, method.substs);
2080 // When the method is confirmed, the `method.substs` includes
2081 // parameters from not just the method, but also the impl of
2082 // the method -- in particular, the `Self` type will be fully
2083 // resolved. However, those are not something that the "user
2084 // specified" -- i.e., those types come from the inferred type
2085 // of the receiver, not something the user wrote. So when we
2086 // create the user-substs, we want to replace those earlier
2087 // types with just the types that the user actually wrote --
2088 // that is, those that appear on the *method itself*.
2090 // As an example, if the user wrote something like
2091 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2092 // type of `foo` (possibly adjusted), but we don't want to
2093 // include that. We want just the `[_, u32]` part.
2094 if !method.substs.is_noop() {
2095 let method_generics = self.tcx.generics_of(method.def_id);
2096 if !method_generics.params.is_empty() {
2097 let user_substs = self.infcx.probe(|_| {
2098 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2099 let i = param.index as usize;
2100 if i < method_generics.parent_count {
2101 self.infcx.var_for_def(DUMMY_SP, param)
2106 self.infcx.canonicalize_response(&just_method_substs)
2109 debug!("write_method_call: user_substs = {:?}", user_substs);
2110 self.write_user_substs(hir_id, user_substs);
2115 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2116 if !substs.is_noop() {
2117 debug!("write_substs({:?}, {:?}) in fcx {}",
2122 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2126 /// Given the substs that we just converted from the HIR, try to
2127 /// canonicalize them and store them as user-given substitutions
2128 /// (i.e., substitutions that must be respected by the NLL check).
2130 /// This should be invoked **before any unifications have
2131 /// occurred**, so that annotations like `Vec<_>` are preserved
2133 pub fn write_user_substs_from_substs(&self, hir_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2134 if !substs.is_noop() {
2135 let user_substs = self.infcx.canonicalize_response(&substs);
2136 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2137 self.write_user_substs(hir_id, user_substs);
2141 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalSubsts<'tcx>) {
2143 "write_user_substs({:?}, {:?}) in fcx {}",
2149 if !substs.is_identity() {
2150 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2152 debug!("write_user_substs: skipping identity substs");
2156 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2157 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2163 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2164 Entry::Vacant(entry) => { entry.insert(adj); },
2165 Entry::Occupied(mut entry) => {
2166 debug!(" - composing on top of {:?}", entry.get());
2167 match (&entry.get()[..], &adj[..]) {
2168 // Applying any adjustment on top of a NeverToAny
2169 // is a valid NeverToAny adjustment, because it can't
2171 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2173 Adjustment { kind: Adjust::Deref(_), .. },
2174 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2176 Adjustment { kind: Adjust::Deref(_), .. },
2177 .. // Any following adjustments are allowed.
2179 // A reborrow has no effect before a dereference.
2181 // FIXME: currently we never try to compose autoderefs
2182 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2184 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2185 expr, entry.get(), adj)
2187 *entry.get_mut() = adj;
2192 /// Basically whenever we are converting from a type scheme into
2193 /// the fn body space, we always want to normalize associated
2194 /// types as well. This function combines the two.
2195 fn instantiate_type_scheme<T>(&self,
2197 substs: &Substs<'tcx>,
2200 where T : TypeFoldable<'tcx>
2202 let value = value.subst(self.tcx, substs);
2203 let result = self.normalize_associated_types_in(span, &value);
2204 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2211 /// As `instantiate_type_scheme`, but for the bounds found in a
2212 /// generic type scheme.
2213 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2214 -> ty::InstantiatedPredicates<'tcx> {
2215 let bounds = self.tcx.predicates_of(def_id);
2216 let result = bounds.instantiate(self.tcx, substs);
2217 let result = self.normalize_associated_types_in(span, &result);
2218 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2225 /// Replace the opaque types from the return value of the
2226 /// function with type variables and records the `OpaqueTypeMap` for
2227 /// later use during writeback. See
2228 /// `InferCtxt::instantiate_opaque_types` for more details.
2229 fn instantiate_opaque_types_from_return_value<T: TypeFoldable<'tcx>>(
2234 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2236 "instantiate_opaque_types_from_return_value(fn_def_id={:?}, value={:?})",
2241 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2242 self.instantiate_opaque_types(
2250 let mut opaque_types = self.opaque_types.borrow_mut();
2251 for (ty, decl) in opaque_type_map {
2252 let old_value = opaque_types.insert(ty, decl);
2253 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2259 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2260 where T : TypeFoldable<'tcx>
2262 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2265 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2267 where T : TypeFoldable<'tcx>
2269 self.inh.partially_normalize_associated_types_in(span,
2275 pub fn require_type_meets(&self,
2278 code: traits::ObligationCauseCode<'tcx>,
2281 self.register_bound(
2284 traits::ObligationCause::new(span, self.body_id, code));
2287 pub fn require_type_is_sized(&self,
2290 code: traits::ObligationCauseCode<'tcx>)
2292 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2293 self.require_type_meets(ty, span, code, lang_item);
2296 pub fn register_bound(&self,
2299 cause: traits::ObligationCause<'tcx>)
2301 self.fulfillment_cx.borrow_mut()
2302 .register_bound(self, self.param_env, ty, def_id, cause);
2305 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2306 let t = AstConv::ast_ty_to_ty(self, ast_t);
2307 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2311 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2312 match self.tables.borrow().node_types().get(id) {
2314 None if self.is_tainted_by_errors() => self.tcx.types.err,
2316 let node_id = self.tcx.hir.hir_to_node_id(id);
2317 bug!("no type for node {}: {} in fcx {}",
2318 node_id, self.tcx.hir.node_to_string(node_id),
2324 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2325 /// outlive the region `r`.
2326 pub fn register_wf_obligation(&self,
2329 code: traits::ObligationCauseCode<'tcx>)
2331 // WF obligations never themselves fail, so no real need to give a detailed cause:
2332 let cause = traits::ObligationCause::new(span, self.body_id, code);
2333 self.register_predicate(traits::Obligation::new(cause,
2335 ty::Predicate::WellFormed(ty)));
2338 /// Registers obligations that all types appearing in `substs` are well-formed.
2339 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2341 for ty in substs.types() {
2342 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2346 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2347 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2348 /// trait/region obligations.
2350 /// For example, if there is a function:
2353 /// fn foo<'a,T:'a>(...)
2356 /// and a reference:
2362 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2363 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2364 pub fn add_obligations_for_parameters(&self,
2365 cause: traits::ObligationCause<'tcx>,
2366 predicates: &ty::InstantiatedPredicates<'tcx>)
2368 assert!(!predicates.has_escaping_regions());
2370 debug!("add_obligations_for_parameters(predicates={:?})",
2373 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2374 self.register_predicate(obligation);
2378 // FIXME(arielb1): use this instead of field.ty everywhere
2379 // Only for fields! Returns <none> for methods>
2380 // Indifferent to privacy flags
2381 pub fn field_ty(&self,
2383 field: &'tcx ty::FieldDef,
2384 substs: &Substs<'tcx>)
2387 self.normalize_associated_types_in(span,
2388 &field.ty(self.tcx, substs))
2391 fn check_casts(&self) {
2392 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2393 for cast in deferred_cast_checks.drain(..) {
2398 fn resolve_generator_interiors(&self, def_id: DefId) {
2399 let mut generators = self.deferred_generator_interiors.borrow_mut();
2400 for (body_id, interior) in generators.drain(..) {
2401 self.select_obligations_where_possible(false);
2402 generator_interior::resolve_interior(self, def_id, body_id, interior);
2406 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2407 // Non-numerics get replaced with ! or () (depending on whether
2408 // feature(never_type) is enabled, unconstrained ints with i32,
2409 // unconstrained floats with f64.
2410 // Fallback becomes very dubious if we have encountered type-checking errors.
2411 // In that case, fallback to Error.
2412 // The return value indicates whether fallback has occurred.
2413 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2414 use rustc::ty::error::UnconstrainedNumeric::Neither;
2415 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2417 assert!(ty.is_ty_infer());
2418 let fallback = match self.type_is_unconstrained_numeric(ty) {
2419 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2420 UnconstrainedInt => self.tcx.types.i32,
2421 UnconstrainedFloat => self.tcx.types.f64,
2422 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2423 Neither => return false,
2425 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2426 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2430 fn select_all_obligations_or_error(&self) {
2431 debug!("select_all_obligations_or_error");
2432 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2433 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2437 /// Select as many obligations as we can at present.
2438 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2439 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2442 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2447 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2449 hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
2451 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2456 hir::ExprKind::Type(ref e, _) => {
2457 self.is_place_expr(e)
2460 hir::ExprKind::Unary(hir::UnDeref, _) |
2461 hir::ExprKind::Field(..) |
2462 hir::ExprKind::Index(..) => {
2466 // Partially qualified paths in expressions can only legally
2467 // refer to associated items which are always rvalues.
2468 hir::ExprKind::Path(hir::QPath::TypeRelative(..)) |
2470 hir::ExprKind::Call(..) |
2471 hir::ExprKind::MethodCall(..) |
2472 hir::ExprKind::Struct(..) |
2473 hir::ExprKind::Tup(..) |
2474 hir::ExprKind::If(..) |
2475 hir::ExprKind::Match(..) |
2476 hir::ExprKind::Closure(..) |
2477 hir::ExprKind::Block(..) |
2478 hir::ExprKind::Repeat(..) |
2479 hir::ExprKind::Array(..) |
2480 hir::ExprKind::Break(..) |
2481 hir::ExprKind::Continue(..) |
2482 hir::ExprKind::Ret(..) |
2483 hir::ExprKind::While(..) |
2484 hir::ExprKind::Loop(..) |
2485 hir::ExprKind::Assign(..) |
2486 hir::ExprKind::InlineAsm(..) |
2487 hir::ExprKind::AssignOp(..) |
2488 hir::ExprKind::Lit(_) |
2489 hir::ExprKind::Unary(..) |
2490 hir::ExprKind::Box(..) |
2491 hir::ExprKind::AddrOf(..) |
2492 hir::ExprKind::Binary(..) |
2493 hir::ExprKind::Yield(..) |
2494 hir::ExprKind::Cast(..) => {
2500 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2501 /// returns a type of `&T`, but the actual type we assign to the
2502 /// *expression* is `T`. So this function just peels off the return
2503 /// type by one layer to yield `T`.
2504 fn make_overloaded_place_return_type(&self,
2505 method: MethodCallee<'tcx>)
2506 -> ty::TypeAndMut<'tcx>
2508 // extract method return type, which will be &T;
2509 let ret_ty = method.sig.output();
2511 // method returns &T, but the type as visible to user is T, so deref
2512 ret_ty.builtin_deref(true).unwrap()
2515 fn lookup_indexing(&self,
2517 base_expr: &'gcx hir::Expr,
2521 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2523 // FIXME(#18741) -- this is almost but not quite the same as the
2524 // autoderef that normal method probing does. They could likely be
2527 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2528 let mut result = None;
2529 while result.is_none() && autoderef.next().is_some() {
2530 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2532 autoderef.finalize();
2536 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2537 /// (and otherwise adjust) `base_expr`, looking for a type which either
2538 /// supports builtin indexing or overloaded indexing.
2539 /// This loop implements one step in that search; the autoderef loop
2540 /// is implemented by `lookup_indexing`.
2541 fn try_index_step(&self,
2543 base_expr: &hir::Expr,
2544 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2547 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2549 let adjusted_ty = autoderef.unambiguous_final_ty();
2550 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2557 for &unsize in &[false, true] {
2558 let mut self_ty = adjusted_ty;
2560 // We only unsize arrays here.
2561 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2562 self_ty = self.tcx.mk_slice(element_ty);
2568 // If some lookup succeeds, write callee into table and extract index/element
2569 // type from the method signature.
2570 // If some lookup succeeded, install method in table
2571 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2572 let method = self.try_overloaded_place_op(
2573 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2575 let result = method.map(|ok| {
2576 debug!("try_index_step: success, using overloaded indexing");
2577 let method = self.register_infer_ok_obligations(ok);
2579 let mut adjustments = autoderef.adjust_steps(needs);
2580 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2581 let mutbl = match r_mutbl {
2582 hir::MutImmutable => AutoBorrowMutability::Immutable,
2583 hir::MutMutable => AutoBorrowMutability::Mutable {
2584 // Indexing can be desugared to a method call,
2585 // so maybe we could use two-phase here.
2586 // See the documentation of AllowTwoPhase for why that's
2587 // not the case today.
2588 allow_two_phase_borrow: AllowTwoPhase::No,
2591 adjustments.push(Adjustment {
2592 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2593 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2600 adjustments.push(Adjustment {
2601 kind: Adjust::Unsize,
2602 target: method.sig.inputs()[0]
2605 self.apply_adjustments(base_expr, adjustments);
2607 self.write_method_call(expr.hir_id, method);
2608 (input_ty, self.make_overloaded_place_return_type(method).ty)
2610 if result.is_some() {
2618 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2619 let (tr, name) = match (op, is_mut) {
2620 (PlaceOp::Deref, false) =>
2621 (self.tcx.lang_items().deref_trait(), "deref"),
2622 (PlaceOp::Deref, true) =>
2623 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2624 (PlaceOp::Index, false) =>
2625 (self.tcx.lang_items().index_trait(), "index"),
2626 (PlaceOp::Index, true) =>
2627 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2629 (tr, ast::Ident::from_str(name))
2632 fn try_overloaded_place_op(&self,
2635 arg_tys: &[Ty<'tcx>],
2638 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2640 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2646 // Try Mut first, if needed.
2647 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2648 let method = match (needs, mut_tr) {
2649 (Needs::MutPlace, Some(trait_did)) => {
2650 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2655 // Otherwise, fall back to the immutable version.
2656 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2657 let method = match (method, imm_tr) {
2658 (None, Some(trait_did)) => {
2659 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2661 (method, _) => method,
2667 fn check_method_argument_types(&self,
2670 method: Result<MethodCallee<'tcx>, ()>,
2671 args_no_rcvr: &'gcx [hir::Expr],
2672 tuple_arguments: TupleArgumentsFlag,
2673 expected: Expectation<'tcx>)
2675 let has_error = match method {
2677 method.substs.references_error() || method.sig.references_error()
2682 let err_inputs = self.err_args(args_no_rcvr.len());
2684 let err_inputs = match tuple_arguments {
2685 DontTupleArguments => err_inputs,
2686 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2689 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2690 false, tuple_arguments, None);
2691 return self.tcx.types.err;
2694 let method = method.unwrap();
2695 // HACK(eddyb) ignore self in the definition (see above).
2696 let expected_arg_tys = self.expected_inputs_for_expected_output(
2699 method.sig.output(),
2700 &method.sig.inputs()[1..]
2702 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2703 args_no_rcvr, method.sig.variadic, tuple_arguments,
2704 self.tcx.hir.span_if_local(method.def_id));
2708 /// Generic function that factors out common logic from function calls,
2709 /// method calls and overloaded operators.
2710 fn check_argument_types(&self,
2713 fn_inputs: &[Ty<'tcx>],
2714 mut expected_arg_tys: &[Ty<'tcx>],
2715 args: &'gcx [hir::Expr],
2717 tuple_arguments: TupleArgumentsFlag,
2718 def_span: Option<Span>) {
2721 // Grab the argument types, supplying fresh type variables
2722 // if the wrong number of arguments were supplied
2723 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2729 // All the input types from the fn signature must outlive the call
2730 // so as to validate implied bounds.
2731 for &fn_input_ty in fn_inputs {
2732 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2735 let expected_arg_count = fn_inputs.len();
2737 let param_count_error = |expected_count: usize,
2742 let mut err = tcx.sess.struct_span_err_with_code(sp,
2743 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2744 if variadic {"at least "} else {""},
2746 if expected_count == 1 {""} else {"s"},
2748 if arg_count == 1 {" was"} else {"s were"}),
2749 DiagnosticId::Error(error_code.to_owned()));
2751 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2752 err.span_label(def_s, "defined here");
2755 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2756 // remove closing `)` from the span
2757 let sugg_span = sugg_span.shrink_to_lo();
2758 err.span_suggestion_with_applicability(
2760 "expected the unit value `()`; create it with empty parentheses",
2762 Applicability::MachineApplicable);
2764 err.span_label(sp, format!("expected {}{} parameter{}",
2765 if variadic {"at least "} else {""},
2767 if expected_count == 1 {""} else {"s"}));
2772 let formal_tys = if tuple_arguments == TupleArguments {
2773 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2774 match tuple_type.sty {
2775 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2776 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2777 expected_arg_tys = &[];
2778 self.err_args(args.len())
2780 ty::Tuple(arg_types) => {
2781 expected_arg_tys = match expected_arg_tys.get(0) {
2782 Some(&ty) => match ty.sty {
2783 ty::Tuple(ref tys) => &tys,
2791 span_err!(tcx.sess, sp, E0059,
2792 "cannot use call notation; the first type parameter \
2793 for the function trait is neither a tuple nor unit");
2794 expected_arg_tys = &[];
2795 self.err_args(args.len())
2798 } else if expected_arg_count == supplied_arg_count {
2800 } else if variadic {
2801 if supplied_arg_count >= expected_arg_count {
2804 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2805 expected_arg_tys = &[];
2806 self.err_args(supplied_arg_count)
2809 // is the missing argument of type `()`?
2810 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2811 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2812 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2813 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2817 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2819 expected_arg_tys = &[];
2820 self.err_args(supplied_arg_count)
2822 // If there is no expectation, expect formal_tys.
2823 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2829 debug!("check_argument_types: formal_tys={:?}",
2830 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2832 // Check the arguments.
2833 // We do this in a pretty awful way: first we typecheck any arguments
2834 // that are not closures, then we typecheck the closures. This is so
2835 // that we have more information about the types of arguments when we
2836 // typecheck the functions. This isn't really the right way to do this.
2837 for &check_closures in &[false, true] {
2838 debug!("check_closures={}", check_closures);
2840 // More awful hacks: before we check argument types, try to do
2841 // an "opportunistic" vtable resolution of any trait bounds on
2842 // the call. This helps coercions.
2844 self.select_obligations_where_possible(false);
2847 // For variadic functions, we don't have a declared type for all of
2848 // the arguments hence we only do our usual type checking with
2849 // the arguments who's types we do know.
2850 let t = if variadic {
2852 } else if tuple_arguments == TupleArguments {
2857 for (i, arg) in args.iter().take(t).enumerate() {
2858 // Warn only for the first loop (the "no closures" one).
2859 // Closure arguments themselves can't be diverging, but
2860 // a previous argument can, e.g. `foo(panic!(), || {})`.
2861 if !check_closures {
2862 self.warn_if_unreachable(arg.id, arg.span, "expression");
2865 let is_closure = match arg.node {
2866 hir::ExprKind::Closure(..) => true,
2870 if is_closure != check_closures {
2874 debug!("checking the argument");
2875 let formal_ty = formal_tys[i];
2877 // The special-cased logic below has three functions:
2878 // 1. Provide as good of an expected type as possible.
2879 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2881 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2883 // 2. Coerce to the most detailed type that could be coerced
2884 // to, which is `expected_ty` if `rvalue_hint` returns an
2885 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2886 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2887 // We're processing function arguments so we definitely want to use
2888 // two-phase borrows.
2889 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2891 // 3. Relate the expected type and the formal one,
2892 // if the expected type was used for the coercion.
2893 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2897 // We also need to make sure we at least write the ty of the other
2898 // arguments which we skipped above.
2900 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2901 use structured_errors::{VariadicError, StructuredDiagnostic};
2902 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2905 for arg in args.iter().skip(expected_arg_count) {
2906 let arg_ty = self.check_expr(&arg);
2908 // There are a few types which get autopromoted when passed via varargs
2909 // in C but we just error out instead and require explicit casts.
2910 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2912 ty::Float(ast::FloatTy::F32) => {
2913 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2915 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2916 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2918 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2919 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2922 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2923 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2924 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2932 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2933 (0..len).map(|_| self.tcx.types.err).collect()
2936 // AST fragment checking
2939 expected: Expectation<'tcx>)
2945 ast::LitKind::Str(..) => tcx.mk_static_str(),
2946 ast::LitKind::ByteStr(ref v) => {
2947 tcx.mk_imm_ref(tcx.types.re_static,
2948 tcx.mk_array(tcx.types.u8, v.len() as u64))
2950 ast::LitKind::Byte(_) => tcx.types.u8,
2951 ast::LitKind::Char(_) => tcx.types.char,
2952 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2953 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2954 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2955 let opt_ty = expected.to_option(self).and_then(|ty| {
2957 ty::Int(_) | ty::Uint(_) => Some(ty),
2958 ty::Char => Some(tcx.types.u8),
2959 ty::RawPtr(..) => Some(tcx.types.usize),
2960 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2964 opt_ty.unwrap_or_else(
2965 || tcx.mk_int_var(self.next_int_var_id()))
2967 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2968 ast::LitKind::FloatUnsuffixed(_) => {
2969 let opt_ty = expected.to_option(self).and_then(|ty| {
2971 ty::Float(_) => Some(ty),
2975 opt_ty.unwrap_or_else(
2976 || tcx.mk_float_var(self.next_float_var_id()))
2978 ast::LitKind::Bool(_) => tcx.types.bool
2982 fn check_expr_eq_type(&self,
2983 expr: &'gcx hir::Expr,
2984 expected: Ty<'tcx>) {
2985 let ty = self.check_expr_with_hint(expr, expected);
2986 self.demand_eqtype(expr.span, expected, ty);
2989 pub fn check_expr_has_type_or_error(&self,
2990 expr: &'gcx hir::Expr,
2991 expected: Ty<'tcx>) -> Ty<'tcx> {
2992 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2995 fn check_expr_meets_expectation_or_error(&self,
2996 expr: &'gcx hir::Expr,
2997 expected: Expectation<'tcx>) -> Ty<'tcx> {
2998 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2999 let mut ty = self.check_expr_with_expectation(expr, expected);
3001 // While we don't allow *arbitrary* coercions here, we *do* allow
3002 // coercions from ! to `expected`.
3004 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3005 "expression with never type wound up being adjusted");
3006 let adj_ty = self.next_diverging_ty_var(
3007 TypeVariableOrigin::AdjustmentType(expr.span));
3008 self.apply_adjustments(expr, vec![Adjustment {
3009 kind: Adjust::NeverToAny,
3015 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3016 // Add help to type error if this is an `if` condition with an assignment
3017 match (expected, &expr.node) {
3018 (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs)) => {
3019 let msg = "try comparing for equality";
3020 if let (Ok(left), Ok(right)) = (
3021 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3022 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3024 err.span_suggestion_with_applicability(
3027 format!("{} == {}", left, right),
3028 Applicability::MaybeIncorrect);
3040 fn check_expr_coercable_to_type(&self,
3041 expr: &'gcx hir::Expr,
3042 expected: Ty<'tcx>) -> Ty<'tcx> {
3043 let ty = self.check_expr_with_hint(expr, expected);
3044 // checks don't need two phase
3045 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3048 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
3049 expected: Ty<'tcx>) -> Ty<'tcx> {
3050 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3053 fn check_expr_with_expectation(&self,
3054 expr: &'gcx hir::Expr,
3055 expected: Expectation<'tcx>) -> Ty<'tcx> {
3056 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3059 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3060 self.check_expr_with_expectation(expr, NoExpectation)
3063 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3064 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3067 // determine the `self` type, using fresh variables for all variables
3068 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3069 // would return ($0, $1) where $0 and $1 are freshly instantiated type
3071 pub fn impl_self_ty(&self,
3072 span: Span, // (potential) receiver for this impl
3074 -> TypeAndSubsts<'tcx> {
3075 let ity = self.tcx.type_of(did);
3076 debug!("impl_self_ty: ity={:?}", ity);
3078 let substs = self.fresh_substs_for_item(span, did);
3079 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3081 TypeAndSubsts { substs: substs, ty: substd_ty }
3084 /// Unifies the output type with the expected type early, for more coercions
3085 /// and forward type information on the input expressions.
3086 fn expected_inputs_for_expected_output(&self,
3088 expected_ret: Expectation<'tcx>,
3089 formal_ret: Ty<'tcx>,
3090 formal_args: &[Ty<'tcx>])
3092 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3093 let ret_ty = match expected_ret.only_has_type(self) {
3095 None => return Vec::new()
3097 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3098 // Attempt to apply a subtyping relationship between the formal
3099 // return type (likely containing type variables if the function
3100 // is polymorphic) and the expected return type.
3101 // No argument expectations are produced if unification fails.
3102 let origin = self.misc(call_span);
3103 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3105 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3106 // to identity so the resulting type is not constrained.
3109 // Process any obligations locally as much as
3110 // we can. We don't care if some things turn
3111 // out unconstrained or ambiguous, as we're
3112 // just trying to get hints here.
3113 self.save_and_restore_in_snapshot_flag(|_| {
3114 let mut fulfill = TraitEngine::new(self.tcx);
3115 for obligation in ok.obligations {
3116 fulfill.register_predicate_obligation(self, obligation);
3118 fulfill.select_where_possible(self)
3119 }).map_err(|_| ())?;
3121 Err(_) => return Err(()),
3124 // Record all the argument types, with the substitutions
3125 // produced from the above subtyping unification.
3126 Ok(formal_args.iter().map(|ty| {
3127 self.resolve_type_vars_if_possible(ty)
3129 }).unwrap_or(Vec::new());
3130 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3131 formal_args, formal_ret,
3132 expect_args, expected_ret);
3136 // Checks a method call.
3137 fn check_method_call(&self,
3138 expr: &'gcx hir::Expr,
3139 segment: &hir::PathSegment,
3141 args: &'gcx [hir::Expr],
3142 expected: Expectation<'tcx>,
3143 needs: Needs) -> Ty<'tcx> {
3144 let rcvr = &args[0];
3145 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3146 // no need to check for bot/err -- callee does that
3147 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3149 let method = match self.lookup_method(rcvr_t,
3155 self.write_method_call(expr.hir_id, method);
3159 if segment.ident.name != keywords::Invalid.name() {
3160 self.report_method_error(span,
3171 // Call the generic checker.
3172 self.check_method_argument_types(span,
3180 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3184 .unwrap_or_else(|| span_bug!(return_expr.span,
3185 "check_return_expr called outside fn body"));
3187 let ret_ty = ret_coercion.borrow().expected_ty();
3188 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3189 ret_coercion.borrow_mut()
3191 &self.cause(return_expr.span,
3192 ObligationCauseCode::ReturnType(return_expr.id)),
3198 // A generic function for checking the then and else in an if
3200 fn check_then_else(&self,
3201 cond_expr: &'gcx hir::Expr,
3202 then_expr: &'gcx hir::Expr,
3203 opt_else_expr: Option<&'gcx hir::Expr>,
3205 expected: Expectation<'tcx>) -> Ty<'tcx> {
3206 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3207 let cond_diverges = self.diverges.get();
3208 self.diverges.set(Diverges::Maybe);
3210 let expected = expected.adjust_for_branches(self);
3211 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3212 let then_diverges = self.diverges.get();
3213 self.diverges.set(Diverges::Maybe);
3215 // We've already taken the expected type's preferences
3216 // into account when typing the `then` branch. To figure
3217 // out the initial shot at a LUB, we thus only consider
3218 // `expected` if it represents a *hard* constraint
3219 // (`only_has_type`); otherwise, we just go with a
3220 // fresh type variable.
3221 let coerce_to_ty = expected.coercion_target_type(self, sp);
3222 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3224 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3225 coerce.coerce(self, &if_cause, then_expr, then_ty);
3227 if let Some(else_expr) = opt_else_expr {
3228 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3229 let else_diverges = self.diverges.get();
3231 coerce.coerce(self, &if_cause, else_expr, else_ty);
3233 // We won't diverge unless both branches do (or the condition does).
3234 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3236 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3237 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3239 // If the condition is false we can't diverge.
3240 self.diverges.set(cond_diverges);
3243 let result_ty = coerce.complete(self);
3244 if cond_ty.references_error() {
3251 // Check field access expressions
3252 fn check_field(&self,
3253 expr: &'gcx hir::Expr,
3255 base: &'gcx hir::Expr,
3256 field: ast::Ident) -> Ty<'tcx> {
3257 let expr_t = self.check_expr_with_needs(base, needs);
3258 let expr_t = self.structurally_resolved_type(base.span,
3260 let mut private_candidate = None;
3261 let mut autoderef = self.autoderef(expr.span, expr_t);
3262 while let Some((base_t, _)) = autoderef.next() {
3264 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3265 debug!("struct named {:?}", base_t);
3266 let (ident, def_scope) =
3267 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3268 let fields = &base_def.non_enum_variant().fields;
3269 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3270 let field = &fields[index];
3271 let field_ty = self.field_ty(expr.span, field, substs);
3272 // Save the index of all fields regardless of their visibility in case
3273 // of error recovery.
3274 self.write_field_index(expr.id, index);
3275 if field.vis.is_accessible_from(def_scope, self.tcx) {
3276 let adjustments = autoderef.adjust_steps(needs);
3277 self.apply_adjustments(base, adjustments);
3278 autoderef.finalize();
3280 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3283 private_candidate = Some((base_def.did, field_ty));
3286 ty::Tuple(ref tys) => {
3287 let fstr = field.as_str();
3288 if let Ok(index) = fstr.parse::<usize>() {
3289 if fstr == index.to_string() {
3290 if let Some(field_ty) = tys.get(index) {
3291 let adjustments = autoderef.adjust_steps(needs);
3292 self.apply_adjustments(base, adjustments);
3293 autoderef.finalize();
3295 self.write_field_index(expr.id, index);
3304 autoderef.unambiguous_final_ty();
3306 if let Some((did, field_ty)) = private_candidate {
3307 let struct_path = self.tcx().item_path_str(did);
3308 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3309 "field `{}` of struct `{}` is private",
3310 field, struct_path);
3311 // Also check if an accessible method exists, which is often what is meant.
3312 if self.method_exists(field, expr_t, expr.id, false) {
3313 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3317 } else if field.name == keywords::Invalid.name() {
3318 self.tcx().types.err
3319 } else if self.method_exists(field, expr_t, expr.id, true) {
3320 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3321 "attempted to take value of method `{}` on type `{}`",
3323 .help("maybe a `()` to call it is missing?")
3325 self.tcx().types.err
3327 if !expr_t.is_primitive_ty() {
3328 let mut err = self.no_such_field_err(field.span, field, expr_t);
3331 ty::Adt(def, _) if !def.is_enum() => {
3332 if let Some(suggested_field_name) =
3333 Self::suggest_field_name(def.non_enum_variant(),
3334 &field.as_str(), vec![]) {
3335 err.span_label(field.span,
3336 format!("did you mean `{}`?", suggested_field_name));
3338 err.span_label(field.span, "unknown field");
3339 let struct_variant_def = def.non_enum_variant();
3340 let field_names = self.available_field_names(struct_variant_def);
3341 if !field_names.is_empty() {
3342 err.note(&format!("available fields are: {}",
3343 self.name_series_display(field_names)));
3348 let base = self.tcx.hir.node_to_pretty_string(base.id);
3349 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3350 let suggestion = format!("(*{}).{}", base, field);
3351 err.span_suggestion(field.span, &msg, suggestion);
3357 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3358 "`{}` is a primitive type and therefore doesn't have fields",
3361 self.tcx().types.err
3365 // Return an hint about the closest match in field names
3366 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3368 skip: Vec<LocalInternedString>)
3370 let names = variant.fields.iter().filter_map(|field| {
3371 // ignore already set fields and private fields from non-local crates
3372 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3373 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3376 Some(&field.ident.name)
3380 find_best_match_for_name(names, field, None)
3383 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3384 let mut available = Vec::new();
3385 for field in variant.fields.iter() {
3386 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3387 if field.vis.is_accessible_from(def_scope, self.tcx) {
3388 available.push(field.ident.name);
3394 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3395 // dynamic limit, to never omit just one field
3396 let limit = if names.len() == 6 { 6 } else { 5 };
3397 let mut display = names.iter().take(limit)
3398 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3399 if names.len() > limit {
3400 display = format!("{} ... and {} others", display, names.len() - limit);
3405 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3406 -> DiagnosticBuilder {
3407 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3408 "no field `{}` on type `{}`",
3412 fn report_unknown_field(&self,
3414 variant: &'tcx ty::VariantDef,
3416 skip_fields: &[hir::Field],
3418 let mut err = self.type_error_struct_with_diag(
3420 |actual| match ty.sty {
3421 ty::Adt(adt, ..) if adt.is_enum() => {
3422 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3423 "{} `{}::{}` has no field named `{}`",
3424 kind_name, actual, variant.name, field.ident)
3427 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3428 "{} `{}` has no field named `{}`",
3429 kind_name, actual, field.ident)
3433 // prevent all specified fields from being suggested
3434 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3435 if let Some(field_name) = Self::suggest_field_name(variant,
3436 &field.ident.as_str(),
3437 skip_fields.collect()) {
3438 err.span_label(field.ident.span,
3439 format!("field does not exist - did you mean `{}`?", field_name));
3442 ty::Adt(adt, ..) => {
3444 err.span_label(field.ident.span,
3445 format!("`{}::{}` does not have this field",
3448 err.span_label(field.ident.span,
3449 format!("`{}` does not have this field", ty));
3451 let available_field_names = self.available_field_names(variant);
3452 if !available_field_names.is_empty() {
3453 err.note(&format!("available fields are: {}",
3454 self.name_series_display(available_field_names)));
3457 _ => bug!("non-ADT passed to report_unknown_field")
3463 fn check_expr_struct_fields(&self,
3465 expected: Expectation<'tcx>,
3466 expr_id: ast::NodeId,
3468 variant: &'tcx ty::VariantDef,
3469 ast_fields: &'gcx [hir::Field],
3470 check_completeness: bool) -> bool {
3474 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3475 .get(0).cloned().unwrap_or(adt_ty);
3476 // re-link the regions that EIfEO can erase.
3477 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3479 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3480 &ty::Adt(adt, substs) => {
3481 (substs, adt.adt_kind(), adt.variant_descr())
3483 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3486 let mut remaining_fields = FxHashMap();
3487 for (i, field) in variant.fields.iter().enumerate() {
3488 remaining_fields.insert(field.ident.modern(), (i, field));
3491 let mut seen_fields = FxHashMap();
3493 let mut error_happened = false;
3495 // Typecheck each field.
3496 for field in ast_fields {
3497 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3498 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3499 seen_fields.insert(ident, field.span);
3500 self.write_field_index(field.id, i);
3502 // we don't look at stability attributes on
3503 // struct-like enums (yet...), but it's definitely not
3504 // a bug to have construct one.
3505 if adt_kind != ty::AdtKind::Enum {
3506 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3509 self.field_ty(field.span, v_field, substs)
3511 error_happened = true;
3512 if let Some(prev_span) = seen_fields.get(&ident) {
3513 let mut err = struct_span_err!(self.tcx.sess,
3516 "field `{}` specified more than once",
3519 err.span_label(field.ident.span, "used more than once");
3520 err.span_label(*prev_span, format!("first use of `{}`", ident));
3524 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3530 // Make sure to give a type to the field even if there's
3531 // an error, so we can continue typechecking
3532 self.check_expr_coercable_to_type(&field.expr, field_type);
3535 // Make sure the programmer specified correct number of fields.
3536 if kind_name == "union" {
3537 if ast_fields.len() != 1 {
3538 tcx.sess.span_err(span, "union expressions should have exactly one field");
3540 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3541 let len = remaining_fields.len();
3543 let mut displayable_field_names = remaining_fields
3545 .map(|ident| ident.as_str())
3546 .collect::<Vec<_>>();
3548 displayable_field_names.sort();
3550 let truncated_fields_error = if len <= 3 {
3553 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3556 let remaining_fields_names = displayable_field_names.iter().take(3)
3557 .map(|n| format!("`{}`", n))
3558 .collect::<Vec<_>>()
3561 struct_span_err!(tcx.sess, span, E0063,
3562 "missing field{} {}{} in initializer of `{}`",
3563 if remaining_fields.len() == 1 { "" } else { "s" },
3564 remaining_fields_names,
3565 truncated_fields_error,
3567 .span_label(span, format!("missing {}{}",
3568 remaining_fields_names,
3569 truncated_fields_error))
3575 fn check_struct_fields_on_error(&self,
3576 fields: &'gcx [hir::Field],
3577 base_expr: &'gcx Option<P<hir::Expr>>) {
3578 for field in fields {
3579 self.check_expr(&field.expr);
3583 self.check_expr(&base);
3589 pub fn check_struct_path(&self,
3591 node_id: ast::NodeId)
3592 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3593 let path_span = match *qpath {
3594 hir::QPath::Resolved(_, ref path) => path.span,
3595 hir::QPath::TypeRelative(ref qself, _) => qself.span
3597 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3598 let variant = match def {
3600 self.set_tainted_by_errors();
3603 Def::Variant(..) => {
3605 ty::Adt(adt, substs) => {
3606 Some((adt.variant_of_def(def), adt.did, substs))
3608 _ => bug!("unexpected type: {:?}", ty.sty)
3611 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3612 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3614 ty::Adt(adt, substs) if !adt.is_enum() => {
3615 Some((adt.non_enum_variant(), adt.did, substs))
3620 _ => bug!("unexpected definition: {:?}", def)
3623 if let Some((variant, did, substs)) = variant {
3624 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3625 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
3626 self.write_user_substs_from_substs(hir_id, substs);
3628 // Check bounds on type arguments used in the path.
3629 let bounds = self.instantiate_bounds(path_span, did, substs);
3630 let cause = traits::ObligationCause::new(path_span, self.body_id,
3631 traits::ItemObligation(did));
3632 self.add_obligations_for_parameters(cause, &bounds);
3636 struct_span_err!(self.tcx.sess, path_span, E0071,
3637 "expected struct, variant or union type, found {}",
3638 ty.sort_string(self.tcx))
3639 .span_label(path_span, "not a struct")
3645 fn check_expr_struct(&self,
3647 expected: Expectation<'tcx>,
3649 fields: &'gcx [hir::Field],
3650 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3652 // Find the relevant variant
3653 let (variant, adt_ty) =
3654 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3657 self.check_struct_fields_on_error(fields, base_expr);
3658 return self.tcx.types.err;
3661 let path_span = match *qpath {
3662 hir::QPath::Resolved(_, ref path) => path.span,
3663 hir::QPath::TypeRelative(ref qself, _) => qself.span
3666 // Prohibit struct expressions when non exhaustive flag is set.
3667 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3668 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3669 span_err!(self.tcx.sess, expr.span, E0639,
3670 "cannot create non-exhaustive {} using struct expression",
3671 adt.variant_descr());
3674 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3675 variant, fields, base_expr.is_none());
3676 if let &Some(ref base_expr) = base_expr {
3677 // If check_expr_struct_fields hit an error, do not attempt to populate
3678 // the fields with the base_expr. This could cause us to hit errors later
3679 // when certain fields are assumed to exist that in fact do not.
3680 if !error_happened {
3681 self.check_expr_has_type_or_error(base_expr, adt_ty);
3683 ty::Adt(adt, substs) if adt.is_struct() => {
3684 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3685 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3690 .fru_field_types_mut()
3691 .insert(expr.hir_id, fru_field_types);
3694 span_err!(self.tcx.sess, base_expr.span, E0436,
3695 "functional record update syntax requires a struct");
3700 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3706 /// If an expression has any sub-expressions that result in a type error,
3707 /// inspecting that expression's type with `ty.references_error()` will return
3708 /// true. Likewise, if an expression is known to diverge, inspecting its
3709 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3710 /// strict, _|_ can appear in the type of an expression that does not,
3711 /// itself, diverge: for example, fn() -> _|_.)
3712 /// Note that inspecting a type's structure *directly* may expose the fact
3713 /// that there are actually multiple representations for `Error`, so avoid
3714 /// that when err needs to be handled differently.
3715 fn check_expr_with_expectation_and_needs(&self,
3716 expr: &'gcx hir::Expr,
3717 expected: Expectation<'tcx>,
3718 needs: Needs) -> Ty<'tcx> {
3719 debug!(">> typechecking: expr={:?} expected={:?}",
3722 // Warn for expressions after diverging siblings.
3723 self.warn_if_unreachable(expr.id, expr.span, "expression");
3725 // Hide the outer diverging and has_errors flags.
3726 let old_diverges = self.diverges.get();
3727 let old_has_errors = self.has_errors.get();
3728 self.diverges.set(Diverges::Maybe);
3729 self.has_errors.set(false);
3731 let ty = self.check_expr_kind(expr, expected, needs);
3733 // Warn for non-block expressions with diverging children.
3735 hir::ExprKind::Block(..) |
3736 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3737 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3739 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3742 // Any expression that produces a value of type `!` must have diverged
3744 self.diverges.set(self.diverges.get() | Diverges::Always);
3747 // Record the type, which applies it effects.
3748 // We need to do this after the warning above, so that
3749 // we don't warn for the diverging expression itself.
3750 self.write_ty(expr.hir_id, ty);
3752 // Combine the diverging and has_error flags.
3753 self.diverges.set(self.diverges.get() | old_diverges);
3754 self.has_errors.set(self.has_errors.get() | old_has_errors);
3756 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3757 debug!("... {:?}, expected is {:?}", ty, expected);
3762 fn check_expr_kind(&self,
3763 expr: &'gcx hir::Expr,
3764 expected: Expectation<'tcx>,
3765 needs: Needs) -> Ty<'tcx> {
3769 hir::ExprKind::Box(ref subexpr) => {
3770 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3772 ty::Adt(def, _) if def.is_box()
3773 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3777 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3778 tcx.mk_box(referent_ty)
3781 hir::ExprKind::Lit(ref lit) => {
3782 self.check_lit(&lit, expected)
3784 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3785 self.check_binop(expr, op, lhs, rhs)
3787 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3788 self.check_binop_assign(expr, op, lhs, rhs)
3790 hir::ExprKind::Unary(unop, ref oprnd) => {
3791 let expected_inner = match unop {
3792 hir::UnNot | hir::UnNeg => {
3799 let needs = match unop {
3800 hir::UnDeref => needs,
3803 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3807 if !oprnd_t.references_error() {
3808 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3811 if let Some(mt) = oprnd_t.builtin_deref(true) {
3813 } else if let Some(ok) = self.try_overloaded_deref(
3814 expr.span, oprnd_t, needs) {
3815 let method = self.register_infer_ok_obligations(ok);
3816 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3817 let mutbl = match mutbl {
3818 hir::MutImmutable => AutoBorrowMutability::Immutable,
3819 hir::MutMutable => AutoBorrowMutability::Mutable {
3820 // (It shouldn't actually matter for unary ops whether
3821 // we enable two-phase borrows or not, since a unary
3822 // op has no additional operands.)
3823 allow_two_phase_borrow: AllowTwoPhase::No,
3826 self.apply_adjustments(oprnd, vec![Adjustment {
3827 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3828 target: method.sig.inputs()[0]
3831 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3832 self.write_method_call(expr.hir_id, method);
3834 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3835 "type `{}` cannot be dereferenced",
3837 oprnd_t = tcx.types.err;
3841 let result = self.check_user_unop(expr, oprnd_t, unop);
3842 // If it's builtin, we can reuse the type, this helps inference.
3843 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3848 let result = self.check_user_unop(expr, oprnd_t, unop);
3849 // If it's builtin, we can reuse the type, this helps inference.
3850 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3858 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3859 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3861 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3862 if self.is_place_expr(&oprnd) {
3863 // Places may legitimately have unsized types.
3864 // For example, dereferences of a fat pointer and
3865 // the last field of a struct can be unsized.
3868 Expectation::rvalue_hint(self, ty)
3874 let needs = Needs::maybe_mut_place(mutbl);
3875 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3877 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3878 if tm.ty.references_error() {
3881 // Note: at this point, we cannot say what the best lifetime
3882 // is to use for resulting pointer. We want to use the
3883 // shortest lifetime possible so as to avoid spurious borrowck
3884 // errors. Moreover, the longest lifetime will depend on the
3885 // precise details of the value whose address is being taken
3886 // (and how long it is valid), which we don't know yet until type
3887 // inference is complete.
3889 // Therefore, here we simply generate a region variable. The
3890 // region inferencer will then select the ultimate value.
3891 // Finally, borrowck is charged with guaranteeing that the
3892 // value whose address was taken can actually be made to live
3893 // as long as it needs to live.
3894 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3895 tcx.mk_ref(region, tm)
3898 hir::ExprKind::Path(ref qpath) => {
3899 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3900 let ty = if def != Def::Err {
3901 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
3903 self.set_tainted_by_errors();
3907 // We always require that the type provided as the value for
3908 // a type parameter outlives the moment of instantiation.
3909 let substs = self.tables.borrow().node_substs(expr.hir_id);
3910 self.add_wf_bounds(substs, expr);
3914 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3915 for output in outputs {
3916 self.check_expr(output);
3918 for input in inputs {
3919 self.check_expr(input);
3923 hir::ExprKind::Break(destination, ref expr_opt) => {
3924 if let Ok(target_id) = destination.target_id {
3926 if let Some(ref e) = *expr_opt {
3927 // If this is a break with a value, we need to type-check
3928 // the expression. Get an expected type from the loop context.
3929 let opt_coerce_to = {
3930 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3931 enclosing_breakables.find_breakable(target_id)
3934 .map(|coerce| coerce.expected_ty())
3937 // If the loop context is not a `loop { }`, then break with
3938 // a value is illegal, and `opt_coerce_to` will be `None`.
3939 // Just set expectation to error in that case.
3940 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3942 // Recurse without `enclosing_breakables` borrowed.
3943 e_ty = self.check_expr_with_hint(e, coerce_to);
3944 cause = self.misc(e.span);
3946 // Otherwise, this is a break *without* a value. That's
3947 // always legal, and is equivalent to `break ()`.
3948 e_ty = tcx.mk_unit();
3949 cause = self.misc(expr.span);
3952 // Now that we have type-checked `expr_opt`, borrow
3953 // the `enclosing_loops` field and let's coerce the
3954 // type of `expr_opt` into what is expected.
3955 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3956 let ctxt = enclosing_breakables.find_breakable(target_id);
3957 if let Some(ref mut coerce) = ctxt.coerce {
3958 if let Some(ref e) = *expr_opt {
3959 coerce.coerce(self, &cause, e, e_ty);
3961 assert!(e_ty.is_unit());
3962 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3965 // If `ctxt.coerce` is `None`, we can just ignore
3966 // the type of the expresison. This is because
3967 // either this was a break *without* a value, in
3968 // which case it is always a legal type (`()`), or
3969 // else an error would have been flagged by the
3970 // `loops` pass for using break with an expression
3971 // where you are not supposed to.
3972 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3975 ctxt.may_break = true;
3977 // the type of a `break` is always `!`, since it diverges
3980 // Otherwise, we failed to find the enclosing loop;
3981 // this can only happen if the `break` was not
3982 // inside a loop at all, which is caught by the
3983 // loop-checking pass.
3984 if self.tcx.sess.err_count() == 0 {
3985 self.tcx.sess.delay_span_bug(expr.span,
3986 "break was outside loop, but no error was emitted");
3989 // We still need to assign a type to the inner expression to
3990 // prevent the ICE in #43162.
3991 if let Some(ref e) = *expr_opt {
3992 self.check_expr_with_hint(e, tcx.types.err);
3994 // ... except when we try to 'break rust;'.
3995 // ICE this expression in particular (see #43162).
3996 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
3997 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3998 fatally_break_rust(self.tcx.sess);
4002 // There was an error, make typecheck fail
4007 hir::ExprKind::Continue(destination) => {
4008 if destination.target_id.is_ok() {
4011 // There was an error, make typecheck fail
4015 hir::ExprKind::Ret(ref expr_opt) => {
4016 if self.ret_coercion.is_none() {
4017 struct_span_err!(self.tcx.sess, expr.span, E0572,
4018 "return statement outside of function body").emit();
4019 } else if let Some(ref e) = *expr_opt {
4020 self.check_return_expr(e);
4022 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4023 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4024 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4028 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4029 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4031 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4034 ExpectIfCondition => {
4035 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4036 expected error elsehwere");
4039 // Only check this if not in an `if` condition, as the
4040 // mistyped comparison help is more appropriate.
4041 if !self.is_place_expr(&lhs) {
4042 struct_span_err!(self.tcx.sess, expr.span, E0070,
4043 "invalid left-hand side expression")
4044 .span_label(expr.span, "left-hand of expression not valid")
4050 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4052 if lhs_ty.references_error() || rhs_ty.references_error() {
4058 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4059 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4060 expr.span, expected)
4062 hir::ExprKind::While(ref cond, ref body, _) => {
4063 let ctxt = BreakableCtxt {
4064 // cannot use break with a value from a while loop
4066 may_break: false, // Will get updated if/when we find a `break`.
4069 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4070 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4071 let cond_diverging = self.diverges.get();
4072 self.check_block_no_value(&body);
4074 // We may never reach the body so it diverging means nothing.
4075 self.diverges.set(cond_diverging);
4079 // No way to know whether it's diverging because
4080 // of a `break` or an outer `break` or `return`.
4081 self.diverges.set(Diverges::Maybe);
4086 hir::ExprKind::Loop(ref body, _, source) => {
4087 let coerce = match source {
4088 // you can only use break with a value from a normal `loop { }`
4089 hir::LoopSource::Loop => {
4090 let coerce_to = expected.coercion_target_type(self, body.span);
4091 Some(CoerceMany::new(coerce_to))
4094 hir::LoopSource::WhileLet |
4095 hir::LoopSource::ForLoop => {
4100 let ctxt = BreakableCtxt {
4102 may_break: false, // Will get updated if/when we find a `break`.
4105 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4106 self.check_block_no_value(&body);
4110 // No way to know whether it's diverging because
4111 // of a `break` or an outer `break` or `return`.
4112 self.diverges.set(Diverges::Maybe);
4115 // If we permit break with a value, then result type is
4116 // the LUB of the breaks (possibly ! if none); else, it
4117 // is nil. This makes sense because infinite loops
4118 // (which would have type !) are only possible iff we
4119 // permit break with a value [1].
4120 if ctxt.coerce.is_none() && !ctxt.may_break {
4122 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4124 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_unit())
4126 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4127 self.check_match(expr, &discrim, arms, expected, match_src)
4129 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4130 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4132 hir::ExprKind::Block(ref body, _) => {
4133 self.check_block_with_expected(&body, expected)
4135 hir::ExprKind::Call(ref callee, ref args) => {
4136 self.check_call(expr, &callee, args, expected)
4138 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4139 self.check_method_call(expr, segment, span, args, expected, needs)
4141 hir::ExprKind::Cast(ref e, ref t) => {
4142 // Find the type of `e`. Supply hints based on the type we are casting to,
4144 let t_cast = self.to_ty(t);
4145 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4146 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4147 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4149 // Eagerly check for some obvious errors.
4150 if t_expr.references_error() || t_cast.references_error() {
4153 // Defer other checks until we're done type checking.
4154 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4155 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4157 deferred_cast_checks.push(cast_check);
4160 Err(ErrorReported) => {
4166 hir::ExprKind::Type(ref e, ref t) => {
4167 let ty = self.to_ty(&t);
4168 self.check_expr_eq_type(&e, ty);
4171 hir::ExprKind::Array(ref args) => {
4172 let uty = expected.to_option(self).and_then(|uty| {
4174 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4179 let element_ty = if !args.is_empty() {
4180 let coerce_to = uty.unwrap_or_else(
4181 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4182 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4183 assert_eq!(self.diverges.get(), Diverges::Maybe);
4185 let e_ty = self.check_expr_with_hint(e, coerce_to);
4186 let cause = self.misc(e.span);
4187 coerce.coerce(self, &cause, e, e_ty);
4189 coerce.complete(self)
4191 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4193 tcx.mk_array(element_ty, args.len() as u64)
4195 hir::ExprKind::Repeat(ref element, ref count) => {
4196 let count_def_id = tcx.hir.local_def_id(count.id);
4197 let param_env = ty::ParamEnv::empty();
4198 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4199 let instance = ty::Instance::resolve(
4205 let global_id = GlobalId {
4209 let count = tcx.const_eval(param_env.and(global_id));
4211 if let Err(ref err) = count {
4212 err.report_as_error(
4213 tcx.at(tcx.def_span(count_def_id)),
4214 "could not evaluate repeat length",
4218 let uty = match expected {
4219 ExpectHasType(uty) => {
4221 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4228 let (element_ty, t) = match uty {
4230 self.check_expr_coercable_to_type(&element, uty);
4234 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4235 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4240 if let Ok(count) = count {
4241 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4243 // For [foo, ..n] where n > 1, `foo` must have
4245 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4246 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4250 if element_ty.references_error() {
4252 } else if let Ok(count) = count {
4253 tcx.mk_ty(ty::Array(t, count))
4258 hir::ExprKind::Tup(ref elts) => {
4259 let flds = expected.only_has_type(self).and_then(|ty| {
4260 let ty = self.resolve_type_vars_with_obligations(ty);
4262 ty::Tuple(ref flds) => Some(&flds[..]),
4267 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4268 let t = match flds {
4269 Some(ref fs) if i < fs.len() => {
4271 self.check_expr_coercable_to_type(&e, ety);
4275 self.check_expr_with_expectation(&e, NoExpectation)
4280 let tuple = tcx.mk_tup(elt_ts_iter);
4281 if tuple.references_error() {
4284 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4288 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4289 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4291 hir::ExprKind::Field(ref base, field) => {
4292 self.check_field(expr, needs, &base, field)
4294 hir::ExprKind::Index(ref base, ref idx) => {
4295 let base_t = self.check_expr_with_needs(&base, needs);
4296 let idx_t = self.check_expr(&idx);
4298 if base_t.references_error() {
4300 } else if idx_t.references_error() {
4303 let base_t = self.structurally_resolved_type(base.span, base_t);
4304 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4305 Some((index_ty, element_ty)) => {
4306 // two-phase not needed because index_ty is never mutable
4307 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4312 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4313 "cannot index into a value of type `{}`",
4315 // Try to give some advice about indexing tuples.
4316 if let ty::Tuple(..) = base_t.sty {
4317 let mut needs_note = true;
4318 // If the index is an integer, we can show the actual
4319 // fixed expression:
4320 if let hir::ExprKind::Lit(ref lit) = idx.node {
4321 if let ast::LitKind::Int(i,
4322 ast::LitIntType::Unsuffixed) = lit.node {
4323 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4324 if let Ok(snip) = snip {
4325 err.span_suggestion_with_applicability(
4327 "to access tuple elements, use",
4328 format!("{}.{}", snip, i),
4329 Applicability::MachineApplicable);
4335 err.help("to access tuple elements, use tuple indexing \
4336 syntax (e.g. `tuple.0`)");
4345 hir::ExprKind::Yield(ref value) => {
4346 match self.yield_ty {
4348 self.check_expr_coercable_to_type(&value, ty);
4351 struct_span_err!(self.tcx.sess, expr.span, E0627,
4352 "yield statement outside of generator literal").emit();
4360 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4361 // The newly resolved definition is written into `type_dependent_defs`.
4362 fn finish_resolving_struct_path(&self,
4365 node_id: ast::NodeId)
4369 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4370 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4371 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4374 hir::QPath::TypeRelative(ref qself, ref segment) => {
4375 let ty = self.to_ty(qself);
4377 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4382 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4385 // Write back the new resolution.
4386 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4387 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4394 // Resolve associated value path into a base type and associated constant or method definition.
4395 // The newly resolved definition is written into `type_dependent_defs`.
4396 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4397 qpath: &'b hir::QPath,
4398 node_id: ast::NodeId,
4400 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4402 let (ty, item_segment) = match *qpath {
4403 hir::QPath::Resolved(ref opt_qself, ref path) => {
4405 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4406 &path.segments[..]);
4408 hir::QPath::TypeRelative(ref qself, ref segment) => {
4409 (self.to_ty(qself), segment)
4412 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4413 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4414 // Return directly on cache hit. This is useful to avoid doubly reporting
4415 // errors with default match binding modes. See #44614.
4416 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4418 let item_name = item_segment.ident;
4419 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4422 let def = match error {
4423 method::MethodError::PrivateMatch(def, _) => def,
4426 if item_name.name != keywords::Invalid.name() {
4427 self.report_method_error(span, ty, item_name, None, error, None);
4433 // Write back the new resolution.
4434 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4435 (def, Some(ty), slice::from_ref(&**item_segment))
4438 pub fn check_decl_initializer(&self,
4439 local: &'gcx hir::Local,
4440 init: &'gcx hir::Expr) -> Ty<'tcx>
4442 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4443 // for #42640 (default match binding modes).
4446 let ref_bindings = local.pat.contains_explicit_ref_binding();
4448 let local_ty = self.local_ty(init.span, local.id);
4449 if let Some(m) = ref_bindings {
4450 // Somewhat subtle: if we have a `ref` binding in the pattern,
4451 // we want to avoid introducing coercions for the RHS. This is
4452 // both because it helps preserve sanity and, in the case of
4453 // ref mut, for soundness (issue #23116). In particular, in
4454 // the latter case, we need to be clear that the type of the
4455 // referent for the reference that results is *equal to* the
4456 // type of the place it is referencing, and not some
4457 // supertype thereof.
4458 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4459 self.demand_eqtype(init.span, local_ty, init_ty);
4462 self.check_expr_coercable_to_type(init, local_ty)
4466 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4467 let t = self.local_ty(local.span, local.id);
4468 self.write_ty(local.hir_id, t);
4470 if let Some(ref init) = local.init {
4471 let init_ty = self.check_decl_initializer(local, &init);
4472 if init_ty.references_error() {
4473 self.write_ty(local.hir_id, init_ty);
4477 self.check_pat_walk(&local.pat, t,
4478 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4480 let pat_ty = self.node_ty(local.pat.hir_id);
4481 if pat_ty.references_error() {
4482 self.write_ty(local.hir_id, pat_ty);
4486 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4487 // Don't do all the complex logic below for DeclItem.
4489 hir::StmtKind::Decl(ref decl, _) => {
4491 hir::DeclKind::Local(_) => {}
4492 hir::DeclKind::Item(_) => {
4497 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4500 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4502 // Hide the outer diverging and has_errors flags.
4503 let old_diverges = self.diverges.get();
4504 let old_has_errors = self.has_errors.get();
4505 self.diverges.set(Diverges::Maybe);
4506 self.has_errors.set(false);
4509 hir::StmtKind::Decl(ref decl, _) => {
4511 hir::DeclKind::Local(ref l) => {
4512 self.check_decl_local(&l);
4514 hir::DeclKind::Item(_) => {/* ignore for now */}
4517 hir::StmtKind::Expr(ref expr, _) => {
4518 // Check with expected type of ()
4519 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4521 hir::StmtKind::Semi(ref expr, _) => {
4522 self.check_expr(&expr);
4526 // Combine the diverging and has_error flags.
4527 self.diverges.set(self.diverges.get() | old_diverges);
4528 self.has_errors.set(self.has_errors.get() | old_has_errors);
4531 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4532 let unit = self.tcx.mk_unit();
4533 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4535 // if the block produces a `!` value, that can always be
4536 // (effectively) coerced to unit.
4538 self.demand_suptype(blk.span, unit, ty);
4542 fn check_block_with_expected(&self,
4543 blk: &'gcx hir::Block,
4544 expected: Expectation<'tcx>) -> Ty<'tcx> {
4546 let mut fcx_ps = self.ps.borrow_mut();
4547 let unsafety_state = fcx_ps.recurse(blk);
4548 replace(&mut *fcx_ps, unsafety_state)
4551 // In some cases, blocks have just one exit, but other blocks
4552 // can be targeted by multiple breaks. This can happen both
4553 // with labeled blocks as well as when we desugar
4554 // a `try { ... }` expression.
4558 // 'a: { if true { break 'a Err(()); } Ok(()) }
4560 // Here we would wind up with two coercions, one from
4561 // `Err(())` and the other from the tail expression
4562 // `Ok(())`. If the tail expression is omitted, that's a
4563 // "forced unit" -- unless the block diverges, in which
4564 // case we can ignore the tail expression (e.g., `'a: {
4565 // break 'a 22; }` would not force the type of the block
4567 let tail_expr = blk.expr.as_ref();
4568 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4569 let coerce = if blk.targeted_by_break {
4570 CoerceMany::new(coerce_to_ty)
4572 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4573 Some(e) => slice::from_ref(e),
4576 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4579 let prev_diverges = self.diverges.get();
4580 let ctxt = BreakableCtxt {
4581 coerce: Some(coerce),
4585 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4586 for s in &blk.stmts {
4590 // check the tail expression **without** holding the
4591 // `enclosing_breakables` lock below.
4592 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4594 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4595 let ctxt = enclosing_breakables.find_breakable(blk.id);
4596 let coerce = ctxt.coerce.as_mut().unwrap();
4597 if let Some(tail_expr_ty) = tail_expr_ty {
4598 let tail_expr = tail_expr.unwrap();
4599 let cause = self.cause(tail_expr.span,
4600 ObligationCauseCode::BlockTailExpression(blk.id));
4606 // Subtle: if there is no explicit tail expression,
4607 // that is typically equivalent to a tail expression
4608 // of `()` -- except if the block diverges. In that
4609 // case, there is no value supplied from the tail
4610 // expression (assuming there are no other breaks,
4611 // this implies that the type of the block will be
4614 // #41425 -- label the implicit `()` as being the
4615 // "found type" here, rather than the "expected type".
4617 // #44579 -- if the block was recovered during parsing,
4618 // the type would be nonsensical and it is not worth it
4619 // to perform the type check, so we avoid generating the
4620 // diagnostic output.
4621 if !self.diverges.get().always() && !blk.recovered {
4622 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4623 if let Some(expected_ty) = expected.only_has_type(self) {
4624 self.consider_hint_about_removing_semicolon(blk,
4634 // If we can break from the block, then the block's exit is always reachable
4635 // (... as long as the entry is reachable) - regardless of the tail of the block.
4636 self.diverges.set(prev_diverges);
4639 let mut ty = ctxt.coerce.unwrap().complete(self);
4641 if self.has_errors.get() || ty.references_error() {
4642 ty = self.tcx.types.err
4645 self.write_ty(blk.hir_id, ty);
4647 *self.ps.borrow_mut() = prev;
4651 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4652 /// suggestion can be made, `None` otherwise.
4653 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4654 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4655 // `while` before reaching it, as block tail returns are not available in them.
4656 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4657 let parent = self.tcx.hir.get(fn_id);
4659 if let Node::Item(&hir::Item {
4660 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4662 decl.clone().and_then(|decl| {
4663 // This is less than ideal, it will not suggest a return type span on any
4664 // method called `main`, regardless of whether it is actually the entry point,
4665 // but it will still present it as the reason for the expected type.
4666 Some((decl, name != Symbol::intern("main")))
4668 } else if let Node::TraitItem(&hir::TraitItem {
4669 node: hir::TraitItemKind::Method(hir::MethodSig {
4673 decl.clone().and_then(|decl| {
4676 } else if let Node::ImplItem(&hir::ImplItem {
4677 node: hir::ImplItemKind::Method(hir::MethodSig {
4681 decl.clone().and_then(|decl| {
4692 /// On implicit return expressions with mismatched types, provide the following suggestions:
4694 /// - Point out the method's return type as the reason for the expected type
4695 /// - Possible missing semicolon
4696 /// - Possible missing return type if the return type is the default, and not `fn main()`
4697 pub fn suggest_mismatched_types_on_tail(&self,
4698 err: &mut DiagnosticBuilder<'tcx>,
4699 expression: &'gcx hir::Expr,
4703 blk_id: ast::NodeId) {
4704 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4705 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4706 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4708 self.suggest_ref_or_into(err, expression, expected, found);
4711 pub fn suggest_ref_or_into(
4713 err: &mut DiagnosticBuilder<'tcx>,
4718 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4719 err.span_suggestion(sp, msg, suggestion);
4720 } else if !self.check_for_cast(err, expr, found, expected) {
4721 let methods = self.get_conversion_methods(expr.span, expected, found);
4722 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4723 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4724 .filter_map(|(receiver, method)| {
4725 let method_call = format!(".{}()", method.ident);
4726 if receiver.ends_with(&method_call) {
4727 None // do not suggest code that is already there (#53348)
4730 methods defined in `method_call_list` will overwrite
4731 `.clone()` in copy of `receiver`
4733 let method_call_list = [".to_vec()", ".to_string()"];
4734 if receiver.ends_with(".clone()")
4735 && method_call_list.contains(&method_call.as_str()){
4736 // created copy of `receiver` because we don't want other
4737 // suggestion to get affected
4738 let mut new_receiver = receiver.clone();
4739 let max_len = new_receiver.rfind(".").unwrap();
4740 new_receiver.truncate(max_len);
4741 Some(format!("{}{}", new_receiver, method_call))
4744 Some(format!("{}{}", receiver, method_call))
4747 }) .collect::<Vec<_>>();
4748 if !suggestions.is_empty() {
4749 err.span_suggestions(expr.span, "try using a conversion method", suggestions);
4755 /// A common error is to forget to add a semicolon at the end of a block:
4759 /// bar_that_returns_u32()
4763 /// This routine checks if the return expression in a block would make sense on its own as a
4764 /// statement and the return type has been left as default or has been specified as `()`. If so,
4765 /// it suggests adding a semicolon.
4766 fn suggest_missing_semicolon(&self,
4767 err: &mut DiagnosticBuilder<'tcx>,
4768 expression: &'gcx hir::Expr,
4771 if expected.is_unit() {
4772 // `BlockTailExpression` only relevant if the tail expr would be
4773 // useful on its own.
4774 match expression.node {
4775 hir::ExprKind::Call(..) |
4776 hir::ExprKind::MethodCall(..) |
4777 hir::ExprKind::If(..) |
4778 hir::ExprKind::While(..) |
4779 hir::ExprKind::Loop(..) |
4780 hir::ExprKind::Match(..) |
4781 hir::ExprKind::Block(..) => {
4782 let sp = self.tcx.sess.source_map().next_point(cause_span);
4783 err.span_suggestion_with_applicability(
4785 "try adding a semicolon",
4787 Applicability::MachineApplicable);
4795 /// A possible error is to forget to add a return type that is needed:
4799 /// bar_that_returns_u32()
4803 /// This routine checks if the return type is left as default, the method is not part of an
4804 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4806 fn suggest_missing_return_type(&self,
4807 err: &mut DiagnosticBuilder<'tcx>,
4808 fn_decl: &hir::FnDecl,
4811 can_suggest: bool) {
4812 // Only suggest changing the return type for methods that
4813 // haven't set a return type at all (and aren't `fn main()` or an impl).
4814 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4815 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4816 err.span_suggestion_with_applicability(
4818 "try adding a return type",
4819 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4820 Applicability::MachineApplicable);
4822 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4823 err.span_label(span, "possibly return type missing here?");
4825 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4826 // `fn main()` must return `()`, do not suggest changing return type
4827 err.span_label(span, "expected `()` because of default return type");
4829 // expectation was caused by something else, not the default return
4830 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4831 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4832 // Only point to return type if the expected type is the return type, as if they
4833 // are not, the expectation must have been caused by something else.
4834 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4836 let ty = AstConv::ast_ty_to_ty(self, ty);
4837 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4838 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4839 if ty.sty == expected.sty {
4840 err.span_label(sp, format!("expected `{}` because of return type",
4848 /// A common error is to add an extra semicolon:
4851 /// fn foo() -> usize {
4856 /// This routine checks if the final statement in a block is an
4857 /// expression with an explicit semicolon whose type is compatible
4858 /// with `expected_ty`. If so, it suggests removing the semicolon.
4859 fn consider_hint_about_removing_semicolon(&self,
4860 blk: &'gcx hir::Block,
4861 expected_ty: Ty<'tcx>,
4862 err: &mut DiagnosticBuilder) {
4863 // Be helpful when the user wrote `{... expr;}` and
4864 // taking the `;` off is enough to fix the error.
4865 let last_stmt = match blk.stmts.last() {
4869 let last_expr = match last_stmt.node {
4870 hir::StmtKind::Semi(ref e, _) => e,
4873 let last_expr_ty = self.node_ty(last_expr.hir_id);
4874 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4877 let original_span = original_sp(last_stmt.span, blk.span);
4878 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4879 err.span_suggestion_with_applicability(
4881 "consider removing this semicolon",
4883 Applicability::MachineApplicable);
4886 fn def_ids_for_path_segments(&self,
4887 segments: &[hir::PathSegment],
4890 // We need to extract the type parameters supplied by the user in
4891 // the path `path`. Due to the current setup, this is a bit of a
4892 // tricky-process; the problem is that resolve only tells us the
4893 // end-point of the path resolution, and not the intermediate steps.
4894 // Luckily, we can (at least for now) deduce the intermediate steps
4895 // just from the end-point.
4897 // There are basically four cases to consider:
4899 // 1. Reference to a constructor of enum variant or struct:
4901 // struct Foo<T>(...)
4902 // enum E<T> { Foo(...) }
4904 // In these cases, the parameters are declared in the type
4907 // 2. Reference to a fn item or a free constant:
4911 // In this case, the path will again always have the form
4912 // `a::b::foo::<T>` where only the final segment should have
4913 // type parameters. However, in this case, those parameters are
4914 // declared on a value, and hence are in the `FnSpace`.
4916 // 3. Reference to a method or an associated constant:
4918 // impl<A> SomeStruct<A> {
4922 // Here we can have a path like
4923 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4924 // may appear in two places. The penultimate segment,
4925 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4926 // final segment, `foo::<B>` contains parameters in fn space.
4928 // 4. Reference to a local variable
4930 // Local variables can't have any type parameters.
4932 // The first step then is to categorize the segments appropriately.
4934 assert!(!segments.is_empty());
4935 let last = segments.len() - 1;
4937 let mut path_segs = vec![];
4940 // Case 1. Reference to a struct/variant constructor.
4941 Def::StructCtor(def_id, ..) |
4942 Def::VariantCtor(def_id, ..) |
4943 Def::SelfCtor(.., def_id) => {
4944 // Everything but the final segment should have no
4945 // parameters at all.
4946 let generics = self.tcx.generics_of(def_id);
4947 // Variant and struct constructors use the
4948 // generics of their parent type definition.
4949 let generics_def_id = generics.parent.unwrap_or(def_id);
4950 path_segs.push(PathSeg(generics_def_id, last));
4953 // Case 2. Reference to a top-level value.
4955 Def::Const(def_id) |
4956 Def::Static(def_id, _) => {
4957 path_segs.push(PathSeg(def_id, last));
4960 // Case 3. Reference to a method or associated const.
4961 Def::Method(def_id) |
4962 Def::AssociatedConst(def_id) => {
4963 if segments.len() >= 2 {
4964 let generics = self.tcx.generics_of(def_id);
4965 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
4967 path_segs.push(PathSeg(def_id, last));
4970 // Case 4. Local variable, no generics.
4971 Def::Local(..) | Def::Upvar(..) => {}
4973 _ => bug!("unexpected definition: {:?}", def),
4976 debug!("path_segs = {:?}", path_segs);
4981 // Instantiates the given path, which must refer to an item with the given
4982 // number of type parameters and type.
4983 pub fn instantiate_value_path(&self,
4984 segments: &[hir::PathSegment],
4985 self_ty: Option<Ty<'tcx>>,
4988 node_id: ast::NodeId)
4989 -> (Ty<'tcx>, Def) {
4990 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4995 let path_segs = self.def_ids_for_path_segments(segments, def);
4997 let mut ufcs_associated = None;
4999 Def::Method(def_id) |
5000 Def::AssociatedConst(def_id) => {
5001 let container = self.tcx.associated_item(def_id).container;
5003 ty::TraitContainer(trait_did) => {
5004 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5006 ty::ImplContainer(_) => {}
5008 if segments.len() == 1 {
5009 // `<T>::assoc` will end up here, and so can `T::assoc`.
5010 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5011 ufcs_associated = Some((container, self_ty));
5017 // Now that we have categorized what space the parameters for each
5018 // segment belong to, let's sort out the parameters that the user
5019 // provided (if any) into their appropriate spaces. We'll also report
5020 // errors if type parameters are provided in an inappropriate place.
5022 let mut generic_segs = FxHashSet::default();
5023 for PathSeg(_, index) in &path_segs {
5024 generic_segs.insert(index);
5026 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5027 if !generic_segs.contains(&index) {
5035 Def::Local(nid) | Def::Upvar(nid, ..) => {
5036 let ty = self.local_ty(span, nid);
5037 let ty = self.normalize_associated_types_in(span, &ty);
5038 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
5044 // Now we have to compare the types that the user *actually*
5045 // provided against the types that were *expected*. If the user
5046 // did not provide any types, then we want to substitute inference
5047 // variables. If the user provided some types, we may still need
5048 // to add defaults. If the user provided *too many* types, that's
5051 let mut infer_args_for_err = FxHashSet::default();
5052 for &PathSeg(def_id, index) in &path_segs {
5053 let seg = &segments[index];
5054 let generics = self.tcx.generics_of(def_id);
5055 // Argument-position `impl Trait` is treated as a normal generic
5056 // parameter internally, but we don't allow users to specify the
5057 // parameter's value explicitly, so we have to do some error-
5059 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5064 false, // `is_method_call`
5066 if suppress_errors {
5067 infer_args_for_err.insert(index);
5068 self.set_tainted_by_errors(); // See issue #53251.
5072 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5073 self.tcx.generics_of(*def_id).has_self
5074 }).unwrap_or(false);
5076 let mut new_def = def;
5077 let (def_id, ty) = if let Def::SelfCtor(impl_def_id) = def {
5078 let ty = self.impl_self_ty(span, impl_def_id).ty;
5080 match ty.ty_adt_def() {
5081 Some(adt_def) if adt_def.is_struct() => {
5082 let variant = adt_def.non_enum_variant();
5083 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5084 (variant.did, self.tcx.type_of(variant.did))
5087 (impl_def_id, self.tcx.types.err)
5091 let def_id = def.def_id();
5093 // The things we are substituting into the type should not contain
5094 // escaping late-bound regions, and nor should the base type scheme.
5095 let ty = self.tcx.type_of(def_id);
5099 let substs = AstConv::create_substs_for_generic_args(
5105 // Provide the generic args, and whether types should be inferred.
5107 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5110 // If we've encountered an `impl Trait`-related error, we're just
5111 // going to infer the arguments for better error messages.
5112 if !infer_args_for_err.contains(&index) {
5113 // Check whether the user has provided generic arguments.
5114 if let Some(ref data) = segments[index].args {
5115 return (Some(data), segments[index].infer_types);
5118 return (None, segments[index].infer_types);
5123 // Provide substitutions for parameters for which (valid) arguments have been provided.
5125 match (¶m.kind, arg) {
5126 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5127 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5129 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5130 self.to_ty(ty).into()
5132 _ => unreachable!(),
5135 // Provide substitutions for parameters for which arguments are inferred.
5136 |substs, param, infer_types| {
5138 GenericParamDefKind::Lifetime => {
5139 self.re_infer(span, Some(param)).unwrap().into()
5141 GenericParamDefKind::Type { has_default, .. } => {
5142 if !infer_types && has_default {
5143 // If we have a default, then we it doesn't matter that we're not
5144 // inferring the type arguments: we provide the default where any
5146 let default = self.tcx.type_of(param.def_id);
5149 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5152 // If no type arguments were provided, we have to infer them.
5153 // This case also occurs as a result of some malformed input, e.g.
5154 // a lifetime argument being given instead of a type paramter.
5155 // Using inference instead of `Error` gives better error messages.
5156 self.var_for_def(span, param)
5162 assert!(!substs.has_escaping_regions());
5163 assert!(!ty.has_escaping_regions());
5165 // Add all the obligations that are required, substituting and
5166 // normalized appropriately.
5167 let bounds = self.instantiate_bounds(span, def_id, &substs);
5168 self.add_obligations_for_parameters(
5169 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5172 // Substitute the values for the type parameters into the type of
5173 // the referenced item.
5174 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5176 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
5177 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5178 // is inherent, there is no `Self` parameter, instead, the impl needs
5179 // type parameters, which we can infer by unifying the provided `Self`
5180 // with the substituted impl type.
5181 let ty = self.tcx.type_of(impl_def_id);
5183 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5184 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5185 Ok(ok) => self.register_infer_ok_obligations(ok),
5188 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5195 self.check_rustc_args_require_const(def_id, node_id, span);
5197 debug!("instantiate_value_path: type of {:?} is {:?}",
5200 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
5201 self.write_substs(hir_id, substs);
5203 self.write_user_substs_from_substs(hir_id, substs);
5205 (ty_substituted, new_def)
5208 fn check_rustc_args_require_const(&self,
5210 node_id: ast::NodeId,
5212 // We're only interested in functions tagged with
5213 // #[rustc_args_required_const], so ignore anything that's not.
5214 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5218 // If our calling expression is indeed the function itself, we're good!
5219 // If not, generate an error that this can only be called directly.
5220 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5221 Node::Expr(expr) => {
5223 hir::ExprKind::Call(ref callee, ..) => {
5224 if callee.id == node_id {
5234 self.tcx.sess.span_err(span, "this function can only be invoked \
5235 directly, not through a function pointer");
5238 // Resolves `typ` by a single level if `typ` is a type variable.
5239 // If no resolution is possible, then an error is reported.
5240 // Numeric inference variables may be left unresolved.
5241 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5242 let ty = self.resolve_type_vars_with_obligations(ty);
5243 if !ty.is_ty_var() {
5246 if !self.is_tainted_by_errors() {
5247 self.need_type_info_err((**self).body_id, sp, ty)
5248 .note("type must be known at this point")
5251 self.demand_suptype(sp, self.tcx.types.err, ty);
5256 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5257 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5258 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5261 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5262 index = enclosing_breakables.stack.len();
5263 enclosing_breakables.by_id.insert(id, index);
5264 enclosing_breakables.stack.push(ctxt);
5268 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5269 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5270 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5271 enclosing_breakables.stack.pop().expect("missing breakable context")
5277 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5278 generics: &ty::Generics,
5280 let own_counts = generics.own_counts();
5281 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5283 if own_counts.types == 0 {
5286 // Make a vector of booleans initially false, set to true when used.
5287 let mut types_used = vec![false; own_counts.types];
5289 for leaf_ty in ty.walk() {
5290 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5291 debug!("Found use of ty param num {}", idx);
5292 types_used[idx as usize - own_counts.lifetimes] = true;
5293 } else if let ty::Error = leaf_ty.sty {
5294 // If there is already another error, do not emit
5295 // an error for not using a type Parameter.
5296 assert!(tcx.sess.err_count() > 0);
5301 let types = generics.params.iter().filter(|param| match param.kind {
5302 ty::GenericParamDefKind::Type { .. } => true,
5305 for (&used, param) in types_used.iter().zip(types) {
5307 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5308 let span = tcx.hir.span(id);
5309 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5310 .span_label(span, "unused type parameter")
5316 fn fatally_break_rust(sess: &Session) {
5317 let handler = sess.diagnostic();
5318 handler.span_bug_no_panic(
5320 "It looks like you're trying to break rust; would you like some ICE?",
5322 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5323 handler.note_without_error(
5324 "we would appreciate a joke overview: \
5325 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5327 handler.note_without_error(&format!("rustc {} running on {}",
5328 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5329 ::session::config::host_triple(),