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::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
99 UserSelfTy, UserSubsts};
100 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
101 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
102 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
103 use rustc::ty::fold::TypeFoldable;
104 use rustc::ty::query::Providers;
105 use rustc::ty::util::{Representability, IntTypeExt, Discr};
106 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
108 use require_c_abi_if_variadic;
109 use session::{CompileIncomplete, config, Session};
112 use util::common::{ErrorReported, indenter};
113 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
115 use std::cell::{Cell, RefCell, Ref, RefMut};
116 use rustc_data_structures::sync::Lrc;
117 use std::collections::hash_map::Entry;
119 use std::fmt::Display;
121 use std::mem::replace;
122 use std::ops::{self, Deref};
123 use rustc_target::spec::abi::Abi;
126 use syntax::source_map::DUMMY_SP;
127 use syntax::source_map::original_sp;
128 use syntax::feature_gate::{GateIssue, emit_feature_err};
130 use syntax::symbol::{Symbol, LocalInternedString, keywords};
131 use syntax::util::lev_distance::find_best_match_for_name;
132 use syntax_pos::{self, BytePos, Span, MultiSpan};
134 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
135 use rustc::hir::itemlikevisit::ItemLikeVisitor;
136 use rustc::hir::Node;
137 use rustc::hir::{self, PatKind, ItemKind};
138 use rustc::middle::lang_items;
154 mod generator_interior;
158 /// The type of a local binding, including the revealed type for anon types.
159 #[derive(Copy, Clone)]
160 pub struct LocalTy<'tcx> {
162 revealed_ty: Ty<'tcx>
165 /// A wrapper for InferCtxt's `in_progress_tables` field.
166 #[derive(Copy, Clone)]
167 struct MaybeInProgressTables<'a, 'tcx: 'a> {
168 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
171 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
172 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
173 match self.maybe_tables {
174 Some(tables) => tables.borrow(),
176 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
181 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
182 match self.maybe_tables {
183 Some(tables) => tables.borrow_mut(),
185 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
191 /// closures defined within the function. For example:
194 /// bar(move|| { ... })
197 /// Here, the function `foo()` and the closure passed to
198 /// `bar()` will each have their own `FnCtxt`, but they will
199 /// share the inherited fields.
200 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
201 infcx: InferCtxt<'a, 'gcx, 'tcx>,
203 tables: MaybeInProgressTables<'a, 'tcx>,
205 locals: RefCell<NodeMap<LocalTy<'tcx>>>,
207 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
209 // When we process a call like `c()` where `c` is a closure type,
210 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
211 // `FnOnce` closure. In that case, we defer full resolution of the
212 // call until upvar inference can kick in and make the
213 // decision. We keep these deferred resolutions grouped by the
214 // def-id of the closure, so that once we decide, we can easily go
215 // back and process them.
216 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
218 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
220 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
222 // Opaque types found in explicit return types and their
223 // associated fresh inference variable. Writeback resolves these
224 // variables to get the concrete type, which can be used to
225 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
226 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
228 /// Each type parameter has an implicit region bound that
229 /// indicates it must outlive at least the function body (the user
230 /// may specify stronger requirements). This field indicates the
231 /// region of the callee. If it is `None`, then the parameter
232 /// environment is for an item or something where the "callee" is
234 implicit_region_bound: Option<ty::Region<'tcx>>,
236 body_id: Option<hir::BodyId>,
239 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
240 type Target = InferCtxt<'a, 'gcx, 'tcx>;
241 fn deref(&self) -> &Self::Target {
246 /// When type-checking an expression, we propagate downward
247 /// whatever type hint we are able in the form of an `Expectation`.
248 #[derive(Copy, Clone, Debug)]
249 pub enum Expectation<'tcx> {
250 /// We know nothing about what type this expression should have.
253 /// This expression is an `if` condition, it must resolve to `bool`.
256 /// This expression should have the type given (or some subtype)
257 ExpectHasType(Ty<'tcx>),
259 /// This expression will be cast to the `Ty`
260 ExpectCastableToType(Ty<'tcx>),
262 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
263 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
264 ExpectRvalueLikeUnsized(Ty<'tcx>),
267 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
268 // Disregard "castable to" expectations because they
269 // can lead us astray. Consider for example `if cond
270 // {22} else {c} as u8` -- if we propagate the
271 // "castable to u8" constraint to 22, it will pick the
272 // type 22u8, which is overly constrained (c might not
273 // be a u8). In effect, the problem is that the
274 // "castable to" expectation is not the tightest thing
275 // we can say, so we want to drop it in this case.
276 // The tightest thing we can say is "must unify with
277 // else branch". Note that in the case of a "has type"
278 // constraint, this limitation does not hold.
280 // If the expected type is just a type variable, then don't use
281 // an expected type. Otherwise, we might write parts of the type
282 // when checking the 'then' block which are incompatible with the
284 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
286 ExpectHasType(ety) => {
287 let ety = fcx.shallow_resolve(ety);
288 if !ety.is_ty_var() {
294 ExpectRvalueLikeUnsized(ety) => {
295 ExpectRvalueLikeUnsized(ety)
301 /// Provide an expectation for an rvalue expression given an *optional*
302 /// hint, which is not required for type safety (the resulting type might
303 /// be checked higher up, as is the case with `&expr` and `box expr`), but
304 /// is useful in determining the concrete type.
306 /// The primary use case is where the expected type is a fat pointer,
307 /// like `&[isize]`. For example, consider the following statement:
309 /// let x: &[isize] = &[1, 2, 3];
311 /// In this case, the expected type for the `&[1, 2, 3]` expression is
312 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
313 /// expectation `ExpectHasType([isize])`, that would be too strong --
314 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
315 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
316 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
317 /// which still is useful, because it informs integer literals and the like.
318 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
319 /// for examples of where this comes up,.
320 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
321 match fcx.tcx.struct_tail(ty).sty {
322 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
323 ExpectRvalueLikeUnsized(ty)
325 _ => ExpectHasType(ty)
329 // Resolves `expected` by a single level if it is a variable. If
330 // there is no expected type or resolution is not possible (e.g.,
331 // no constraints yet present), just returns `None`.
332 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
334 NoExpectation => NoExpectation,
335 ExpectIfCondition => ExpectIfCondition,
336 ExpectCastableToType(t) => {
337 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
339 ExpectHasType(t) => {
340 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
342 ExpectRvalueLikeUnsized(t) => {
343 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
348 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
349 match self.resolve(fcx) {
350 NoExpectation => None,
351 ExpectIfCondition => Some(fcx.tcx.types.bool),
352 ExpectCastableToType(ty) |
354 ExpectRvalueLikeUnsized(ty) => Some(ty),
358 /// It sometimes happens that we want to turn an expectation into
359 /// a **hard constraint** (i.e., something that must be satisfied
360 /// for the program to type-check). `only_has_type` will return
361 /// such a constraint, if it exists.
362 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
363 match self.resolve(fcx) {
364 ExpectHasType(ty) => Some(ty),
365 ExpectIfCondition => Some(fcx.tcx.types.bool),
366 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
370 /// Like `only_has_type`, but instead of returning `None` if no
371 /// hard constraint exists, creates a fresh type variable.
372 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
373 self.only_has_type(fcx)
374 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
378 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
385 fn maybe_mut_place(m: hir::Mutability) -> Self {
387 hir::MutMutable => Needs::MutPlace,
388 hir::MutImmutable => Needs::None,
393 #[derive(Copy, Clone)]
394 pub struct UnsafetyState {
395 pub def: ast::NodeId,
396 pub unsafety: hir::Unsafety,
397 pub unsafe_push_count: u32,
402 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
403 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
406 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
407 match self.unsafety {
408 // If this unsafe, then if the outer function was already marked as
409 // unsafe we shouldn't attribute the unsafe'ness to the block. This
410 // way the block can be warned about instead of ignoring this
411 // extraneous block (functions are never warned about).
412 hir::Unsafety::Unsafe if self.from_fn => *self,
415 let (unsafety, def, count) = match blk.rules {
416 hir::PushUnsafeBlock(..) =>
417 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
418 hir::PopUnsafeBlock(..) =>
419 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
420 hir::UnsafeBlock(..) =>
421 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
423 (unsafety, self.def, self.unsafe_push_count),
427 unsafe_push_count: count,
434 #[derive(Debug, Copy, Clone)]
440 /// Tracks whether executing a node may exit normally (versus
441 /// return/break/panic, which "diverge", leaving dead code in their
442 /// wake). Tracked semi-automatically (through type variables marked
443 /// as diverging), with some manual adjustments for control-flow
444 /// primitives (approximating a CFG).
445 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
447 /// Potentially unknown, some cases converge,
448 /// others require a CFG to determine them.
451 /// Definitely known to diverge and therefore
452 /// not reach the next sibling or its parent.
455 /// Same as `Always` but with a reachability
456 /// warning already emitted
460 // Convenience impls for combinig `Diverges`.
462 impl ops::BitAnd for Diverges {
464 fn bitand(self, other: Self) -> Self {
465 cmp::min(self, other)
469 impl ops::BitOr for Diverges {
471 fn bitor(self, other: Self) -> Self {
472 cmp::max(self, other)
476 impl ops::BitAndAssign for Diverges {
477 fn bitand_assign(&mut self, other: Self) {
478 *self = *self & other;
482 impl ops::BitOrAssign for Diverges {
483 fn bitor_assign(&mut self, other: Self) {
484 *self = *self | other;
489 fn always(self) -> bool {
490 self >= Diverges::Always
494 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
497 // this is `null` for loops where break with a value is illegal,
498 // such as `while`, `for`, and `while let`
499 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
502 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
503 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
504 by_id: NodeMap<usize>,
507 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
508 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
509 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
510 bug!("could not find enclosing breakable with id {}", target_id);
517 struct PathSeg(DefId, usize);
519 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
520 body_id: ast::NodeId,
522 /// The parameter environment used for proving trait obligations
523 /// in this function. This can change when we descend into
524 /// closures (as they bring new things into scope), hence it is
525 /// not part of `Inherited` (as of the time of this writing,
526 /// closures do not yet change the environment, but they will
528 param_env: ty::ParamEnv<'tcx>,
530 // Number of errors that had been reported when we started
531 // checking this function. On exit, if we find that *more* errors
532 // have been reported, we will skip regionck and other work that
533 // expects the types within the function to be consistent.
534 err_count_on_creation: usize,
536 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
538 yield_ty: Option<Ty<'tcx>>,
540 ps: RefCell<UnsafetyState>,
542 /// Whether the last checked node generates a divergence (e.g.,
543 /// `return` will set this to Always). In general, when entering
544 /// an expression or other node in the tree, the initial value
545 /// indicates whether prior parts of the containing expression may
546 /// have diverged. It is then typically set to `Maybe` (and the
547 /// old value remembered) for processing the subparts of the
548 /// current expression. As each subpart is processed, they may set
549 /// the flag to `Always` etc. Finally, at the end, we take the
550 /// result and "union" it with the original value, so that when we
551 /// return the flag indicates if any subpart of the the parent
552 /// expression (up to and including this part) has diverged. So,
553 /// if you read it after evaluating a subexpression `X`, the value
554 /// you get indicates whether any subexpression that was
555 /// evaluating up to and including `X` diverged.
557 /// We currently use this flag only for diagnostic purposes:
559 /// - To warn about unreachable code: if, after processing a
560 /// sub-expression but before we have applied the effects of the
561 /// current node, we see that the flag is set to `Always`, we
562 /// can issue a warning. This corresponds to something like
563 /// `foo(return)`; we warn on the `foo()` expression. (We then
564 /// update the flag to `WarnedAlways` to suppress duplicate
565 /// reports.) Similarly, if we traverse to a fresh statement (or
566 /// tail expression) from a `Always` setting, we will issue a
567 /// warning. This corresponds to something like `{return;
568 /// foo();}` or `{return; 22}`, where we would warn on the
571 /// An expression represents dead-code if, after checking it,
572 /// the diverges flag is set to something other than `Maybe`.
573 diverges: Cell<Diverges>,
575 /// Whether any child nodes have any type errors.
576 has_errors: Cell<bool>,
578 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
580 inh: &'a Inherited<'a, 'gcx, 'tcx>,
583 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
584 type Target = Inherited<'a, 'gcx, 'tcx>;
585 fn deref(&self) -> &Self::Target {
590 /// Helper type of a temporary returned by Inherited::build(...).
591 /// Necessary because we can't write the following bound:
592 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
593 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
594 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
598 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
599 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
600 -> InheritedBuilder<'a, 'gcx, 'tcx> {
601 let hir_id_root = if def_id.is_local() {
602 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
603 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
604 DefId::local(hir_id.owner)
610 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
616 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
617 fn enter<F, R>(&'tcx mut self, f: F) -> R
618 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
620 let def_id = self.def_id;
621 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
625 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
626 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
628 let item_id = tcx.hir.as_local_node_id(def_id);
629 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
630 let implicit_region_bound = body_id.map(|body_id| {
631 let body = tcx.hir.body(body_id);
632 tcx.mk_region(ty::ReScope(region::Scope {
633 id: body.value.hir_id.local_id,
634 data: region::ScopeData::CallSite
639 tables: MaybeInProgressTables {
640 maybe_tables: infcx.in_progress_tables,
643 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
644 locals: RefCell::new(NodeMap()),
645 deferred_call_resolutions: RefCell::new(DefIdMap()),
646 deferred_cast_checks: RefCell::new(Vec::new()),
647 deferred_generator_interiors: RefCell::new(Vec::new()),
648 opaque_types: RefCell::new(DefIdMap()),
649 implicit_region_bound,
654 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
655 debug!("register_predicate({:?})", obligation);
656 if obligation.has_escaping_regions() {
657 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
662 .register_predicate_obligation(self, obligation);
665 fn register_predicates<I>(&self, obligations: I)
666 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
668 for obligation in obligations {
669 self.register_predicate(obligation);
673 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
674 self.register_predicates(infer_ok.obligations);
678 fn normalize_associated_types_in<T>(&self,
680 body_id: ast::NodeId,
681 param_env: ty::ParamEnv<'tcx>,
683 where T : TypeFoldable<'tcx>
685 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
686 self.register_infer_ok_obligations(ok)
690 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
692 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
693 fn visit_item(&mut self, i: &'tcx hir::Item) {
694 check_item_type(self.tcx, i);
696 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
697 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
700 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
701 tcx.sess.track_errors(|| {
702 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
703 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
707 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
708 tcx.sess.track_errors(|| {
709 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
713 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
714 tcx.typeck_item_bodies(LOCAL_CRATE)
717 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
718 -> Result<(), CompileIncomplete>
720 debug_assert!(crate_num == LOCAL_CRATE);
721 Ok(tcx.sess.track_errors(|| {
722 tcx.par_body_owners(|body_owner_def_id| {
723 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
728 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
729 wfcheck::check_item_well_formed(tcx, def_id);
732 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
733 wfcheck::check_trait_item(tcx, def_id);
736 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
737 wfcheck::check_impl_item(tcx, def_id);
740 pub fn provide(providers: &mut Providers) {
741 method::provide(providers);
742 *providers = Providers {
748 check_item_well_formed,
749 check_trait_item_well_formed,
750 check_impl_item_well_formed,
755 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
757 -> Option<ty::Destructor> {
758 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
761 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
762 /// with information about it's body-id and fn-decl (if any). Otherwise,
765 /// If this function returns "some", then `typeck_tables(def_id)` will
766 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
767 /// may not succeed. In some cases where this function returns `None`
768 /// (notably closures), `typeck_tables(def_id)` would wind up
769 /// redirecting to the owning function.
770 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
772 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
774 match tcx.hir.get(id) {
775 Node::Item(item) => {
777 hir::ItemKind::Const(_, body) |
778 hir::ItemKind::Static(_, _, body) =>
780 hir::ItemKind::Fn(ref decl, .., body) =>
781 Some((body, Some(decl))),
786 Node::TraitItem(item) => {
788 hir::TraitItemKind::Const(_, Some(body)) =>
790 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
791 Some((body, Some(&sig.decl))),
796 Node::ImplItem(item) => {
798 hir::ImplItemKind::Const(_, body) =>
800 hir::ImplItemKind::Method(ref sig, body) =>
801 Some((body, Some(&sig.decl))),
806 Node::AnonConst(constant) => Some((constant.body, None)),
811 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
814 // Closures' tables come from their outermost function,
815 // as they are part of the same "inference environment".
816 let outer_def_id = tcx.closure_base_def_id(def_id);
817 if outer_def_id != def_id {
818 return tcx.has_typeck_tables(outer_def_id);
821 let id = tcx.hir.as_local_node_id(def_id).unwrap();
822 primary_body_of(tcx, id).is_some()
825 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
828 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
831 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
833 -> &'tcx ty::TypeckTables<'tcx> {
834 // Closures' tables come from their outermost function,
835 // as they are part of the same "inference environment".
836 let outer_def_id = tcx.closure_base_def_id(def_id);
837 if outer_def_id != def_id {
838 return tcx.typeck_tables_of(outer_def_id);
841 let id = tcx.hir.as_local_node_id(def_id).unwrap();
842 let span = tcx.hir.span(id);
844 // Figure out what primary body this item has.
845 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
846 span_bug!(span, "can't type-check body of {:?}", def_id);
848 let body = tcx.hir.body(body_id);
850 let tables = Inherited::build(tcx, def_id).enter(|inh| {
851 let param_env = tcx.param_env(def_id);
852 let fcx = if let Some(decl) = fn_decl {
853 let fn_sig = tcx.fn_sig(def_id);
855 check_abi(tcx, span, fn_sig.abi());
857 // Compute the fty from point of view of inside the fn.
859 tcx.liberate_late_bound_regions(def_id, &fn_sig);
861 inh.normalize_associated_types_in(body.value.span,
866 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
869 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
870 let expected_type = tcx.type_of(def_id);
871 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
872 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
874 let revealed_ty = if tcx.features().impl_trait_in_bindings {
875 fcx.instantiate_opaque_types_from_value(
883 // Gather locals in statics (because of block expressions).
884 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
886 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
891 // All type checking constraints were added, try to fallback unsolved variables.
892 fcx.select_obligations_where_possible(false);
893 let mut fallback_has_occurred = false;
894 for ty in &fcx.unsolved_variables() {
895 fallback_has_occurred |= fcx.fallback_if_possible(ty);
897 fcx.select_obligations_where_possible(fallback_has_occurred);
899 // Even though coercion casts provide type hints, we check casts after fallback for
900 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
903 // Closure and generator analysis may run after fallback
904 // because they don't constrain other type variables.
905 fcx.closure_analyze(body);
906 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
907 fcx.resolve_generator_interiors(def_id);
908 fcx.select_all_obligations_or_error();
910 if fn_decl.is_some() {
911 fcx.regionck_fn(id, body);
913 fcx.regionck_expr(body);
916 fcx.resolve_type_vars_in_body(body)
919 // Consistency check our TypeckTables instance can hold all ItemLocalIds
920 // it will need to hold.
921 assert_eq!(tables.local_id_root,
922 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
926 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
927 if !tcx.sess.target.target.is_abi_supported(abi) {
928 struct_span_err!(tcx.sess, span, E0570,
929 "The ABI `{}` is not supported for the current target", abi).emit()
933 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
934 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
935 parent_id: ast::NodeId,
938 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
939 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
942 // infer the variable's type
943 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
944 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
951 // take type that the user specified
952 self.fcx.locals.borrow_mut().insert(nid, typ);
959 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
960 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
961 NestedVisitorMap::None
964 // Add explicitly-declared locals.
965 fn visit_local(&mut self, local: &'gcx hir::Local) {
966 let local_ty = match local.ty {
968 let o_ty = self.fcx.to_ty(&ty);
970 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
971 self.fcx.instantiate_opaque_types_from_value(
979 let c_ty = self.fcx.inh.infcx.canonicalize_response(&revealed_ty);
980 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
981 ty.hir_id, o_ty, revealed_ty, c_ty);
982 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
984 Some(LocalTy { decl_ty: o_ty, revealed_ty })
988 self.assign(local.span, local.id, local_ty);
990 debug!("Local variable {:?} is assigned type {}",
992 self.fcx.ty_to_string(
993 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
994 intravisit::walk_local(self, local);
997 // Add pattern bindings.
998 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
999 if let PatKind::Binding(_, _, ident, _) = p.node {
1000 let var_ty = self.assign(p.span, p.id, None);
1002 if !self.fcx.tcx.features().unsized_locals {
1003 self.fcx.require_type_is_sized(var_ty, p.span,
1004 traits::VariableType(p.id));
1007 debug!("Pattern binding {} is assigned to {} with type {:?}",
1009 self.fcx.ty_to_string(
1010 self.fcx.locals.borrow().get(&p.id).unwrap().clone().decl_ty),
1013 intravisit::walk_pat(self, p);
1016 // Don't descend into the bodies of nested closures
1017 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1018 _: hir::BodyId, _: Span, _: ast::NodeId) { }
1021 /// When `check_fn` is invoked on a generator (i.e., a body that
1022 /// includes yield), it returns back some information about the yield
1024 struct GeneratorTypes<'tcx> {
1025 /// Type of value that is yielded.
1026 yield_ty: ty::Ty<'tcx>,
1028 /// Types that are captured (see `GeneratorInterior` for more).
1029 interior: ty::Ty<'tcx>,
1031 /// Indicates if the generator is movable or static (immovable)
1032 movability: hir::GeneratorMovability,
1035 /// Helper used for fns and closures. Does the grungy work of checking a function
1036 /// body and returns the function context used for that purpose, since in the case of a fn item
1037 /// there is still a bit more to do.
1040 /// * inherited: other fields inherited from the enclosing fn (if any)
1041 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1042 param_env: ty::ParamEnv<'tcx>,
1043 fn_sig: ty::FnSig<'tcx>,
1044 decl: &'gcx hir::FnDecl,
1046 body: &'gcx hir::Body,
1047 can_be_generator: Option<hir::GeneratorMovability>)
1048 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1050 let mut fn_sig = fn_sig.clone();
1052 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1054 // Create the function context. This is either derived from scratch or,
1055 // in the case of closures, based on the outer context.
1056 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1057 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1059 let declared_ret_ty = fn_sig.output();
1060 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1061 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1062 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1063 fn_sig = fcx.tcx.mk_fn_sig(
1064 fn_sig.inputs().iter().cloned(),
1071 let span = body.value.span;
1073 if body.is_generator && can_be_generator.is_some() {
1074 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1075 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1076 fcx.yield_ty = Some(yield_ty);
1079 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir.local_def_id(fn_id));
1080 let outer_node_id = fcx.tcx.hir.as_local_node_id(outer_def_id).unwrap();
1081 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
1083 // Add formal parameters.
1084 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1085 // Check the pattern.
1086 fcx.check_pat_walk(&arg.pat, arg_ty,
1087 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1089 // Check that argument is Sized.
1090 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1091 // for simple cases like `fn foo(x: Trait)`,
1092 // where we would error once on the parameter as a whole, and once on the binding `x`.
1093 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1094 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1097 fcx.write_ty(arg.hir_id, arg_ty);
1100 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1101 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1103 fcx.check_return_expr(&body.value);
1105 // We insert the deferred_generator_interiors entry after visiting the body.
1106 // This ensures that all nested generators appear before the entry of this generator.
1107 // resolve_generator_interiors relies on this property.
1108 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1109 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1110 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1111 Some(GeneratorTypes {
1112 yield_ty: fcx.yield_ty.unwrap(),
1114 movability: can_be_generator.unwrap(),
1120 // Finalize the return check by taking the LUB of the return types
1121 // we saw and assigning it to the expected return type. This isn't
1122 // really expected to fail, since the coercions would have failed
1123 // earlier when trying to find a LUB.
1125 // However, the behavior around `!` is sort of complex. In the
1126 // event that the `actual_return_ty` comes back as `!`, that
1127 // indicates that the fn either does not return or "returns" only
1128 // values of type `!`. In this case, if there is an expected
1129 // return type that is *not* `!`, that should be ok. But if the
1130 // return type is being inferred, we want to "fallback" to `!`:
1132 // let x = move || panic!();
1134 // To allow for that, I am creating a type variable with diverging
1135 // fallback. This was deemed ever so slightly better than unifying
1136 // the return value with `!` because it allows for the caller to
1137 // make more assumptions about the return type (e.g., they could do
1139 // let y: Option<u32> = Some(x());
1141 // which would then cause this return type to become `u32`, not
1143 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1144 let mut actual_return_ty = coercion.complete(&fcx);
1145 if actual_return_ty.is_never() {
1146 actual_return_ty = fcx.next_diverging_ty_var(
1147 TypeVariableOrigin::DivergingFn(span));
1149 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1151 // Check that the main return type implements the termination trait.
1152 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1153 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1155 if let config::EntryFnType::Main = entry_type {
1156 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1157 let trait_ref = ty::TraitRef::new(term_id, substs);
1158 let return_ty_span = decl.output.span();
1159 let cause = traits::ObligationCause::new(
1160 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1162 inherited.register_predicate(
1163 traits::Obligation::new(
1164 cause, param_env, trait_ref.to_predicate()));
1170 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1171 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1172 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1173 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1174 // at this point we don't care if there are duplicate handlers or if the handler has
1175 // the wrong signature as this value we'll be used when writing metadata and that
1176 // only happens if compilation succeeded
1177 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1179 if declared_ret_ty.sty != ty::Never {
1180 fcx.tcx.sess.span_err(
1182 "return type should be `!`",
1186 let inputs = fn_sig.inputs();
1187 let span = fcx.tcx.hir.span(fn_id);
1188 if inputs.len() == 1 {
1189 let arg_is_panic_info = match inputs[0].sty {
1190 ty::Ref(region, ty, mutbl) => match ty.sty {
1191 ty::Adt(ref adt, _) => {
1192 adt.did == panic_info_did &&
1193 mutbl == hir::Mutability::MutImmutable &&
1194 *region != RegionKind::ReStatic
1201 if !arg_is_panic_info {
1202 fcx.tcx.sess.span_err(
1203 decl.inputs[0].span,
1204 "argument should be `&PanicInfo`",
1208 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1209 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1210 if !generics.params.is_empty() {
1211 fcx.tcx.sess.span_err(
1213 "should have no type parameters",
1219 let span = fcx.tcx.sess.source_map().def_span(span);
1220 fcx.tcx.sess.span_err(span, "function should have one argument");
1223 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1228 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1229 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1230 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1231 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1232 if declared_ret_ty.sty != ty::Never {
1233 fcx.tcx.sess.span_err(
1235 "return type should be `!`",
1239 let inputs = fn_sig.inputs();
1240 let span = fcx.tcx.hir.span(fn_id);
1241 if inputs.len() == 1 {
1242 let arg_is_alloc_layout = match inputs[0].sty {
1243 ty::Adt(ref adt, _) => {
1244 adt.did == alloc_layout_did
1249 if !arg_is_alloc_layout {
1250 fcx.tcx.sess.span_err(
1251 decl.inputs[0].span,
1252 "argument should be `Layout`",
1256 if let Node::Item(item) = fcx.tcx.hir.get(fn_id) {
1257 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1258 if !generics.params.is_empty() {
1259 fcx.tcx.sess.span_err(
1261 "`#[alloc_error_handler]` function should have no type \
1268 let span = fcx.tcx.sess.source_map().def_span(span);
1269 fcx.tcx.sess.span_err(span, "function should have one argument");
1272 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1280 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1283 let def_id = tcx.hir.local_def_id(id);
1284 let def = tcx.adt_def(def_id);
1285 def.destructor(tcx); // force the destructor to be evaluated
1286 check_representable(tcx, span, def_id);
1288 if def.repr.simd() {
1289 check_simd(tcx, span, def_id);
1292 check_transparent(tcx, span, def_id);
1293 check_packed(tcx, span, def_id);
1296 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1299 let def_id = tcx.hir.local_def_id(id);
1300 let def = tcx.adt_def(def_id);
1301 def.destructor(tcx); // force the destructor to be evaluated
1302 check_representable(tcx, span, def_id);
1304 check_packed(tcx, span, def_id);
1307 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1309 "check_item_type(it.id={}, it.name={})",
1311 tcx.item_path_str(tcx.hir.local_def_id(it.id))
1313 let _indenter = indenter();
1315 // Consts can play a role in type-checking, so they are included here.
1316 hir::ItemKind::Static(..) => {
1317 let def_id = tcx.hir.local_def_id(it.id);
1318 tcx.typeck_tables_of(def_id);
1319 maybe_check_static_with_link_section(tcx, def_id, it.span);
1321 hir::ItemKind::Const(..) => {
1322 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1324 hir::ItemKind::Enum(ref enum_definition, _) => {
1325 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1327 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1328 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1329 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1330 let impl_def_id = tcx.hir.local_def_id(it.id);
1331 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1332 check_impl_items_against_trait(
1339 let trait_def_id = impl_trait_ref.def_id;
1340 check_on_unimplemented(tcx, trait_def_id, it);
1343 hir::ItemKind::Trait(..) => {
1344 let def_id = tcx.hir.local_def_id(it.id);
1345 check_on_unimplemented(tcx, def_id, it);
1347 hir::ItemKind::Struct(..) => {
1348 check_struct(tcx, it.id, it.span);
1350 hir::ItemKind::Union(..) => {
1351 check_union(tcx, it.id, it.span);
1353 hir::ItemKind::Existential(..) | hir::ItemKind::Ty(..) => {
1354 let def_id = tcx.hir.local_def_id(it.id);
1355 let pty_ty = tcx.type_of(def_id);
1356 let generics = tcx.generics_of(def_id);
1357 check_bounds_are_used(tcx, &generics, pty_ty);
1359 hir::ItemKind::ForeignMod(ref m) => {
1360 check_abi(tcx, it.span, m.abi);
1362 if m.abi == Abi::RustIntrinsic {
1363 for item in &m.items {
1364 intrinsic::check_intrinsic_type(tcx, item);
1366 } else if m.abi == Abi::PlatformIntrinsic {
1367 for item in &m.items {
1368 intrinsic::check_platform_intrinsic_type(tcx, item);
1371 for item in &m.items {
1372 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1373 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1374 let mut err = struct_span_err!(
1378 "foreign items may not have type parameters"
1380 err.span_label(item.span, "can't have type parameters");
1381 // FIXME: once we start storing spans for type arguments, turn this into a
1384 "use specialization instead of type parameters by replacing them \
1385 with concrete types like `u32`",
1390 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1391 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1396 _ => { /* nothing to do */ }
1400 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1401 // Only restricted on wasm32 target for now
1402 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1406 // If `#[link_section]` is missing, then nothing to verify
1407 let attrs = tcx.codegen_fn_attrs(id);
1408 if attrs.link_section.is_none() {
1412 // For the wasm32 target statics with #[link_section] are placed into custom
1413 // sections of the final output file, but this isn't link custom sections of
1414 // other executable formats. Namely we can only embed a list of bytes,
1415 // nothing with pointers to anything else or relocations. If any relocation
1416 // show up, reject them here.
1417 let instance = ty::Instance::mono(tcx, id);
1418 let cid = GlobalId {
1422 let param_env = ty::ParamEnv::reveal_all();
1423 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1424 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1427 bug!("Matching on non-ByRef static")
1429 if alloc.relocations.len() != 0 {
1430 let msg = "statics with a custom `#[link_section]` must be a \
1431 simple list of bytes on the wasm target with no \
1432 extra levels of indirection such as references";
1433 tcx.sess.span_err(span, msg);
1438 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1439 trait_def_id: DefId,
1441 let item_def_id = tcx.hir.local_def_id(item.id);
1442 // an error would be reported if this fails.
1443 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1446 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1447 impl_item: &hir::ImplItem,
1450 let mut err = struct_span_err!(
1451 tcx.sess, impl_item.span, E0520,
1452 "`{}` specializes an item from a parent `impl`, but \
1453 that item is not marked `default`",
1455 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1458 match tcx.span_of_impl(parent_impl) {
1460 err.span_label(span, "parent `impl` is here");
1461 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1465 err.note(&format!("parent implementation is in crate `{}`", cname));
1472 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1473 trait_def: &ty::TraitDef,
1474 trait_item: &ty::AssociatedItem,
1476 impl_item: &hir::ImplItem)
1478 let ancestors = trait_def.ancestors(tcx, impl_id);
1480 let kind = match impl_item.node {
1481 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1482 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1483 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1484 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1487 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1488 .map(|node_item| node_item.map(|parent| parent.defaultness));
1490 if let Some(parent) = parent {
1491 if tcx.impl_item_is_final(&parent) {
1492 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1498 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1501 impl_trait_ref: ty::TraitRef<'tcx>,
1502 impl_item_refs: &[hir::ImplItemRef]) {
1503 let impl_span = tcx.sess.source_map().def_span(impl_span);
1505 // If the trait reference itself is erroneous (so the compilation is going
1506 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1507 // isn't populated for such impls.
1508 if impl_trait_ref.references_error() { return; }
1510 // Locate trait definition and items
1511 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1512 let mut overridden_associated_type = None;
1514 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1516 // Check existing impl methods to see if they are both present in trait
1517 // and compatible with trait signature
1518 for impl_item in impl_items() {
1519 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1520 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1521 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1522 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1524 // Not compatible, but needed for the error message
1525 tcx.associated_items(impl_trait_ref.def_id)
1526 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1529 // Check that impl definition matches trait definition
1530 if let Some(ty_trait_item) = ty_trait_item {
1531 match impl_item.node {
1532 hir::ImplItemKind::Const(..) => {
1533 // Find associated const definition.
1534 if ty_trait_item.kind == ty::AssociatedKind::Const {
1535 compare_const_impl(tcx,
1541 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1542 "item `{}` is an associated const, \
1543 which doesn't match its trait `{}`",
1546 err.span_label(impl_item.span, "does not match trait");
1547 // We can only get the spans from local trait definition
1548 // Same for E0324 and E0325
1549 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1550 err.span_label(trait_span, "item in trait");
1555 hir::ImplItemKind::Method(..) => {
1556 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1557 if ty_trait_item.kind == ty::AssociatedKind::Method {
1558 compare_impl_method(tcx,
1565 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1566 "item `{}` is an associated method, \
1567 which doesn't match its trait `{}`",
1570 err.span_label(impl_item.span, "does not match trait");
1571 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1572 err.span_label(trait_span, "item in trait");
1577 hir::ImplItemKind::Existential(..) |
1578 hir::ImplItemKind::Type(_) => {
1579 if ty_trait_item.kind == ty::AssociatedKind::Type {
1580 if ty_trait_item.defaultness.has_value() {
1581 overridden_associated_type = Some(impl_item);
1584 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1585 "item `{}` is an associated type, \
1586 which doesn't match its trait `{}`",
1589 err.span_label(impl_item.span, "does not match trait");
1590 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1591 err.span_label(trait_span, "item in trait");
1598 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1602 // Check for missing items from trait
1603 let mut missing_items = Vec::new();
1604 let mut invalidated_items = Vec::new();
1605 let associated_type_overridden = overridden_associated_type.is_some();
1606 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1607 let is_implemented = trait_def.ancestors(tcx, impl_id)
1608 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1610 .map(|node_item| !node_item.node.is_from_trait())
1613 if !is_implemented && !tcx.impl_is_default(impl_id) {
1614 if !trait_item.defaultness.has_value() {
1615 missing_items.push(trait_item);
1616 } else if associated_type_overridden {
1617 invalidated_items.push(trait_item.ident);
1622 if !missing_items.is_empty() {
1623 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1624 "not all trait items implemented, missing: `{}`",
1625 missing_items.iter()
1626 .map(|trait_item| trait_item.ident.to_string())
1627 .collect::<Vec<_>>().join("`, `"));
1628 err.span_label(impl_span, format!("missing `{}` in implementation",
1629 missing_items.iter()
1630 .map(|trait_item| trait_item.ident.to_string())
1631 .collect::<Vec<_>>().join("`, `")));
1632 for trait_item in missing_items {
1633 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1634 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1636 err.note_trait_signature(trait_item.ident.to_string(),
1637 trait_item.signature(&tcx));
1643 if !invalidated_items.is_empty() {
1644 let invalidator = overridden_associated_type.unwrap();
1645 span_err!(tcx.sess, invalidator.span, E0399,
1646 "the following trait items need to be reimplemented \
1647 as `{}` was overridden: `{}`",
1649 invalidated_items.iter()
1650 .map(|name| name.to_string())
1651 .collect::<Vec<_>>().join("`, `"))
1655 /// Checks whether a type can be represented in memory. In particular, it
1656 /// identifies types that contain themselves without indirection through a
1657 /// pointer, which would mean their size is unbounded.
1658 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1662 let rty = tcx.type_of(item_def_id);
1664 // Check that it is possible to represent this type. This call identifies
1665 // (1) types that contain themselves and (2) types that contain a different
1666 // recursive type. It is only necessary to throw an error on those that
1667 // contain themselves. For case 2, there must be an inner type that will be
1668 // caught by case 1.
1669 match rty.is_representable(tcx, sp) {
1670 Representability::SelfRecursive(spans) => {
1671 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1673 err.span_label(span, "recursive without indirection");
1678 Representability::Representable | Representability::ContainsRecursive => (),
1683 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1684 let t = tcx.type_of(def_id);
1685 if let ty::Adt(def, substs) = t.sty {
1686 if def.is_struct() {
1687 let fields = &def.non_enum_variant().fields;
1688 if fields.is_empty() {
1689 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1692 let e = fields[0].ty(tcx, substs);
1693 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1694 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1695 .span_label(sp, "SIMD elements must have the same type")
1700 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1701 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1703 span_err!(tcx.sess, sp, E0077,
1704 "SIMD vector element type should be machine type");
1712 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1713 let repr = tcx.adt_def(def_id).repr;
1715 for attr in tcx.get_attrs(def_id).iter() {
1716 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1717 if let attr::ReprPacked(pack) = r {
1718 if pack != repr.pack {
1719 struct_span_err!(tcx.sess, sp, E0634,
1720 "type has conflicting packed representation hints").emit();
1726 struct_span_err!(tcx.sess, sp, E0587,
1727 "type has conflicting packed and align representation hints").emit();
1729 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1730 struct_span_err!(tcx.sess, sp, E0588,
1731 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1736 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1738 stack: &mut Vec<DefId>) -> bool {
1739 let t = tcx.type_of(def_id);
1740 if stack.contains(&def_id) {
1741 debug!("check_packed_inner: {:?} is recursive", t);
1744 if let ty::Adt(def, substs) = t.sty {
1745 if def.is_struct() || def.is_union() {
1746 if tcx.adt_def(def.did).repr.align > 0 {
1749 // push struct def_id before checking fields
1751 for field in &def.non_enum_variant().fields {
1752 let f = field.ty(tcx, substs);
1753 if let ty::Adt(def, _) = f.sty {
1754 if check_packed_inner(tcx, def.did, stack) {
1759 // only need to pop if not early out
1766 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1767 let adt = tcx.adt_def(def_id);
1768 if !adt.repr.transparent() {
1772 // For each field, figure out if it's known to be a ZST and align(1)
1773 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1774 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1775 let param_env = tcx.param_env(field.did);
1776 let layout = tcx.layout_of(param_env.and(ty));
1777 // We are currently checking the type this field came from, so it must be local
1778 let span = tcx.hir.span_if_local(field.did).unwrap();
1779 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1780 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1784 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1785 let non_zst_count = non_zst_fields.clone().count();
1786 if non_zst_count != 1 {
1787 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1788 struct_span_err!(tcx.sess, sp, E0690,
1789 "transparent struct needs exactly one non-zero-sized field, but has {}",
1791 .span_note(field_spans, "non-zero-sized field")
1794 for (span, zst, align1) in field_infos {
1796 span_err!(tcx.sess, span, E0691,
1797 "zero-sized field in transparent struct has alignment larger than 1");
1802 #[allow(trivial_numeric_casts)]
1803 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1805 vs: &'tcx [hir::Variant],
1807 let def_id = tcx.hir.local_def_id(id);
1808 let def = tcx.adt_def(def_id);
1809 def.destructor(tcx); // force the destructor to be evaluated
1812 let attributes = tcx.get_attrs(def_id);
1813 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1815 tcx.sess, attr.span, E0084,
1816 "unsupported representation for zero-variant enum")
1817 .span_label(sp, "zero-variant enum")
1822 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1823 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1824 if !tcx.features().repr128 {
1825 emit_feature_err(&tcx.sess.parse_sess,
1828 GateIssue::Language,
1829 "repr with 128-bit type is unstable");
1834 if let Some(ref e) = v.node.disr_expr {
1835 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1839 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1840 for (discr, v) in def.discriminants(tcx).zip(vs) {
1841 // Check for duplicate discriminant values
1842 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1843 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1844 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1845 let i_span = match variant_i.node.disr_expr {
1846 Some(ref expr) => tcx.hir.span(expr.id),
1847 None => tcx.hir.span(variant_i_node_id)
1849 let span = match v.node.disr_expr {
1850 Some(ref expr) => tcx.hir.span(expr.id),
1853 struct_span_err!(tcx.sess, span, E0081,
1854 "discriminant value `{}` already exists", disr_vals[i])
1855 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1856 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1859 disr_vals.push(discr);
1862 check_representable(tcx, sp, def_id);
1865 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1866 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1868 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1869 -> ty::GenericPredicates<'tcx>
1872 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1873 let item_id = tcx.hir.ty_param_owner(node_id);
1874 let item_def_id = tcx.hir.local_def_id(item_id);
1875 let generics = tcx.generics_of(item_def_id);
1876 let index = generics.param_def_id_to_index[&def_id];
1877 ty::GenericPredicates {
1879 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1881 ty::Predicate::Trait(ref data)
1882 if data.skip_binder().self_ty().is_param(index) => {
1883 // HACK(eddyb) should get the original `Span`.
1884 let span = tcx.def_span(def_id);
1885 Some((predicate, span))
1893 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1894 -> Option<ty::Region<'tcx>> {
1896 Some(def) => infer::EarlyBoundRegion(span, def.name),
1897 None => infer::MiscVariable(span)
1899 Some(self.next_region_var(v))
1902 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1903 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1906 fn ty_infer_for_def(&self,
1907 ty_param_def: &ty::GenericParamDef,
1908 span: Span) -> Ty<'tcx> {
1909 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1915 fn projected_ty_from_poly_trait_ref(&self,
1918 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1921 let (trait_ref, _) =
1922 self.replace_late_bound_regions_with_fresh_var(
1924 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1927 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1930 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1931 if ty.has_escaping_regions() {
1932 ty // FIXME: normalization and escaping regions
1934 self.normalize_associated_types_in(span, &ty)
1938 fn set_tainted_by_errors(&self) {
1939 self.infcx.set_tainted_by_errors()
1942 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1943 self.write_ty(hir_id, ty)
1947 /// Controls whether the arguments are tupled. This is used for the call
1950 /// Tupling means that all call-side arguments are packed into a tuple and
1951 /// passed as a single parameter. For example, if tupling is enabled, this
1954 /// fn f(x: (isize, isize))
1956 /// Can be called as:
1963 #[derive(Clone, Eq, PartialEq)]
1964 enum TupleArgumentsFlag {
1969 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1970 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1971 param_env: ty::ParamEnv<'tcx>,
1972 body_id: ast::NodeId)
1973 -> FnCtxt<'a, 'gcx, 'tcx> {
1977 err_count_on_creation: inh.tcx.sess.err_count(),
1980 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1981 ast::CRATE_NODE_ID)),
1982 diverges: Cell::new(Diverges::Maybe),
1983 has_errors: Cell::new(false),
1984 enclosing_breakables: RefCell::new(EnclosingBreakables {
1992 pub fn sess(&self) -> &Session {
1996 pub fn err_count_since_creation(&self) -> usize {
1997 self.tcx.sess.err_count() - self.err_count_on_creation
2000 /// Produce warning on the given node, if the current point in the
2001 /// function is unreachable, and there hasn't been another warning.
2002 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2003 if self.diverges.get() == Diverges::Always {
2004 self.diverges.set(Diverges::WarnedAlways);
2006 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2008 self.tcx().lint_node(
2009 lint::builtin::UNREACHABLE_CODE,
2011 &format!("unreachable {}", kind));
2017 code: ObligationCauseCode<'tcx>)
2018 -> ObligationCause<'tcx> {
2019 ObligationCause::new(span, self.body_id, code)
2022 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2023 self.cause(span, ObligationCauseCode::MiscObligation)
2026 /// Resolves type variables in `ty` if possible. Unlike the infcx
2027 /// version (resolve_type_vars_if_possible), this version will
2028 /// also select obligations if it seems useful, in an effort
2029 /// to get more type information.
2030 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2031 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2033 // No Infer()? Nothing needs doing.
2034 if !ty.has_infer_types() {
2035 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2039 // If `ty` is a type variable, see whether we already know what it is.
2040 ty = self.resolve_type_vars_if_possible(&ty);
2041 if !ty.has_infer_types() {
2042 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2046 // If not, try resolving pending obligations as much as
2047 // possible. This can help substantially when there are
2048 // indirect dependencies that don't seem worth tracking
2050 self.select_obligations_where_possible(false);
2051 ty = self.resolve_type_vars_if_possible(&ty);
2053 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2057 fn record_deferred_call_resolution(&self,
2058 closure_def_id: DefId,
2059 r: DeferredCallResolution<'gcx, 'tcx>) {
2060 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2061 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2064 fn remove_deferred_call_resolutions(&self,
2065 closure_def_id: DefId)
2066 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2068 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2069 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2072 pub fn tag(&self) -> String {
2073 let self_ptr: *const FnCtxt = self;
2074 format!("{:?}", self_ptr)
2077 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2078 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2079 span_bug!(span, "no type for local variable {}",
2080 self.tcx.hir.node_to_string(nid))
2085 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2086 debug!("write_ty({:?}, {:?}) in fcx {}",
2087 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2088 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2090 if ty.references_error() {
2091 self.has_errors.set(true);
2092 self.set_tainted_by_errors();
2096 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2097 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2098 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2101 // The NodeId and the ItemLocalId must identify the same item. We just pass
2102 // both of them for consistency checking.
2103 pub fn write_method_call(&self,
2105 method: MethodCallee<'tcx>) {
2106 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2109 .type_dependent_defs_mut()
2110 .insert(hir_id, Def::Method(method.def_id));
2112 self.write_substs(hir_id, method.substs);
2114 // When the method is confirmed, the `method.substs` includes
2115 // parameters from not just the method, but also the impl of
2116 // the method -- in particular, the `Self` type will be fully
2117 // resolved. However, those are not something that the "user
2118 // specified" -- i.e., those types come from the inferred type
2119 // of the receiver, not something the user wrote. So when we
2120 // create the user-substs, we want to replace those earlier
2121 // types with just the types that the user actually wrote --
2122 // that is, those that appear on the *method itself*.
2124 // As an example, if the user wrote something like
2125 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2126 // type of `foo` (possibly adjusted), but we don't want to
2127 // include that. We want just the `[_, u32]` part.
2128 if !method.substs.is_noop() {
2129 let method_generics = self.tcx.generics_of(method.def_id);
2130 if !method_generics.params.is_empty() {
2131 let user_substs = self.infcx.probe(|_| {
2132 let just_method_substs = Substs::for_item(self.tcx, method.def_id, |param, _| {
2133 let i = param.index as usize;
2134 if i < method_generics.parent_count {
2135 self.infcx.var_for_def(DUMMY_SP, param)
2140 self.infcx.canonicalize_response(&UserSubsts {
2141 substs: just_method_substs,
2142 user_self_ty: None, // not relevant here
2146 debug!("write_method_call: user_substs = {:?}", user_substs);
2147 self.write_user_substs(hir_id, user_substs);
2152 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2153 if !substs.is_noop() {
2154 debug!("write_substs({:?}, {:?}) in fcx {}",
2159 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2163 /// Given the substs that we just converted from the HIR, try to
2164 /// canonicalize them and store them as user-given substitutions
2165 /// (i.e., substitutions that must be respected by the NLL check).
2167 /// This should be invoked **before any unifications have
2168 /// occurred**, so that annotations like `Vec<_>` are preserved
2170 pub fn write_user_substs_from_substs(
2173 substs: &'tcx Substs<'tcx>,
2174 user_self_ty: Option<UserSelfTy<'tcx>>,
2177 "write_user_substs_from_substs({:?}, {:?}) in fcx {}",
2183 if !substs.is_noop() {
2184 let user_substs = self.infcx.canonicalize_response(&UserSubsts {
2188 debug!("instantiate_value_path: user_substs = {:?}", user_substs);
2189 self.write_user_substs(hir_id, user_substs);
2193 pub fn write_user_substs(&self, hir_id: hir::HirId, substs: CanonicalUserSubsts<'tcx>) {
2195 "write_user_substs({:?}, {:?}) in fcx {}",
2201 if !substs.is_identity() {
2202 self.tables.borrow_mut().user_substs_mut().insert(hir_id, substs);
2204 debug!("write_user_substs: skipping identity substs");
2208 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2209 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2215 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2216 Entry::Vacant(entry) => { entry.insert(adj); },
2217 Entry::Occupied(mut entry) => {
2218 debug!(" - composing on top of {:?}", entry.get());
2219 match (&entry.get()[..], &adj[..]) {
2220 // Applying any adjustment on top of a NeverToAny
2221 // is a valid NeverToAny adjustment, because it can't
2223 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2225 Adjustment { kind: Adjust::Deref(_), .. },
2226 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2228 Adjustment { kind: Adjust::Deref(_), .. },
2229 .. // Any following adjustments are allowed.
2231 // A reborrow has no effect before a dereference.
2233 // FIXME: currently we never try to compose autoderefs
2234 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2236 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2237 expr, entry.get(), adj)
2239 *entry.get_mut() = adj;
2244 /// Basically whenever we are converting from a type scheme into
2245 /// the fn body space, we always want to normalize associated
2246 /// types as well. This function combines the two.
2247 fn instantiate_type_scheme<T>(&self,
2249 substs: &Substs<'tcx>,
2252 where T : TypeFoldable<'tcx>
2254 let value = value.subst(self.tcx, substs);
2255 let result = self.normalize_associated_types_in(span, &value);
2256 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2263 /// As `instantiate_type_scheme`, but for the bounds found in a
2264 /// generic type scheme.
2265 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2266 -> ty::InstantiatedPredicates<'tcx> {
2267 let bounds = self.tcx.predicates_of(def_id);
2268 let result = bounds.instantiate(self.tcx, substs);
2269 let result = self.normalize_associated_types_in(span, &result);
2270 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2277 /// Replace the opaque types from the given value with type variables,
2278 /// and records the `OpaqueTypeMap` for later use during writeback. See
2279 /// `InferCtxt::instantiate_opaque_types` for more details.
2280 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2282 parent_id: ast::NodeId,
2285 let parent_def_id = self.tcx.hir.local_def_id(parent_id);
2286 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2290 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2291 self.instantiate_opaque_types(
2299 let mut opaque_types = self.opaque_types.borrow_mut();
2300 for (ty, decl) in opaque_type_map {
2301 let old_value = opaque_types.insert(ty, decl);
2302 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2308 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2309 where T : TypeFoldable<'tcx>
2311 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2314 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2316 where T : TypeFoldable<'tcx>
2318 self.inh.partially_normalize_associated_types_in(span,
2324 pub fn require_type_meets(&self,
2327 code: traits::ObligationCauseCode<'tcx>,
2330 self.register_bound(
2333 traits::ObligationCause::new(span, self.body_id, code));
2336 pub fn require_type_is_sized(&self,
2339 code: traits::ObligationCauseCode<'tcx>)
2341 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2342 self.require_type_meets(ty, span, code, lang_item);
2345 pub fn register_bound(&self,
2348 cause: traits::ObligationCause<'tcx>)
2350 self.fulfillment_cx.borrow_mut()
2351 .register_bound(self, self.param_env, ty, def_id, cause);
2354 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2355 let t = AstConv::ast_ty_to_ty(self, ast_t);
2356 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2360 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2361 let ty = self.to_ty(ast_ty);
2363 // If the type given by the user has free regions, save it for
2364 // later, since NLL would like to enforce those. Also pass in
2365 // types that involve projections, since those can resolve to
2366 // `'static` bounds (modulo #54940, which hopefully will be
2367 // fixed by the time you see this comment, dear reader,
2368 // although I have my doubts). Other sorts of things are
2369 // already sufficiently enforced with erased regions. =)
2370 if ty.has_free_regions() || ty.has_projections() {
2371 let c_ty = self.infcx.canonicalize_response(&ty);
2372 self.tables.borrow_mut().user_provided_tys_mut().insert(ast_ty.hir_id, c_ty);
2378 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2379 match self.tables.borrow().node_types().get(id) {
2381 None if self.is_tainted_by_errors() => self.tcx.types.err,
2383 let node_id = self.tcx.hir.hir_to_node_id(id);
2384 bug!("no type for node {}: {} in fcx {}",
2385 node_id, self.tcx.hir.node_to_string(node_id),
2391 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2392 /// outlive the region `r`.
2393 pub fn register_wf_obligation(&self,
2396 code: traits::ObligationCauseCode<'tcx>)
2398 // WF obligations never themselves fail, so no real need to give a detailed cause:
2399 let cause = traits::ObligationCause::new(span, self.body_id, code);
2400 self.register_predicate(traits::Obligation::new(cause,
2402 ty::Predicate::WellFormed(ty)));
2405 /// Registers obligations that all types appearing in `substs` are well-formed.
2406 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2407 for ty in substs.types() {
2408 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2412 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2413 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2414 /// trait/region obligations.
2416 /// For example, if there is a function:
2419 /// fn foo<'a,T:'a>(...)
2422 /// and a reference:
2428 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2429 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2430 pub fn add_obligations_for_parameters(&self,
2431 cause: traits::ObligationCause<'tcx>,
2432 predicates: &ty::InstantiatedPredicates<'tcx>)
2434 assert!(!predicates.has_escaping_regions());
2436 debug!("add_obligations_for_parameters(predicates={:?})",
2439 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2440 self.register_predicate(obligation);
2444 // FIXME(arielb1): use this instead of field.ty everywhere
2445 // Only for fields! Returns <none> for methods>
2446 // Indifferent to privacy flags
2447 pub fn field_ty(&self,
2449 field: &'tcx ty::FieldDef,
2450 substs: &Substs<'tcx>)
2453 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2456 fn check_casts(&self) {
2457 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2458 for cast in deferred_cast_checks.drain(..) {
2463 fn resolve_generator_interiors(&self, def_id: DefId) {
2464 let mut generators = self.deferred_generator_interiors.borrow_mut();
2465 for (body_id, interior) in generators.drain(..) {
2466 self.select_obligations_where_possible(false);
2467 generator_interior::resolve_interior(self, def_id, body_id, interior);
2471 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2472 // Non-numerics get replaced with ! or () (depending on whether
2473 // feature(never_type) is enabled, unconstrained ints with i32,
2474 // unconstrained floats with f64.
2475 // Fallback becomes very dubious if we have encountered type-checking errors.
2476 // In that case, fallback to Error.
2477 // The return value indicates whether fallback has occurred.
2478 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2479 use rustc::ty::error::UnconstrainedNumeric::Neither;
2480 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2482 assert!(ty.is_ty_infer());
2483 let fallback = match self.type_is_unconstrained_numeric(ty) {
2484 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2485 UnconstrainedInt => self.tcx.types.i32,
2486 UnconstrainedFloat => self.tcx.types.f64,
2487 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2488 Neither => return false,
2490 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2491 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2495 fn select_all_obligations_or_error(&self) {
2496 debug!("select_all_obligations_or_error");
2497 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2498 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2502 /// Select as many obligations as we can at present.
2503 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2504 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2505 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2509 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2510 /// returns a type of `&T`, but the actual type we assign to the
2511 /// *expression* is `T`. So this function just peels off the return
2512 /// type by one layer to yield `T`.
2513 fn make_overloaded_place_return_type(&self,
2514 method: MethodCallee<'tcx>)
2515 -> ty::TypeAndMut<'tcx>
2517 // extract method return type, which will be &T;
2518 let ret_ty = method.sig.output();
2520 // method returns &T, but the type as visible to user is T, so deref
2521 ret_ty.builtin_deref(true).unwrap()
2524 fn lookup_indexing(&self,
2526 base_expr: &'gcx hir::Expr,
2530 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2532 // FIXME(#18741) -- this is almost but not quite the same as the
2533 // autoderef that normal method probing does. They could likely be
2536 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2537 let mut result = None;
2538 while result.is_none() && autoderef.next().is_some() {
2539 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2541 autoderef.finalize();
2545 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2546 /// (and otherwise adjust) `base_expr`, looking for a type which either
2547 /// supports builtin indexing or overloaded indexing.
2548 /// This loop implements one step in that search; the autoderef loop
2549 /// is implemented by `lookup_indexing`.
2550 fn try_index_step(&self,
2552 base_expr: &hir::Expr,
2553 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2556 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2558 let adjusted_ty = autoderef.unambiguous_final_ty();
2559 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2566 for &unsize in &[false, true] {
2567 let mut self_ty = adjusted_ty;
2569 // We only unsize arrays here.
2570 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2571 self_ty = self.tcx.mk_slice(element_ty);
2577 // If some lookup succeeds, write callee into table and extract index/element
2578 // type from the method signature.
2579 // If some lookup succeeded, install method in table
2580 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2581 let method = self.try_overloaded_place_op(
2582 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2584 let result = method.map(|ok| {
2585 debug!("try_index_step: success, using overloaded indexing");
2586 let method = self.register_infer_ok_obligations(ok);
2588 let mut adjustments = autoderef.adjust_steps(needs);
2589 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2590 let mutbl = match r_mutbl {
2591 hir::MutImmutable => AutoBorrowMutability::Immutable,
2592 hir::MutMutable => AutoBorrowMutability::Mutable {
2593 // Indexing can be desugared to a method call,
2594 // so maybe we could use two-phase here.
2595 // See the documentation of AllowTwoPhase for why that's
2596 // not the case today.
2597 allow_two_phase_borrow: AllowTwoPhase::No,
2600 adjustments.push(Adjustment {
2601 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2602 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2609 adjustments.push(Adjustment {
2610 kind: Adjust::Unsize,
2611 target: method.sig.inputs()[0]
2614 self.apply_adjustments(base_expr, adjustments);
2616 self.write_method_call(expr.hir_id, method);
2617 (input_ty, self.make_overloaded_place_return_type(method).ty)
2619 if result.is_some() {
2627 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2628 let (tr, name) = match (op, is_mut) {
2629 (PlaceOp::Deref, false) =>
2630 (self.tcx.lang_items().deref_trait(), "deref"),
2631 (PlaceOp::Deref, true) =>
2632 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2633 (PlaceOp::Index, false) =>
2634 (self.tcx.lang_items().index_trait(), "index"),
2635 (PlaceOp::Index, true) =>
2636 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2638 (tr, ast::Ident::from_str(name))
2641 fn try_overloaded_place_op(&self,
2644 arg_tys: &[Ty<'tcx>],
2647 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2649 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2655 // Try Mut first, if needed.
2656 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2657 let method = match (needs, mut_tr) {
2658 (Needs::MutPlace, Some(trait_did)) => {
2659 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2664 // Otherwise, fall back to the immutable version.
2665 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2666 let method = match (method, imm_tr) {
2667 (None, Some(trait_did)) => {
2668 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2670 (method, _) => method,
2676 fn check_method_argument_types(&self,
2679 method: Result<MethodCallee<'tcx>, ()>,
2680 args_no_rcvr: &'gcx [hir::Expr],
2681 tuple_arguments: TupleArgumentsFlag,
2682 expected: Expectation<'tcx>)
2684 let has_error = match method {
2686 method.substs.references_error() || method.sig.references_error()
2691 let err_inputs = self.err_args(args_no_rcvr.len());
2693 let err_inputs = match tuple_arguments {
2694 DontTupleArguments => err_inputs,
2695 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2698 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2699 false, tuple_arguments, None);
2700 return self.tcx.types.err;
2703 let method = method.unwrap();
2704 // HACK(eddyb) ignore self in the definition (see above).
2705 let expected_arg_tys = self.expected_inputs_for_expected_output(
2708 method.sig.output(),
2709 &method.sig.inputs()[1..]
2711 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2712 args_no_rcvr, method.sig.variadic, tuple_arguments,
2713 self.tcx.hir.span_if_local(method.def_id));
2717 /// Generic function that factors out common logic from function calls,
2718 /// method calls and overloaded operators.
2719 fn check_argument_types(&self,
2722 fn_inputs: &[Ty<'tcx>],
2723 mut expected_arg_tys: &[Ty<'tcx>],
2724 args: &'gcx [hir::Expr],
2726 tuple_arguments: TupleArgumentsFlag,
2727 def_span: Option<Span>) {
2730 // Grab the argument types, supplying fresh type variables
2731 // if the wrong number of arguments were supplied
2732 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2738 // All the input types from the fn signature must outlive the call
2739 // so as to validate implied bounds.
2740 for &fn_input_ty in fn_inputs {
2741 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2744 let expected_arg_count = fn_inputs.len();
2746 let param_count_error = |expected_count: usize,
2751 let mut err = tcx.sess.struct_span_err_with_code(sp,
2752 &format!("this function takes {}{} but {} {} supplied",
2753 if variadic {"at least "} else {""},
2754 potentially_plural_count(expected_count, "parameter"),
2755 potentially_plural_count(arg_count, "parameter"),
2756 if arg_count == 1 {"was"} else {"were"}),
2757 DiagnosticId::Error(error_code.to_owned()));
2759 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2760 err.span_label(def_s, "defined here");
2763 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2764 // remove closing `)` from the span
2765 let sugg_span = sugg_span.shrink_to_lo();
2766 err.span_suggestion_with_applicability(
2768 "expected the unit value `()`; create it with empty parentheses",
2770 Applicability::MachineApplicable);
2772 err.span_label(sp, format!("expected {}{}",
2773 if variadic {"at least "} else {""},
2774 potentially_plural_count(expected_count, "parameter")));
2779 let formal_tys = if tuple_arguments == TupleArguments {
2780 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2781 match tuple_type.sty {
2782 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2783 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2784 expected_arg_tys = &[];
2785 self.err_args(args.len())
2787 ty::Tuple(arg_types) => {
2788 expected_arg_tys = match expected_arg_tys.get(0) {
2789 Some(&ty) => match ty.sty {
2790 ty::Tuple(ref tys) => &tys,
2798 span_err!(tcx.sess, sp, E0059,
2799 "cannot use call notation; the first type parameter \
2800 for the function trait is neither a tuple nor unit");
2801 expected_arg_tys = &[];
2802 self.err_args(args.len())
2805 } else if expected_arg_count == supplied_arg_count {
2807 } else if variadic {
2808 if supplied_arg_count >= expected_arg_count {
2811 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2812 expected_arg_tys = &[];
2813 self.err_args(supplied_arg_count)
2816 // is the missing argument of type `()`?
2817 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2818 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2819 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2820 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2824 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2826 expected_arg_tys = &[];
2827 self.err_args(supplied_arg_count)
2829 // If there is no expectation, expect formal_tys.
2830 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2836 debug!("check_argument_types: formal_tys={:?}",
2837 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2839 // Check the arguments.
2840 // We do this in a pretty awful way: first we typecheck any arguments
2841 // that are not closures, then we typecheck the closures. This is so
2842 // that we have more information about the types of arguments when we
2843 // typecheck the functions. This isn't really the right way to do this.
2844 for &check_closures in &[false, true] {
2845 debug!("check_closures={}", check_closures);
2847 // More awful hacks: before we check argument types, try to do
2848 // an "opportunistic" vtable resolution of any trait bounds on
2849 // the call. This helps coercions.
2851 self.select_obligations_where_possible(false);
2854 // For variadic functions, we don't have a declared type for all of
2855 // the arguments hence we only do our usual type checking with
2856 // the arguments who's types we do know.
2857 let t = if variadic {
2859 } else if tuple_arguments == TupleArguments {
2864 for (i, arg) in args.iter().take(t).enumerate() {
2865 // Warn only for the first loop (the "no closures" one).
2866 // Closure arguments themselves can't be diverging, but
2867 // a previous argument can, e.g. `foo(panic!(), || {})`.
2868 if !check_closures {
2869 self.warn_if_unreachable(arg.id, arg.span, "expression");
2872 let is_closure = match arg.node {
2873 hir::ExprKind::Closure(..) => true,
2877 if is_closure != check_closures {
2881 debug!("checking the argument");
2882 let formal_ty = formal_tys[i];
2884 // The special-cased logic below has three functions:
2885 // 1. Provide as good of an expected type as possible.
2886 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2888 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2890 // 2. Coerce to the most detailed type that could be coerced
2891 // to, which is `expected_ty` if `rvalue_hint` returns an
2892 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2893 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2894 // We're processing function arguments so we definitely want to use
2895 // two-phase borrows.
2896 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2898 // 3. Relate the expected type and the formal one,
2899 // if the expected type was used for the coercion.
2900 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2904 // We also need to make sure we at least write the ty of the other
2905 // arguments which we skipped above.
2907 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2908 use structured_errors::{VariadicError, StructuredDiagnostic};
2909 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2912 for arg in args.iter().skip(expected_arg_count) {
2913 let arg_ty = self.check_expr(&arg);
2915 // There are a few types which get autopromoted when passed via varargs
2916 // in C but we just error out instead and require explicit casts.
2917 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2919 ty::Float(ast::FloatTy::F32) => {
2920 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2922 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2923 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2925 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2926 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2929 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2930 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2931 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2939 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2940 vec![self.tcx.types.err; len]
2943 // AST fragment checking
2946 expected: Expectation<'tcx>)
2952 ast::LitKind::Str(..) => tcx.mk_static_str(),
2953 ast::LitKind::ByteStr(ref v) => {
2954 tcx.mk_imm_ref(tcx.types.re_static,
2955 tcx.mk_array(tcx.types.u8, v.len() as u64))
2957 ast::LitKind::Byte(_) => tcx.types.u8,
2958 ast::LitKind::Char(_) => tcx.types.char,
2959 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2960 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2961 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2962 let opt_ty = expected.to_option(self).and_then(|ty| {
2964 ty::Int(_) | ty::Uint(_) => Some(ty),
2965 ty::Char => Some(tcx.types.u8),
2966 ty::RawPtr(..) => Some(tcx.types.usize),
2967 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2971 opt_ty.unwrap_or_else(
2972 || tcx.mk_int_var(self.next_int_var_id()))
2974 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2975 ast::LitKind::FloatUnsuffixed(_) => {
2976 let opt_ty = expected.to_option(self).and_then(|ty| {
2978 ty::Float(_) => Some(ty),
2982 opt_ty.unwrap_or_else(
2983 || tcx.mk_float_var(self.next_float_var_id()))
2985 ast::LitKind::Bool(_) => tcx.types.bool
2989 fn check_expr_eq_type(&self,
2990 expr: &'gcx hir::Expr,
2991 expected: Ty<'tcx>) {
2992 let ty = self.check_expr_with_hint(expr, expected);
2993 self.demand_eqtype(expr.span, expected, ty);
2996 pub fn check_expr_has_type_or_error(&self,
2997 expr: &'gcx hir::Expr,
2998 expected: Ty<'tcx>) -> Ty<'tcx> {
2999 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3002 fn check_expr_meets_expectation_or_error(&self,
3003 expr: &'gcx hir::Expr,
3004 expected: Expectation<'tcx>) -> Ty<'tcx> {
3005 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3006 let mut ty = self.check_expr_with_expectation(expr, expected);
3008 // While we don't allow *arbitrary* coercions here, we *do* allow
3009 // coercions from ! to `expected`.
3011 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3012 "expression with never type wound up being adjusted");
3013 let adj_ty = self.next_diverging_ty_var(
3014 TypeVariableOrigin::AdjustmentType(expr.span));
3015 self.apply_adjustments(expr, vec![Adjustment {
3016 kind: Adjust::NeverToAny,
3022 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3023 // Add help to type error if this is an `if` condition with an assignment
3024 if let (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs))
3025 = (expected, &expr.node)
3027 let msg = "try comparing for equality";
3028 if let (Ok(left), Ok(right)) = (
3029 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3030 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3032 err.span_suggestion_with_applicability(
3035 format!("{} == {}", left, right),
3036 Applicability::MaybeIncorrect);
3046 fn check_expr_coercable_to_type(&self,
3047 expr: &'gcx hir::Expr,
3048 expected: Ty<'tcx>) -> Ty<'tcx> {
3049 let ty = self.check_expr_with_hint(expr, expected);
3050 // checks don't need two phase
3051 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3054 fn check_expr_with_hint(&self,
3055 expr: &'gcx hir::Expr,
3056 expected: Ty<'tcx>) -> Ty<'tcx> {
3057 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3060 fn check_expr_with_expectation(&self,
3061 expr: &'gcx hir::Expr,
3062 expected: Expectation<'tcx>) -> Ty<'tcx> {
3063 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3066 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3067 self.check_expr_with_expectation(expr, NoExpectation)
3070 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3071 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3074 // determine the `self` type, using fresh variables for all variables
3075 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3076 // would return ($0, $1) where $0 and $1 are freshly instantiated type
3078 pub fn impl_self_ty(&self,
3079 span: Span, // (potential) receiver for this impl
3081 -> TypeAndSubsts<'tcx> {
3082 let ity = self.tcx.type_of(did);
3083 debug!("impl_self_ty: ity={:?}", ity);
3085 let substs = self.fresh_substs_for_item(span, did);
3086 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3088 TypeAndSubsts { substs: substs, ty: substd_ty }
3091 /// Unifies the output type with the expected type early, for more coercions
3092 /// and forward type information on the input expressions.
3093 fn expected_inputs_for_expected_output(&self,
3095 expected_ret: Expectation<'tcx>,
3096 formal_ret: Ty<'tcx>,
3097 formal_args: &[Ty<'tcx>])
3099 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3100 let ret_ty = match expected_ret.only_has_type(self) {
3102 None => return Vec::new()
3104 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3105 // Attempt to apply a subtyping relationship between the formal
3106 // return type (likely containing type variables if the function
3107 // is polymorphic) and the expected return type.
3108 // No argument expectations are produced if unification fails.
3109 let origin = self.misc(call_span);
3110 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3112 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3113 // to identity so the resulting type is not constrained.
3116 // Process any obligations locally as much as
3117 // we can. We don't care if some things turn
3118 // out unconstrained or ambiguous, as we're
3119 // just trying to get hints here.
3120 self.save_and_restore_in_snapshot_flag(|_| {
3121 let mut fulfill = TraitEngine::new(self.tcx);
3122 for obligation in ok.obligations {
3123 fulfill.register_predicate_obligation(self, obligation);
3125 fulfill.select_where_possible(self)
3126 }).map_err(|_| ())?;
3128 Err(_) => return Err(()),
3131 // Record all the argument types, with the substitutions
3132 // produced from the above subtyping unification.
3133 Ok(formal_args.iter().map(|ty| {
3134 self.resolve_type_vars_if_possible(ty)
3136 }).unwrap_or_default();
3137 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3138 formal_args, formal_ret,
3139 expect_args, expected_ret);
3143 // Checks a method call.
3144 fn check_method_call(&self,
3145 expr: &'gcx hir::Expr,
3146 segment: &hir::PathSegment,
3148 args: &'gcx [hir::Expr],
3149 expected: Expectation<'tcx>,
3150 needs: Needs) -> Ty<'tcx> {
3151 let rcvr = &args[0];
3152 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3153 // no need to check for bot/err -- callee does that
3154 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3156 let method = match self.lookup_method(rcvr_t,
3162 self.write_method_call(expr.hir_id, method);
3166 if segment.ident.name != keywords::Invalid.name() {
3167 self.report_method_error(span,
3178 // Call the generic checker.
3179 self.check_method_argument_types(span,
3187 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3191 .unwrap_or_else(|| span_bug!(return_expr.span,
3192 "check_return_expr called outside fn body"));
3194 let ret_ty = ret_coercion.borrow().expected_ty();
3195 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3196 ret_coercion.borrow_mut()
3198 &self.cause(return_expr.span,
3199 ObligationCauseCode::ReturnType(return_expr.id)),
3204 // A generic function for checking the then and else in an if
3206 fn check_then_else(&self,
3207 cond_expr: &'gcx hir::Expr,
3208 then_expr: &'gcx hir::Expr,
3209 opt_else_expr: Option<&'gcx hir::Expr>,
3211 expected: Expectation<'tcx>) -> Ty<'tcx> {
3212 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3213 let cond_diverges = self.diverges.get();
3214 self.diverges.set(Diverges::Maybe);
3216 let expected = expected.adjust_for_branches(self);
3217 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3218 let then_diverges = self.diverges.get();
3219 self.diverges.set(Diverges::Maybe);
3221 // We've already taken the expected type's preferences
3222 // into account when typing the `then` branch. To figure
3223 // out the initial shot at a LUB, we thus only consider
3224 // `expected` if it represents a *hard* constraint
3225 // (`only_has_type`); otherwise, we just go with a
3226 // fresh type variable.
3227 let coerce_to_ty = expected.coercion_target_type(self, sp);
3228 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3230 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3231 coerce.coerce(self, &if_cause, then_expr, then_ty);
3233 if let Some(else_expr) = opt_else_expr {
3234 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3235 let else_diverges = self.diverges.get();
3237 coerce.coerce(self, &if_cause, else_expr, else_ty);
3239 // We won't diverge unless both branches do (or the condition does).
3240 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3242 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3243 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3245 // If the condition is false we can't diverge.
3246 self.diverges.set(cond_diverges);
3249 let result_ty = coerce.complete(self);
3250 if cond_ty.references_error() {
3257 // Check field access expressions
3258 fn check_field(&self,
3259 expr: &'gcx hir::Expr,
3261 base: &'gcx hir::Expr,
3262 field: ast::Ident) -> Ty<'tcx> {
3263 let expr_t = self.check_expr_with_needs(base, needs);
3264 let expr_t = self.structurally_resolved_type(base.span,
3266 let mut private_candidate = None;
3267 let mut autoderef = self.autoderef(expr.span, expr_t);
3268 while let Some((base_t, _)) = autoderef.next() {
3270 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3271 debug!("struct named {:?}", base_t);
3272 let (ident, def_scope) =
3273 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3274 let fields = &base_def.non_enum_variant().fields;
3275 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3276 let field = &fields[index];
3277 let field_ty = self.field_ty(expr.span, field, substs);
3278 // Save the index of all fields regardless of their visibility in case
3279 // of error recovery.
3280 self.write_field_index(expr.id, index);
3281 if field.vis.is_accessible_from(def_scope, self.tcx) {
3282 let adjustments = autoderef.adjust_steps(needs);
3283 self.apply_adjustments(base, adjustments);
3284 autoderef.finalize();
3286 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3289 private_candidate = Some((base_def.did, field_ty));
3292 ty::Tuple(ref tys) => {
3293 let fstr = field.as_str();
3294 if let Ok(index) = fstr.parse::<usize>() {
3295 if fstr == index.to_string() {
3296 if let Some(field_ty) = tys.get(index) {
3297 let adjustments = autoderef.adjust_steps(needs);
3298 self.apply_adjustments(base, adjustments);
3299 autoderef.finalize();
3301 self.write_field_index(expr.id, index);
3310 autoderef.unambiguous_final_ty();
3312 if let Some((did, field_ty)) = private_candidate {
3313 let struct_path = self.tcx().item_path_str(did);
3314 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3315 "field `{}` of struct `{}` is private",
3316 field, struct_path);
3317 // Also check if an accessible method exists, which is often what is meant.
3318 if self.method_exists(field, expr_t, expr.id, false) {
3319 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3323 } else if field.name == keywords::Invalid.name() {
3324 self.tcx().types.err
3325 } else if self.method_exists(field, expr_t, expr.id, true) {
3326 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3327 "attempted to take value of method `{}` on type `{}`",
3329 .help("maybe a `()` to call it is missing?")
3331 self.tcx().types.err
3333 if !expr_t.is_primitive_ty() {
3334 let mut err = self.no_such_field_err(field.span, field, expr_t);
3337 ty::Adt(def, _) if !def.is_enum() => {
3338 if let Some(suggested_field_name) =
3339 Self::suggest_field_name(def.non_enum_variant(),
3340 &field.as_str(), vec![]) {
3341 err.span_label(field.span,
3342 format!("did you mean `{}`?", suggested_field_name));
3344 err.span_label(field.span, "unknown field");
3345 let struct_variant_def = def.non_enum_variant();
3346 let field_names = self.available_field_names(struct_variant_def);
3347 if !field_names.is_empty() {
3348 err.note(&format!("available fields are: {}",
3349 self.name_series_display(field_names)));
3353 ty::Array(_, len) => {
3354 if let (Some(len), Ok(user_index)) = (
3355 len.assert_usize(self.tcx),
3356 field.as_str().parse::<u64>()
3358 let base = self.tcx.hir.node_to_pretty_string(base.id);
3359 let help = "instead of using tuple indexing, use array indexing";
3360 let suggestion = format!("{}[{}]", base, field);
3361 let applicability = if len < user_index {
3362 Applicability::MachineApplicable
3364 Applicability::MaybeIncorrect
3366 err.span_suggestion_with_applicability(
3367 expr.span, help, suggestion, applicability
3372 let base = self.tcx.hir.node_to_pretty_string(base.id);
3373 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3374 let suggestion = format!("(*{}).{}", base, field);
3375 err.span_suggestion_with_applicability(
3379 Applicability::MaybeIncorrect,
3386 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3387 "`{}` is a primitive type and therefore doesn't have fields",
3390 self.tcx().types.err
3394 // Return an hint about the closest match in field names
3395 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3397 skip: Vec<LocalInternedString>)
3399 let names = variant.fields.iter().filter_map(|field| {
3400 // ignore already set fields and private fields from non-local crates
3401 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3402 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3405 Some(&field.ident.name)
3409 find_best_match_for_name(names, field, None)
3412 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3413 variant.fields.iter().filter(|field| {
3414 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3415 field.vis.is_accessible_from(def_scope, self.tcx)
3417 .map(|field| field.ident.name)
3421 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3422 // dynamic limit, to never omit just one field
3423 let limit = if names.len() == 6 { 6 } else { 5 };
3424 let mut display = names.iter().take(limit)
3425 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3426 if names.len() > limit {
3427 display = format!("{} ... and {} others", display, names.len() - limit);
3432 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3433 -> DiagnosticBuilder {
3434 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3435 "no field `{}` on type `{}`",
3439 fn report_unknown_field(&self,
3441 variant: &'tcx ty::VariantDef,
3443 skip_fields: &[hir::Field],
3445 let mut err = self.type_error_struct_with_diag(
3447 |actual| match ty.sty {
3448 ty::Adt(adt, ..) if adt.is_enum() => {
3449 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3450 "{} `{}::{}` has no field named `{}`",
3451 kind_name, actual, variant.name, field.ident)
3454 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3455 "{} `{}` has no field named `{}`",
3456 kind_name, actual, field.ident)
3460 // prevent all specified fields from being suggested
3461 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3462 if let Some(field_name) = Self::suggest_field_name(variant,
3463 &field.ident.as_str(),
3464 skip_fields.collect()) {
3465 err.span_label(field.ident.span,
3466 format!("field does not exist - did you mean `{}`?", field_name));
3469 ty::Adt(adt, ..) => {
3471 err.span_label(field.ident.span,
3472 format!("`{}::{}` does not have this field",
3475 err.span_label(field.ident.span,
3476 format!("`{}` does not have this field", ty));
3478 let available_field_names = self.available_field_names(variant);
3479 if !available_field_names.is_empty() {
3480 err.note(&format!("available fields are: {}",
3481 self.name_series_display(available_field_names)));
3484 _ => bug!("non-ADT passed to report_unknown_field")
3490 fn check_expr_struct_fields(&self,
3492 expected: Expectation<'tcx>,
3493 expr_id: ast::NodeId,
3495 variant: &'tcx ty::VariantDef,
3496 ast_fields: &'gcx [hir::Field],
3497 check_completeness: bool) -> bool {
3501 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3502 .get(0).cloned().unwrap_or(adt_ty);
3503 // re-link the regions that EIfEO can erase.
3504 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3506 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3507 &ty::Adt(adt, substs) => {
3508 (substs, adt.adt_kind(), adt.variant_descr())
3510 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3513 let mut remaining_fields = FxHashMap::default();
3514 for (i, field) in variant.fields.iter().enumerate() {
3515 remaining_fields.insert(field.ident.modern(), (i, field));
3518 let mut seen_fields = FxHashMap::default();
3520 let mut error_happened = false;
3522 // Typecheck each field.
3523 for field in ast_fields {
3524 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3525 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3526 seen_fields.insert(ident, field.span);
3527 self.write_field_index(field.id, i);
3529 // we don't look at stability attributes on
3530 // struct-like enums (yet...), but it's definitely not
3531 // a bug to have construct one.
3532 if adt_kind != ty::AdtKind::Enum {
3533 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3536 self.field_ty(field.span, v_field, substs)
3538 error_happened = true;
3539 if let Some(prev_span) = seen_fields.get(&ident) {
3540 let mut err = struct_span_err!(self.tcx.sess,
3543 "field `{}` specified more than once",
3546 err.span_label(field.ident.span, "used more than once");
3547 err.span_label(*prev_span, format!("first use of `{}`", ident));
3551 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3557 // Make sure to give a type to the field even if there's
3558 // an error, so we can continue typechecking
3559 self.check_expr_coercable_to_type(&field.expr, field_type);
3562 // Make sure the programmer specified correct number of fields.
3563 if kind_name == "union" {
3564 if ast_fields.len() != 1 {
3565 tcx.sess.span_err(span, "union expressions should have exactly one field");
3567 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3568 let len = remaining_fields.len();
3570 let mut displayable_field_names = remaining_fields
3572 .map(|ident| ident.as_str())
3573 .collect::<Vec<_>>();
3575 displayable_field_names.sort();
3577 let truncated_fields_error = if len <= 3 {
3580 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3583 let remaining_fields_names = displayable_field_names.iter().take(3)
3584 .map(|n| format!("`{}`", n))
3585 .collect::<Vec<_>>()
3588 struct_span_err!(tcx.sess, span, E0063,
3589 "missing field{} {}{} in initializer of `{}`",
3590 if remaining_fields.len() == 1 { "" } else { "s" },
3591 remaining_fields_names,
3592 truncated_fields_error,
3594 .span_label(span, format!("missing {}{}",
3595 remaining_fields_names,
3596 truncated_fields_error))
3602 fn check_struct_fields_on_error(&self,
3603 fields: &'gcx [hir::Field],
3604 base_expr: &'gcx Option<P<hir::Expr>>) {
3605 for field in fields {
3606 self.check_expr(&field.expr);
3608 if let Some(ref base) = *base_expr {
3609 self.check_expr(&base);
3613 pub fn check_struct_path(&self,
3615 node_id: ast::NodeId)
3616 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3617 let path_span = match *qpath {
3618 hir::QPath::Resolved(_, ref path) => path.span,
3619 hir::QPath::TypeRelative(ref qself, _) => qself.span
3621 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3622 let variant = match def {
3624 self.set_tainted_by_errors();
3627 Def::Variant(..) => {
3629 ty::Adt(adt, substs) => {
3630 Some((adt.variant_of_def(def), adt.did, substs))
3632 _ => bug!("unexpected type: {:?}", ty.sty)
3635 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3636 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3638 ty::Adt(adt, substs) if !adt.is_enum() => {
3639 Some((adt.non_enum_variant(), adt.did, substs))
3644 _ => bug!("unexpected definition: {:?}", def)
3647 if let Some((variant, did, substs)) = variant {
3648 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3649 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
3650 self.write_user_substs_from_substs(hir_id, substs, None);
3652 // Check bounds on type arguments used in the path.
3653 let bounds = self.instantiate_bounds(path_span, did, substs);
3654 let cause = traits::ObligationCause::new(path_span, self.body_id,
3655 traits::ItemObligation(did));
3656 self.add_obligations_for_parameters(cause, &bounds);
3660 struct_span_err!(self.tcx.sess, path_span, E0071,
3661 "expected struct, variant or union type, found {}",
3662 ty.sort_string(self.tcx))
3663 .span_label(path_span, "not a struct")
3669 fn check_expr_struct(&self,
3671 expected: Expectation<'tcx>,
3673 fields: &'gcx [hir::Field],
3674 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3676 // Find the relevant variant
3677 let (variant, adt_ty) =
3678 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3681 self.check_struct_fields_on_error(fields, base_expr);
3682 return self.tcx.types.err;
3685 let path_span = match *qpath {
3686 hir::QPath::Resolved(_, ref path) => path.span,
3687 hir::QPath::TypeRelative(ref qself, _) => qself.span
3690 // Prohibit struct expressions when non exhaustive flag is set.
3691 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3692 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3693 span_err!(self.tcx.sess, expr.span, E0639,
3694 "cannot create non-exhaustive {} using struct expression",
3695 adt.variant_descr());
3698 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3699 variant, fields, base_expr.is_none());
3700 if let &Some(ref base_expr) = base_expr {
3701 // If check_expr_struct_fields hit an error, do not attempt to populate
3702 // the fields with the base_expr. This could cause us to hit errors later
3703 // when certain fields are assumed to exist that in fact do not.
3704 if !error_happened {
3705 self.check_expr_has_type_or_error(base_expr, adt_ty);
3707 ty::Adt(adt, substs) if adt.is_struct() => {
3708 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3709 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3714 .fru_field_types_mut()
3715 .insert(expr.hir_id, fru_field_types);
3718 span_err!(self.tcx.sess, base_expr.span, E0436,
3719 "functional record update syntax requires a struct");
3724 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3730 /// If an expression has any sub-expressions that result in a type error,
3731 /// inspecting that expression's type with `ty.references_error()` will return
3732 /// true. Likewise, if an expression is known to diverge, inspecting its
3733 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3734 /// strict, _|_ can appear in the type of an expression that does not,
3735 /// itself, diverge: for example, fn() -> _|_.)
3736 /// Note that inspecting a type's structure *directly* may expose the fact
3737 /// that there are actually multiple representations for `Error`, so avoid
3738 /// that when err needs to be handled differently.
3739 fn check_expr_with_expectation_and_needs(&self,
3740 expr: &'gcx hir::Expr,
3741 expected: Expectation<'tcx>,
3742 needs: Needs) -> Ty<'tcx> {
3743 debug!(">> typechecking: expr={:?} expected={:?}",
3746 // Warn for expressions after diverging siblings.
3747 self.warn_if_unreachable(expr.id, expr.span, "expression");
3749 // Hide the outer diverging and has_errors flags.
3750 let old_diverges = self.diverges.get();
3751 let old_has_errors = self.has_errors.get();
3752 self.diverges.set(Diverges::Maybe);
3753 self.has_errors.set(false);
3755 let ty = self.check_expr_kind(expr, expected, needs);
3757 // Warn for non-block expressions with diverging children.
3759 hir::ExprKind::Block(..) |
3760 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3761 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3763 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3766 // Any expression that produces a value of type `!` must have diverged
3768 self.diverges.set(self.diverges.get() | Diverges::Always);
3771 // Record the type, which applies it effects.
3772 // We need to do this after the warning above, so that
3773 // we don't warn for the diverging expression itself.
3774 self.write_ty(expr.hir_id, ty);
3776 // Combine the diverging and has_error flags.
3777 self.diverges.set(self.diverges.get() | old_diverges);
3778 self.has_errors.set(self.has_errors.get() | old_has_errors);
3780 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3781 debug!("... {:?}, expected is {:?}", ty, expected);
3788 expr: &'gcx hir::Expr,
3789 expected: Expectation<'tcx>,
3793 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3802 hir::ExprKind::Box(ref subexpr) => {
3803 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3805 ty::Adt(def, _) if def.is_box()
3806 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3810 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3811 tcx.mk_box(referent_ty)
3814 hir::ExprKind::Lit(ref lit) => {
3815 self.check_lit(&lit, expected)
3817 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3818 self.check_binop(expr, op, lhs, rhs)
3820 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3821 self.check_binop_assign(expr, op, lhs, rhs)
3823 hir::ExprKind::Unary(unop, ref oprnd) => {
3824 let expected_inner = match unop {
3825 hir::UnNot | hir::UnNeg => {
3832 let needs = match unop {
3833 hir::UnDeref => needs,
3836 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3840 if !oprnd_t.references_error() {
3841 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3844 if let Some(mt) = oprnd_t.builtin_deref(true) {
3846 } else if let Some(ok) = self.try_overloaded_deref(
3847 expr.span, oprnd_t, needs) {
3848 let method = self.register_infer_ok_obligations(ok);
3849 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3850 let mutbl = match mutbl {
3851 hir::MutImmutable => AutoBorrowMutability::Immutable,
3852 hir::MutMutable => AutoBorrowMutability::Mutable {
3853 // (It shouldn't actually matter for unary ops whether
3854 // we enable two-phase borrows or not, since a unary
3855 // op has no additional operands.)
3856 allow_two_phase_borrow: AllowTwoPhase::No,
3859 self.apply_adjustments(oprnd, vec![Adjustment {
3860 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3861 target: method.sig.inputs()[0]
3864 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3865 self.write_method_call(expr.hir_id, method);
3867 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3868 "type `{}` cannot be dereferenced",
3870 oprnd_t = tcx.types.err;
3874 let result = self.check_user_unop(expr, oprnd_t, unop);
3875 // If it's builtin, we can reuse the type, this helps inference.
3876 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3881 let result = self.check_user_unop(expr, oprnd_t, unop);
3882 // If it's builtin, we can reuse the type, this helps inference.
3883 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3891 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3892 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3894 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3895 if oprnd.is_place_expr() {
3896 // Places may legitimately have unsized types.
3897 // For example, dereferences of a fat pointer and
3898 // the last field of a struct can be unsized.
3901 Expectation::rvalue_hint(self, ty)
3907 let needs = Needs::maybe_mut_place(mutbl);
3908 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3910 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3911 if tm.ty.references_error() {
3914 // Note: at this point, we cannot say what the best lifetime
3915 // is to use for resulting pointer. We want to use the
3916 // shortest lifetime possible so as to avoid spurious borrowck
3917 // errors. Moreover, the longest lifetime will depend on the
3918 // precise details of the value whose address is being taken
3919 // (and how long it is valid), which we don't know yet until type
3920 // inference is complete.
3922 // Therefore, here we simply generate a region variable. The
3923 // region inferencer will then select the ultimate value.
3924 // Finally, borrowck is charged with guaranteeing that the
3925 // value whose address was taken can actually be made to live
3926 // as long as it needs to live.
3927 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3928 tcx.mk_ref(region, tm)
3931 hir::ExprKind::Path(ref qpath) => {
3932 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3933 let ty = if def != Def::Err {
3934 self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0
3936 self.set_tainted_by_errors();
3940 // We always require that the type provided as the value for
3941 // a type parameter outlives the moment of instantiation.
3942 let substs = self.tables.borrow().node_substs(expr.hir_id);
3943 self.add_wf_bounds(substs, expr);
3947 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3948 for expr in outputs.iter().chain(inputs.iter()) {
3949 self.check_expr(expr);
3953 hir::ExprKind::Break(destination, ref expr_opt) => {
3954 if let Ok(target_id) = destination.target_id {
3956 if let Some(ref e) = *expr_opt {
3957 // If this is a break with a value, we need to type-check
3958 // the expression. Get an expected type from the loop context.
3959 let opt_coerce_to = {
3960 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3961 enclosing_breakables.find_breakable(target_id)
3964 .map(|coerce| coerce.expected_ty())
3967 // If the loop context is not a `loop { }`, then break with
3968 // a value is illegal, and `opt_coerce_to` will be `None`.
3969 // Just set expectation to error in that case.
3970 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3972 // Recurse without `enclosing_breakables` borrowed.
3973 e_ty = self.check_expr_with_hint(e, coerce_to);
3974 cause = self.misc(e.span);
3976 // Otherwise, this is a break *without* a value. That's
3977 // always legal, and is equivalent to `break ()`.
3978 e_ty = tcx.mk_unit();
3979 cause = self.misc(expr.span);
3982 // Now that we have type-checked `expr_opt`, borrow
3983 // the `enclosing_loops` field and let's coerce the
3984 // type of `expr_opt` into what is expected.
3985 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3986 let ctxt = enclosing_breakables.find_breakable(target_id);
3987 if let Some(ref mut coerce) = ctxt.coerce {
3988 if let Some(ref e) = *expr_opt {
3989 coerce.coerce(self, &cause, e, e_ty);
3991 assert!(e_ty.is_unit());
3992 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3995 // If `ctxt.coerce` is `None`, we can just ignore
3996 // the type of the expresison. This is because
3997 // either this was a break *without* a value, in
3998 // which case it is always a legal type (`()`), or
3999 // else an error would have been flagged by the
4000 // `loops` pass for using break with an expression
4001 // where you are not supposed to.
4002 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4005 ctxt.may_break = true;
4007 // the type of a `break` is always `!`, since it diverges
4010 // Otherwise, we failed to find the enclosing loop;
4011 // this can only happen if the `break` was not
4012 // inside a loop at all, which is caught by the
4013 // loop-checking pass.
4014 if self.tcx.sess.err_count() == 0 {
4015 self.tcx.sess.delay_span_bug(expr.span,
4016 "break was outside loop, but no error was emitted");
4019 // We still need to assign a type to the inner expression to
4020 // prevent the ICE in #43162.
4021 if let Some(ref e) = *expr_opt {
4022 self.check_expr_with_hint(e, tcx.types.err);
4024 // ... except when we try to 'break rust;'.
4025 // ICE this expression in particular (see #43162).
4026 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
4027 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4028 fatally_break_rust(self.tcx.sess);
4032 // There was an error, make typecheck fail
4037 hir::ExprKind::Continue(destination) => {
4038 if destination.target_id.is_ok() {
4041 // There was an error, make typecheck fail
4045 hir::ExprKind::Ret(ref expr_opt) => {
4046 if self.ret_coercion.is_none() {
4047 struct_span_err!(self.tcx.sess, expr.span, E0572,
4048 "return statement outside of function body").emit();
4049 } else if let Some(ref e) = *expr_opt {
4050 self.check_return_expr(e);
4052 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4053 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4054 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4058 hir::ExprKind::Assign(ref lhs, ref rhs) => {
4059 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4061 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4064 ExpectIfCondition => {
4065 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4066 expected error elsehwere");
4069 // Only check this if not in an `if` condition, as the
4070 // mistyped comparison help is more appropriate.
4071 if !lhs.is_place_expr() {
4072 struct_span_err!(self.tcx.sess, expr.span, E0070,
4073 "invalid left-hand side expression")
4074 .span_label(expr.span, "left-hand of expression not valid")
4080 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4082 if lhs_ty.references_error() || rhs_ty.references_error() {
4088 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4089 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4090 expr.span, expected)
4092 hir::ExprKind::While(ref cond, ref body, _) => {
4093 let ctxt = BreakableCtxt {
4094 // cannot use break with a value from a while loop
4096 may_break: false, // Will get updated if/when we find a `break`.
4099 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4100 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4101 let cond_diverging = self.diverges.get();
4102 self.check_block_no_value(&body);
4104 // We may never reach the body so it diverging means nothing.
4105 self.diverges.set(cond_diverging);
4109 // No way to know whether it's diverging because
4110 // of a `break` or an outer `break` or `return`.
4111 self.diverges.set(Diverges::Maybe);
4116 hir::ExprKind::Loop(ref body, _, source) => {
4117 let coerce = match source {
4118 // you can only use break with a value from a normal `loop { }`
4119 hir::LoopSource::Loop => {
4120 let coerce_to = expected.coercion_target_type(self, body.span);
4121 Some(CoerceMany::new(coerce_to))
4124 hir::LoopSource::WhileLet |
4125 hir::LoopSource::ForLoop => {
4130 let ctxt = BreakableCtxt {
4132 may_break: false, // Will get updated if/when we find a `break`.
4135 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4136 self.check_block_no_value(&body);
4140 // No way to know whether it's diverging because
4141 // of a `break` or an outer `break` or `return`.
4142 self.diverges.set(Diverges::Maybe);
4145 // If we permit break with a value, then result type is
4146 // the LUB of the breaks (possibly ! if none); else, it
4147 // is nil. This makes sense because infinite loops
4148 // (which would have type !) are only possible iff we
4149 // permit break with a value [1].
4150 if ctxt.coerce.is_none() && !ctxt.may_break {
4152 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4154 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4156 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4157 self.check_match(expr, &discrim, arms, expected, match_src)
4159 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4160 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4162 hir::ExprKind::Block(ref body, _) => {
4163 self.check_block_with_expected(&body, expected)
4165 hir::ExprKind::Call(ref callee, ref args) => {
4166 self.check_call(expr, &callee, args, expected)
4168 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4169 self.check_method_call(expr, segment, span, args, expected, needs)
4171 hir::ExprKind::Cast(ref e, ref t) => {
4172 // Find the type of `e`. Supply hints based on the type we are casting to,
4174 let t_cast = self.to_ty_saving_user_provided_ty(t);
4175 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4176 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4177 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4179 // Eagerly check for some obvious errors.
4180 if t_expr.references_error() || t_cast.references_error() {
4183 // Defer other checks until we're done type checking.
4184 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4185 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4187 deferred_cast_checks.push(cast_check);
4190 Err(ErrorReported) => {
4196 hir::ExprKind::Type(ref e, ref t) => {
4197 let ty = self.to_ty_saving_user_provided_ty(&t);
4198 self.check_expr_eq_type(&e, ty);
4201 hir::ExprKind::Array(ref args) => {
4202 let uty = expected.to_option(self).and_then(|uty| {
4204 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4209 let element_ty = if !args.is_empty() {
4210 let coerce_to = uty.unwrap_or_else(
4211 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4212 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4213 assert_eq!(self.diverges.get(), Diverges::Maybe);
4215 let e_ty = self.check_expr_with_hint(e, coerce_to);
4216 let cause = self.misc(e.span);
4217 coerce.coerce(self, &cause, e, e_ty);
4219 coerce.complete(self)
4221 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4223 tcx.mk_array(element_ty, args.len() as u64)
4225 hir::ExprKind::Repeat(ref element, ref count) => {
4226 let count_def_id = tcx.hir.local_def_id(count.id);
4227 let param_env = ty::ParamEnv::empty();
4228 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4229 let instance = ty::Instance::resolve(
4235 let global_id = GlobalId {
4239 let count = tcx.const_eval(param_env.and(global_id));
4241 if let Err(ref err) = count {
4242 err.report_as_error(
4243 tcx.at(tcx.def_span(count_def_id)),
4244 "could not evaluate repeat length",
4248 let uty = match expected {
4249 ExpectHasType(uty) => {
4251 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4258 let (element_ty, t) = match uty {
4260 self.check_expr_coercable_to_type(&element, uty);
4264 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4265 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4270 if let Ok(count) = count {
4271 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4273 // For [foo, ..n] where n > 1, `foo` must have
4275 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4276 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4280 if element_ty.references_error() {
4282 } else if let Ok(count) = count {
4283 tcx.mk_ty(ty::Array(t, count))
4288 hir::ExprKind::Tup(ref elts) => {
4289 let flds = expected.only_has_type(self).and_then(|ty| {
4290 let ty = self.resolve_type_vars_with_obligations(ty);
4292 ty::Tuple(ref flds) => Some(&flds[..]),
4297 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4298 let t = match flds {
4299 Some(ref fs) if i < fs.len() => {
4301 self.check_expr_coercable_to_type(&e, ety);
4305 self.check_expr_with_expectation(&e, NoExpectation)
4310 let tuple = tcx.mk_tup(elt_ts_iter);
4311 if tuple.references_error() {
4314 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4318 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4319 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4321 hir::ExprKind::Field(ref base, field) => {
4322 self.check_field(expr, needs, &base, field)
4324 hir::ExprKind::Index(ref base, ref idx) => {
4325 let base_t = self.check_expr_with_needs(&base, needs);
4326 let idx_t = self.check_expr(&idx);
4328 if base_t.references_error() {
4330 } else if idx_t.references_error() {
4333 let base_t = self.structurally_resolved_type(base.span, base_t);
4334 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4335 Some((index_ty, element_ty)) => {
4336 // two-phase not needed because index_ty is never mutable
4337 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4342 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4343 "cannot index into a value of type `{}`",
4345 // Try to give some advice about indexing tuples.
4346 if let ty::Tuple(..) = base_t.sty {
4347 let mut needs_note = true;
4348 // If the index is an integer, we can show the actual
4349 // fixed expression:
4350 if let hir::ExprKind::Lit(ref lit) = idx.node {
4351 if let ast::LitKind::Int(i,
4352 ast::LitIntType::Unsuffixed) = lit.node {
4353 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4354 if let Ok(snip) = snip {
4355 err.span_suggestion_with_applicability(
4357 "to access tuple elements, use",
4358 format!("{}.{}", snip, i),
4359 Applicability::MachineApplicable);
4365 err.help("to access tuple elements, use tuple indexing \
4366 syntax (e.g. `tuple.0`)");
4375 hir::ExprKind::Yield(ref value) => {
4376 match self.yield_ty {
4378 self.check_expr_coercable_to_type(&value, ty);
4381 struct_span_err!(self.tcx.sess, expr.span, E0627,
4382 "yield statement outside of generator literal").emit();
4390 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4391 // The newly resolved definition is written into `type_dependent_defs`.
4392 fn finish_resolving_struct_path(&self,
4395 node_id: ast::NodeId)
4399 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4400 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4401 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4404 hir::QPath::TypeRelative(ref qself, ref segment) => {
4405 let ty = self.to_ty(qself);
4407 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4412 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4415 // Write back the new resolution.
4416 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4417 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4424 // Resolve associated value path into a base type and associated constant or method definition.
4425 // The newly resolved definition is written into `type_dependent_defs`.
4426 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4427 qpath: &'b hir::QPath,
4428 node_id: ast::NodeId,
4430 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4432 let (ty, item_segment) = match *qpath {
4433 hir::QPath::Resolved(ref opt_qself, ref path) => {
4435 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4436 &path.segments[..]);
4438 hir::QPath::TypeRelative(ref qself, ref segment) => {
4439 (self.to_ty(qself), segment)
4442 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4443 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4444 // Return directly on cache hit. This is useful to avoid doubly reporting
4445 // errors with default match binding modes. See #44614.
4446 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4448 let item_name = item_segment.ident;
4449 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4452 let def = match error {
4453 method::MethodError::PrivateMatch(def, _) => def,
4456 if item_name.name != keywords::Invalid.name() {
4457 self.report_method_error(span, ty, item_name, None, error, None);
4463 // Write back the new resolution.
4464 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4465 (def, Some(ty), slice::from_ref(&**item_segment))
4468 pub fn check_decl_initializer(&self,
4469 local: &'gcx hir::Local,
4470 init: &'gcx hir::Expr) -> Ty<'tcx>
4472 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4473 // for #42640 (default match binding modes).
4476 let ref_bindings = local.pat.contains_explicit_ref_binding();
4478 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4479 if let Some(m) = ref_bindings {
4480 // Somewhat subtle: if we have a `ref` binding in the pattern,
4481 // we want to avoid introducing coercions for the RHS. This is
4482 // both because it helps preserve sanity and, in the case of
4483 // ref mut, for soundness (issue #23116). In particular, in
4484 // the latter case, we need to be clear that the type of the
4485 // referent for the reference that results is *equal to* the
4486 // type of the place it is referencing, and not some
4487 // supertype thereof.
4488 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4489 self.demand_eqtype(init.span, local_ty, init_ty);
4492 self.check_expr_coercable_to_type(init, local_ty)
4496 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4497 let t = self.local_ty(local.span, local.id).decl_ty;
4498 self.write_ty(local.hir_id, t);
4500 if let Some(ref init) = local.init {
4501 let init_ty = self.check_decl_initializer(local, &init);
4502 if init_ty.references_error() {
4503 self.write_ty(local.hir_id, init_ty);
4507 self.check_pat_walk(&local.pat, t,
4508 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4510 let pat_ty = self.node_ty(local.pat.hir_id);
4511 if pat_ty.references_error() {
4512 self.write_ty(local.hir_id, pat_ty);
4516 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4517 // Don't do all the complex logic below for DeclItem.
4519 hir::StmtKind::Decl(ref decl, _) => {
4520 if let hir::DeclKind::Item(_) = decl.node {
4524 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4527 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4529 // Hide the outer diverging and has_errors flags.
4530 let old_diverges = self.diverges.get();
4531 let old_has_errors = self.has_errors.get();
4532 self.diverges.set(Diverges::Maybe);
4533 self.has_errors.set(false);
4536 hir::StmtKind::Decl(ref decl, _) => {
4538 hir::DeclKind::Local(ref l) => {
4539 self.check_decl_local(&l);
4541 hir::DeclKind::Item(_) => {/* ignore for now */}
4544 hir::StmtKind::Expr(ref expr, _) => {
4545 // Check with expected type of ()
4546 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4548 hir::StmtKind::Semi(ref expr, _) => {
4549 self.check_expr(&expr);
4553 // Combine the diverging and has_error flags.
4554 self.diverges.set(self.diverges.get() | old_diverges);
4555 self.has_errors.set(self.has_errors.get() | old_has_errors);
4558 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4559 let unit = self.tcx.mk_unit();
4560 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4562 // if the block produces a `!` value, that can always be
4563 // (effectively) coerced to unit.
4565 self.demand_suptype(blk.span, unit, ty);
4569 fn check_block_with_expected(&self,
4570 blk: &'gcx hir::Block,
4571 expected: Expectation<'tcx>) -> Ty<'tcx> {
4573 let mut fcx_ps = self.ps.borrow_mut();
4574 let unsafety_state = fcx_ps.recurse(blk);
4575 replace(&mut *fcx_ps, unsafety_state)
4578 // In some cases, blocks have just one exit, but other blocks
4579 // can be targeted by multiple breaks. This can happen both
4580 // with labeled blocks as well as when we desugar
4581 // a `try { ... }` expression.
4585 // 'a: { if true { break 'a Err(()); } Ok(()) }
4587 // Here we would wind up with two coercions, one from
4588 // `Err(())` and the other from the tail expression
4589 // `Ok(())`. If the tail expression is omitted, that's a
4590 // "forced unit" -- unless the block diverges, in which
4591 // case we can ignore the tail expression (e.g., `'a: {
4592 // break 'a 22; }` would not force the type of the block
4594 let tail_expr = blk.expr.as_ref();
4595 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4596 let coerce = if blk.targeted_by_break {
4597 CoerceMany::new(coerce_to_ty)
4599 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4600 Some(e) => slice::from_ref(e),
4603 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4606 let prev_diverges = self.diverges.get();
4607 let ctxt = BreakableCtxt {
4608 coerce: Some(coerce),
4612 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4613 for s in &blk.stmts {
4617 // check the tail expression **without** holding the
4618 // `enclosing_breakables` lock below.
4619 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4621 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4622 let ctxt = enclosing_breakables.find_breakable(blk.id);
4623 let coerce = ctxt.coerce.as_mut().unwrap();
4624 if let Some(tail_expr_ty) = tail_expr_ty {
4625 let tail_expr = tail_expr.unwrap();
4626 let cause = self.cause(tail_expr.span,
4627 ObligationCauseCode::BlockTailExpression(blk.id));
4633 // Subtle: if there is no explicit tail expression,
4634 // that is typically equivalent to a tail expression
4635 // of `()` -- except if the block diverges. In that
4636 // case, there is no value supplied from the tail
4637 // expression (assuming there are no other breaks,
4638 // this implies that the type of the block will be
4641 // #41425 -- label the implicit `()` as being the
4642 // "found type" here, rather than the "expected type".
4644 // #44579 -- if the block was recovered during parsing,
4645 // the type would be nonsensical and it is not worth it
4646 // to perform the type check, so we avoid generating the
4647 // diagnostic output.
4648 if !self.diverges.get().always() && !blk.recovered {
4649 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4650 if let Some(expected_ty) = expected.only_has_type(self) {
4651 self.consider_hint_about_removing_semicolon(blk,
4661 // If we can break from the block, then the block's exit is always reachable
4662 // (... as long as the entry is reachable) - regardless of the tail of the block.
4663 self.diverges.set(prev_diverges);
4666 let mut ty = ctxt.coerce.unwrap().complete(self);
4668 if self.has_errors.get() || ty.references_error() {
4669 ty = self.tcx.types.err
4672 self.write_ty(blk.hir_id, ty);
4674 *self.ps.borrow_mut() = prev;
4678 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4679 /// suggestion can be made, `None` otherwise.
4680 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4681 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4682 // `while` before reaching it, as block tail returns are not available in them.
4683 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4684 let parent = self.tcx.hir.get(fn_id);
4686 if let Node::Item(&hir::Item {
4687 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4689 decl.clone().and_then(|decl| {
4690 // This is less than ideal, it will not suggest a return type span on any
4691 // method called `main`, regardless of whether it is actually the entry point,
4692 // but it will still present it as the reason for the expected type.
4693 Some((decl, name != Symbol::intern("main")))
4695 } else if let Node::TraitItem(&hir::TraitItem {
4696 node: hir::TraitItemKind::Method(hir::MethodSig {
4700 decl.clone().and_then(|decl| {
4703 } else if let Node::ImplItem(&hir::ImplItem {
4704 node: hir::ImplItemKind::Method(hir::MethodSig {
4708 decl.clone().and_then(|decl| {
4719 /// On implicit return expressions with mismatched types, provide the following suggestions:
4721 /// - Point out the method's return type as the reason for the expected type
4722 /// - Possible missing semicolon
4723 /// - Possible missing return type if the return type is the default, and not `fn main()`
4724 pub fn suggest_mismatched_types_on_tail(&self,
4725 err: &mut DiagnosticBuilder<'tcx>,
4726 expression: &'gcx hir::Expr,
4730 blk_id: ast::NodeId) {
4731 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4732 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4733 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4735 self.suggest_ref_or_into(err, expression, expected, found);
4738 pub fn suggest_ref_or_into(
4740 err: &mut DiagnosticBuilder<'tcx>,
4745 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4746 err.span_suggestion_with_applicability(
4750 Applicability::MachineApplicable,
4752 } else if !self.check_for_cast(err, expr, found, expected) {
4753 let methods = self.get_conversion_methods(expr.span, expected, found);
4754 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4755 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4756 .filter_map(|(receiver, method)| {
4757 let method_call = format!(".{}()", method.ident);
4758 if receiver.ends_with(&method_call) {
4759 None // do not suggest code that is already there (#53348)
4762 methods defined in `method_call_list` will overwrite
4763 `.clone()` in copy of `receiver`
4765 let method_call_list = [".to_vec()", ".to_string()"];
4766 if receiver.ends_with(".clone()")
4767 && method_call_list.contains(&method_call.as_str()){
4768 // created copy of `receiver` because we don't want other
4769 // suggestion to get affected
4770 let mut new_receiver = receiver.clone();
4771 let max_len = new_receiver.rfind(".").unwrap();
4772 new_receiver.truncate(max_len);
4773 Some(format!("{}{}", new_receiver, method_call))
4776 Some(format!("{}{}", receiver, method_call))
4779 }).collect::<Vec<_>>();
4780 if !suggestions.is_empty() {
4781 err.span_suggestions_with_applicability(
4783 "try using a conversion method",
4785 Applicability::MaybeIncorrect,
4792 /// A common error is to forget to add a semicolon at the end of a block:
4796 /// bar_that_returns_u32()
4800 /// This routine checks if the return expression in a block would make sense on its own as a
4801 /// statement and the return type has been left as default or has been specified as `()`. If so,
4802 /// it suggests adding a semicolon.
4803 fn suggest_missing_semicolon(&self,
4804 err: &mut DiagnosticBuilder<'tcx>,
4805 expression: &'gcx hir::Expr,
4808 if expected.is_unit() {
4809 // `BlockTailExpression` only relevant if the tail expr would be
4810 // useful on its own.
4811 match expression.node {
4812 hir::ExprKind::Call(..) |
4813 hir::ExprKind::MethodCall(..) |
4814 hir::ExprKind::If(..) |
4815 hir::ExprKind::While(..) |
4816 hir::ExprKind::Loop(..) |
4817 hir::ExprKind::Match(..) |
4818 hir::ExprKind::Block(..) => {
4819 let sp = self.tcx.sess.source_map().next_point(cause_span);
4820 err.span_suggestion_with_applicability(
4822 "try adding a semicolon",
4824 Applicability::MachineApplicable);
4831 /// A possible error is to forget to add a return type that is needed:
4835 /// bar_that_returns_u32()
4839 /// This routine checks if the return type is left as default, the method is not part of an
4840 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4842 fn suggest_missing_return_type(&self,
4843 err: &mut DiagnosticBuilder<'tcx>,
4844 fn_decl: &hir::FnDecl,
4847 can_suggest: bool) {
4848 // Only suggest changing the return type for methods that
4849 // haven't set a return type at all (and aren't `fn main()` or an impl).
4850 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4851 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4852 err.span_suggestion_with_applicability(
4854 "try adding a return type",
4855 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4856 Applicability::MachineApplicable);
4858 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4859 err.span_label(span, "possibly return type missing here?");
4861 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4862 // `fn main()` must return `()`, do not suggest changing return type
4863 err.span_label(span, "expected `()` because of default return type");
4865 // expectation was caused by something else, not the default return
4866 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4867 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4868 // Only point to return type if the expected type is the return type, as if they
4869 // are not, the expectation must have been caused by something else.
4870 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4872 let ty = AstConv::ast_ty_to_ty(self, ty);
4873 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4874 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4875 if ty.sty == expected.sty {
4876 err.span_label(sp, format!("expected `{}` because of return type",
4884 /// A common error is to add an extra semicolon:
4887 /// fn foo() -> usize {
4892 /// This routine checks if the final statement in a block is an
4893 /// expression with an explicit semicolon whose type is compatible
4894 /// with `expected_ty`. If so, it suggests removing the semicolon.
4895 fn consider_hint_about_removing_semicolon(&self,
4896 blk: &'gcx hir::Block,
4897 expected_ty: Ty<'tcx>,
4898 err: &mut DiagnosticBuilder) {
4899 // Be helpful when the user wrote `{... expr;}` and
4900 // taking the `;` off is enough to fix the error.
4901 let last_stmt = match blk.stmts.last() {
4905 let last_expr = match last_stmt.node {
4906 hir::StmtKind::Semi(ref e, _) => e,
4909 let last_expr_ty = self.node_ty(last_expr.hir_id);
4910 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4913 let original_span = original_sp(last_stmt.span, blk.span);
4914 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4915 err.span_suggestion_with_applicability(
4917 "consider removing this semicolon",
4919 Applicability::MachineApplicable);
4922 fn def_ids_for_path_segments(&self,
4923 segments: &[hir::PathSegment],
4926 // We need to extract the type parameters supplied by the user in
4927 // the path `path`. Due to the current setup, this is a bit of a
4928 // tricky-process; the problem is that resolve only tells us the
4929 // end-point of the path resolution, and not the intermediate steps.
4930 // Luckily, we can (at least for now) deduce the intermediate steps
4931 // just from the end-point.
4933 // There are basically four cases to consider:
4935 // 1. Reference to a constructor of enum variant or struct:
4937 // struct Foo<T>(...)
4938 // enum E<T> { Foo(...) }
4940 // In these cases, the parameters are declared in the type
4943 // 2. Reference to a fn item or a free constant:
4947 // In this case, the path will again always have the form
4948 // `a::b::foo::<T>` where only the final segment should have
4949 // type parameters. However, in this case, those parameters are
4950 // declared on a value, and hence are in the `FnSpace`.
4952 // 3. Reference to a method or an associated constant:
4954 // impl<A> SomeStruct<A> {
4958 // Here we can have a path like
4959 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4960 // may appear in two places. The penultimate segment,
4961 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4962 // final segment, `foo::<B>` contains parameters in fn space.
4964 // 4. Reference to a local variable
4966 // Local variables can't have any type parameters.
4968 // The first step then is to categorize the segments appropriately.
4970 assert!(!segments.is_empty());
4971 let last = segments.len() - 1;
4973 let mut path_segs = vec![];
4976 // Case 1. Reference to a struct/variant constructor.
4977 Def::StructCtor(def_id, ..) |
4978 Def::VariantCtor(def_id, ..) |
4979 Def::SelfCtor(.., def_id) => {
4980 // Everything but the final segment should have no
4981 // parameters at all.
4982 let generics = self.tcx.generics_of(def_id);
4983 // Variant and struct constructors use the
4984 // generics of their parent type definition.
4985 let generics_def_id = generics.parent.unwrap_or(def_id);
4986 path_segs.push(PathSeg(generics_def_id, last));
4989 // Case 2. Reference to a top-level value.
4991 Def::Const(def_id) |
4992 Def::Static(def_id, _) => {
4993 path_segs.push(PathSeg(def_id, last));
4996 // Case 3. Reference to a method or associated const.
4997 Def::Method(def_id) |
4998 Def::AssociatedConst(def_id) => {
4999 if segments.len() >= 2 {
5000 let generics = self.tcx.generics_of(def_id);
5001 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
5003 path_segs.push(PathSeg(def_id, last));
5006 // Case 4. Local variable, no generics.
5007 Def::Local(..) | Def::Upvar(..) => {}
5009 _ => bug!("unexpected definition: {:?}", def),
5012 debug!("path_segs = {:?}", path_segs);
5017 // Instantiates the given path, which must refer to an item with the given
5018 // number of type parameters and type.
5019 pub fn instantiate_value_path(&self,
5020 segments: &[hir::PathSegment],
5021 self_ty: Option<Ty<'tcx>>,
5024 node_id: ast::NodeId)
5025 -> (Ty<'tcx>, Def) {
5027 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5034 let path_segs = self.def_ids_for_path_segments(segments, def);
5036 let mut user_self_ty = None;
5038 Def::Method(def_id) |
5039 Def::AssociatedConst(def_id) => {
5040 let container = self.tcx.associated_item(def_id).container;
5042 ty::TraitContainer(trait_did) => {
5043 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
5045 ty::ImplContainer(impl_def_id) => {
5046 if segments.len() == 1 {
5047 // `<T>::assoc` will end up here, and so
5048 // can `T::assoc`. It this came from an
5049 // inherent impl, we need to record the
5050 // `T` for posterity (see `UserSelfTy` for
5052 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5053 user_self_ty = Some(UserSelfTy {
5064 // Now that we have categorized what space the parameters for each
5065 // segment belong to, let's sort out the parameters that the user
5066 // provided (if any) into their appropriate spaces. We'll also report
5067 // errors if type parameters are provided in an inappropriate place.
5069 let mut generic_segs = FxHashSet::default();
5070 for PathSeg(_, index) in &path_segs {
5071 generic_segs.insert(index);
5073 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
5074 if !generic_segs.contains(&index) {
5082 Def::Local(nid) | Def::Upvar(nid, ..) => {
5083 let ty = self.local_ty(span, nid).decl_ty;
5084 let ty = self.normalize_associated_types_in(span, &ty);
5085 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
5091 // Now we have to compare the types that the user *actually*
5092 // provided against the types that were *expected*. If the user
5093 // did not provide any types, then we want to substitute inference
5094 // variables. If the user provided some types, we may still need
5095 // to add defaults. If the user provided *too many* types, that's
5098 let mut infer_args_for_err = FxHashSet::default();
5099 for &PathSeg(def_id, index) in &path_segs {
5100 let seg = &segments[index];
5101 let generics = self.tcx.generics_of(def_id);
5102 // Argument-position `impl Trait` is treated as a normal generic
5103 // parameter internally, but we don't allow users to specify the
5104 // parameter's value explicitly, so we have to do some error-
5106 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5111 false, // `is_method_call`
5113 if suppress_errors {
5114 infer_args_for_err.insert(index);
5115 self.set_tainted_by_errors(); // See issue #53251.
5119 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5120 self.tcx.generics_of(*def_id).has_self
5121 }).unwrap_or(false);
5123 let mut new_def = def;
5124 let (def_id, ty) = if let Def::SelfCtor(impl_def_id) = def {
5125 let ty = self.impl_self_ty(span, impl_def_id).ty;
5127 match ty.ty_adt_def() {
5128 Some(adt_def) if adt_def.is_struct() => {
5129 let variant = adt_def.non_enum_variant();
5130 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5131 (variant.did, self.tcx.type_of(variant.did))
5134 (impl_def_id, self.tcx.types.err)
5138 let def_id = def.def_id();
5140 // The things we are substituting into the type should not contain
5141 // escaping late-bound regions, and nor should the base type scheme.
5142 let ty = self.tcx.type_of(def_id);
5146 let substs = AstConv::create_substs_for_generic_args(
5152 // Provide the generic args, and whether types should be inferred.
5154 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5157 // If we've encountered an `impl Trait`-related error, we're just
5158 // going to infer the arguments for better error messages.
5159 if !infer_args_for_err.contains(&index) {
5160 // Check whether the user has provided generic arguments.
5161 if let Some(ref data) = segments[index].args {
5162 return (Some(data), segments[index].infer_types);
5165 return (None, segments[index].infer_types);
5170 // Provide substitutions for parameters for which (valid) arguments have been provided.
5172 match (¶m.kind, arg) {
5173 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5174 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5176 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5177 self.to_ty(ty).into()
5179 _ => unreachable!(),
5182 // Provide substitutions for parameters for which arguments are inferred.
5183 |substs, param, infer_types| {
5185 GenericParamDefKind::Lifetime => {
5186 self.re_infer(span, Some(param)).unwrap().into()
5188 GenericParamDefKind::Type { has_default, .. } => {
5189 if !infer_types && has_default {
5190 // If we have a default, then we it doesn't matter that we're not
5191 // inferring the type arguments: we provide the default where any
5193 let default = self.tcx.type_of(param.def_id);
5196 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5199 // If no type arguments were provided, we have to infer them.
5200 // This case also occurs as a result of some malformed input, e.g.
5201 // a lifetime argument being given instead of a type parameter.
5202 // Using inference instead of `Error` gives better error messages.
5203 self.var_for_def(span, param)
5209 assert!(!substs.has_escaping_regions());
5210 assert!(!ty.has_escaping_regions());
5212 // Write the "user substs" down first thing for later.
5213 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
5214 self.write_user_substs_from_substs(hir_id, substs, user_self_ty);
5216 // Add all the obligations that are required, substituting and
5217 // normalized appropriately.
5218 let bounds = self.instantiate_bounds(span, def_id, &substs);
5219 self.add_obligations_for_parameters(
5220 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5223 // Substitute the values for the type parameters into the type of
5224 // the referenced item.
5225 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5227 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5228 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5229 // is inherent, there is no `Self` parameter, instead, the impl needs
5230 // type parameters, which we can infer by unifying the provided `Self`
5231 // with the substituted impl type.
5232 let ty = self.tcx.type_of(impl_def_id);
5234 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5235 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5236 Ok(ok) => self.register_infer_ok_obligations(ok),
5239 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5246 self.check_rustc_args_require_const(def_id, node_id, span);
5248 debug!("instantiate_value_path: type of {:?} is {:?}",
5251 self.write_substs(hir_id, substs);
5253 (ty_substituted, new_def)
5256 fn check_rustc_args_require_const(&self,
5258 node_id: ast::NodeId,
5260 // We're only interested in functions tagged with
5261 // #[rustc_args_required_const], so ignore anything that's not.
5262 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5266 // If our calling expression is indeed the function itself, we're good!
5267 // If not, generate an error that this can only be called directly.
5268 if let Node::Expr(expr) = self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5269 if let hir::ExprKind::Call(ref callee, ..) = expr.node {
5270 if callee.id == node_id {
5276 self.tcx.sess.span_err(span, "this function can only be invoked \
5277 directly, not through a function pointer");
5280 // Resolves `typ` by a single level if `typ` is a type variable.
5281 // If no resolution is possible, then an error is reported.
5282 // Numeric inference variables may be left unresolved.
5283 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5284 let ty = self.resolve_type_vars_with_obligations(ty);
5285 if !ty.is_ty_var() {
5288 if !self.is_tainted_by_errors() {
5289 self.need_type_info_err((**self).body_id, sp, ty)
5290 .note("type must be known at this point")
5293 self.demand_suptype(sp, self.tcx.types.err, ty);
5298 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5299 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5300 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5303 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5304 index = enclosing_breakables.stack.len();
5305 enclosing_breakables.by_id.insert(id, index);
5306 enclosing_breakables.stack.push(ctxt);
5310 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5311 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5312 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5313 enclosing_breakables.stack.pop().expect("missing breakable context")
5319 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5320 generics: &ty::Generics,
5322 let own_counts = generics.own_counts();
5323 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5325 if own_counts.types == 0 {
5328 // Make a vector of booleans initially false, set to true when used.
5329 let mut types_used = vec![false; own_counts.types];
5331 for leaf_ty in ty.walk() {
5332 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5333 debug!("Found use of ty param num {}", idx);
5334 types_used[idx as usize - own_counts.lifetimes] = true;
5335 } else if let ty::Error = leaf_ty.sty {
5336 // If there is already another error, do not emit
5337 // an error for not using a type Parameter.
5338 assert!(tcx.sess.err_count() > 0);
5343 let types = generics.params.iter().filter(|param| match param.kind {
5344 ty::GenericParamDefKind::Type { .. } => true,
5347 for (&used, param) in types_used.iter().zip(types) {
5349 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5350 let span = tcx.hir.span(id);
5351 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5352 .span_label(span, "unused type parameter")
5358 fn fatally_break_rust(sess: &Session) {
5359 let handler = sess.diagnostic();
5360 handler.span_bug_no_panic(
5362 "It looks like you're trying to break rust; would you like some ICE?",
5364 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5365 handler.note_without_error(
5366 "we would appreciate a joke overview: \
5367 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5369 handler.note_without_error(&format!("rustc {} running on {}",
5370 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5371 ::session::config::host_triple(),
5375 fn potentially_plural_count(count: usize, word: &str) -> String {
5376 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })