1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 n.b.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
92 use namespace::Namespace;
93 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
94 use rustc::infer::anon_types::AnonTypeDecl;
95 use rustc::infer::type_variable::{TypeVariableOrigin};
96 use rustc::middle::region;
97 use rustc::mir::interpret::{GlobalId};
98 use rustc::ty::subst::{UnpackedKind, Subst, Substs};
99 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
100 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
101 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
102 use rustc::ty::fold::TypeFoldable;
103 use rustc::ty::query::Providers;
104 use rustc::ty::util::{Representability, IntTypeExt, Discr};
105 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
107 use require_c_abi_if_variadic;
108 use session::{CompileIncomplete, config, Session};
111 use util::common::{ErrorReported, indenter};
112 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
114 use std::cell::{Cell, RefCell, Ref, RefMut};
115 use rustc_data_structures::sync::Lrc;
116 use std::collections::hash_map::Entry;
118 use std::fmt::Display;
120 use std::mem::replace;
121 use std::ops::{self, Deref};
122 use rustc_target::spec::abi::Abi;
125 use syntax::source_map::original_sp;
126 use syntax::feature_gate::{GateIssue, emit_feature_err};
128 use syntax::symbol::{Symbol, LocalInternedString, keywords};
129 use syntax::util::lev_distance::find_best_match_for_name;
130 use syntax_pos::{self, BytePos, Span, MultiSpan};
132 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
133 use rustc::hir::itemlikevisit::ItemLikeVisitor;
134 use rustc::hir::map::Node;
135 use rustc::hir::{self, PatKind, ItemKind};
136 use rustc::middle::lang_items;
152 mod generator_interior;
156 /// A wrapper for InferCtxt's `in_progress_tables` field.
157 #[derive(Copy, Clone)]
158 struct MaybeInProgressTables<'a, 'tcx: 'a> {
159 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
162 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
163 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
164 match self.maybe_tables {
165 Some(tables) => tables.borrow(),
167 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
172 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
173 match self.maybe_tables {
174 Some(tables) => tables.borrow_mut(),
176 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
183 /// closures defined within the function. For example:
186 /// bar(move|| { ... })
189 /// Here, the function `foo()` and the closure passed to
190 /// `bar()` will each have their own `FnCtxt`, but they will
191 /// share the inherited fields.
192 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
193 infcx: InferCtxt<'a, 'gcx, 'tcx>,
195 tables: MaybeInProgressTables<'a, 'tcx>,
197 locals: RefCell<NodeMap<Ty<'tcx>>>,
199 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
201 // When we process a call like `c()` where `c` is a closure type,
202 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
203 // `FnOnce` closure. In that case, we defer full resolution of the
204 // call until upvar inference can kick in and make the
205 // decision. We keep these deferred resolutions grouped by the
206 // def-id of the closure, so that once we decide, we can easily go
207 // back and process them.
208 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
210 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
212 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
214 // Anonymized types found in explicit return types and their
215 // associated fresh inference variable. Writeback resolves these
216 // variables to get the concrete type, which can be used to
217 // deanonymize Anon, after typeck is done with all functions.
218 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
220 /// Each type parameter has an implicit region bound that
221 /// indicates it must outlive at least the function body (the user
222 /// may specify stronger requirements). This field indicates the
223 /// region of the callee. If it is `None`, then the parameter
224 /// environment is for an item or something where the "callee" is
226 implicit_region_bound: Option<ty::Region<'tcx>>,
228 body_id: Option<hir::BodyId>,
231 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
232 type Target = InferCtxt<'a, 'gcx, 'tcx>;
233 fn deref(&self) -> &Self::Target {
238 /// When type-checking an expression, we propagate downward
239 /// whatever type hint we are able in the form of an `Expectation`.
240 #[derive(Copy, Clone, Debug)]
241 pub enum Expectation<'tcx> {
242 /// We know nothing about what type this expression should have.
245 /// This expression is an `if` condition, it must resolve to `bool`.
248 /// This expression should have the type given (or some subtype)
249 ExpectHasType(Ty<'tcx>),
251 /// This expression will be cast to the `Ty`
252 ExpectCastableToType(Ty<'tcx>),
254 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
255 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
256 ExpectRvalueLikeUnsized(Ty<'tcx>),
259 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
260 // Disregard "castable to" expectations because they
261 // can lead us astray. Consider for example `if cond
262 // {22} else {c} as u8` -- if we propagate the
263 // "castable to u8" constraint to 22, it will pick the
264 // type 22u8, which is overly constrained (c might not
265 // be a u8). In effect, the problem is that the
266 // "castable to" expectation is not the tightest thing
267 // we can say, so we want to drop it in this case.
268 // The tightest thing we can say is "must unify with
269 // else branch". Note that in the case of a "has type"
270 // constraint, this limitation does not hold.
272 // If the expected type is just a type variable, then don't use
273 // an expected type. Otherwise, we might write parts of the type
274 // when checking the 'then' block which are incompatible with the
276 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
278 ExpectHasType(ety) => {
279 let ety = fcx.shallow_resolve(ety);
280 if !ety.is_ty_var() {
286 ExpectRvalueLikeUnsized(ety) => {
287 ExpectRvalueLikeUnsized(ety)
293 /// Provide an expectation for an rvalue expression given an *optional*
294 /// hint, which is not required for type safety (the resulting type might
295 /// be checked higher up, as is the case with `&expr` and `box expr`), but
296 /// is useful in determining the concrete type.
298 /// The primary use case is where the expected type is a fat pointer,
299 /// like `&[isize]`. For example, consider the following statement:
301 /// let x: &[isize] = &[1, 2, 3];
303 /// In this case, the expected type for the `&[1, 2, 3]` expression is
304 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
305 /// expectation `ExpectHasType([isize])`, that would be too strong --
306 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
307 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
308 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
309 /// which still is useful, because it informs integer literals and the like.
310 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
311 /// for examples of where this comes up,.
312 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
313 match fcx.tcx.struct_tail(ty).sty {
314 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
315 ExpectRvalueLikeUnsized(ty)
317 _ => ExpectHasType(ty)
321 // Resolves `expected` by a single level if it is a variable. If
322 // there is no expected type or resolution is not possible (e.g.,
323 // no constraints yet present), just returns `None`.
324 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
326 NoExpectation => NoExpectation,
327 ExpectIfCondition => ExpectIfCondition,
328 ExpectCastableToType(t) => {
329 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
331 ExpectHasType(t) => {
332 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
334 ExpectRvalueLikeUnsized(t) => {
335 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
340 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
341 match self.resolve(fcx) {
342 NoExpectation => None,
343 ExpectIfCondition => Some(fcx.tcx.types.bool),
344 ExpectCastableToType(ty) |
346 ExpectRvalueLikeUnsized(ty) => Some(ty),
350 /// It sometimes happens that we want to turn an expectation into
351 /// a **hard constraint** (i.e., something that must be satisfied
352 /// for the program to type-check). `only_has_type` will return
353 /// such a constraint, if it exists.
354 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
355 match self.resolve(fcx) {
356 ExpectHasType(ty) => Some(ty),
357 ExpectIfCondition => Some(fcx.tcx.types.bool),
358 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
362 /// Like `only_has_type`, but instead of returning `None` if no
363 /// hard constraint exists, creates a fresh type variable.
364 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
365 self.only_has_type(fcx)
366 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
370 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
377 fn maybe_mut_place(m: hir::Mutability) -> Self {
379 hir::MutMutable => Needs::MutPlace,
380 hir::MutImmutable => Needs::None,
385 #[derive(Copy, Clone)]
386 pub struct UnsafetyState {
387 pub def: ast::NodeId,
388 pub unsafety: hir::Unsafety,
389 pub unsafe_push_count: u32,
394 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
395 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
398 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
399 match self.unsafety {
400 // If this unsafe, then if the outer function was already marked as
401 // unsafe we shouldn't attribute the unsafe'ness to the block. This
402 // way the block can be warned about instead of ignoring this
403 // extraneous block (functions are never warned about).
404 hir::Unsafety::Unsafe if self.from_fn => *self,
407 let (unsafety, def, count) = match blk.rules {
408 hir::PushUnsafeBlock(..) =>
409 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
410 hir::PopUnsafeBlock(..) =>
411 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
412 hir::UnsafeBlock(..) =>
413 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
415 (unsafety, self.def, self.unsafe_push_count),
419 unsafe_push_count: count,
426 #[derive(Debug, Copy, Clone)]
432 /// Tracks whether executing a node may exit normally (versus
433 /// return/break/panic, which "diverge", leaving dead code in their
434 /// wake). Tracked semi-automatically (through type variables marked
435 /// as diverging), with some manual adjustments for control-flow
436 /// primitives (approximating a CFG).
437 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
439 /// Potentially unknown, some cases converge,
440 /// others require a CFG to determine them.
443 /// Definitely known to diverge and therefore
444 /// not reach the next sibling or its parent.
447 /// Same as `Always` but with a reachability
448 /// warning already emitted
452 // Convenience impls for combinig `Diverges`.
454 impl ops::BitAnd for Diverges {
456 fn bitand(self, other: Self) -> Self {
457 cmp::min(self, other)
461 impl ops::BitOr for Diverges {
463 fn bitor(self, other: Self) -> Self {
464 cmp::max(self, other)
468 impl ops::BitAndAssign for Diverges {
469 fn bitand_assign(&mut self, other: Self) {
470 *self = *self & other;
474 impl ops::BitOrAssign for Diverges {
475 fn bitor_assign(&mut self, other: Self) {
476 *self = *self | other;
481 fn always(self) -> bool {
482 self >= Diverges::Always
486 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
489 // this is `null` for loops where break with a value is illegal,
490 // such as `while`, `for`, and `while let`
491 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
494 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
495 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
496 by_id: NodeMap<usize>,
499 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
500 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
501 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
502 bug!("could not find enclosing breakable with id {}", target_id);
509 struct PathSeg(DefId, usize);
511 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
512 body_id: ast::NodeId,
514 /// The parameter environment used for proving trait obligations
515 /// in this function. This can change when we descend into
516 /// closures (as they bring new things into scope), hence it is
517 /// not part of `Inherited` (as of the time of this writing,
518 /// closures do not yet change the environment, but they will
520 param_env: ty::ParamEnv<'tcx>,
522 // Number of errors that had been reported when we started
523 // checking this function. On exit, if we find that *more* errors
524 // have been reported, we will skip regionck and other work that
525 // expects the types within the function to be consistent.
526 err_count_on_creation: usize,
528 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
530 yield_ty: Option<Ty<'tcx>>,
532 ps: RefCell<UnsafetyState>,
534 /// Whether the last checked node generates a divergence (e.g.,
535 /// `return` will set this to Always). In general, when entering
536 /// an expression or other node in the tree, the initial value
537 /// indicates whether prior parts of the containing expression may
538 /// have diverged. It is then typically set to `Maybe` (and the
539 /// old value remembered) for processing the subparts of the
540 /// current expression. As each subpart is processed, they may set
541 /// the flag to `Always` etc. Finally, at the end, we take the
542 /// result and "union" it with the original value, so that when we
543 /// return the flag indicates if any subpart of the the parent
544 /// expression (up to and including this part) has diverged. So,
545 /// if you read it after evaluating a subexpression `X`, the value
546 /// you get indicates whether any subexpression that was
547 /// evaluating up to and including `X` diverged.
549 /// We currently use this flag only for diagnostic purposes:
551 /// - To warn about unreachable code: if, after processing a
552 /// sub-expression but before we have applied the effects of the
553 /// current node, we see that the flag is set to `Always`, we
554 /// can issue a warning. This corresponds to something like
555 /// `foo(return)`; we warn on the `foo()` expression. (We then
556 /// update the flag to `WarnedAlways` to suppress duplicate
557 /// reports.) Similarly, if we traverse to a fresh statement (or
558 /// tail expression) from a `Always` setting, we will issue a
559 /// warning. This corresponds to something like `{return;
560 /// foo();}` or `{return; 22}`, where we would warn on the
563 /// An expression represents dead-code if, after checking it,
564 /// the diverges flag is set to something other than `Maybe`.
565 diverges: Cell<Diverges>,
567 /// Whether any child nodes have any type errors.
568 has_errors: Cell<bool>,
570 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
572 inh: &'a Inherited<'a, 'gcx, 'tcx>,
575 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
576 type Target = Inherited<'a, 'gcx, 'tcx>;
577 fn deref(&self) -> &Self::Target {
582 /// Helper type of a temporary returned by Inherited::build(...).
583 /// Necessary because we can't write the following bound:
584 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
585 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
586 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
590 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
591 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
592 -> InheritedBuilder<'a, 'gcx, 'tcx> {
593 let hir_id_root = if def_id.is_local() {
594 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
595 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
596 DefId::local(hir_id.owner)
602 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
608 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
609 fn enter<F, R>(&'tcx mut self, f: F) -> R
610 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
612 let def_id = self.def_id;
613 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
617 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
618 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
620 let item_id = tcx.hir.as_local_node_id(def_id);
621 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
622 let implicit_region_bound = body_id.map(|body_id| {
623 let body = tcx.hir.body(body_id);
624 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
628 tables: MaybeInProgressTables {
629 maybe_tables: infcx.in_progress_tables,
632 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
633 locals: RefCell::new(NodeMap()),
634 deferred_call_resolutions: RefCell::new(DefIdMap()),
635 deferred_cast_checks: RefCell::new(Vec::new()),
636 deferred_generator_interiors: RefCell::new(Vec::new()),
637 anon_types: RefCell::new(DefIdMap()),
638 implicit_region_bound,
643 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
644 debug!("register_predicate({:?})", obligation);
645 if obligation.has_escaping_regions() {
646 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
651 .register_predicate_obligation(self, obligation);
654 fn register_predicates<I>(&self, obligations: I)
655 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
656 for obligation in obligations {
657 self.register_predicate(obligation);
661 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
662 self.register_predicates(infer_ok.obligations);
666 fn normalize_associated_types_in<T>(&self,
668 body_id: ast::NodeId,
669 param_env: ty::ParamEnv<'tcx>,
671 where T : TypeFoldable<'tcx>
673 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
674 self.register_infer_ok_obligations(ok)
678 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
680 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
681 fn visit_item(&mut self, i: &'tcx hir::Item) {
682 check_item_type(self.tcx, i);
684 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
685 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
688 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
689 tcx.sess.track_errors(|| {
690 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
691 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
695 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
696 tcx.sess.track_errors(|| {
697 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
701 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
702 tcx.typeck_item_bodies(LOCAL_CRATE)
705 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
706 -> Result<(), CompileIncomplete>
708 debug_assert!(crate_num == LOCAL_CRATE);
709 Ok(tcx.sess.track_errors(|| {
710 tcx.par_body_owners(|body_owner_def_id| {
711 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
716 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
717 wfcheck::check_item_well_formed(tcx, def_id);
720 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
721 wfcheck::check_trait_item(tcx, def_id);
724 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
725 wfcheck::check_impl_item(tcx, def_id);
728 pub fn provide(providers: &mut Providers) {
729 method::provide(providers);
730 *providers = Providers {
736 check_item_well_formed,
737 check_trait_item_well_formed,
738 check_impl_item_well_formed,
743 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
745 -> Option<ty::Destructor> {
746 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
749 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
750 /// with information about it's body-id and fn-decl (if any). Otherwise,
753 /// If this function returns "some", then `typeck_tables(def_id)` will
754 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
755 /// may not succeed. In some cases where this function returns `None`
756 /// (notably closures), `typeck_tables(def_id)` would wind up
757 /// redirecting to the owning function.
758 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
760 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
762 match tcx.hir.get(id) {
763 hir::map::NodeItem(item) => {
765 hir::ItemKind::Const(_, body) |
766 hir::ItemKind::Static(_, _, body) =>
768 hir::ItemKind::Fn(ref decl, .., body) =>
769 Some((body, Some(decl))),
774 hir::map::NodeTraitItem(item) => {
776 hir::TraitItemKind::Const(_, Some(body)) =>
778 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
779 Some((body, Some(&sig.decl))),
784 hir::map::NodeImplItem(item) => {
786 hir::ImplItemKind::Const(_, body) =>
788 hir::ImplItemKind::Method(ref sig, body) =>
789 Some((body, Some(&sig.decl))),
794 hir::map::NodeAnonConst(constant) => Some((constant.body, None)),
799 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
802 // Closures' tables come from their outermost function,
803 // as they are part of the same "inference environment".
804 let outer_def_id = tcx.closure_base_def_id(def_id);
805 if outer_def_id != def_id {
806 return tcx.has_typeck_tables(outer_def_id);
809 let id = tcx.hir.as_local_node_id(def_id).unwrap();
810 primary_body_of(tcx, id).is_some()
813 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
816 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
819 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
821 -> &'tcx ty::TypeckTables<'tcx> {
822 // Closures' tables come from their outermost function,
823 // as they are part of the same "inference environment".
824 let outer_def_id = tcx.closure_base_def_id(def_id);
825 if outer_def_id != def_id {
826 return tcx.typeck_tables_of(outer_def_id);
829 let id = tcx.hir.as_local_node_id(def_id).unwrap();
830 let span = tcx.hir.span(id);
832 // Figure out what primary body this item has.
833 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
834 span_bug!(span, "can't type-check body of {:?}", def_id);
836 let body = tcx.hir.body(body_id);
838 let tables = Inherited::build(tcx, def_id).enter(|inh| {
839 let param_env = tcx.param_env(def_id);
840 let fcx = if let Some(decl) = fn_decl {
841 let fn_sig = tcx.fn_sig(def_id);
843 check_abi(tcx, span, fn_sig.abi());
845 // Compute the fty from point of view of inside fn.
847 tcx.liberate_late_bound_regions(def_id, &fn_sig);
849 inh.normalize_associated_types_in(body.value.span,
854 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
857 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
858 let expected_type = tcx.type_of(def_id);
859 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
860 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
862 // Gather locals in statics (because of block expressions).
863 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
865 fcx.check_expr_coercable_to_type(&body.value, expected_type);
870 // All type checking constraints were added, try to fallback unsolved variables.
871 fcx.select_obligations_where_possible(false);
872 let mut fallback_has_occurred = false;
873 for ty in &fcx.unsolved_variables() {
874 fallback_has_occurred |= fcx.fallback_if_possible(ty);
876 fcx.select_obligations_where_possible(fallback_has_occurred);
878 // Even though coercion casts provide type hints, we check casts after fallback for
879 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
882 // Closure and generator analysis may run after fallback
883 // because they don't constrain other type variables.
884 fcx.closure_analyze(body);
885 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
886 fcx.resolve_generator_interiors(def_id);
887 fcx.select_all_obligations_or_error();
889 if fn_decl.is_some() {
890 fcx.regionck_fn(id, body);
892 fcx.regionck_expr(body);
895 fcx.resolve_type_vars_in_body(body)
898 // Consistency check our TypeckTables instance can hold all ItemLocalIds
899 // it will need to hold.
900 assert_eq!(tables.local_id_root,
901 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
905 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
906 if !tcx.sess.target.target.is_abi_supported(abi) {
907 struct_span_err!(tcx.sess, span, E0570,
908 "The ABI `{}` is not supported for the current target", abi).emit()
912 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
913 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
916 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
917 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
920 // infer the variable's type
921 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
922 self.fcx.locals.borrow_mut().insert(nid, var_ty);
926 // take type that the user specified
927 self.fcx.locals.borrow_mut().insert(nid, typ);
934 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
935 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
936 NestedVisitorMap::None
939 // Add explicitly-declared locals.
940 fn visit_local(&mut self, local: &'gcx hir::Local) {
941 let o_ty = match local.ty {
943 let o_ty = self.fcx.to_ty(&ty);
945 let c_ty = self.fcx.inh.infcx.canonicalize_response(&o_ty);
946 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
947 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
953 self.assign(local.span, local.id, o_ty);
955 debug!("Local variable {:?} is assigned type {}",
957 self.fcx.ty_to_string(
958 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
959 intravisit::walk_local(self, local);
962 // Add pattern bindings.
963 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
964 if let PatKind::Binding(_, _, ident, _) = p.node {
965 let var_ty = self.assign(p.span, p.id, None);
967 if !self.fcx.tcx.features().unsized_locals {
968 self.fcx.require_type_is_sized(var_ty, p.span,
969 traits::VariableType(p.id));
972 debug!("Pattern binding {} is assigned to {} with type {:?}",
974 self.fcx.ty_to_string(
975 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
978 intravisit::walk_pat(self, p);
981 // Don't descend into the bodies of nested closures
982 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
983 _: hir::BodyId, _: Span, _: ast::NodeId) { }
986 /// When `check_fn` is invoked on a generator (i.e., a body that
987 /// includes yield), it returns back some information about the yield
989 struct GeneratorTypes<'tcx> {
990 /// Type of value that is yielded.
991 yield_ty: ty::Ty<'tcx>,
993 /// Types that are captured (see `GeneratorInterior` for more).
994 interior: ty::Ty<'tcx>,
996 /// Indicates if the generator is movable or static (immovable)
997 movability: hir::GeneratorMovability,
1000 /// Helper used for fns and closures. Does the grungy work of checking a function
1001 /// body and returns the function context used for that purpose, since in the case of a fn item
1002 /// there is still a bit more to do.
1005 /// * inherited: other fields inherited from the enclosing fn (if any)
1006 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1007 param_env: ty::ParamEnv<'tcx>,
1008 fn_sig: ty::FnSig<'tcx>,
1009 decl: &'gcx hir::FnDecl,
1011 body: &'gcx hir::Body,
1012 can_be_generator: Option<hir::GeneratorMovability>)
1013 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1015 let mut fn_sig = fn_sig.clone();
1017 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1019 // Create the function context. This is either derived from scratch or,
1020 // in the case of closures, based on the outer context.
1021 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1022 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1024 let declared_ret_ty = fn_sig.output();
1025 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1026 let revealed_ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &declared_ret_ty);
1027 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1028 fn_sig = fcx.tcx.mk_fn_sig(
1029 fn_sig.inputs().iter().cloned(),
1036 let span = body.value.span;
1038 if body.is_generator && can_be_generator.is_some() {
1039 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1040 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1041 fcx.yield_ty = Some(yield_ty);
1044 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1046 // Add formal parameters.
1047 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1048 // Check the pattern.
1049 fcx.check_pat_walk(&arg.pat, arg_ty,
1050 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1052 // Check that argument is Sized.
1053 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1054 // for simple cases like `fn foo(x: Trait)`,
1055 // where we would error once on the parameter as a whole, and once on the binding `x`.
1056 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1057 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1060 fcx.write_ty(arg.hir_id, arg_ty);
1063 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1064 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1066 fcx.check_return_expr(&body.value);
1068 // We insert the deferred_generator_interiors entry after visiting the body.
1069 // This ensures that all nested generators appear before the entry of this generator.
1070 // resolve_generator_interiors relies on this property.
1071 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1072 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1073 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1074 Some(GeneratorTypes {
1075 yield_ty: fcx.yield_ty.unwrap(),
1077 movability: can_be_generator.unwrap(),
1083 // Finalize the return check by taking the LUB of the return types
1084 // we saw and assigning it to the expected return type. This isn't
1085 // really expected to fail, since the coercions would have failed
1086 // earlier when trying to find a LUB.
1088 // However, the behavior around `!` is sort of complex. In the
1089 // event that the `actual_return_ty` comes back as `!`, that
1090 // indicates that the fn either does not return or "returns" only
1091 // values of type `!`. In this case, if there is an expected
1092 // return type that is *not* `!`, that should be ok. But if the
1093 // return type is being inferred, we want to "fallback" to `!`:
1095 // let x = move || panic!();
1097 // To allow for that, I am creating a type variable with diverging
1098 // fallback. This was deemed ever so slightly better than unifying
1099 // the return value with `!` because it allows for the caller to
1100 // make more assumptions about the return type (e.g., they could do
1102 // let y: Option<u32> = Some(x());
1104 // which would then cause this return type to become `u32`, not
1106 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1107 let mut actual_return_ty = coercion.complete(&fcx);
1108 if actual_return_ty.is_never() {
1109 actual_return_ty = fcx.next_diverging_ty_var(
1110 TypeVariableOrigin::DivergingFn(span));
1112 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1114 // Check that the main return type implements the termination trait.
1115 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1116 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1119 config::EntryFnType::Main => {
1120 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1121 let trait_ref = ty::TraitRef::new(term_id, substs);
1122 let return_ty_span = decl.output.span();
1123 let cause = traits::ObligationCause::new(
1124 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1126 inherited.register_predicate(
1127 traits::Obligation::new(
1128 cause, param_env, trait_ref.to_predicate()));
1130 config::EntryFnType::Start => {},
1136 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1137 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1138 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1139 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1140 if declared_ret_ty.sty != ty::Never {
1141 fcx.tcx.sess.span_err(
1143 "return type should be `!`",
1147 let inputs = fn_sig.inputs();
1148 let span = fcx.tcx.hir.span(fn_id);
1149 if inputs.len() == 1 {
1150 let arg_is_panic_info = match inputs[0].sty {
1151 ty::Ref(region, ty, mutbl) => match ty.sty {
1152 ty::Adt(ref adt, _) => {
1153 adt.did == panic_info_did &&
1154 mutbl == hir::Mutability::MutImmutable &&
1155 *region != RegionKind::ReStatic
1162 if !arg_is_panic_info {
1163 fcx.tcx.sess.span_err(
1164 decl.inputs[0].span,
1165 "argument should be `&PanicInfo`",
1169 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1170 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1171 if !generics.params.is_empty() {
1172 fcx.tcx.sess.span_err(
1174 "`#[panic_implementation]` function should have no type \
1181 fcx.tcx.sess.span_err(span, "function should have one argument");
1184 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1189 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1190 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1191 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1192 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1193 if declared_ret_ty.sty != ty::Never {
1194 fcx.tcx.sess.span_err(
1196 "return type should be `!`",
1200 let inputs = fn_sig.inputs();
1201 let span = fcx.tcx.hir.span(fn_id);
1202 if inputs.len() == 1 {
1203 let arg_is_alloc_layout = match inputs[0].sty {
1204 ty::Adt(ref adt, _) => {
1205 adt.did == alloc_layout_did
1210 if !arg_is_alloc_layout {
1211 fcx.tcx.sess.span_err(
1212 decl.inputs[0].span,
1213 "argument should be `Layout`",
1217 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1218 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1219 if !generics.params.is_empty() {
1220 fcx.tcx.sess.span_err(
1222 "`#[alloc_error_handler]` function should have no type \
1229 fcx.tcx.sess.span_err(span, "function should have one argument");
1232 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1240 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1243 let def_id = tcx.hir.local_def_id(id);
1244 let def = tcx.adt_def(def_id);
1245 def.destructor(tcx); // force the destructor to be evaluated
1246 check_representable(tcx, span, def_id);
1248 if def.repr.simd() {
1249 check_simd(tcx, span, def_id);
1252 check_transparent(tcx, span, def_id);
1253 check_packed(tcx, span, def_id);
1256 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1259 let def_id = tcx.hir.local_def_id(id);
1260 let def = tcx.adt_def(def_id);
1261 def.destructor(tcx); // force the destructor to be evaluated
1262 check_representable(tcx, span, def_id);
1264 check_packed(tcx, span, def_id);
1267 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1268 debug!("check_item_type(it.id={}, it.name={})",
1270 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1271 let _indenter = indenter();
1273 // Consts can play a role in type-checking, so they are included here.
1274 hir::ItemKind::Static(..) => {
1275 let def_id = tcx.hir.local_def_id(it.id);
1276 tcx.typeck_tables_of(def_id);
1277 maybe_check_static_with_link_section(tcx, def_id, it.span);
1279 hir::ItemKind::Const(..) => {
1280 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1282 hir::ItemKind::Enum(ref enum_definition, _) => {
1285 &enum_definition.variants,
1288 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1289 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1290 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1291 let impl_def_id = tcx.hir.local_def_id(it.id);
1292 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1293 check_impl_items_against_trait(tcx,
1298 let trait_def_id = impl_trait_ref.def_id;
1299 check_on_unimplemented(tcx, trait_def_id, it);
1302 hir::ItemKind::Trait(..) => {
1303 let def_id = tcx.hir.local_def_id(it.id);
1304 check_on_unimplemented(tcx, def_id, it);
1306 hir::ItemKind::Struct(..) => {
1307 check_struct(tcx, it.id, it.span);
1309 hir::ItemKind::Union(..) => {
1310 check_union(tcx, it.id, it.span);
1312 hir::ItemKind::Existential(..) |
1313 hir::ItemKind::Ty(..) => {
1314 let def_id = tcx.hir.local_def_id(it.id);
1315 let pty_ty = tcx.type_of(def_id);
1316 let generics = tcx.generics_of(def_id);
1317 check_bounds_are_used(tcx, &generics, pty_ty);
1319 hir::ItemKind::ForeignMod(ref m) => {
1320 check_abi(tcx, it.span, m.abi);
1322 if m.abi == Abi::RustIntrinsic {
1323 for item in &m.items {
1324 intrinsic::check_intrinsic_type(tcx, item);
1326 } else if m.abi == Abi::PlatformIntrinsic {
1327 for item in &m.items {
1328 intrinsic::check_platform_intrinsic_type(tcx, item);
1331 for item in &m.items {
1332 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1333 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1334 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1335 "foreign items may not have type parameters");
1336 err.span_label(item.span, "can't have type parameters");
1337 // FIXME: once we start storing spans for type arguments, turn this into a
1339 err.help("use specialization instead of type parameters by replacing them \
1340 with concrete types like `u32`");
1344 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1345 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1350 _ => {/* nothing to do */ }
1354 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1355 // Only restricted on wasm32 target for now
1356 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1360 // If `#[link_section]` is missing, then nothing to verify
1361 let attrs = tcx.codegen_fn_attrs(id);
1362 if attrs.link_section.is_none() {
1366 // For the wasm32 target statics with #[link_section] are placed into custom
1367 // sections of the final output file, but this isn't link custom sections of
1368 // other executable formats. Namely we can only embed a list of bytes,
1369 // nothing with pointers to anything else or relocations. If any relocation
1370 // show up, reject them here.
1371 let instance = ty::Instance::mono(tcx, id);
1372 let cid = GlobalId {
1376 let param_env = ty::ParamEnv::reveal_all();
1377 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1378 let alloc = tcx.const_to_allocation(static_);
1379 if alloc.relocations.len() != 0 {
1380 let msg = "statics with a custom `#[link_section]` must be a \
1381 simple list of bytes on the wasm target with no \
1382 extra levels of indirection such as references";
1383 tcx.sess.span_err(span, msg);
1388 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1389 trait_def_id: DefId,
1391 let item_def_id = tcx.hir.local_def_id(item.id);
1392 // an error would be reported if this fails.
1393 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1396 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1397 impl_item: &hir::ImplItem,
1400 let mut err = struct_span_err!(
1401 tcx.sess, impl_item.span, E0520,
1402 "`{}` specializes an item from a parent `impl`, but \
1403 that item is not marked `default`",
1405 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1408 match tcx.span_of_impl(parent_impl) {
1410 err.span_label(span, "parent `impl` is here");
1411 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1415 err.note(&format!("parent implementation is in crate `{}`", cname));
1422 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1423 trait_def: &ty::TraitDef,
1424 trait_item: &ty::AssociatedItem,
1426 impl_item: &hir::ImplItem)
1428 let ancestors = trait_def.ancestors(tcx, impl_id);
1430 let kind = match impl_item.node {
1431 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1432 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1433 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1434 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1437 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1438 .map(|node_item| node_item.map(|parent| parent.defaultness));
1440 if let Some(parent) = parent {
1441 if tcx.impl_item_is_final(&parent) {
1442 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1448 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1451 impl_trait_ref: ty::TraitRef<'tcx>,
1452 impl_item_refs: &[hir::ImplItemRef]) {
1453 let impl_span = tcx.sess.source_map().def_span(impl_span);
1455 // If the trait reference itself is erroneous (so the compilation is going
1456 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1457 // isn't populated for such impls.
1458 if impl_trait_ref.references_error() { return; }
1460 // Locate trait definition and items
1461 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1462 let mut overridden_associated_type = None;
1464 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1466 // Check existing impl methods to see if they are both present in trait
1467 // and compatible with trait signature
1468 for impl_item in impl_items() {
1469 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1470 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1471 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1472 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1474 // Not compatible, but needed for the error message
1475 tcx.associated_items(impl_trait_ref.def_id)
1476 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1479 // Check that impl definition matches trait definition
1480 if let Some(ty_trait_item) = ty_trait_item {
1481 match impl_item.node {
1482 hir::ImplItemKind::Const(..) => {
1483 // Find associated const definition.
1484 if ty_trait_item.kind == ty::AssociatedKind::Const {
1485 compare_const_impl(tcx,
1491 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1492 "item `{}` is an associated const, \
1493 which doesn't match its trait `{}`",
1496 err.span_label(impl_item.span, "does not match trait");
1497 // We can only get the spans from local trait definition
1498 // Same for E0324 and E0325
1499 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1500 err.span_label(trait_span, "item in trait");
1505 hir::ImplItemKind::Method(..) => {
1506 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1507 if ty_trait_item.kind == ty::AssociatedKind::Method {
1508 compare_impl_method(tcx,
1515 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1516 "item `{}` is an associated method, \
1517 which doesn't match its trait `{}`",
1520 err.span_label(impl_item.span, "does not match trait");
1521 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1522 err.span_label(trait_span, "item in trait");
1527 hir::ImplItemKind::Existential(..) |
1528 hir::ImplItemKind::Type(_) => {
1529 if ty_trait_item.kind == ty::AssociatedKind::Type {
1530 if ty_trait_item.defaultness.has_value() {
1531 overridden_associated_type = Some(impl_item);
1534 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1535 "item `{}` is an associated type, \
1536 which doesn't match its trait `{}`",
1539 err.span_label(impl_item.span, "does not match trait");
1540 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1541 err.span_label(trait_span, "item in trait");
1548 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1552 // Check for missing items from trait
1553 let mut missing_items = Vec::new();
1554 let mut invalidated_items = Vec::new();
1555 let associated_type_overridden = overridden_associated_type.is_some();
1556 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1557 let is_implemented = trait_def.ancestors(tcx, impl_id)
1558 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1560 .map(|node_item| !node_item.node.is_from_trait())
1563 if !is_implemented && !tcx.impl_is_default(impl_id) {
1564 if !trait_item.defaultness.has_value() {
1565 missing_items.push(trait_item);
1566 } else if associated_type_overridden {
1567 invalidated_items.push(trait_item.ident);
1572 if !missing_items.is_empty() {
1573 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1574 "not all trait items implemented, missing: `{}`",
1575 missing_items.iter()
1576 .map(|trait_item| trait_item.ident.to_string())
1577 .collect::<Vec<_>>().join("`, `"));
1578 err.span_label(impl_span, format!("missing `{}` in implementation",
1579 missing_items.iter()
1580 .map(|trait_item| trait_item.ident.to_string())
1581 .collect::<Vec<_>>().join("`, `")));
1582 for trait_item in missing_items {
1583 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1584 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1586 err.note_trait_signature(trait_item.ident.to_string(),
1587 trait_item.signature(&tcx));
1593 if !invalidated_items.is_empty() {
1594 let invalidator = overridden_associated_type.unwrap();
1595 span_err!(tcx.sess, invalidator.span, E0399,
1596 "the following trait items need to be reimplemented \
1597 as `{}` was overridden: `{}`",
1599 invalidated_items.iter()
1600 .map(|name| name.to_string())
1601 .collect::<Vec<_>>().join("`, `"))
1605 /// Checks whether a type can be represented in memory. In particular, it
1606 /// identifies types that contain themselves without indirection through a
1607 /// pointer, which would mean their size is unbounded.
1608 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1612 let rty = tcx.type_of(item_def_id);
1614 // Check that it is possible to represent this type. This call identifies
1615 // (1) types that contain themselves and (2) types that contain a different
1616 // recursive type. It is only necessary to throw an error on those that
1617 // contain themselves. For case 2, there must be an inner type that will be
1618 // caught by case 1.
1619 match rty.is_representable(tcx, sp) {
1620 Representability::SelfRecursive(spans) => {
1621 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1623 err.span_label(span, "recursive without indirection");
1628 Representability::Representable | Representability::ContainsRecursive => (),
1633 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1634 let t = tcx.type_of(def_id);
1636 ty::Adt(def, substs) if def.is_struct() => {
1637 let fields = &def.non_enum_variant().fields;
1638 if fields.is_empty() {
1639 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1642 let e = fields[0].ty(tcx, substs);
1643 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1644 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1645 .span_label(sp, "SIMD elements must have the same type")
1650 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1651 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1653 span_err!(tcx.sess, sp, E0077,
1654 "SIMD vector element type should be machine type");
1663 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1664 let repr = tcx.adt_def(def_id).repr;
1666 for attr in tcx.get_attrs(def_id).iter() {
1667 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1668 if let attr::ReprPacked(pack) = r {
1669 if pack != repr.pack {
1670 struct_span_err!(tcx.sess, sp, E0634,
1671 "type has conflicting packed representation hints").emit();
1677 struct_span_err!(tcx.sess, sp, E0587,
1678 "type has conflicting packed and align representation hints").emit();
1680 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1681 struct_span_err!(tcx.sess, sp, E0588,
1682 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1687 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1689 stack: &mut Vec<DefId>) -> bool {
1690 let t = tcx.type_of(def_id);
1691 if stack.contains(&def_id) {
1692 debug!("check_packed_inner: {:?} is recursive", t);
1696 ty::Adt(def, substs) if def.is_struct() || def.is_union() => {
1697 if tcx.adt_def(def.did).repr.align > 0 {
1700 // push struct def_id before checking fields
1702 for field in &def.non_enum_variant().fields {
1703 let f = field.ty(tcx, substs);
1705 ty::Adt(def, _) => {
1706 if check_packed_inner(tcx, def.did, stack) {
1713 // only need to pop if not early out
1721 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1722 let adt = tcx.adt_def(def_id);
1723 if !adt.repr.transparent() {
1727 // For each field, figure out if it's known to be a ZST and align(1)
1728 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1729 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1730 let param_env = tcx.param_env(field.did);
1731 let layout = tcx.layout_of(param_env.and(ty));
1732 // We are currently checking the type this field came from, so it must be local
1733 let span = tcx.hir.span_if_local(field.did).unwrap();
1734 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1735 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1739 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1740 let non_zst_count = non_zst_fields.clone().count();
1741 if non_zst_count != 1 {
1742 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1743 struct_span_err!(tcx.sess, sp, E0690,
1744 "transparent struct needs exactly one non-zero-sized field, but has {}",
1746 .span_note(field_spans, "non-zero-sized field")
1749 for &(span, zst, align1) in &field_infos {
1751 span_err!(tcx.sess, span, E0691,
1752 "zero-sized field in transparent struct has alignment larger than 1");
1757 #[allow(trivial_numeric_casts)]
1758 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1760 vs: &'tcx [hir::Variant],
1762 let def_id = tcx.hir.local_def_id(id);
1763 let def = tcx.adt_def(def_id);
1764 def.destructor(tcx); // force the destructor to be evaluated
1767 let attributes = tcx.get_attrs(def_id);
1768 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1770 tcx.sess, attr.span, E0084,
1771 "unsupported representation for zero-variant enum")
1772 .span_label(sp, "zero-variant enum")
1777 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1778 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1779 if !tcx.features().repr128 {
1780 emit_feature_err(&tcx.sess.parse_sess,
1783 GateIssue::Language,
1784 "repr with 128-bit type is unstable");
1789 if let Some(ref e) = v.node.disr_expr {
1790 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1794 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1795 for (discr, v) in def.discriminants(tcx).zip(vs) {
1796 // Check for duplicate discriminant values
1797 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1798 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1799 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1800 let i_span = match variant_i.node.disr_expr {
1801 Some(ref expr) => tcx.hir.span(expr.id),
1802 None => tcx.hir.span(variant_i_node_id)
1804 let span = match v.node.disr_expr {
1805 Some(ref expr) => tcx.hir.span(expr.id),
1808 struct_span_err!(tcx.sess, span, E0081,
1809 "discriminant value `{}` already exists", disr_vals[i])
1810 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1811 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1814 disr_vals.push(discr);
1817 check_representable(tcx, sp, def_id);
1820 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1821 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1823 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1824 -> ty::GenericPredicates<'tcx>
1827 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1828 let item_id = tcx.hir.ty_param_owner(node_id);
1829 let item_def_id = tcx.hir.local_def_id(item_id);
1830 let generics = tcx.generics_of(item_def_id);
1831 let index = generics.param_def_id_to_index[&def_id];
1832 ty::GenericPredicates {
1834 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1836 ty::Predicate::Trait(ref data) => {
1837 data.skip_binder().self_ty().is_param(index)
1841 }).cloned().collect()
1845 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1846 -> Option<ty::Region<'tcx>> {
1848 Some(def) => infer::EarlyBoundRegion(span, def.name),
1849 None => infer::MiscVariable(span)
1851 Some(self.next_region_var(v))
1854 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1855 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1858 fn ty_infer_for_def(&self,
1859 ty_param_def: &ty::GenericParamDef,
1860 span: Span) -> Ty<'tcx> {
1861 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1867 fn projected_ty_from_poly_trait_ref(&self,
1870 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1873 let (trait_ref, _) =
1874 self.replace_late_bound_regions_with_fresh_var(
1876 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1879 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1882 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1883 if ty.has_escaping_regions() {
1884 ty // FIXME: normalization and escaping regions
1886 self.normalize_associated_types_in(span, &ty)
1890 fn set_tainted_by_errors(&self) {
1891 self.infcx.set_tainted_by_errors()
1894 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1895 self.write_ty(hir_id, ty)
1899 /// Controls whether the arguments are tupled. This is used for the call
1902 /// Tupling means that all call-side arguments are packed into a tuple and
1903 /// passed as a single parameter. For example, if tupling is enabled, this
1906 /// fn f(x: (isize, isize))
1908 /// Can be called as:
1915 #[derive(Clone, Eq, PartialEq)]
1916 enum TupleArgumentsFlag {
1921 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1922 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1923 param_env: ty::ParamEnv<'tcx>,
1924 body_id: ast::NodeId)
1925 -> FnCtxt<'a, 'gcx, 'tcx> {
1929 err_count_on_creation: inh.tcx.sess.err_count(),
1932 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1933 ast::CRATE_NODE_ID)),
1934 diverges: Cell::new(Diverges::Maybe),
1935 has_errors: Cell::new(false),
1936 enclosing_breakables: RefCell::new(EnclosingBreakables {
1944 pub fn sess(&self) -> &Session {
1948 pub fn err_count_since_creation(&self) -> usize {
1949 self.tcx.sess.err_count() - self.err_count_on_creation
1952 /// Produce warning on the given node, if the current point in the
1953 /// function is unreachable, and there hasn't been another warning.
1954 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1955 if self.diverges.get() == Diverges::Always {
1956 self.diverges.set(Diverges::WarnedAlways);
1958 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1960 self.tcx().lint_node(
1961 lint::builtin::UNREACHABLE_CODE,
1963 &format!("unreachable {}", kind));
1969 code: ObligationCauseCode<'tcx>)
1970 -> ObligationCause<'tcx> {
1971 ObligationCause::new(span, self.body_id, code)
1974 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1975 self.cause(span, ObligationCauseCode::MiscObligation)
1978 /// Resolves type variables in `ty` if possible. Unlike the infcx
1979 /// version (resolve_type_vars_if_possible), this version will
1980 /// also select obligations if it seems useful, in an effort
1981 /// to get more type information.
1982 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1983 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1985 // No Infer()? Nothing needs doing.
1986 if !ty.has_infer_types() {
1987 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1991 // If `ty` is a type variable, see whether we already know what it is.
1992 ty = self.resolve_type_vars_if_possible(&ty);
1993 if !ty.has_infer_types() {
1994 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1998 // If not, try resolving pending obligations as much as
1999 // possible. This can help substantially when there are
2000 // indirect dependencies that don't seem worth tracking
2002 self.select_obligations_where_possible(false);
2003 ty = self.resolve_type_vars_if_possible(&ty);
2005 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2009 fn record_deferred_call_resolution(&self,
2010 closure_def_id: DefId,
2011 r: DeferredCallResolution<'gcx, 'tcx>) {
2012 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2013 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2016 fn remove_deferred_call_resolutions(&self,
2017 closure_def_id: DefId)
2018 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2020 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2021 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2024 pub fn tag(&self) -> String {
2025 let self_ptr: *const FnCtxt = self;
2026 format!("{:?}", self_ptr)
2029 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
2030 match self.locals.borrow().get(&nid) {
2033 span_bug!(span, "no type for local variable {}",
2034 self.tcx.hir.node_to_string(nid));
2040 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2041 debug!("write_ty({:?}, {:?}) in fcx {}",
2042 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2043 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2045 if ty.references_error() {
2046 self.has_errors.set(true);
2047 self.set_tainted_by_errors();
2051 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2052 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2053 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2056 // The NodeId and the ItemLocalId must identify the same item. We just pass
2057 // both of them for consistency checking.
2058 pub fn write_method_call(&self,
2060 method: MethodCallee<'tcx>) {
2063 .type_dependent_defs_mut()
2064 .insert(hir_id, Def::Method(method.def_id));
2065 self.write_substs(hir_id, method.substs);
2068 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2069 if !substs.is_noop() {
2070 debug!("write_substs({:?}, {:?}) in fcx {}",
2075 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2079 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2080 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2086 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2087 Entry::Vacant(entry) => { entry.insert(adj); },
2088 Entry::Occupied(mut entry) => {
2089 debug!(" - composing on top of {:?}", entry.get());
2090 match (&entry.get()[..], &adj[..]) {
2091 // Applying any adjustment on top of a NeverToAny
2092 // is a valid NeverToAny adjustment, because it can't
2094 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2096 Adjustment { kind: Adjust::Deref(_), .. },
2097 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2099 Adjustment { kind: Adjust::Deref(_), .. },
2100 .. // Any following adjustments are allowed.
2102 // A reborrow has no effect before a dereference.
2104 // FIXME: currently we never try to compose autoderefs
2105 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2107 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2108 expr, entry.get(), adj)
2110 *entry.get_mut() = adj;
2115 /// Basically whenever we are converting from a type scheme into
2116 /// the fn body space, we always want to normalize associated
2117 /// types as well. This function combines the two.
2118 fn instantiate_type_scheme<T>(&self,
2120 substs: &Substs<'tcx>,
2123 where T : TypeFoldable<'tcx>
2125 let value = value.subst(self.tcx, substs);
2126 let result = self.normalize_associated_types_in(span, &value);
2127 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2134 /// As `instantiate_type_scheme`, but for the bounds found in a
2135 /// generic type scheme.
2136 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2137 -> ty::InstantiatedPredicates<'tcx> {
2138 let bounds = self.tcx.predicates_of(def_id);
2139 let result = bounds.instantiate(self.tcx, substs);
2140 let result = self.normalize_associated_types_in(span, &result);
2141 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2148 /// Replace the anonymized types from the return value of the
2149 /// function with type variables and records the `AnonTypeMap` for
2150 /// later use during writeback. See
2151 /// `InferCtxt::instantiate_anon_types` for more details.
2152 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2157 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2159 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2164 let (value, anon_type_map) = self.register_infer_ok_obligations(
2165 self.instantiate_anon_types(
2173 let mut anon_types = self.anon_types.borrow_mut();
2174 for (ty, decl) in anon_type_map {
2175 let old_value = anon_types.insert(ty, decl);
2176 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2182 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2183 where T : TypeFoldable<'tcx>
2185 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2188 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2190 where T : TypeFoldable<'tcx>
2192 self.inh.partially_normalize_associated_types_in(span,
2198 pub fn require_type_meets(&self,
2201 code: traits::ObligationCauseCode<'tcx>,
2204 self.register_bound(
2207 traits::ObligationCause::new(span, self.body_id, code));
2210 pub fn require_type_is_sized(&self,
2213 code: traits::ObligationCauseCode<'tcx>)
2215 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2216 self.require_type_meets(ty, span, code, lang_item);
2219 pub fn register_bound(&self,
2222 cause: traits::ObligationCause<'tcx>)
2224 self.fulfillment_cx.borrow_mut()
2225 .register_bound(self, self.param_env, ty, def_id, cause);
2228 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2229 let t = AstConv::ast_ty_to_ty(self, ast_t);
2230 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2234 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2235 match self.tables.borrow().node_types().get(id) {
2237 None if self.is_tainted_by_errors() => self.tcx.types.err,
2239 let node_id = self.tcx.hir.hir_to_node_id(id);
2240 bug!("no type for node {}: {} in fcx {}",
2241 node_id, self.tcx.hir.node_to_string(node_id),
2247 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2248 /// outlive the region `r`.
2249 pub fn register_wf_obligation(&self,
2252 code: traits::ObligationCauseCode<'tcx>)
2254 // WF obligations never themselves fail, so no real need to give a detailed cause:
2255 let cause = traits::ObligationCause::new(span, self.body_id, code);
2256 self.register_predicate(traits::Obligation::new(cause,
2258 ty::Predicate::WellFormed(ty)));
2261 /// Registers obligations that all types appearing in `substs` are well-formed.
2262 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2264 for ty in substs.types() {
2265 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2269 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2270 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2271 /// trait/region obligations.
2273 /// For example, if there is a function:
2276 /// fn foo<'a,T:'a>(...)
2279 /// and a reference:
2285 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2286 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2287 pub fn add_obligations_for_parameters(&self,
2288 cause: traits::ObligationCause<'tcx>,
2289 predicates: &ty::InstantiatedPredicates<'tcx>)
2291 assert!(!predicates.has_escaping_regions());
2293 debug!("add_obligations_for_parameters(predicates={:?})",
2296 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2297 self.register_predicate(obligation);
2301 // FIXME(arielb1): use this instead of field.ty everywhere
2302 // Only for fields! Returns <none> for methods>
2303 // Indifferent to privacy flags
2304 pub fn field_ty(&self,
2306 field: &'tcx ty::FieldDef,
2307 substs: &Substs<'tcx>)
2310 self.normalize_associated_types_in(span,
2311 &field.ty(self.tcx, substs))
2314 fn check_casts(&self) {
2315 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2316 for cast in deferred_cast_checks.drain(..) {
2321 fn resolve_generator_interiors(&self, def_id: DefId) {
2322 let mut generators = self.deferred_generator_interiors.borrow_mut();
2323 for (body_id, interior) in generators.drain(..) {
2324 self.select_obligations_where_possible(false);
2325 generator_interior::resolve_interior(self, def_id, body_id, interior);
2329 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2330 // Non-numerics get replaced with ! or () (depending on whether
2331 // feature(never_type) is enabled, unconstrained ints with i32,
2332 // unconstrained floats with f64.
2333 // Fallback becomes very dubious if we have encountered type-checking errors.
2334 // In that case, fallback to Error.
2335 // The return value indicates whether fallback has occurred.
2336 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2337 use rustc::ty::error::UnconstrainedNumeric::Neither;
2338 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2340 assert!(ty.is_ty_infer());
2341 let fallback = match self.type_is_unconstrained_numeric(ty) {
2342 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2343 UnconstrainedInt => self.tcx.types.i32,
2344 UnconstrainedFloat => self.tcx.types.f64,
2345 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2346 Neither => return false,
2348 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2349 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2353 fn select_all_obligations_or_error(&self) {
2354 debug!("select_all_obligations_or_error");
2355 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2356 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2360 /// Select as many obligations as we can at present.
2361 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2362 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2365 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2370 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2372 hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
2374 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2379 hir::ExprKind::Type(ref e, _) => {
2380 self.is_place_expr(e)
2383 hir::ExprKind::Unary(hir::UnDeref, _) |
2384 hir::ExprKind::Field(..) |
2385 hir::ExprKind::Index(..) => {
2389 // Partially qualified paths in expressions can only legally
2390 // refer to associated items which are always rvalues.
2391 hir::ExprKind::Path(hir::QPath::TypeRelative(..)) |
2393 hir::ExprKind::Call(..) |
2394 hir::ExprKind::MethodCall(..) |
2395 hir::ExprKind::Struct(..) |
2396 hir::ExprKind::Tup(..) |
2397 hir::ExprKind::If(..) |
2398 hir::ExprKind::Match(..) |
2399 hir::ExprKind::Closure(..) |
2400 hir::ExprKind::Block(..) |
2401 hir::ExprKind::Repeat(..) |
2402 hir::ExprKind::Array(..) |
2403 hir::ExprKind::Break(..) |
2404 hir::ExprKind::Continue(..) |
2405 hir::ExprKind::Ret(..) |
2406 hir::ExprKind::While(..) |
2407 hir::ExprKind::Loop(..) |
2408 hir::ExprKind::Assign(..) |
2409 hir::ExprKind::InlineAsm(..) |
2410 hir::ExprKind::AssignOp(..) |
2411 hir::ExprKind::Lit(_) |
2412 hir::ExprKind::Unary(..) |
2413 hir::ExprKind::Box(..) |
2414 hir::ExprKind::AddrOf(..) |
2415 hir::ExprKind::Binary(..) |
2416 hir::ExprKind::Yield(..) |
2417 hir::ExprKind::Cast(..) => {
2423 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2424 /// returns a type of `&T`, but the actual type we assign to the
2425 /// *expression* is `T`. So this function just peels off the return
2426 /// type by one layer to yield `T`.
2427 fn make_overloaded_place_return_type(&self,
2428 method: MethodCallee<'tcx>)
2429 -> ty::TypeAndMut<'tcx>
2431 // extract method return type, which will be &T;
2432 let ret_ty = method.sig.output();
2434 // method returns &T, but the type as visible to user is T, so deref
2435 ret_ty.builtin_deref(true).unwrap()
2438 fn lookup_indexing(&self,
2440 base_expr: &'gcx hir::Expr,
2444 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2446 // FIXME(#18741) -- this is almost but not quite the same as the
2447 // autoderef that normal method probing does. They could likely be
2450 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2451 let mut result = None;
2452 while result.is_none() && autoderef.next().is_some() {
2453 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2455 autoderef.finalize();
2459 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2460 /// (and otherwise adjust) `base_expr`, looking for a type which either
2461 /// supports builtin indexing or overloaded indexing.
2462 /// This loop implements one step in that search; the autoderef loop
2463 /// is implemented by `lookup_indexing`.
2464 fn try_index_step(&self,
2466 base_expr: &hir::Expr,
2467 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2470 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2472 let adjusted_ty = autoderef.unambiguous_final_ty();
2473 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2480 for &unsize in &[false, true] {
2481 let mut self_ty = adjusted_ty;
2483 // We only unsize arrays here.
2484 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2485 self_ty = self.tcx.mk_slice(element_ty);
2491 // If some lookup succeeds, write callee into table and extract index/element
2492 // type from the method signature.
2493 // If some lookup succeeded, install method in table
2494 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2495 let method = self.try_overloaded_place_op(
2496 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2498 let result = method.map(|ok| {
2499 debug!("try_index_step: success, using overloaded indexing");
2500 let method = self.register_infer_ok_obligations(ok);
2502 let mut adjustments = autoderef.adjust_steps(needs);
2503 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2504 let mutbl = match r_mutbl {
2505 hir::MutImmutable => AutoBorrowMutability::Immutable,
2506 hir::MutMutable => AutoBorrowMutability::Mutable {
2507 // Indexing can be desugared to a method call,
2508 // so maybe we could use two-phase here.
2509 // See the documentation of AllowTwoPhase for why that's
2510 // not the case today.
2511 allow_two_phase_borrow: AllowTwoPhase::No,
2514 adjustments.push(Adjustment {
2515 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2516 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2523 adjustments.push(Adjustment {
2524 kind: Adjust::Unsize,
2525 target: method.sig.inputs()[0]
2528 self.apply_adjustments(base_expr, adjustments);
2530 self.write_method_call(expr.hir_id, method);
2531 (input_ty, self.make_overloaded_place_return_type(method).ty)
2533 if result.is_some() {
2541 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2542 let (tr, name) = match (op, is_mut) {
2543 (PlaceOp::Deref, false) =>
2544 (self.tcx.lang_items().deref_trait(), "deref"),
2545 (PlaceOp::Deref, true) =>
2546 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2547 (PlaceOp::Index, false) =>
2548 (self.tcx.lang_items().index_trait(), "index"),
2549 (PlaceOp::Index, true) =>
2550 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2552 (tr, ast::Ident::from_str(name))
2555 fn try_overloaded_place_op(&self,
2558 arg_tys: &[Ty<'tcx>],
2561 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2563 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2569 // Try Mut first, if needed.
2570 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2571 let method = match (needs, mut_tr) {
2572 (Needs::MutPlace, Some(trait_did)) => {
2573 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2578 // Otherwise, fall back to the immutable version.
2579 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2580 let method = match (method, imm_tr) {
2581 (None, Some(trait_did)) => {
2582 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2584 (method, _) => method,
2590 fn check_method_argument_types(&self,
2593 method: Result<MethodCallee<'tcx>, ()>,
2594 args_no_rcvr: &'gcx [hir::Expr],
2595 tuple_arguments: TupleArgumentsFlag,
2596 expected: Expectation<'tcx>)
2598 let has_error = match method {
2600 method.substs.references_error() || method.sig.references_error()
2605 let err_inputs = self.err_args(args_no_rcvr.len());
2607 let err_inputs = match tuple_arguments {
2608 DontTupleArguments => err_inputs,
2609 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2612 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2613 false, tuple_arguments, None);
2614 return self.tcx.types.err;
2617 let method = method.unwrap();
2618 // HACK(eddyb) ignore self in the definition (see above).
2619 let expected_arg_tys = self.expected_inputs_for_expected_output(
2622 method.sig.output(),
2623 &method.sig.inputs()[1..]
2625 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2626 args_no_rcvr, method.sig.variadic, tuple_arguments,
2627 self.tcx.hir.span_if_local(method.def_id));
2631 /// Generic function that factors out common logic from function calls,
2632 /// method calls and overloaded operators.
2633 fn check_argument_types(&self,
2636 fn_inputs: &[Ty<'tcx>],
2637 mut expected_arg_tys: &[Ty<'tcx>],
2638 args: &'gcx [hir::Expr],
2640 tuple_arguments: TupleArgumentsFlag,
2641 def_span: Option<Span>) {
2644 // Grab the argument types, supplying fresh type variables
2645 // if the wrong number of arguments were supplied
2646 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2652 // All the input types from the fn signature must outlive the call
2653 // so as to validate implied bounds.
2654 for &fn_input_ty in fn_inputs {
2655 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2658 let expected_arg_count = fn_inputs.len();
2660 let param_count_error = |expected_count: usize,
2665 let mut err = tcx.sess.struct_span_err_with_code(sp,
2666 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2667 if variadic {"at least "} else {""},
2669 if expected_count == 1 {""} else {"s"},
2671 if arg_count == 1 {" was"} else {"s were"}),
2672 DiagnosticId::Error(error_code.to_owned()));
2674 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2675 err.span_label(def_s, "defined here");
2678 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2679 // remove closing `)` from the span
2680 let sugg_span = sugg_span.shrink_to_lo();
2681 err.span_suggestion_with_applicability(
2683 "expected the unit value `()`; create it with empty parentheses",
2685 Applicability::MachineApplicable);
2687 err.span_label(sp, format!("expected {}{} parameter{}",
2688 if variadic {"at least "} else {""},
2690 if expected_count == 1 {""} else {"s"}));
2695 let formal_tys = if tuple_arguments == TupleArguments {
2696 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2697 match tuple_type.sty {
2698 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2699 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2700 expected_arg_tys = &[];
2701 self.err_args(args.len())
2703 ty::Tuple(arg_types) => {
2704 expected_arg_tys = match expected_arg_tys.get(0) {
2705 Some(&ty) => match ty.sty {
2706 ty::Tuple(ref tys) => &tys,
2714 span_err!(tcx.sess, sp, E0059,
2715 "cannot use call notation; the first type parameter \
2716 for the function trait is neither a tuple nor unit");
2717 expected_arg_tys = &[];
2718 self.err_args(args.len())
2721 } else if expected_arg_count == supplied_arg_count {
2723 } else if variadic {
2724 if supplied_arg_count >= expected_arg_count {
2727 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2728 expected_arg_tys = &[];
2729 self.err_args(supplied_arg_count)
2732 // is the missing argument of type `()`?
2733 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2734 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2735 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2736 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2740 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2742 expected_arg_tys = &[];
2743 self.err_args(supplied_arg_count)
2745 // If there is no expectation, expect formal_tys.
2746 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2752 debug!("check_argument_types: formal_tys={:?}",
2753 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2755 // Check the arguments.
2756 // We do this in a pretty awful way: first we typecheck any arguments
2757 // that are not closures, then we typecheck the closures. This is so
2758 // that we have more information about the types of arguments when we
2759 // typecheck the functions. This isn't really the right way to do this.
2760 for &check_closures in &[false, true] {
2761 debug!("check_closures={}", check_closures);
2763 // More awful hacks: before we check argument types, try to do
2764 // an "opportunistic" vtable resolution of any trait bounds on
2765 // the call. This helps coercions.
2767 self.select_obligations_where_possible(false);
2770 // For variadic functions, we don't have a declared type for all of
2771 // the arguments hence we only do our usual type checking with
2772 // the arguments who's types we do know.
2773 let t = if variadic {
2775 } else if tuple_arguments == TupleArguments {
2780 for (i, arg) in args.iter().take(t).enumerate() {
2781 // Warn only for the first loop (the "no closures" one).
2782 // Closure arguments themselves can't be diverging, but
2783 // a previous argument can, e.g. `foo(panic!(), || {})`.
2784 if !check_closures {
2785 self.warn_if_unreachable(arg.id, arg.span, "expression");
2788 let is_closure = match arg.node {
2789 hir::ExprKind::Closure(..) => true,
2793 if is_closure != check_closures {
2797 debug!("checking the argument");
2798 let formal_ty = formal_tys[i];
2800 // The special-cased logic below has three functions:
2801 // 1. Provide as good of an expected type as possible.
2802 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2804 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2806 // 2. Coerce to the most detailed type that could be coerced
2807 // to, which is `expected_ty` if `rvalue_hint` returns an
2808 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2809 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2810 // We're processing function arguments so we definitely want to use
2811 // two-phase borrows.
2812 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2814 // 3. Relate the expected type and the formal one,
2815 // if the expected type was used for the coercion.
2816 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2820 // We also need to make sure we at least write the ty of the other
2821 // arguments which we skipped above.
2823 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2824 use structured_errors::{VariadicError, StructuredDiagnostic};
2825 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2828 for arg in args.iter().skip(expected_arg_count) {
2829 let arg_ty = self.check_expr(&arg);
2831 // There are a few types which get autopromoted when passed via varargs
2832 // in C but we just error out instead and require explicit casts.
2833 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2835 ty::Float(ast::FloatTy::F32) => {
2836 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2838 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
2839 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2841 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
2842 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2845 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2846 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2847 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2855 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2856 (0..len).map(|_| self.tcx.types.err).collect()
2859 // AST fragment checking
2862 expected: Expectation<'tcx>)
2868 ast::LitKind::Str(..) => tcx.mk_static_str(),
2869 ast::LitKind::ByteStr(ref v) => {
2870 tcx.mk_imm_ref(tcx.types.re_static,
2871 tcx.mk_array(tcx.types.u8, v.len() as u64))
2873 ast::LitKind::Byte(_) => tcx.types.u8,
2874 ast::LitKind::Char(_) => tcx.types.char,
2875 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2876 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2877 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2878 let opt_ty = expected.to_option(self).and_then(|ty| {
2880 ty::Int(_) | ty::Uint(_) => Some(ty),
2881 ty::Char => Some(tcx.types.u8),
2882 ty::RawPtr(..) => Some(tcx.types.usize),
2883 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
2887 opt_ty.unwrap_or_else(
2888 || tcx.mk_int_var(self.next_int_var_id()))
2890 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2891 ast::LitKind::FloatUnsuffixed(_) => {
2892 let opt_ty = expected.to_option(self).and_then(|ty| {
2894 ty::Float(_) => Some(ty),
2898 opt_ty.unwrap_or_else(
2899 || tcx.mk_float_var(self.next_float_var_id()))
2901 ast::LitKind::Bool(_) => tcx.types.bool
2905 fn check_expr_eq_type(&self,
2906 expr: &'gcx hir::Expr,
2907 expected: Ty<'tcx>) {
2908 let ty = self.check_expr_with_hint(expr, expected);
2909 self.demand_eqtype(expr.span, expected, ty);
2912 pub fn check_expr_has_type_or_error(&self,
2913 expr: &'gcx hir::Expr,
2914 expected: Ty<'tcx>) -> Ty<'tcx> {
2915 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2918 fn check_expr_meets_expectation_or_error(&self,
2919 expr: &'gcx hir::Expr,
2920 expected: Expectation<'tcx>) -> Ty<'tcx> {
2921 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2922 let mut ty = self.check_expr_with_expectation(expr, expected);
2924 // While we don't allow *arbitrary* coercions here, we *do* allow
2925 // coercions from ! to `expected`.
2927 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2928 "expression with never type wound up being adjusted");
2929 let adj_ty = self.next_diverging_ty_var(
2930 TypeVariableOrigin::AdjustmentType(expr.span));
2931 self.apply_adjustments(expr, vec![Adjustment {
2932 kind: Adjust::NeverToAny,
2938 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2939 // Add help to type error if this is an `if` condition with an assignment
2940 match (expected, &expr.node) {
2941 (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs)) => {
2942 let msg = "try comparing for equality";
2943 if let (Ok(left), Ok(right)) = (
2944 self.tcx.sess.source_map().span_to_snippet(lhs.span),
2945 self.tcx.sess.source_map().span_to_snippet(rhs.span))
2947 err.span_suggestion_with_applicability(
2950 format!("{} == {}", left, right),
2951 Applicability::MaybeIncorrect);
2963 fn check_expr_coercable_to_type(&self,
2964 expr: &'gcx hir::Expr,
2965 expected: Ty<'tcx>) -> Ty<'tcx> {
2966 let ty = self.check_expr_with_hint(expr, expected);
2967 // checks don't need two phase
2968 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2971 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2972 expected: Ty<'tcx>) -> Ty<'tcx> {
2973 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2976 fn check_expr_with_expectation(&self,
2977 expr: &'gcx hir::Expr,
2978 expected: Expectation<'tcx>) -> Ty<'tcx> {
2979 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2982 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2983 self.check_expr_with_expectation(expr, NoExpectation)
2986 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2987 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2990 // determine the `self` type, using fresh variables for all variables
2991 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2992 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2994 pub fn impl_self_ty(&self,
2995 span: Span, // (potential) receiver for this impl
2997 -> TypeAndSubsts<'tcx> {
2998 let ity = self.tcx.type_of(did);
2999 debug!("impl_self_ty: ity={:?}", ity);
3001 let substs = self.fresh_substs_for_item(span, did);
3002 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3004 TypeAndSubsts { substs: substs, ty: substd_ty }
3007 /// Unifies the output type with the expected type early, for more coercions
3008 /// and forward type information on the input expressions.
3009 fn expected_inputs_for_expected_output(&self,
3011 expected_ret: Expectation<'tcx>,
3012 formal_ret: Ty<'tcx>,
3013 formal_args: &[Ty<'tcx>])
3015 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3016 let ret_ty = match expected_ret.only_has_type(self) {
3018 None => return Vec::new()
3020 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3021 // Attempt to apply a subtyping relationship between the formal
3022 // return type (likely containing type variables if the function
3023 // is polymorphic) and the expected return type.
3024 // No argument expectations are produced if unification fails.
3025 let origin = self.misc(call_span);
3026 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3028 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3029 // to identity so the resulting type is not constrained.
3032 // Process any obligations locally as much as
3033 // we can. We don't care if some things turn
3034 // out unconstrained or ambiguous, as we're
3035 // just trying to get hints here.
3036 self.save_and_restore_in_snapshot_flag(|_| {
3037 let mut fulfill = TraitEngine::new(self.tcx);
3038 for obligation in ok.obligations {
3039 fulfill.register_predicate_obligation(self, obligation);
3041 fulfill.select_where_possible(self)
3042 }).map_err(|_| ())?;
3044 Err(_) => return Err(()),
3047 // Record all the argument types, with the substitutions
3048 // produced from the above subtyping unification.
3049 Ok(formal_args.iter().map(|ty| {
3050 self.resolve_type_vars_if_possible(ty)
3052 }).unwrap_or(Vec::new());
3053 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3054 formal_args, formal_ret,
3055 expect_args, expected_ret);
3059 // Checks a method call.
3060 fn check_method_call(&self,
3061 expr: &'gcx hir::Expr,
3062 segment: &hir::PathSegment,
3064 args: &'gcx [hir::Expr],
3065 expected: Expectation<'tcx>,
3066 needs: Needs) -> Ty<'tcx> {
3067 let rcvr = &args[0];
3068 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3069 // no need to check for bot/err -- callee does that
3070 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3072 let method = match self.lookup_method(rcvr_t,
3078 self.write_method_call(expr.hir_id, method);
3082 if segment.ident.name != keywords::Invalid.name() {
3083 self.report_method_error(span,
3094 // Call the generic checker.
3095 self.check_method_argument_types(span,
3103 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3107 .unwrap_or_else(|| span_bug!(return_expr.span,
3108 "check_return_expr called outside fn body"));
3110 let ret_ty = ret_coercion.borrow().expected_ty();
3111 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3112 ret_coercion.borrow_mut()
3114 &self.cause(return_expr.span,
3115 ObligationCauseCode::ReturnType(return_expr.id)),
3121 // A generic function for checking the then and else in an if
3123 fn check_then_else(&self,
3124 cond_expr: &'gcx hir::Expr,
3125 then_expr: &'gcx hir::Expr,
3126 opt_else_expr: Option<&'gcx hir::Expr>,
3128 expected: Expectation<'tcx>) -> Ty<'tcx> {
3129 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3130 let cond_diverges = self.diverges.get();
3131 self.diverges.set(Diverges::Maybe);
3133 let expected = expected.adjust_for_branches(self);
3134 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3135 let then_diverges = self.diverges.get();
3136 self.diverges.set(Diverges::Maybe);
3138 // We've already taken the expected type's preferences
3139 // into account when typing the `then` branch. To figure
3140 // out the initial shot at a LUB, we thus only consider
3141 // `expected` if it represents a *hard* constraint
3142 // (`only_has_type`); otherwise, we just go with a
3143 // fresh type variable.
3144 let coerce_to_ty = expected.coercion_target_type(self, sp);
3145 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3147 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3148 coerce.coerce(self, &if_cause, then_expr, then_ty);
3150 if let Some(else_expr) = opt_else_expr {
3151 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3152 let else_diverges = self.diverges.get();
3154 coerce.coerce(self, &if_cause, else_expr, else_ty);
3156 // We won't diverge unless both branches do (or the condition does).
3157 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3159 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3160 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3162 // If the condition is false we can't diverge.
3163 self.diverges.set(cond_diverges);
3166 let result_ty = coerce.complete(self);
3167 if cond_ty.references_error() {
3174 // Check field access expressions
3175 fn check_field(&self,
3176 expr: &'gcx hir::Expr,
3178 base: &'gcx hir::Expr,
3179 field: ast::Ident) -> Ty<'tcx> {
3180 let expr_t = self.check_expr_with_needs(base, needs);
3181 let expr_t = self.structurally_resolved_type(base.span,
3183 let mut private_candidate = None;
3184 let mut autoderef = self.autoderef(expr.span, expr_t);
3185 while let Some((base_t, _)) = autoderef.next() {
3187 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3188 debug!("struct named {:?}", base_t);
3189 let (ident, def_scope) =
3190 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3191 let fields = &base_def.non_enum_variant().fields;
3192 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3193 let field = &fields[index];
3194 let field_ty = self.field_ty(expr.span, field, substs);
3195 // Save the index of all fields regardless of their visibility in case
3196 // of error recovery.
3197 self.write_field_index(expr.id, index);
3198 if field.vis.is_accessible_from(def_scope, self.tcx) {
3199 let adjustments = autoderef.adjust_steps(needs);
3200 self.apply_adjustments(base, adjustments);
3201 autoderef.finalize();
3203 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3206 private_candidate = Some((base_def.did, field_ty));
3209 ty::Tuple(ref tys) => {
3210 let fstr = field.as_str();
3211 if let Ok(index) = fstr.parse::<usize>() {
3212 if fstr == index.to_string() {
3213 if let Some(field_ty) = tys.get(index) {
3214 let adjustments = autoderef.adjust_steps(needs);
3215 self.apply_adjustments(base, adjustments);
3216 autoderef.finalize();
3218 self.write_field_index(expr.id, index);
3227 autoderef.unambiguous_final_ty();
3229 if let Some((did, field_ty)) = private_candidate {
3230 let struct_path = self.tcx().item_path_str(did);
3231 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3232 "field `{}` of struct `{}` is private",
3233 field, struct_path);
3234 // Also check if an accessible method exists, which is often what is meant.
3235 if self.method_exists(field, expr_t, expr.id, false) {
3236 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3240 } else if field.name == keywords::Invalid.name() {
3241 self.tcx().types.err
3242 } else if self.method_exists(field, expr_t, expr.id, true) {
3243 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3244 "attempted to take value of method `{}` on type `{}`",
3246 .help("maybe a `()` to call it is missing?")
3248 self.tcx().types.err
3250 if !expr_t.is_primitive_ty() {
3251 let mut err = self.no_such_field_err(field.span, field, expr_t);
3254 ty::Adt(def, _) if !def.is_enum() => {
3255 if let Some(suggested_field_name) =
3256 Self::suggest_field_name(def.non_enum_variant(),
3257 &field.as_str(), vec![]) {
3258 err.span_label(field.span,
3259 format!("did you mean `{}`?", suggested_field_name));
3261 err.span_label(field.span, "unknown field");
3262 let struct_variant_def = def.non_enum_variant();
3263 let field_names = self.available_field_names(struct_variant_def);
3264 if !field_names.is_empty() {
3265 err.note(&format!("available fields are: {}",
3266 self.name_series_display(field_names)));
3271 let base = self.tcx.hir.node_to_pretty_string(base.id);
3272 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3273 let suggestion = format!("(*{}).{}", base, field);
3274 err.span_suggestion(field.span, &msg, suggestion);
3280 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3281 "`{}` is a primitive type and therefore doesn't have fields",
3284 self.tcx().types.err
3288 // Return an hint about the closest match in field names
3289 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3291 skip: Vec<LocalInternedString>)
3293 let names = variant.fields.iter().filter_map(|field| {
3294 // ignore already set fields and private fields from non-local crates
3295 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3296 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3299 Some(&field.ident.name)
3303 find_best_match_for_name(names, field, None)
3306 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3307 let mut available = Vec::new();
3308 for field in variant.fields.iter() {
3309 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3310 if field.vis.is_accessible_from(def_scope, self.tcx) {
3311 available.push(field.ident.name);
3317 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3318 // dynamic limit, to never omit just one field
3319 let limit = if names.len() == 6 { 6 } else { 5 };
3320 let mut display = names.iter().take(limit)
3321 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3322 if names.len() > limit {
3323 display = format!("{} ... and {} others", display, names.len() - limit);
3328 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3329 -> DiagnosticBuilder {
3330 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3331 "no field `{}` on type `{}`",
3335 fn report_unknown_field(&self,
3337 variant: &'tcx ty::VariantDef,
3339 skip_fields: &[hir::Field],
3341 let mut err = self.type_error_struct_with_diag(
3343 |actual| match ty.sty {
3344 ty::Adt(adt, ..) if adt.is_enum() => {
3345 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3346 "{} `{}::{}` has no field named `{}`",
3347 kind_name, actual, variant.name, field.ident)
3350 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3351 "{} `{}` has no field named `{}`",
3352 kind_name, actual, field.ident)
3356 // prevent all specified fields from being suggested
3357 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3358 if let Some(field_name) = Self::suggest_field_name(variant,
3359 &field.ident.as_str(),
3360 skip_fields.collect()) {
3361 err.span_label(field.ident.span,
3362 format!("field does not exist - did you mean `{}`?", field_name));
3365 ty::Adt(adt, ..) => {
3367 err.span_label(field.ident.span,
3368 format!("`{}::{}` does not have this field",
3371 err.span_label(field.ident.span,
3372 format!("`{}` does not have this field", ty));
3374 let available_field_names = self.available_field_names(variant);
3375 if !available_field_names.is_empty() {
3376 err.note(&format!("available fields are: {}",
3377 self.name_series_display(available_field_names)));
3380 _ => bug!("non-ADT passed to report_unknown_field")
3386 fn check_expr_struct_fields(&self,
3388 expected: Expectation<'tcx>,
3389 expr_id: ast::NodeId,
3391 variant: &'tcx ty::VariantDef,
3392 ast_fields: &'gcx [hir::Field],
3393 check_completeness: bool) -> bool {
3397 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3398 .get(0).cloned().unwrap_or(adt_ty);
3399 // re-link the regions that EIfEO can erase.
3400 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3402 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3403 &ty::Adt(adt, substs) => {
3404 (substs, adt.adt_kind(), adt.variant_descr())
3406 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3409 let mut remaining_fields = FxHashMap();
3410 for (i, field) in variant.fields.iter().enumerate() {
3411 remaining_fields.insert(field.ident.modern(), (i, field));
3414 let mut seen_fields = FxHashMap();
3416 let mut error_happened = false;
3418 // Typecheck each field.
3419 for field in ast_fields {
3420 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3421 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3422 seen_fields.insert(ident, field.span);
3423 self.write_field_index(field.id, i);
3425 // we don't look at stability attributes on
3426 // struct-like enums (yet...), but it's definitely not
3427 // a bug to have construct one.
3428 if adt_kind != ty::AdtKind::Enum {
3429 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3432 self.field_ty(field.span, v_field, substs)
3434 error_happened = true;
3435 if let Some(prev_span) = seen_fields.get(&ident) {
3436 let mut err = struct_span_err!(self.tcx.sess,
3439 "field `{}` specified more than once",
3442 err.span_label(field.ident.span, "used more than once");
3443 err.span_label(*prev_span, format!("first use of `{}`", ident));
3447 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3453 // Make sure to give a type to the field even if there's
3454 // an error, so we can continue typechecking
3455 self.check_expr_coercable_to_type(&field.expr, field_type);
3458 // Make sure the programmer specified correct number of fields.
3459 if kind_name == "union" {
3460 if ast_fields.len() != 1 {
3461 tcx.sess.span_err(span, "union expressions should have exactly one field");
3463 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3464 let len = remaining_fields.len();
3466 let mut displayable_field_names = remaining_fields
3468 .map(|ident| ident.as_str())
3469 .collect::<Vec<_>>();
3471 displayable_field_names.sort();
3473 let truncated_fields_error = if len <= 3 {
3476 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3479 let remaining_fields_names = displayable_field_names.iter().take(3)
3480 .map(|n| format!("`{}`", n))
3481 .collect::<Vec<_>>()
3484 struct_span_err!(tcx.sess, span, E0063,
3485 "missing field{} {}{} in initializer of `{}`",
3486 if remaining_fields.len() == 1 { "" } else { "s" },
3487 remaining_fields_names,
3488 truncated_fields_error,
3490 .span_label(span, format!("missing {}{}",
3491 remaining_fields_names,
3492 truncated_fields_error))
3498 fn check_struct_fields_on_error(&self,
3499 fields: &'gcx [hir::Field],
3500 base_expr: &'gcx Option<P<hir::Expr>>) {
3501 for field in fields {
3502 self.check_expr(&field.expr);
3506 self.check_expr(&base);
3512 pub fn check_struct_path(&self,
3514 node_id: ast::NodeId)
3515 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3516 let path_span = match *qpath {
3517 hir::QPath::Resolved(_, ref path) => path.span,
3518 hir::QPath::TypeRelative(ref qself, _) => qself.span
3520 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3521 let variant = match def {
3523 self.set_tainted_by_errors();
3526 Def::Variant(..) => {
3528 ty::Adt(adt, substs) => {
3529 Some((adt.variant_of_def(def), adt.did, substs))
3531 _ => bug!("unexpected type: {:?}", ty.sty)
3534 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3535 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3537 ty::Adt(adt, substs) if !adt.is_enum() => {
3538 Some((adt.non_enum_variant(), adt.did, substs))
3543 _ => bug!("unexpected definition: {:?}", def)
3546 if let Some((variant, did, substs)) = variant {
3547 // Check bounds on type arguments used in the path.
3548 let bounds = self.instantiate_bounds(path_span, did, substs);
3549 let cause = traits::ObligationCause::new(path_span, self.body_id,
3550 traits::ItemObligation(did));
3551 self.add_obligations_for_parameters(cause, &bounds);
3555 struct_span_err!(self.tcx.sess, path_span, E0071,
3556 "expected struct, variant or union type, found {}",
3557 ty.sort_string(self.tcx))
3558 .span_label(path_span, "not a struct")
3564 fn check_expr_struct(&self,
3566 expected: Expectation<'tcx>,
3568 fields: &'gcx [hir::Field],
3569 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3571 // Find the relevant variant
3572 let (variant, struct_ty) =
3573 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3576 self.check_struct_fields_on_error(fields, base_expr);
3577 return self.tcx.types.err;
3580 let path_span = match *qpath {
3581 hir::QPath::Resolved(_, ref path) => path.span,
3582 hir::QPath::TypeRelative(ref qself, _) => qself.span
3585 // Prohibit struct expressions when non exhaustive flag is set.
3586 if let ty::Adt(adt, _) = struct_ty.sty {
3587 if !adt.did.is_local() && adt.is_non_exhaustive() {
3588 span_err!(self.tcx.sess, expr.span, E0639,
3589 "cannot create non-exhaustive {} using struct expression",
3590 adt.variant_descr());
3594 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3595 variant, fields, base_expr.is_none());
3596 if let &Some(ref base_expr) = base_expr {
3597 // If check_expr_struct_fields hit an error, do not attempt to populate
3598 // the fields with the base_expr. This could cause us to hit errors later
3599 // when certain fields are assumed to exist that in fact do not.
3600 if !error_happened {
3601 self.check_expr_has_type_or_error(base_expr, struct_ty);
3602 match struct_ty.sty {
3603 ty::Adt(adt, substs) if adt.is_struct() => {
3604 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3605 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3610 .fru_field_types_mut()
3611 .insert(expr.hir_id, fru_field_types);
3614 span_err!(self.tcx.sess, base_expr.span, E0436,
3615 "functional record update syntax requires a struct");
3620 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3626 /// If an expression has any sub-expressions that result in a type error,
3627 /// inspecting that expression's type with `ty.references_error()` will return
3628 /// true. Likewise, if an expression is known to diverge, inspecting its
3629 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3630 /// strict, _|_ can appear in the type of an expression that does not,
3631 /// itself, diverge: for example, fn() -> _|_.)
3632 /// Note that inspecting a type's structure *directly* may expose the fact
3633 /// that there are actually multiple representations for `Error`, so avoid
3634 /// that when err needs to be handled differently.
3635 fn check_expr_with_expectation_and_needs(&self,
3636 expr: &'gcx hir::Expr,
3637 expected: Expectation<'tcx>,
3638 needs: Needs) -> Ty<'tcx> {
3639 debug!(">> typechecking: expr={:?} expected={:?}",
3642 // Warn for expressions after diverging siblings.
3643 self.warn_if_unreachable(expr.id, expr.span, "expression");
3645 // Hide the outer diverging and has_errors flags.
3646 let old_diverges = self.diverges.get();
3647 let old_has_errors = self.has_errors.get();
3648 self.diverges.set(Diverges::Maybe);
3649 self.has_errors.set(false);
3651 let ty = self.check_expr_kind(expr, expected, needs);
3653 // Warn for non-block expressions with diverging children.
3655 hir::ExprKind::Block(..) |
3656 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3657 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3659 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3662 // Any expression that produces a value of type `!` must have diverged
3664 self.diverges.set(self.diverges.get() | Diverges::Always);
3667 // Record the type, which applies it effects.
3668 // We need to do this after the warning above, so that
3669 // we don't warn for the diverging expression itself.
3670 self.write_ty(expr.hir_id, ty);
3672 // Combine the diverging and has_error flags.
3673 self.diverges.set(self.diverges.get() | old_diverges);
3674 self.has_errors.set(self.has_errors.get() | old_has_errors);
3676 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3677 debug!("... {:?}, expected is {:?}", ty, expected);
3682 fn check_expr_kind(&self,
3683 expr: &'gcx hir::Expr,
3684 expected: Expectation<'tcx>,
3685 needs: Needs) -> Ty<'tcx> {
3689 hir::ExprKind::Box(ref subexpr) => {
3690 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3692 ty::Adt(def, _) if def.is_box()
3693 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3697 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3698 tcx.mk_box(referent_ty)
3701 hir::ExprKind::Lit(ref lit) => {
3702 self.check_lit(&lit, expected)
3704 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3705 self.check_binop(expr, op, lhs, rhs)
3707 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3708 self.check_binop_assign(expr, op, lhs, rhs)
3710 hir::ExprKind::Unary(unop, ref oprnd) => {
3711 let expected_inner = match unop {
3712 hir::UnNot | hir::UnNeg => {
3719 let needs = match unop {
3720 hir::UnDeref => needs,
3723 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3727 if !oprnd_t.references_error() {
3728 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3731 if let Some(mt) = oprnd_t.builtin_deref(true) {
3733 } else if let Some(ok) = self.try_overloaded_deref(
3734 expr.span, oprnd_t, needs) {
3735 let method = self.register_infer_ok_obligations(ok);
3736 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3737 let mutbl = match mutbl {
3738 hir::MutImmutable => AutoBorrowMutability::Immutable,
3739 hir::MutMutable => AutoBorrowMutability::Mutable {
3740 // (It shouldn't actually matter for unary ops whether
3741 // we enable two-phase borrows or not, since a unary
3742 // op has no additional operands.)
3743 allow_two_phase_borrow: AllowTwoPhase::No,
3746 self.apply_adjustments(oprnd, vec![Adjustment {
3747 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3748 target: method.sig.inputs()[0]
3751 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3752 self.write_method_call(expr.hir_id, method);
3754 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3755 "type `{}` cannot be dereferenced",
3757 oprnd_t = tcx.types.err;
3761 let result = self.check_user_unop(expr, oprnd_t, unop);
3762 // If it's builtin, we can reuse the type, this helps inference.
3763 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3768 let result = self.check_user_unop(expr, oprnd_t, unop);
3769 // If it's builtin, we can reuse the type, this helps inference.
3770 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3778 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3779 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3781 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
3782 if self.is_place_expr(&oprnd) {
3783 // Places may legitimately have unsized types.
3784 // For example, dereferences of a fat pointer and
3785 // the last field of a struct can be unsized.
3788 Expectation::rvalue_hint(self, ty)
3794 let needs = Needs::maybe_mut_place(mutbl);
3795 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3797 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3798 if tm.ty.references_error() {
3801 // Note: at this point, we cannot say what the best lifetime
3802 // is to use for resulting pointer. We want to use the
3803 // shortest lifetime possible so as to avoid spurious borrowck
3804 // errors. Moreover, the longest lifetime will depend on the
3805 // precise details of the value whose address is being taken
3806 // (and how long it is valid), which we don't know yet until type
3807 // inference is complete.
3809 // Therefore, here we simply generate a region variable. The
3810 // region inferencer will then select the ultimate value.
3811 // Finally, borrowck is charged with guaranteeing that the
3812 // value whose address was taken can actually be made to live
3813 // as long as it needs to live.
3814 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3815 tcx.mk_ref(region, tm)
3818 hir::ExprKind::Path(ref qpath) => {
3819 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3820 let ty = if def != Def::Err {
3821 self.instantiate_value_path(segs, opt_ty, def, expr.span, id)
3823 self.set_tainted_by_errors();
3827 // We always require that the type provided as the value for
3828 // a type parameter outlives the moment of instantiation.
3829 let substs = self.tables.borrow().node_substs(expr.hir_id);
3830 self.add_wf_bounds(substs, expr);
3834 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3835 for output in outputs {
3836 self.check_expr(output);
3838 for input in inputs {
3839 self.check_expr(input);
3843 hir::ExprKind::Break(destination, ref expr_opt) => {
3844 if let Ok(target_id) = destination.target_id {
3846 if let Some(ref e) = *expr_opt {
3847 // If this is a break with a value, we need to type-check
3848 // the expression. Get an expected type from the loop context.
3849 let opt_coerce_to = {
3850 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3851 enclosing_breakables.find_breakable(target_id)
3854 .map(|coerce| coerce.expected_ty())
3857 // If the loop context is not a `loop { }`, then break with
3858 // a value is illegal, and `opt_coerce_to` will be `None`.
3859 // Just set expectation to error in that case.
3860 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3862 // Recurse without `enclosing_breakables` borrowed.
3863 e_ty = self.check_expr_with_hint(e, coerce_to);
3864 cause = self.misc(e.span);
3866 // Otherwise, this is a break *without* a value. That's
3867 // always legal, and is equivalent to `break ()`.
3868 e_ty = tcx.mk_nil();
3869 cause = self.misc(expr.span);
3872 // Now that we have type-checked `expr_opt`, borrow
3873 // the `enclosing_loops` field and let's coerce the
3874 // type of `expr_opt` into what is expected.
3875 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3876 let ctxt = enclosing_breakables.find_breakable(target_id);
3877 if let Some(ref mut coerce) = ctxt.coerce {
3878 if let Some(ref e) = *expr_opt {
3879 coerce.coerce(self, &cause, e, e_ty);
3881 assert!(e_ty.is_nil());
3882 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3885 // If `ctxt.coerce` is `None`, we can just ignore
3886 // the type of the expresison. This is because
3887 // either this was a break *without* a value, in
3888 // which case it is always a legal type (`()`), or
3889 // else an error would have been flagged by the
3890 // `loops` pass for using break with an expression
3891 // where you are not supposed to.
3892 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3895 ctxt.may_break = true;
3897 // the type of a `break` is always `!`, since it diverges
3900 // Otherwise, we failed to find the enclosing loop;
3901 // this can only happen if the `break` was not
3902 // inside a loop at all, which is caught by the
3903 // loop-checking pass.
3904 if self.tcx.sess.err_count() == 0 {
3905 self.tcx.sess.delay_span_bug(expr.span,
3906 "break was outside loop, but no error was emitted");
3909 // We still need to assign a type to the inner expression to
3910 // prevent the ICE in #43162.
3911 if let Some(ref e) = *expr_opt {
3912 self.check_expr_with_hint(e, tcx.types.err);
3914 // ... except when we try to 'break rust;'.
3915 // ICE this expression in particular (see #43162).
3916 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
3917 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3918 fatally_break_rust(self.tcx.sess);
3922 // There was an error, make typecheck fail
3927 hir::ExprKind::Continue(destination) => {
3928 if destination.target_id.is_ok() {
3931 // There was an error, make typecheck fail
3935 hir::ExprKind::Ret(ref expr_opt) => {
3936 if self.ret_coercion.is_none() {
3937 struct_span_err!(self.tcx.sess, expr.span, E0572,
3938 "return statement outside of function body").emit();
3939 } else if let Some(ref e) = *expr_opt {
3940 self.check_return_expr(e);
3942 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3943 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3944 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3948 hir::ExprKind::Assign(ref lhs, ref rhs) => {
3949 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3951 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3954 ExpectIfCondition => {
3955 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3956 expected error elsehwere");
3959 // Only check this if not in an `if` condition, as the
3960 // mistyped comparison help is more appropriate.
3961 if !self.is_place_expr(&lhs) {
3962 struct_span_err!(self.tcx.sess, expr.span, E0070,
3963 "invalid left-hand side expression")
3964 .span_label(expr.span, "left-hand of expression not valid")
3970 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3972 if lhs_ty.references_error() || rhs_ty.references_error() {
3978 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
3979 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3980 expr.span, expected)
3982 hir::ExprKind::While(ref cond, ref body, _) => {
3983 let ctxt = BreakableCtxt {
3984 // cannot use break with a value from a while loop
3986 may_break: false, // Will get updated if/when we find a `break`.
3989 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3990 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3991 let cond_diverging = self.diverges.get();
3992 self.check_block_no_value(&body);
3994 // We may never reach the body so it diverging means nothing.
3995 self.diverges.set(cond_diverging);
3999 // No way to know whether it's diverging because
4000 // of a `break` or an outer `break` or `return`.
4001 self.diverges.set(Diverges::Maybe);
4006 hir::ExprKind::Loop(ref body, _, source) => {
4007 let coerce = match source {
4008 // you can only use break with a value from a normal `loop { }`
4009 hir::LoopSource::Loop => {
4010 let coerce_to = expected.coercion_target_type(self, body.span);
4011 Some(CoerceMany::new(coerce_to))
4014 hir::LoopSource::WhileLet |
4015 hir::LoopSource::ForLoop => {
4020 let ctxt = BreakableCtxt {
4022 may_break: false, // Will get updated if/when we find a `break`.
4025 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4026 self.check_block_no_value(&body);
4030 // No way to know whether it's diverging because
4031 // of a `break` or an outer `break` or `return`.
4032 self.diverges.set(Diverges::Maybe);
4035 // If we permit break with a value, then result type is
4036 // the LUB of the breaks (possibly ! if none); else, it
4037 // is nil. This makes sense because infinite loops
4038 // (which would have type !) are only possible iff we
4039 // permit break with a value [1].
4040 if ctxt.coerce.is_none() && !ctxt.may_break {
4042 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4044 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
4046 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4047 self.check_match(expr, &discrim, arms, expected, match_src)
4049 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4050 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4052 hir::ExprKind::Block(ref body, _) => {
4053 self.check_block_with_expected(&body, expected)
4055 hir::ExprKind::Call(ref callee, ref args) => {
4056 self.check_call(expr, &callee, args, expected)
4058 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4059 self.check_method_call(expr, segment, span, args, expected, needs)
4061 hir::ExprKind::Cast(ref e, ref t) => {
4062 // Find the type of `e`. Supply hints based on the type we are casting to,
4064 let t_cast = self.to_ty(t);
4065 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4066 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4067 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4069 // Eagerly check for some obvious errors.
4070 if t_expr.references_error() || t_cast.references_error() {
4073 // Defer other checks until we're done type checking.
4074 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4075 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4077 deferred_cast_checks.push(cast_check);
4080 Err(ErrorReported) => {
4086 hir::ExprKind::Type(ref e, ref t) => {
4087 let ty = self.to_ty(&t);
4088 self.check_expr_eq_type(&e, ty);
4091 hir::ExprKind::Array(ref args) => {
4092 let uty = expected.to_option(self).and_then(|uty| {
4094 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4099 let element_ty = if !args.is_empty() {
4100 let coerce_to = uty.unwrap_or_else(
4101 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4102 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4103 assert_eq!(self.diverges.get(), Diverges::Maybe);
4105 let e_ty = self.check_expr_with_hint(e, coerce_to);
4106 let cause = self.misc(e.span);
4107 coerce.coerce(self, &cause, e, e_ty);
4109 coerce.complete(self)
4111 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4113 tcx.mk_array(element_ty, args.len() as u64)
4115 hir::ExprKind::Repeat(ref element, ref count) => {
4116 let count_def_id = tcx.hir.local_def_id(count.id);
4117 let param_env = ty::ParamEnv::empty();
4118 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4119 let instance = ty::Instance::resolve(
4125 let global_id = GlobalId {
4129 let count = tcx.const_eval(param_env.and(global_id));
4131 if let Err(ref err) = count {
4132 err.report_as_error(
4133 tcx.at(tcx.def_span(count_def_id)),
4134 "could not evaluate repeat length",
4138 let uty = match expected {
4139 ExpectHasType(uty) => {
4141 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4148 let (element_ty, t) = match uty {
4150 self.check_expr_coercable_to_type(&element, uty);
4154 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4155 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4160 if let Ok(count) = count {
4161 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4163 // For [foo, ..n] where n > 1, `foo` must have
4165 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4166 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4170 if element_ty.references_error() {
4172 } else if let Ok(count) = count {
4173 tcx.mk_ty(ty::Array(t, count))
4178 hir::ExprKind::Tup(ref elts) => {
4179 let flds = expected.only_has_type(self).and_then(|ty| {
4180 let ty = self.resolve_type_vars_with_obligations(ty);
4182 ty::Tuple(ref flds) => Some(&flds[..]),
4187 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4188 let t = match flds {
4189 Some(ref fs) if i < fs.len() => {
4191 self.check_expr_coercable_to_type(&e, ety);
4195 self.check_expr_with_expectation(&e, NoExpectation)
4200 let tuple = tcx.mk_tup(elt_ts_iter);
4201 if tuple.references_error() {
4204 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4208 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4209 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4211 hir::ExprKind::Field(ref base, field) => {
4212 self.check_field(expr, needs, &base, field)
4214 hir::ExprKind::Index(ref base, ref idx) => {
4215 let base_t = self.check_expr_with_needs(&base, needs);
4216 let idx_t = self.check_expr(&idx);
4218 if base_t.references_error() {
4220 } else if idx_t.references_error() {
4223 let base_t = self.structurally_resolved_type(base.span, base_t);
4224 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4225 Some((index_ty, element_ty)) => {
4226 // two-phase not needed because index_ty is never mutable
4227 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4232 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4233 "cannot index into a value of type `{}`",
4235 // Try to give some advice about indexing tuples.
4236 if let ty::Tuple(..) = base_t.sty {
4237 let mut needs_note = true;
4238 // If the index is an integer, we can show the actual
4239 // fixed expression:
4240 if let hir::ExprKind::Lit(ref lit) = idx.node {
4241 if let ast::LitKind::Int(i,
4242 ast::LitIntType::Unsuffixed) = lit.node {
4243 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4244 if let Ok(snip) = snip {
4245 err.span_suggestion_with_applicability(
4247 "to access tuple elements, use",
4248 format!("{}.{}", snip, i),
4249 Applicability::MachineApplicable);
4255 err.help("to access tuple elements, use tuple indexing \
4256 syntax (e.g. `tuple.0`)");
4265 hir::ExprKind::Yield(ref value) => {
4266 match self.yield_ty {
4268 self.check_expr_coercable_to_type(&value, ty);
4271 struct_span_err!(self.tcx.sess, expr.span, E0627,
4272 "yield statement outside of generator literal").emit();
4280 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4281 // The newly resolved definition is written into `type_dependent_defs`.
4282 fn finish_resolving_struct_path(&self,
4285 node_id: ast::NodeId)
4289 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4290 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4291 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4294 hir::QPath::TypeRelative(ref qself, ref segment) => {
4295 let ty = self.to_ty(qself);
4297 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4302 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4305 // Write back the new resolution.
4306 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4307 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4314 // Resolve associated value path into a base type and associated constant or method definition.
4315 // The newly resolved definition is written into `type_dependent_defs`.
4316 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4317 qpath: &'b hir::QPath,
4318 node_id: ast::NodeId,
4320 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4322 let (ty, item_segment) = match *qpath {
4323 hir::QPath::Resolved(ref opt_qself, ref path) => {
4325 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4326 &path.segments[..]);
4328 hir::QPath::TypeRelative(ref qself, ref segment) => {
4329 (self.to_ty(qself), segment)
4332 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4333 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4334 // Return directly on cache hit. This is useful to avoid doubly reporting
4335 // errors with default match binding modes. See #44614.
4336 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4338 let item_name = item_segment.ident;
4339 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4342 let def = match error {
4343 method::MethodError::PrivateMatch(def, _) => def,
4346 if item_name.name != keywords::Invalid.name() {
4347 self.report_method_error(span, ty, item_name, None, error, None);
4353 // Write back the new resolution.
4354 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4355 (def, Some(ty), slice::from_ref(&**item_segment))
4358 pub fn check_decl_initializer(&self,
4359 local: &'gcx hir::Local,
4360 init: &'gcx hir::Expr) -> Ty<'tcx>
4362 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4363 // for #42640 (default match binding modes).
4366 let ref_bindings = local.pat.contains_explicit_ref_binding();
4368 let local_ty = self.local_ty(init.span, local.id);
4369 if let Some(m) = ref_bindings {
4370 // Somewhat subtle: if we have a `ref` binding in the pattern,
4371 // we want to avoid introducing coercions for the RHS. This is
4372 // both because it helps preserve sanity and, in the case of
4373 // ref mut, for soundness (issue #23116). In particular, in
4374 // the latter case, we need to be clear that the type of the
4375 // referent for the reference that results is *equal to* the
4376 // type of the place it is referencing, and not some
4377 // supertype thereof.
4378 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4379 self.demand_eqtype(init.span, local_ty, init_ty);
4382 self.check_expr_coercable_to_type(init, local_ty)
4386 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4387 let t = self.local_ty(local.span, local.id);
4388 self.write_ty(local.hir_id, t);
4390 if let Some(ref init) = local.init {
4391 let init_ty = self.check_decl_initializer(local, &init);
4392 if init_ty.references_error() {
4393 self.write_ty(local.hir_id, init_ty);
4397 self.check_pat_walk(&local.pat, t,
4398 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4400 let pat_ty = self.node_ty(local.pat.hir_id);
4401 if pat_ty.references_error() {
4402 self.write_ty(local.hir_id, pat_ty);
4406 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4407 // Don't do all the complex logic below for DeclItem.
4409 hir::StmtKind::Decl(ref decl, _) => {
4411 hir::DeclKind::Local(_) => {}
4412 hir::DeclKind::Item(_) => {
4417 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4420 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4422 // Hide the outer diverging and has_errors flags.
4423 let old_diverges = self.diverges.get();
4424 let old_has_errors = self.has_errors.get();
4425 self.diverges.set(Diverges::Maybe);
4426 self.has_errors.set(false);
4429 hir::StmtKind::Decl(ref decl, _) => {
4431 hir::DeclKind::Local(ref l) => {
4432 self.check_decl_local(&l);
4434 hir::DeclKind::Item(_) => {/* ignore for now */}
4437 hir::StmtKind::Expr(ref expr, _) => {
4438 // Check with expected type of ()
4439 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4441 hir::StmtKind::Semi(ref expr, _) => {
4442 self.check_expr(&expr);
4446 // Combine the diverging and has_error flags.
4447 self.diverges.set(self.diverges.get() | old_diverges);
4448 self.has_errors.set(self.has_errors.get() | old_has_errors);
4451 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4452 let unit = self.tcx.mk_nil();
4453 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4455 // if the block produces a `!` value, that can always be
4456 // (effectively) coerced to unit.
4458 self.demand_suptype(blk.span, unit, ty);
4462 fn check_block_with_expected(&self,
4463 blk: &'gcx hir::Block,
4464 expected: Expectation<'tcx>) -> Ty<'tcx> {
4466 let mut fcx_ps = self.ps.borrow_mut();
4467 let unsafety_state = fcx_ps.recurse(blk);
4468 replace(&mut *fcx_ps, unsafety_state)
4471 // In some cases, blocks have just one exit, but other blocks
4472 // can be targeted by multiple breaks. This can happen both
4473 // with labeled blocks as well as when we desugar
4474 // a `try { ... }` expression.
4478 // 'a: { if true { break 'a Err(()); } Ok(()) }
4480 // Here we would wind up with two coercions, one from
4481 // `Err(())` and the other from the tail expression
4482 // `Ok(())`. If the tail expression is omitted, that's a
4483 // "forced unit" -- unless the block diverges, in which
4484 // case we can ignore the tail expression (e.g., `'a: {
4485 // break 'a 22; }` would not force the type of the block
4487 let tail_expr = blk.expr.as_ref();
4488 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4489 let coerce = if blk.targeted_by_break {
4490 CoerceMany::new(coerce_to_ty)
4492 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4493 Some(e) => slice::from_ref(e),
4496 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4499 let prev_diverges = self.diverges.get();
4500 let ctxt = BreakableCtxt {
4501 coerce: Some(coerce),
4505 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4506 for s in &blk.stmts {
4510 // check the tail expression **without** holding the
4511 // `enclosing_breakables` lock below.
4512 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4514 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4515 let ctxt = enclosing_breakables.find_breakable(blk.id);
4516 let coerce = ctxt.coerce.as_mut().unwrap();
4517 if let Some(tail_expr_ty) = tail_expr_ty {
4518 let tail_expr = tail_expr.unwrap();
4519 let cause = self.cause(tail_expr.span,
4520 ObligationCauseCode::BlockTailExpression(blk.id));
4526 // Subtle: if there is no explicit tail expression,
4527 // that is typically equivalent to a tail expression
4528 // of `()` -- except if the block diverges. In that
4529 // case, there is no value supplied from the tail
4530 // expression (assuming there are no other breaks,
4531 // this implies that the type of the block will be
4534 // #41425 -- label the implicit `()` as being the
4535 // "found type" here, rather than the "expected type".
4537 // #44579 -- if the block was recovered during parsing,
4538 // the type would be nonsensical and it is not worth it
4539 // to perform the type check, so we avoid generating the
4540 // diagnostic output.
4541 if !self.diverges.get().always() && !blk.recovered {
4542 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4543 if let Some(expected_ty) = expected.only_has_type(self) {
4544 self.consider_hint_about_removing_semicolon(blk,
4554 // If we can break from the block, then the block's exit is always reachable
4555 // (... as long as the entry is reachable) - regardless of the tail of the block.
4556 self.diverges.set(prev_diverges);
4559 let mut ty = ctxt.coerce.unwrap().complete(self);
4561 if self.has_errors.get() || ty.references_error() {
4562 ty = self.tcx.types.err
4565 self.write_ty(blk.hir_id, ty);
4567 *self.ps.borrow_mut() = prev;
4571 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4572 /// suggestion can be made, `None` otherwise.
4573 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4574 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4575 // `while` before reaching it, as block tail returns are not available in them.
4576 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4577 let parent = self.tcx.hir.get(fn_id);
4579 if let Node::NodeItem(&hir::Item {
4580 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4582 decl.clone().and_then(|decl| {
4583 // This is less than ideal, it will not suggest a return type span on any
4584 // method called `main`, regardless of whether it is actually the entry point,
4585 // but it will still present it as the reason for the expected type.
4586 Some((decl, name != Symbol::intern("main")))
4588 } else if let Node::NodeTraitItem(&hir::TraitItem {
4589 node: hir::TraitItemKind::Method(hir::MethodSig {
4593 decl.clone().and_then(|decl| {
4596 } else if let Node::NodeImplItem(&hir::ImplItem {
4597 node: hir::ImplItemKind::Method(hir::MethodSig {
4601 decl.clone().and_then(|decl| {
4612 /// On implicit return expressions with mismatched types, provide the following suggestions:
4614 /// - Point out the method's return type as the reason for the expected type
4615 /// - Possible missing semicolon
4616 /// - Possible missing return type if the return type is the default, and not `fn main()`
4617 pub fn suggest_mismatched_types_on_tail(&self,
4618 err: &mut DiagnosticBuilder<'tcx>,
4619 expression: &'gcx hir::Expr,
4623 blk_id: ast::NodeId) {
4624 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4625 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4626 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4628 self.suggest_ref_or_into(err, expression, expected, found);
4631 pub fn suggest_ref_or_into(
4633 err: &mut DiagnosticBuilder<'tcx>,
4638 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4639 err.span_suggestion(sp, msg, suggestion);
4640 } else if !self.check_for_cast(err, expr, found, expected) {
4641 let methods = self.get_conversion_methods(expr.span, expected, found);
4642 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4643 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4644 .filter_map(|(receiver, method)| {
4645 let method_call = format!(".{}()", method.ident);
4646 if receiver.ends_with(&method_call) {
4647 None // do not suggest code that is already there (#53348)
4649 Some(format!("{}{}", receiver, method_call))
4651 }) .collect::<Vec<_>>();
4652 if !suggestions.is_empty() {
4653 err.span_suggestions(expr.span, "try using a conversion method", suggestions);
4659 /// A common error is to forget to add a semicolon at the end of a block:
4663 /// bar_that_returns_u32()
4667 /// This routine checks if the return expression in a block would make sense on its own as a
4668 /// statement and the return type has been left as default or has been specified as `()`. If so,
4669 /// it suggests adding a semicolon.
4670 fn suggest_missing_semicolon(&self,
4671 err: &mut DiagnosticBuilder<'tcx>,
4672 expression: &'gcx hir::Expr,
4675 if expected.is_nil() {
4676 // `BlockTailExpression` only relevant if the tail expr would be
4677 // useful on its own.
4678 match expression.node {
4679 hir::ExprKind::Call(..) |
4680 hir::ExprKind::MethodCall(..) |
4681 hir::ExprKind::If(..) |
4682 hir::ExprKind::While(..) |
4683 hir::ExprKind::Loop(..) |
4684 hir::ExprKind::Match(..) |
4685 hir::ExprKind::Block(..) => {
4686 let sp = self.tcx.sess.source_map().next_point(cause_span);
4687 err.span_suggestion_with_applicability(
4689 "try adding a semicolon",
4691 Applicability::MachineApplicable);
4699 /// A possible error is to forget to add a return type that is needed:
4703 /// bar_that_returns_u32()
4707 /// This routine checks if the return type is left as default, the method is not part of an
4708 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4710 fn suggest_missing_return_type(&self,
4711 err: &mut DiagnosticBuilder<'tcx>,
4712 fn_decl: &hir::FnDecl,
4715 can_suggest: bool) {
4716 // Only suggest changing the return type for methods that
4717 // haven't set a return type at all (and aren't `fn main()` or an impl).
4718 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_nil()) {
4719 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4720 err.span_suggestion_with_applicability(
4722 "try adding a return type",
4723 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4724 Applicability::MachineApplicable);
4726 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4727 err.span_label(span, "possibly return type missing here?");
4729 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4730 // `fn main()` must return `()`, do not suggest changing return type
4731 err.span_label(span, "expected `()` because of default return type");
4733 // expectation was caused by something else, not the default return
4734 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4735 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4736 // Only point to return type if the expected type is the return type, as if they
4737 // are not, the expectation must have been caused by something else.
4738 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4740 let ty = AstConv::ast_ty_to_ty(self, ty);
4741 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4742 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4743 if ty.sty == expected.sty {
4744 err.span_label(sp, format!("expected `{}` because of return type",
4752 /// A common error is to add an extra semicolon:
4755 /// fn foo() -> usize {
4760 /// This routine checks if the final statement in a block is an
4761 /// expression with an explicit semicolon whose type is compatible
4762 /// with `expected_ty`. If so, it suggests removing the semicolon.
4763 fn consider_hint_about_removing_semicolon(&self,
4764 blk: &'gcx hir::Block,
4765 expected_ty: Ty<'tcx>,
4766 err: &mut DiagnosticBuilder) {
4767 // Be helpful when the user wrote `{... expr;}` and
4768 // taking the `;` off is enough to fix the error.
4769 let last_stmt = match blk.stmts.last() {
4773 let last_expr = match last_stmt.node {
4774 hir::StmtKind::Semi(ref e, _) => e,
4777 let last_expr_ty = self.node_ty(last_expr.hir_id);
4778 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4781 let original_span = original_sp(last_stmt.span, blk.span);
4782 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4783 err.span_suggestion_with_applicability(
4785 "consider removing this semicolon",
4787 Applicability::MachineApplicable);
4790 fn def_ids_for_path_segments(&self,
4791 segments: &[hir::PathSegment],
4794 // We need to extract the type parameters supplied by the user in
4795 // the path `path`. Due to the current setup, this is a bit of a
4796 // tricky-process; the problem is that resolve only tells us the
4797 // end-point of the path resolution, and not the intermediate steps.
4798 // Luckily, we can (at least for now) deduce the intermediate steps
4799 // just from the end-point.
4801 // There are basically four cases to consider:
4803 // 1. Reference to a constructor of enum variant or struct:
4805 // struct Foo<T>(...)
4806 // enum E<T> { Foo(...) }
4808 // In these cases, the parameters are declared in the type
4811 // 2. Reference to a fn item or a free constant:
4815 // In this case, the path will again always have the form
4816 // `a::b::foo::<T>` where only the final segment should have
4817 // type parameters. However, in this case, those parameters are
4818 // declared on a value, and hence are in the `FnSpace`.
4820 // 3. Reference to a method or an associated constant:
4822 // impl<A> SomeStruct<A> {
4826 // Here we can have a path like
4827 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4828 // may appear in two places. The penultimate segment,
4829 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4830 // final segment, `foo::<B>` contains parameters in fn space.
4832 // 4. Reference to a local variable
4834 // Local variables can't have any type parameters.
4836 // The first step then is to categorize the segments appropriately.
4838 assert!(!segments.is_empty());
4839 let last = segments.len() - 1;
4841 let mut path_segs = vec![];
4844 // Case 1. Reference to a struct/variant constructor.
4845 Def::StructCtor(def_id, ..) |
4846 Def::VariantCtor(def_id, ..) => {
4847 // Everything but the final segment should have no
4848 // parameters at all.
4849 let generics = self.tcx.generics_of(def_id);
4850 // Variant and struct constructors use the
4851 // generics of their parent type definition.
4852 let generics_def_id = generics.parent.unwrap_or(def_id);
4853 path_segs.push(PathSeg(generics_def_id, last));
4856 // Case 2. Reference to a top-level value.
4858 Def::Const(def_id) |
4859 Def::Static(def_id, _) => {
4860 path_segs.push(PathSeg(def_id, last));
4863 // Case 3. Reference to a method or associated const.
4864 Def::Method(def_id) |
4865 Def::AssociatedConst(def_id) => {
4866 if segments.len() >= 2 {
4867 let generics = self.tcx.generics_of(def_id);
4868 path_segs.push(PathSeg(generics.parent.unwrap(), last - 1));
4870 path_segs.push(PathSeg(def_id, last));
4873 // Case 4. Local variable, no generics.
4874 Def::Local(..) | Def::Upvar(..) => {}
4876 _ => bug!("unexpected definition: {:?}", def),
4879 debug!("path_segs = {:?}", path_segs);
4884 // Instantiates the given path, which must refer to an item with the given
4885 // number of type parameters and type.
4886 pub fn instantiate_value_path(&self,
4887 segments: &[hir::PathSegment],
4888 self_ty: Option<Ty<'tcx>>,
4891 node_id: ast::NodeId)
4893 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4898 let path_segs = self.def_ids_for_path_segments(segments, def);
4900 let mut ufcs_associated = None;
4902 Def::Method(def_id) |
4903 Def::AssociatedConst(def_id) => {
4904 let container = self.tcx.associated_item(def_id).container;
4906 ty::TraitContainer(trait_did) => {
4907 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4909 ty::ImplContainer(_) => {}
4911 if segments.len() == 1 {
4912 // `<T>::assoc` will end up here, and so can `T::assoc`.
4913 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4914 ufcs_associated = Some((container, self_ty));
4920 // Now that we have categorized what space the parameters for each
4921 // segment belong to, let's sort out the parameters that the user
4922 // provided (if any) into their appropriate spaces. We'll also report
4923 // errors if type parameters are provided in an inappropriate place.
4925 let mut generic_segs = FxHashSet::default();
4926 for PathSeg(_, index) in &path_segs {
4927 generic_segs.insert(index);
4929 AstConv::prohibit_generics(self, segments.iter().enumerate().filter_map(|(index, seg)| {
4930 if !generic_segs.contains(&index) {
4938 Def::Local(nid) | Def::Upvar(nid, ..) => {
4939 let ty = self.local_ty(span, nid);
4940 let ty = self.normalize_associated_types_in(span, &ty);
4941 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4947 // Now we have to compare the types that the user *actually*
4948 // provided against the types that were *expected*. If the user
4949 // did not provide any types, then we want to substitute inference
4950 // variables. If the user provided some types, we may still need
4951 // to add defaults. If the user provided *too many* types, that's
4954 let mut infer_args_for_err = FxHashSet::default();
4955 for &PathSeg(def_id, index) in &path_segs {
4956 let seg = &segments[index];
4957 let generics = self.tcx.generics_of(def_id);
4958 // Argument-position `impl Trait` is treated as a normal generic
4959 // parameter internally, but we don't allow users to specify the
4960 // parameter's value explicitly, so we have to do some error-
4962 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4967 false, // `is_method_call`
4969 if suppress_errors {
4970 infer_args_for_err.insert(index);
4971 self.set_tainted_by_errors(); // See issue #53251.
4975 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4976 self.tcx.generics_of(*def_id).has_self
4977 }).unwrap_or(false);
4979 let def_id = def.def_id();
4981 let substs = AstConv::create_substs_for_generic_args(
4987 // Provide the generic args, and whether types should be inferred.
4989 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4992 // If we've encountered an `impl Trait`-related error, we're just
4993 // going to infer the arguments for better error messages.
4994 if !infer_args_for_err.contains(&index) {
4995 // Check whether the user has provided generic arguments.
4996 if let Some(ref data) = segments[index].args {
4997 return (Some(data), segments[index].infer_types);
5000 return (None, segments[index].infer_types);
5005 // Provide substitutions for parameters for which (valid) arguments have been provided.
5007 match (¶m.kind, arg) {
5008 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5009 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5011 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5012 self.to_ty(ty).into()
5014 _ => unreachable!(),
5017 // Provide substitutions for parameters for which arguments are inferred.
5018 |substs, param, infer_types| {
5020 GenericParamDefKind::Lifetime => {
5021 self.re_infer(span, Some(param)).unwrap().into()
5023 GenericParamDefKind::Type { has_default, .. } => {
5024 if !infer_types && has_default {
5025 // If we have a default, then we it doesn't matter that we're not
5026 // inferring the type arguments: we provide the default where any
5028 let default = self.tcx.type_of(param.def_id);
5031 default.subst_spanned(self.tcx, substs.unwrap(), Some(span))
5034 // If no type arguments were provided, we have to infer them.
5035 // This case also occurs as a result of some malformed input, e.g.
5036 // a lifetime argument being given instead of a type paramter.
5037 // Using inference instead of `Error` gives better error messages.
5038 self.var_for_def(span, param)
5045 // The things we are substituting into the type should not contain
5046 // escaping late-bound regions, and nor should the base type scheme.
5047 let ty = self.tcx.type_of(def_id);
5048 assert!(!substs.has_escaping_regions());
5049 assert!(!ty.has_escaping_regions());
5051 // Add all the obligations that are required, substituting and
5052 // normalized appropriately.
5053 let bounds = self.instantiate_bounds(span, def_id, &substs);
5054 self.add_obligations_for_parameters(
5055 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5058 // Substitute the values for the type parameters into the type of
5059 // the referenced item.
5060 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5062 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
5063 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5064 // is inherent, there is no `Self` parameter, instead, the impl needs
5065 // type parameters, which we can infer by unifying the provided `Self`
5066 // with the substituted impl type.
5067 let ty = self.tcx.type_of(impl_def_id);
5069 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5070 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5071 Ok(ok) => self.register_infer_ok_obligations(ok),
5074 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5081 self.check_rustc_args_require_const(def_id, node_id, span);
5083 debug!("instantiate_value_path: type of {:?} is {:?}",
5086 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
5090 fn check_rustc_args_require_const(&self,
5092 node_id: ast::NodeId,
5094 // We're only interested in functions tagged with
5095 // #[rustc_args_required_const], so ignore anything that's not.
5096 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5100 // If our calling expression is indeed the function itself, we're good!
5101 // If not, generate an error that this can only be called directly.
5102 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5103 Node::NodeExpr(expr) => {
5105 hir::ExprKind::Call(ref callee, ..) => {
5106 if callee.id == node_id {
5116 self.tcx.sess.span_err(span, "this function can only be invoked \
5117 directly, not through a function pointer");
5120 // Resolves `typ` by a single level if `typ` is a type variable.
5121 // If no resolution is possible, then an error is reported.
5122 // Numeric inference variables may be left unresolved.
5123 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5124 let ty = self.resolve_type_vars_with_obligations(ty);
5125 if !ty.is_ty_var() {
5128 if !self.is_tainted_by_errors() {
5129 self.need_type_info_err((**self).body_id, sp, ty)
5130 .note("type must be known at this point")
5133 self.demand_suptype(sp, self.tcx.types.err, ty);
5138 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5139 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5140 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5143 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5144 index = enclosing_breakables.stack.len();
5145 enclosing_breakables.by_id.insert(id, index);
5146 enclosing_breakables.stack.push(ctxt);
5150 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5151 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5152 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5153 enclosing_breakables.stack.pop().expect("missing breakable context")
5159 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5160 generics: &ty::Generics,
5162 let own_counts = generics.own_counts();
5163 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5165 if own_counts.types == 0 {
5168 // Make a vector of booleans initially false, set to true when used.
5169 let mut types_used = vec![false; own_counts.types];
5171 for leaf_ty in ty.walk() {
5172 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5173 debug!("Found use of ty param num {}", idx);
5174 types_used[idx as usize - own_counts.lifetimes] = true;
5175 } else if let ty::Error = leaf_ty.sty {
5176 // If there is already another error, do not emit
5177 // an error for not using a type Parameter.
5178 assert!(tcx.sess.err_count() > 0);
5183 let types = generics.params.iter().filter(|param| match param.kind {
5184 ty::GenericParamDefKind::Type { .. } => true,
5187 for (&used, param) in types_used.iter().zip(types) {
5189 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5190 let span = tcx.hir.span(id);
5191 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5192 .span_label(span, "unused type parameter")
5198 fn fatally_break_rust(sess: &Session) {
5199 let handler = sess.diagnostic();
5200 handler.span_bug_no_panic(
5202 "It looks like you're trying to break rust; would you like some ICE?",
5204 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5205 handler.note_without_error(
5206 "we would appreciate a joke overview: \
5207 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5209 handler.note_without_error(&format!("rustc {} running on {}",
5210 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5211 ::session::config::host_triple(),