1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 n.b.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
92 use namespace::Namespace;
93 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
94 use rustc::infer::anon_types::AnonTypeDecl;
95 use rustc::infer::type_variable::{TypeVariableOrigin};
96 use rustc::middle::region;
97 use rustc::mir::interpret::{GlobalId};
98 use rustc::ty::subst::{UnpackedKind, Subst, Substs};
99 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
100 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
101 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
102 use rustc::ty::fold::TypeFoldable;
103 use rustc::ty::query::Providers;
104 use rustc::ty::util::{Representability, IntTypeExt, Discr};
105 use errors::{DiagnosticBuilder, DiagnosticId};
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, 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::codemap::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 TyAnon, 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::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
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);
508 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
509 body_id: ast::NodeId,
511 /// The parameter environment used for proving trait obligations
512 /// in this function. This can change when we descend into
513 /// closures (as they bring new things into scope), hence it is
514 /// not part of `Inherited` (as of the time of this writing,
515 /// closures do not yet change the environment, but they will
517 param_env: ty::ParamEnv<'tcx>,
519 // Number of errors that had been reported when we started
520 // checking this function. On exit, if we find that *more* errors
521 // have been reported, we will skip regionck and other work that
522 // expects the types within the function to be consistent.
523 err_count_on_creation: usize,
525 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
527 yield_ty: Option<Ty<'tcx>>,
529 ps: RefCell<UnsafetyState>,
531 /// Whether the last checked node generates a divergence (e.g.,
532 /// `return` will set this to Always). In general, when entering
533 /// an expression or other node in the tree, the initial value
534 /// indicates whether prior parts of the containing expression may
535 /// have diverged. It is then typically set to `Maybe` (and the
536 /// old value remembered) for processing the subparts of the
537 /// current expression. As each subpart is processed, they may set
538 /// the flag to `Always` etc. Finally, at the end, we take the
539 /// result and "union" it with the original value, so that when we
540 /// return the flag indicates if any subpart of the the parent
541 /// expression (up to and including this part) has diverged. So,
542 /// if you read it after evaluating a subexpression `X`, the value
543 /// you get indicates whether any subexpression that was
544 /// evaluating up to and including `X` diverged.
546 /// We currently use this flag only for diagnostic purposes:
548 /// - To warn about unreachable code: if, after processing a
549 /// sub-expression but before we have applied the effects of the
550 /// current node, we see that the flag is set to `Always`, we
551 /// can issue a warning. This corresponds to something like
552 /// `foo(return)`; we warn on the `foo()` expression. (We then
553 /// update the flag to `WarnedAlways` to suppress duplicate
554 /// reports.) Similarly, if we traverse to a fresh statement (or
555 /// tail expression) from a `Always` setting, we will issue a
556 /// warning. This corresponds to something like `{return;
557 /// foo();}` or `{return; 22}`, where we would warn on the
560 /// An expression represents dead-code if, after checking it,
561 /// the diverges flag is set to something other than `Maybe`.
562 diverges: Cell<Diverges>,
564 /// Whether any child nodes have any type errors.
565 has_errors: Cell<bool>,
567 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
569 inh: &'a Inherited<'a, 'gcx, 'tcx>,
572 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
573 type Target = Inherited<'a, 'gcx, 'tcx>;
574 fn deref(&self) -> &Self::Target {
579 /// Helper type of a temporary returned by Inherited::build(...).
580 /// Necessary because we can't write the following bound:
581 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
582 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
583 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
587 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
588 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
589 -> InheritedBuilder<'a, 'gcx, 'tcx> {
590 let hir_id_root = if def_id.is_local() {
591 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
592 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
593 DefId::local(hir_id.owner)
599 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
605 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
606 fn enter<F, R>(&'tcx mut self, f: F) -> R
607 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
609 let def_id = self.def_id;
610 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
614 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
615 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
617 let item_id = tcx.hir.as_local_node_id(def_id);
618 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
619 let implicit_region_bound = body_id.map(|body_id| {
620 let body = tcx.hir.body(body_id);
621 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
625 tables: MaybeInProgressTables {
626 maybe_tables: infcx.in_progress_tables,
629 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
630 locals: RefCell::new(NodeMap()),
631 deferred_call_resolutions: RefCell::new(DefIdMap()),
632 deferred_cast_checks: RefCell::new(Vec::new()),
633 deferred_generator_interiors: RefCell::new(Vec::new()),
634 anon_types: RefCell::new(DefIdMap()),
635 implicit_region_bound,
640 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
641 debug!("register_predicate({:?})", obligation);
642 if obligation.has_escaping_regions() {
643 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
648 .register_predicate_obligation(self, obligation);
651 fn register_predicates<I>(&self, obligations: I)
652 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
653 for obligation in obligations {
654 self.register_predicate(obligation);
658 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
659 self.register_predicates(infer_ok.obligations);
663 fn normalize_associated_types_in<T>(&self,
665 body_id: ast::NodeId,
666 param_env: ty::ParamEnv<'tcx>,
668 where T : TypeFoldable<'tcx>
670 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
671 self.register_infer_ok_obligations(ok)
675 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
677 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
678 fn visit_item(&mut self, i: &'tcx hir::Item) {
679 check_item_type(self.tcx, i);
681 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
682 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
685 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
686 tcx.sess.track_errors(|| {
687 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
688 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
692 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
693 tcx.sess.track_errors(|| {
694 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
698 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
699 tcx.typeck_item_bodies(LOCAL_CRATE)
702 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
703 -> Result<(), CompileIncomplete>
705 debug_assert!(crate_num == LOCAL_CRATE);
706 Ok(tcx.sess.track_errors(|| {
707 tcx.par_body_owners(|body_owner_def_id| {
708 ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
713 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
714 wfcheck::check_item_well_formed(tcx, def_id);
717 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
718 wfcheck::check_trait_item(tcx, def_id);
721 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
722 wfcheck::check_impl_item(tcx, def_id);
725 pub fn provide(providers: &mut Providers) {
726 method::provide(providers);
727 *providers = Providers {
733 check_item_well_formed,
734 check_trait_item_well_formed,
735 check_impl_item_well_formed,
740 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
742 -> Option<ty::Destructor> {
743 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
746 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
747 /// with information about it's body-id and fn-decl (if any). Otherwise,
750 /// If this function returns "some", then `typeck_tables(def_id)` will
751 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
752 /// may not succeed. In some cases where this function returns `None`
753 /// (notably closures), `typeck_tables(def_id)` would wind up
754 /// redirecting to the owning function.
755 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
757 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
759 match tcx.hir.get(id) {
760 hir::map::NodeItem(item) => {
762 hir::ItemKind::Const(_, body) |
763 hir::ItemKind::Static(_, _, body) =>
765 hir::ItemKind::Fn(ref decl, .., body) =>
766 Some((body, Some(decl))),
771 hir::map::NodeTraitItem(item) => {
773 hir::TraitItemKind::Const(_, Some(body)) =>
775 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
776 Some((body, Some(&sig.decl))),
781 hir::map::NodeImplItem(item) => {
783 hir::ImplItemKind::Const(_, body) =>
785 hir::ImplItemKind::Method(ref sig, body) =>
786 Some((body, Some(&sig.decl))),
791 hir::map::NodeAnonConst(constant) => Some((constant.body, None)),
796 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
799 // Closures' tables come from their outermost function,
800 // as they are part of the same "inference environment".
801 let outer_def_id = tcx.closure_base_def_id(def_id);
802 if outer_def_id != def_id {
803 return tcx.has_typeck_tables(outer_def_id);
806 let id = tcx.hir.as_local_node_id(def_id).unwrap();
807 primary_body_of(tcx, id).is_some()
810 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
813 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
816 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
818 -> &'tcx ty::TypeckTables<'tcx> {
819 // Closures' tables come from their outermost function,
820 // as they are part of the same "inference environment".
821 let outer_def_id = tcx.closure_base_def_id(def_id);
822 if outer_def_id != def_id {
823 return tcx.typeck_tables_of(outer_def_id);
826 let id = tcx.hir.as_local_node_id(def_id).unwrap();
827 let span = tcx.hir.span(id);
829 // Figure out what primary body this item has.
830 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
831 span_bug!(span, "can't type-check body of {:?}", def_id);
833 let body = tcx.hir.body(body_id);
835 let tables = Inherited::build(tcx, def_id).enter(|inh| {
836 let param_env = tcx.param_env(def_id);
837 let fcx = if let Some(decl) = fn_decl {
838 let fn_sig = tcx.fn_sig(def_id);
840 check_abi(tcx, span, fn_sig.abi());
842 // Compute the fty from point of view of inside fn.
844 tcx.liberate_late_bound_regions(def_id, &fn_sig);
846 inh.normalize_associated_types_in(body.value.span,
851 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
854 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
855 let expected_type = tcx.type_of(def_id);
856 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
857 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
859 // Gather locals in statics (because of block expressions).
860 // This is technically unnecessary because locals in static items are forbidden,
861 // but prevents type checking from blowing up before const checking can properly
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 generater 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, _orig_values) = 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 self.fcx.require_type_is_sized(var_ty, p.span,
968 traits::VariableType(p.id));
970 debug!("Pattern binding {} is assigned to {} with type {:?}",
972 self.fcx.ty_to_string(
973 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
976 intravisit::walk_pat(self, p);
979 // Don't descend into the bodies of nested closures
980 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
981 _: hir::BodyId, _: Span, _: ast::NodeId) { }
984 /// When `check_fn` is invoked on a generator (i.e., a body that
985 /// includes yield), it returns back some information about the yield
987 struct GeneratorTypes<'tcx> {
988 /// Type of value that is yielded.
989 yield_ty: ty::Ty<'tcx>,
991 /// Types that are captured (see `GeneratorInterior` for more).
992 interior: ty::Ty<'tcx>,
994 /// Indicates if the generator is movable or static (immovable)
995 movability: hir::GeneratorMovability,
998 /// Helper used for fns and closures. Does the grungy work of checking a function
999 /// body and returns the function context used for that purpose, since in the case of a fn item
1000 /// there is still a bit more to do.
1003 /// * inherited: other fields inherited from the enclosing fn (if any)
1004 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1005 param_env: ty::ParamEnv<'tcx>,
1006 fn_sig: ty::FnSig<'tcx>,
1007 decl: &'gcx hir::FnDecl,
1009 body: &'gcx hir::Body,
1010 can_be_generator: Option<hir::GeneratorMovability>)
1011 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1013 let mut fn_sig = fn_sig.clone();
1015 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1017 // Create the function context. This is either derived from scratch or,
1018 // in the case of closures, based on the outer context.
1019 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1020 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1022 let declared_ret_ty = fn_sig.output();
1023 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1024 let revealed_ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &declared_ret_ty);
1025 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1026 fn_sig = fcx.tcx.mk_fn_sig(
1027 fn_sig.inputs().iter().cloned(),
1034 let span = body.value.span;
1036 if body.is_generator && can_be_generator.is_some() {
1037 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1038 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1039 fcx.yield_ty = Some(yield_ty);
1042 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1044 // Add formal parameters.
1045 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1046 // Check the pattern.
1047 fcx.check_pat_walk(&arg.pat, arg_ty,
1048 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1050 // Check that argument is Sized.
1051 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1052 // for simple cases like `fn foo(x: Trait)`,
1053 // where we would error once on the parameter as a whole, and once on the binding `x`.
1054 if arg.pat.simple_ident().is_none() {
1055 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1058 fcx.write_ty(arg.hir_id, arg_ty);
1061 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1062 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1064 fcx.check_return_expr(&body.value);
1066 // We insert the deferred_generator_interiors entry after visiting the body.
1067 // This ensures that all nested generators appear before the entry of this generator.
1068 // resolve_generator_interiors relies on this property.
1069 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1070 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1071 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1072 Some(GeneratorTypes {
1073 yield_ty: fcx.yield_ty.unwrap(),
1075 movability: can_be_generator.unwrap(),
1081 // Finalize the return check by taking the LUB of the return types
1082 // we saw and assigning it to the expected return type. This isn't
1083 // really expected to fail, since the coercions would have failed
1084 // earlier when trying to find a LUB.
1086 // However, the behavior around `!` is sort of complex. In the
1087 // event that the `actual_return_ty` comes back as `!`, that
1088 // indicates that the fn either does not return or "returns" only
1089 // values of type `!`. In this case, if there is an expected
1090 // return type that is *not* `!`, that should be ok. But if the
1091 // return type is being inferred, we want to "fallback" to `!`:
1093 // let x = move || panic!();
1095 // To allow for that, I am creating a type variable with diverging
1096 // fallback. This was deemed ever so slightly better than unifying
1097 // the return value with `!` because it allows for the caller to
1098 // make more assumptions about the return type (e.g., they could do
1100 // let y: Option<u32> = Some(x());
1102 // which would then cause this return type to become `u32`, not
1104 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1105 let mut actual_return_ty = coercion.complete(&fcx);
1106 if actual_return_ty.is_never() {
1107 actual_return_ty = fcx.next_diverging_ty_var(
1108 TypeVariableOrigin::DivergingFn(span));
1110 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1112 // Check that the main return type implements the termination trait.
1113 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1114 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1117 config::EntryMain => {
1118 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1119 let trait_ref = ty::TraitRef::new(term_id, substs);
1120 let return_ty_span = decl.output.span();
1121 let cause = traits::ObligationCause::new(
1122 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1124 inherited.register_predicate(
1125 traits::Obligation::new(
1126 cause, param_env, trait_ref.to_predicate()));
1128 config::EntryStart => {},
1134 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1135 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1136 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1137 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1138 if declared_ret_ty.sty != ty::TyNever {
1139 fcx.tcx.sess.span_err(
1141 "return type should be `!`",
1145 let inputs = fn_sig.inputs();
1146 let span = fcx.tcx.hir.span(fn_id);
1147 if inputs.len() == 1 {
1148 let arg_is_panic_info = match inputs[0].sty {
1149 ty::TyRef(region, ty, mutbl) => match ty.sty {
1150 ty::TyAdt(ref adt, _) => {
1151 adt.did == panic_info_did &&
1152 mutbl == hir::Mutability::MutImmutable &&
1153 *region != RegionKind::ReStatic
1160 if !arg_is_panic_info {
1161 fcx.tcx.sess.span_err(
1162 decl.inputs[0].span,
1163 "argument should be `&PanicInfo`",
1167 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1168 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1169 if !generics.params.is_empty() {
1170 fcx.tcx.sess.span_err(
1172 "`#[panic_implementation]` function should have no type \
1179 fcx.tcx.sess.span_err(span, "function should have one argument");
1182 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1187 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1188 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1189 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1190 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1191 if declared_ret_ty.sty != ty::TyNever {
1192 fcx.tcx.sess.span_err(
1194 "return type should be `!`",
1198 let inputs = fn_sig.inputs();
1199 let span = fcx.tcx.hir.span(fn_id);
1200 if inputs.len() == 1 {
1201 let arg_is_alloc_layout = match inputs[0].sty {
1202 ty::TyAdt(ref adt, _) => {
1203 adt.did == alloc_layout_did
1208 if !arg_is_alloc_layout {
1209 fcx.tcx.sess.span_err(
1210 decl.inputs[0].span,
1211 "argument should be `Layout`",
1215 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1216 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1217 if !generics.params.is_empty() {
1218 fcx.tcx.sess.span_err(
1220 "`#[alloc_error_handler]` function should have no type \
1227 fcx.tcx.sess.span_err(span, "function should have one argument");
1230 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1238 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1241 let def_id = tcx.hir.local_def_id(id);
1242 let def = tcx.adt_def(def_id);
1243 def.destructor(tcx); // force the destructor to be evaluated
1244 check_representable(tcx, span, def_id);
1246 if def.repr.simd() {
1247 check_simd(tcx, span, def_id);
1250 check_transparent(tcx, span, def_id);
1251 check_packed(tcx, span, def_id);
1254 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1257 let def_id = tcx.hir.local_def_id(id);
1258 let def = tcx.adt_def(def_id);
1259 def.destructor(tcx); // force the destructor to be evaluated
1260 check_representable(tcx, span, def_id);
1262 check_packed(tcx, span, def_id);
1265 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1266 debug!("check_item_type(it.id={}, it.name={})",
1268 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1269 let _indenter = indenter();
1271 // Consts can play a role in type-checking, so they are included here.
1272 hir::ItemKind::Static(..) => {
1273 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1275 hir::ItemKind::Const(..) => {
1276 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1277 if it.attrs.iter().any(|a| a.check_name("wasm_custom_section")) {
1278 let def_id = tcx.hir.local_def_id(it.id);
1279 check_const_is_u8_array(tcx, def_id, it.span);
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::Ty(..) => {
1313 let def_id = tcx.hir.local_def_id(it.id);
1314 let pty_ty = tcx.type_of(def_id);
1315 let generics = tcx.generics_of(def_id);
1316 check_bounds_are_used(tcx, &generics, pty_ty);
1318 hir::ItemKind::ForeignMod(ref m) => {
1319 check_abi(tcx, it.span, m.abi);
1321 if m.abi == Abi::RustIntrinsic {
1322 for item in &m.items {
1323 intrinsic::check_intrinsic_type(tcx, item);
1325 } else if m.abi == Abi::PlatformIntrinsic {
1326 for item in &m.items {
1327 intrinsic::check_platform_intrinsic_type(tcx, item);
1330 for item in &m.items {
1331 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1332 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1333 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1334 "foreign items may not have type parameters");
1335 err.span_label(item.span, "can't have type parameters");
1336 // FIXME: once we start storing spans for type arguments, turn this into a
1338 err.help("use specialization instead of type parameters by replacing them \
1339 with concrete types like `u32`");
1343 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1344 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1349 _ => {/* nothing to do */ }
1353 fn check_const_is_u8_array<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1356 match tcx.type_of(def_id).sty {
1357 ty::TyArray(t, _) => {
1359 ty::TyUint(ast::UintTy::U8) => return,
1365 tcx.sess.span_err(span, "must be an array of bytes like `[u8; N]`");
1368 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1369 trait_def_id: DefId,
1371 let item_def_id = tcx.hir.local_def_id(item.id);
1372 // an error would be reported if this fails.
1373 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1376 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1377 impl_item: &hir::ImplItem,
1380 let mut err = struct_span_err!(
1381 tcx.sess, impl_item.span, E0520,
1382 "`{}` specializes an item from a parent `impl`, but \
1383 that item is not marked `default`",
1385 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1388 match tcx.span_of_impl(parent_impl) {
1390 err.span_label(span, "parent `impl` is here");
1391 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1395 err.note(&format!("parent implementation is in crate `{}`", cname));
1402 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1403 trait_def: &ty::TraitDef,
1404 trait_item: &ty::AssociatedItem,
1406 impl_item: &hir::ImplItem)
1408 let ancestors = trait_def.ancestors(tcx, impl_id);
1410 let kind = match impl_item.node {
1411 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1412 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1413 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1414 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1417 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).skip(1).next()
1418 .map(|node_item| node_item.map(|parent| parent.defaultness));
1420 if let Some(parent) = parent {
1421 if tcx.impl_item_is_final(&parent) {
1422 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1428 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1431 impl_trait_ref: ty::TraitRef<'tcx>,
1432 impl_item_refs: &[hir::ImplItemRef]) {
1433 let impl_span = tcx.sess.codemap().def_span(impl_span);
1435 // If the trait reference itself is erroneous (so the compilation is going
1436 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1437 // isn't populated for such impls.
1438 if impl_trait_ref.references_error() { return; }
1440 // Locate trait definition and items
1441 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1442 let mut overridden_associated_type = None;
1444 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1446 // Check existing impl methods to see if they are both present in trait
1447 // and compatible with trait signature
1448 for impl_item in impl_items() {
1449 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1450 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1451 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1452 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1454 // Not compatible, but needed for the error message
1455 tcx.associated_items(impl_trait_ref.def_id)
1456 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1459 // Check that impl definition matches trait definition
1460 if let Some(ty_trait_item) = ty_trait_item {
1461 match impl_item.node {
1462 hir::ImplItemKind::Const(..) => {
1463 // Find associated const definition.
1464 if ty_trait_item.kind == ty::AssociatedKind::Const {
1465 compare_const_impl(tcx,
1471 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1472 "item `{}` is an associated const, \
1473 which doesn't match its trait `{}`",
1476 err.span_label(impl_item.span, "does not match trait");
1477 // We can only get the spans from local trait definition
1478 // Same for E0324 and E0325
1479 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1480 err.span_label(trait_span, "item in trait");
1485 hir::ImplItemKind::Method(..) => {
1486 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1487 if ty_trait_item.kind == ty::AssociatedKind::Method {
1488 compare_impl_method(tcx,
1495 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1496 "item `{}` is an associated method, \
1497 which doesn't match its trait `{}`",
1500 err.span_label(impl_item.span, "does not match trait");
1501 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1502 err.span_label(trait_span, "item in trait");
1507 hir::ImplItemKind::Existential(..) |
1508 hir::ImplItemKind::Type(_) => {
1509 if ty_trait_item.kind == ty::AssociatedKind::Type {
1510 if ty_trait_item.defaultness.has_value() {
1511 overridden_associated_type = Some(impl_item);
1514 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1515 "item `{}` is an associated type, \
1516 which doesn't match its trait `{}`",
1519 err.span_label(impl_item.span, "does not match trait");
1520 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1521 err.span_label(trait_span, "item in trait");
1528 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1532 // Check for missing items from trait
1533 let mut missing_items = Vec::new();
1534 let mut invalidated_items = Vec::new();
1535 let associated_type_overridden = overridden_associated_type.is_some();
1536 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1537 let is_implemented = trait_def.ancestors(tcx, impl_id)
1538 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1540 .map(|node_item| !node_item.node.is_from_trait())
1543 if !is_implemented && !tcx.impl_is_default(impl_id) {
1544 if !trait_item.defaultness.has_value() {
1545 missing_items.push(trait_item);
1546 } else if associated_type_overridden {
1547 invalidated_items.push(trait_item.ident);
1552 if !missing_items.is_empty() {
1553 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1554 "not all trait items implemented, missing: `{}`",
1555 missing_items.iter()
1556 .map(|trait_item| trait_item.ident.to_string())
1557 .collect::<Vec<_>>().join("`, `"));
1558 err.span_label(impl_span, format!("missing `{}` in implementation",
1559 missing_items.iter()
1560 .map(|trait_item| trait_item.ident.to_string())
1561 .collect::<Vec<_>>().join("`, `")));
1562 for trait_item in missing_items {
1563 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1564 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1566 err.note_trait_signature(trait_item.ident.to_string(),
1567 trait_item.signature(&tcx));
1573 if !invalidated_items.is_empty() {
1574 let invalidator = overridden_associated_type.unwrap();
1575 span_err!(tcx.sess, invalidator.span, E0399,
1576 "the following trait items need to be reimplemented \
1577 as `{}` was overridden: `{}`",
1579 invalidated_items.iter()
1580 .map(|name| name.to_string())
1581 .collect::<Vec<_>>().join("`, `"))
1585 /// Checks whether a type can be represented in memory. In particular, it
1586 /// identifies types that contain themselves without indirection through a
1587 /// pointer, which would mean their size is unbounded.
1588 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1592 let rty = tcx.type_of(item_def_id);
1594 // Check that it is possible to represent this type. This call identifies
1595 // (1) types that contain themselves and (2) types that contain a different
1596 // recursive type. It is only necessary to throw an error on those that
1597 // contain themselves. For case 2, there must be an inner type that will be
1598 // caught by case 1.
1599 match rty.is_representable(tcx, sp) {
1600 Representability::SelfRecursive(spans) => {
1601 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1603 err.span_label(span, "recursive without indirection");
1608 Representability::Representable | Representability::ContainsRecursive => (),
1613 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1614 let t = tcx.type_of(def_id);
1616 ty::TyAdt(def, substs) if def.is_struct() => {
1617 let fields = &def.non_enum_variant().fields;
1618 if fields.is_empty() {
1619 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1622 let e = fields[0].ty(tcx, substs);
1623 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1624 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1625 .span_label(sp, "SIMD elements must have the same type")
1630 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1631 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1633 span_err!(tcx.sess, sp, E0077,
1634 "SIMD vector element type should be machine type");
1643 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1644 let repr = tcx.adt_def(def_id).repr;
1646 for attr in tcx.get_attrs(def_id).iter() {
1647 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1648 if let attr::ReprPacked(pack) = r {
1649 if pack != repr.pack {
1650 struct_span_err!(tcx.sess, sp, E0634,
1651 "type has conflicting packed representation hints").emit();
1657 struct_span_err!(tcx.sess, sp, E0587,
1658 "type has conflicting packed and align representation hints").emit();
1660 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1661 struct_span_err!(tcx.sess, sp, E0588,
1662 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1667 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1669 stack: &mut Vec<DefId>) -> bool {
1670 let t = tcx.type_of(def_id);
1671 if stack.contains(&def_id) {
1672 debug!("check_packed_inner: {:?} is recursive", t);
1676 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1677 if tcx.adt_def(def.did).repr.align > 0 {
1680 // push struct def_id before checking fields
1682 for field in &def.non_enum_variant().fields {
1683 let f = field.ty(tcx, substs);
1685 ty::TyAdt(def, _) => {
1686 if check_packed_inner(tcx, def.did, stack) {
1693 // only need to pop if not early out
1701 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1702 let adt = tcx.adt_def(def_id);
1703 if !adt.repr.transparent() {
1707 // For each field, figure out if it's known to be a ZST and align(1)
1708 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1709 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1710 let param_env = tcx.param_env(field.did);
1711 let layout = tcx.layout_of(param_env.and(ty));
1712 // We are currently checking the type this field came from, so it must be local
1713 let span = tcx.hir.span_if_local(field.did).unwrap();
1714 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1715 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1719 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1720 let non_zst_count = non_zst_fields.clone().count();
1721 if non_zst_count != 1 {
1722 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1723 struct_span_err!(tcx.sess, sp, E0690,
1724 "transparent struct needs exactly one non-zero-sized field, but has {}",
1726 .span_note(field_spans, "non-zero-sized field")
1729 for &(span, zst, align1) in &field_infos {
1731 span_err!(tcx.sess, span, E0691,
1732 "zero-sized field in transparent struct has alignment larger than 1");
1737 #[allow(trivial_numeric_casts)]
1738 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1740 vs: &'tcx [hir::Variant],
1742 let def_id = tcx.hir.local_def_id(id);
1743 let def = tcx.adt_def(def_id);
1744 def.destructor(tcx); // force the destructor to be evaluated
1747 let attributes = tcx.get_attrs(def_id);
1748 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1750 tcx.sess, attr.span, E0084,
1751 "unsupported representation for zero-variant enum")
1752 .span_label(sp, "zero-variant enum")
1757 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1758 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1759 if !tcx.features().repr128 {
1760 emit_feature_err(&tcx.sess.parse_sess,
1763 GateIssue::Language,
1764 "repr with 128-bit type is unstable");
1769 if let Some(ref e) = v.node.disr_expr {
1770 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1774 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1775 for (discr, v) in def.discriminants(tcx).zip(vs) {
1776 // Check for duplicate discriminant values
1777 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1778 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1779 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1780 let i_span = match variant_i.node.disr_expr {
1781 Some(ref expr) => tcx.hir.span(expr.id),
1782 None => tcx.hir.span(variant_i_node_id)
1784 let span = match v.node.disr_expr {
1785 Some(ref expr) => tcx.hir.span(expr.id),
1788 struct_span_err!(tcx.sess, span, E0081,
1789 "discriminant value `{}` already exists", disr_vals[i])
1790 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1791 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1794 disr_vals.push(discr);
1797 check_representable(tcx, sp, def_id);
1800 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1801 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1803 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1804 -> ty::GenericPredicates<'tcx>
1807 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1808 let item_id = tcx.hir.ty_param_owner(node_id);
1809 let item_def_id = tcx.hir.local_def_id(item_id);
1810 let generics = tcx.generics_of(item_def_id);
1811 let index = generics.param_def_id_to_index[&def_id];
1812 ty::GenericPredicates {
1814 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1816 ty::Predicate::Trait(ref data) => {
1817 data.skip_binder().self_ty().is_param(index)
1821 }).cloned().collect()
1825 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1826 -> Option<ty::Region<'tcx>> {
1828 Some(def) => infer::EarlyBoundRegion(span, def.name),
1829 None => infer::MiscVariable(span)
1831 Some(self.next_region_var(v))
1834 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1835 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1838 fn ty_infer_for_def(&self,
1839 ty_param_def: &ty::GenericParamDef,
1840 span: Span) -> Ty<'tcx> {
1841 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1847 fn projected_ty_from_poly_trait_ref(&self,
1850 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1853 let (trait_ref, _) =
1854 self.replace_late_bound_regions_with_fresh_var(
1856 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1859 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1862 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1863 if ty.has_escaping_regions() {
1864 ty // FIXME: normalization and escaping regions
1866 self.normalize_associated_types_in(span, &ty)
1870 fn set_tainted_by_errors(&self) {
1871 self.infcx.set_tainted_by_errors()
1874 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1875 self.write_ty(hir_id, ty)
1879 /// Controls whether the arguments are tupled. This is used for the call
1882 /// Tupling means that all call-side arguments are packed into a tuple and
1883 /// passed as a single parameter. For example, if tupling is enabled, this
1886 /// fn f(x: (isize, isize))
1888 /// Can be called as:
1895 #[derive(Clone, Eq, PartialEq)]
1896 enum TupleArgumentsFlag {
1901 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1902 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1903 param_env: ty::ParamEnv<'tcx>,
1904 body_id: ast::NodeId)
1905 -> FnCtxt<'a, 'gcx, 'tcx> {
1909 err_count_on_creation: inh.tcx.sess.err_count(),
1912 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1913 ast::CRATE_NODE_ID)),
1914 diverges: Cell::new(Diverges::Maybe),
1915 has_errors: Cell::new(false),
1916 enclosing_breakables: RefCell::new(EnclosingBreakables {
1924 pub fn sess(&self) -> &Session {
1928 pub fn err_count_since_creation(&self) -> usize {
1929 self.tcx.sess.err_count() - self.err_count_on_creation
1932 /// Produce warning on the given node, if the current point in the
1933 /// function is unreachable, and there hasn't been another warning.
1934 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1935 if self.diverges.get() == Diverges::Always {
1936 self.diverges.set(Diverges::WarnedAlways);
1938 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1940 self.tcx().lint_node(
1941 lint::builtin::UNREACHABLE_CODE,
1943 &format!("unreachable {}", kind));
1949 code: ObligationCauseCode<'tcx>)
1950 -> ObligationCause<'tcx> {
1951 ObligationCause::new(span, self.body_id, code)
1954 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1955 self.cause(span, ObligationCauseCode::MiscObligation)
1958 /// Resolves type variables in `ty` if possible. Unlike the infcx
1959 /// version (resolve_type_vars_if_possible), this version will
1960 /// also select obligations if it seems useful, in an effort
1961 /// to get more type information.
1962 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1963 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1965 // No TyInfer()? Nothing needs doing.
1966 if !ty.has_infer_types() {
1967 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1971 // If `ty` is a type variable, see whether we already know what it is.
1972 ty = self.resolve_type_vars_if_possible(&ty);
1973 if !ty.has_infer_types() {
1974 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1978 // If not, try resolving pending obligations as much as
1979 // possible. This can help substantially when there are
1980 // indirect dependencies that don't seem worth tracking
1982 self.select_obligations_where_possible(false);
1983 ty = self.resolve_type_vars_if_possible(&ty);
1985 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1989 fn record_deferred_call_resolution(&self,
1990 closure_def_id: DefId,
1991 r: DeferredCallResolution<'gcx, 'tcx>) {
1992 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1993 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1996 fn remove_deferred_call_resolutions(&self,
1997 closure_def_id: DefId)
1998 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2000 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2001 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2004 pub fn tag(&self) -> String {
2005 let self_ptr: *const FnCtxt = self;
2006 format!("{:?}", self_ptr)
2009 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
2010 match self.locals.borrow().get(&nid) {
2013 span_bug!(span, "no type for local variable {}",
2014 self.tcx.hir.node_to_string(nid));
2020 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2021 debug!("write_ty({:?}, {:?}) in fcx {}",
2022 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2023 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2025 if ty.references_error() {
2026 self.has_errors.set(true);
2027 self.set_tainted_by_errors();
2031 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2032 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2033 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2036 // The NodeId and the ItemLocalId must identify the same item. We just pass
2037 // both of them for consistency checking.
2038 pub fn write_method_call(&self,
2040 method: MethodCallee<'tcx>) {
2043 .type_dependent_defs_mut()
2044 .insert(hir_id, Def::Method(method.def_id));
2045 self.write_substs(hir_id, method.substs);
2048 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2049 if !substs.is_noop() {
2050 debug!("write_substs({:?}, {:?}) in fcx {}",
2055 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2059 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2060 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2066 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2067 Entry::Vacant(entry) => { entry.insert(adj); },
2068 Entry::Occupied(mut entry) => {
2069 debug!(" - composing on top of {:?}", entry.get());
2070 match (&entry.get()[..], &adj[..]) {
2071 // Applying any adjustment on top of a NeverToAny
2072 // is a valid NeverToAny adjustment, because it can't
2074 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2076 Adjustment { kind: Adjust::Deref(_), .. },
2077 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2079 Adjustment { kind: Adjust::Deref(_), .. },
2080 .. // Any following adjustments are allowed.
2082 // A reborrow has no effect before a dereference.
2084 // FIXME: currently we never try to compose autoderefs
2085 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2087 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2088 expr, entry.get(), adj)
2090 *entry.get_mut() = adj;
2095 /// Basically whenever we are converting from a type scheme into
2096 /// the fn body space, we always want to normalize associated
2097 /// types as well. This function combines the two.
2098 fn instantiate_type_scheme<T>(&self,
2100 substs: &Substs<'tcx>,
2103 where T : TypeFoldable<'tcx>
2105 let value = value.subst(self.tcx, substs);
2106 let result = self.normalize_associated_types_in(span, &value);
2107 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2114 /// As `instantiate_type_scheme`, but for the bounds found in a
2115 /// generic type scheme.
2116 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2117 -> ty::InstantiatedPredicates<'tcx> {
2118 let bounds = self.tcx.predicates_of(def_id);
2119 let result = bounds.instantiate(self.tcx, substs);
2120 let result = self.normalize_associated_types_in(span, &result);
2121 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2128 /// Replace the anonymized types from the return value of the
2129 /// function with type variables and records the `AnonTypeMap` for
2130 /// later use during writeback. See
2131 /// `InferCtxt::instantiate_anon_types` for more details.
2132 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2137 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2139 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2144 let (value, anon_type_map) = self.register_infer_ok_obligations(
2145 self.instantiate_anon_types(
2153 let mut anon_types = self.anon_types.borrow_mut();
2154 for (ty, decl) in anon_type_map {
2155 let old_value = anon_types.insert(ty, decl);
2156 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2162 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2163 where T : TypeFoldable<'tcx>
2165 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2168 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2170 where T : TypeFoldable<'tcx>
2172 self.inh.partially_normalize_associated_types_in(span,
2178 pub fn require_type_meets(&self,
2181 code: traits::ObligationCauseCode<'tcx>,
2184 self.register_bound(
2187 traits::ObligationCause::new(span, self.body_id, code));
2190 pub fn require_type_is_sized(&self,
2193 code: traits::ObligationCauseCode<'tcx>)
2195 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2196 self.require_type_meets(ty, span, code, lang_item);
2199 pub fn register_bound(&self,
2202 cause: traits::ObligationCause<'tcx>)
2204 self.fulfillment_cx.borrow_mut()
2205 .register_bound(self, self.param_env, ty, def_id, cause);
2208 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2209 let t = AstConv::ast_ty_to_ty(self, ast_t);
2210 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2214 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2215 match self.tables.borrow().node_types().get(id) {
2217 None if self.is_tainted_by_errors() => self.tcx.types.err,
2219 let node_id = self.tcx.hir.hir_to_node_id(id);
2220 bug!("no type for node {}: {} in fcx {}",
2221 node_id, self.tcx.hir.node_to_string(node_id),
2227 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2228 /// outlive the region `r`.
2229 pub fn register_wf_obligation(&self,
2232 code: traits::ObligationCauseCode<'tcx>)
2234 // WF obligations never themselves fail, so no real need to give a detailed cause:
2235 let cause = traits::ObligationCause::new(span, self.body_id, code);
2236 self.register_predicate(traits::Obligation::new(cause,
2238 ty::Predicate::WellFormed(ty)));
2241 /// Registers obligations that all types appearing in `substs` are well-formed.
2242 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2244 for ty in substs.types() {
2245 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2249 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2250 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2251 /// trait/region obligations.
2253 /// For example, if there is a function:
2256 /// fn foo<'a,T:'a>(...)
2259 /// and a reference:
2265 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2266 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2267 pub fn add_obligations_for_parameters(&self,
2268 cause: traits::ObligationCause<'tcx>,
2269 predicates: &ty::InstantiatedPredicates<'tcx>)
2271 assert!(!predicates.has_escaping_regions());
2273 debug!("add_obligations_for_parameters(predicates={:?})",
2276 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2277 self.register_predicate(obligation);
2281 // FIXME(arielb1): use this instead of field.ty everywhere
2282 // Only for fields! Returns <none> for methods>
2283 // Indifferent to privacy flags
2284 pub fn field_ty(&self,
2286 field: &'tcx ty::FieldDef,
2287 substs: &Substs<'tcx>)
2290 self.normalize_associated_types_in(span,
2291 &field.ty(self.tcx, substs))
2294 fn check_casts(&self) {
2295 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2296 for cast in deferred_cast_checks.drain(..) {
2301 fn resolve_generator_interiors(&self, def_id: DefId) {
2302 let mut generators = self.deferred_generator_interiors.borrow_mut();
2303 for (body_id, interior) in generators.drain(..) {
2304 self.select_obligations_where_possible(false);
2305 generator_interior::resolve_interior(self, def_id, body_id, interior);
2309 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2310 // Non-numerics get replaced with ! or () (depending on whether
2311 // feature(never_type) is enabled, unconstrained ints with i32,
2312 // unconstrained floats with f64.
2313 // Fallback becomes very dubious if we have encountered type-checking errors.
2314 // In that case, fallback to TyError.
2315 // The return value indicates whether fallback has occured.
2316 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2317 use rustc::ty::error::UnconstrainedNumeric::Neither;
2318 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2320 assert!(ty.is_ty_infer());
2321 let fallback = match self.type_is_unconstrained_numeric(ty) {
2322 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2323 UnconstrainedInt => self.tcx.types.i32,
2324 UnconstrainedFloat => self.tcx.types.f64,
2325 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2326 Neither => return false,
2328 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2329 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2333 fn select_all_obligations_or_error(&self) {
2334 debug!("select_all_obligations_or_error");
2335 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2336 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2340 /// Select as many obligations as we can at present.
2341 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2342 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2345 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2350 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2352 hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
2354 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2359 hir::ExprKind::Type(ref e, _) => {
2360 self.is_place_expr(e)
2363 hir::ExprKind::Unary(hir::UnDeref, _) |
2364 hir::ExprKind::Field(..) |
2365 hir::ExprKind::Index(..) => {
2369 // Partially qualified paths in expressions can only legally
2370 // refer to associated items which are always rvalues.
2371 hir::ExprKind::Path(hir::QPath::TypeRelative(..)) |
2373 hir::ExprKind::Call(..) |
2374 hir::ExprKind::MethodCall(..) |
2375 hir::ExprKind::Struct(..) |
2376 hir::ExprKind::Tup(..) |
2377 hir::ExprKind::If(..) |
2378 hir::ExprKind::Match(..) |
2379 hir::ExprKind::Closure(..) |
2380 hir::ExprKind::Block(..) |
2381 hir::ExprKind::Repeat(..) |
2382 hir::ExprKind::Array(..) |
2383 hir::ExprKind::Break(..) |
2384 hir::ExprKind::Continue(..) |
2385 hir::ExprKind::Ret(..) |
2386 hir::ExprKind::While(..) |
2387 hir::ExprKind::Loop(..) |
2388 hir::ExprKind::Assign(..) |
2389 hir::ExprKind::InlineAsm(..) |
2390 hir::ExprKind::AssignOp(..) |
2391 hir::ExprKind::Lit(_) |
2392 hir::ExprKind::Unary(..) |
2393 hir::ExprKind::Box(..) |
2394 hir::ExprKind::AddrOf(..) |
2395 hir::ExprKind::Binary(..) |
2396 hir::ExprKind::Yield(..) |
2397 hir::ExprKind::Cast(..) => {
2403 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2404 /// returns a type of `&T`, but the actual type we assign to the
2405 /// *expression* is `T`. So this function just peels off the return
2406 /// type by one layer to yield `T`.
2407 fn make_overloaded_place_return_type(&self,
2408 method: MethodCallee<'tcx>)
2409 -> ty::TypeAndMut<'tcx>
2411 // extract method return type, which will be &T;
2412 let ret_ty = method.sig.output();
2414 // method returns &T, but the type as visible to user is T, so deref
2415 ret_ty.builtin_deref(true).unwrap()
2418 fn lookup_indexing(&self,
2420 base_expr: &'gcx hir::Expr,
2424 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2426 // FIXME(#18741) -- this is almost but not quite the same as the
2427 // autoderef that normal method probing does. They could likely be
2430 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2431 let mut result = None;
2432 while result.is_none() && autoderef.next().is_some() {
2433 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2435 autoderef.finalize();
2439 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2440 /// (and otherwise adjust) `base_expr`, looking for a type which either
2441 /// supports builtin indexing or overloaded indexing.
2442 /// This loop implements one step in that search; the autoderef loop
2443 /// is implemented by `lookup_indexing`.
2444 fn try_index_step(&self,
2446 base_expr: &hir::Expr,
2447 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2450 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2452 let adjusted_ty = autoderef.unambiguous_final_ty();
2453 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2460 for &unsize in &[false, true] {
2461 let mut self_ty = adjusted_ty;
2463 // We only unsize arrays here.
2464 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2465 self_ty = self.tcx.mk_slice(element_ty);
2471 // If some lookup succeeds, write callee into table and extract index/element
2472 // type from the method signature.
2473 // If some lookup succeeded, install method in table
2474 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2475 let method = self.try_overloaded_place_op(
2476 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2478 let result = method.map(|ok| {
2479 debug!("try_index_step: success, using overloaded indexing");
2480 let method = self.register_infer_ok_obligations(ok);
2482 let mut adjustments = autoderef.adjust_steps(needs);
2483 if let ty::TyRef(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2484 let mutbl = match r_mutbl {
2485 hir::MutImmutable => AutoBorrowMutability::Immutable,
2486 hir::MutMutable => AutoBorrowMutability::Mutable {
2487 // Indexing can be desugared to a method call,
2488 // so maybe we could use two-phase here.
2489 // See the documentation of AllowTwoPhase for why that's
2490 // not the case today.
2491 allow_two_phase_borrow: AllowTwoPhase::No,
2494 adjustments.push(Adjustment {
2495 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2496 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2503 adjustments.push(Adjustment {
2504 kind: Adjust::Unsize,
2505 target: method.sig.inputs()[0]
2508 self.apply_adjustments(base_expr, adjustments);
2510 self.write_method_call(expr.hir_id, method);
2511 (input_ty, self.make_overloaded_place_return_type(method).ty)
2513 if result.is_some() {
2521 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2522 let (tr, name) = match (op, is_mut) {
2523 (PlaceOp::Deref, false) =>
2524 (self.tcx.lang_items().deref_trait(), "deref"),
2525 (PlaceOp::Deref, true) =>
2526 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2527 (PlaceOp::Index, false) =>
2528 (self.tcx.lang_items().index_trait(), "index"),
2529 (PlaceOp::Index, true) =>
2530 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2532 (tr, ast::Ident::from_str(name))
2535 fn try_overloaded_place_op(&self,
2538 arg_tys: &[Ty<'tcx>],
2541 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2543 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2549 // Try Mut first, if needed.
2550 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2551 let method = match (needs, mut_tr) {
2552 (Needs::MutPlace, Some(trait_did)) => {
2553 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2558 // Otherwise, fall back to the immutable version.
2559 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2560 let method = match (method, imm_tr) {
2561 (None, Some(trait_did)) => {
2562 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2564 (method, _) => method,
2570 fn check_method_argument_types(&self,
2573 method: Result<MethodCallee<'tcx>, ()>,
2574 args_no_rcvr: &'gcx [hir::Expr],
2575 tuple_arguments: TupleArgumentsFlag,
2576 expected: Expectation<'tcx>)
2578 let has_error = match method {
2580 method.substs.references_error() || method.sig.references_error()
2585 let err_inputs = self.err_args(args_no_rcvr.len());
2587 let err_inputs = match tuple_arguments {
2588 DontTupleArguments => err_inputs,
2589 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2592 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2593 false, tuple_arguments, None);
2594 return self.tcx.types.err;
2597 let method = method.unwrap();
2598 // HACK(eddyb) ignore self in the definition (see above).
2599 let expected_arg_tys = self.expected_inputs_for_expected_output(
2602 method.sig.output(),
2603 &method.sig.inputs()[1..]
2605 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2606 args_no_rcvr, method.sig.variadic, tuple_arguments,
2607 self.tcx.hir.span_if_local(method.def_id));
2611 /// Generic function that factors out common logic from function calls,
2612 /// method calls and overloaded operators.
2613 fn check_argument_types(&self,
2616 fn_inputs: &[Ty<'tcx>],
2617 mut expected_arg_tys: &[Ty<'tcx>],
2618 args: &'gcx [hir::Expr],
2620 tuple_arguments: TupleArgumentsFlag,
2621 def_span: Option<Span>) {
2624 // Grab the argument types, supplying fresh type variables
2625 // if the wrong number of arguments were supplied
2626 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2632 // All the input types from the fn signature must outlive the call
2633 // so as to validate implied bounds.
2634 for &fn_input_ty in fn_inputs {
2635 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2638 let expected_arg_count = fn_inputs.len();
2640 let param_count_error = |expected_count: usize,
2645 let mut err = tcx.sess.struct_span_err_with_code(sp,
2646 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2647 if variadic {"at least "} else {""},
2649 if expected_count == 1 {""} else {"s"},
2651 if arg_count == 1 {" was"} else {"s were"}),
2652 DiagnosticId::Error(error_code.to_owned()));
2654 if let Some(def_s) = def_span.map(|sp| tcx.sess.codemap().def_span(sp)) {
2655 err.span_label(def_s, "defined here");
2658 let sugg_span = tcx.sess.codemap().end_point(expr_sp);
2659 // remove closing `)` from the span
2660 let sugg_span = sugg_span.shrink_to_lo();
2661 err.span_suggestion(
2663 "expected the unit value `()`; create it with empty parentheses",
2664 String::from("()"));
2666 err.span_label(sp, format!("expected {}{} parameter{}",
2667 if variadic {"at least "} else {""},
2669 if expected_count == 1 {""} else {"s"}));
2674 let formal_tys = if tuple_arguments == TupleArguments {
2675 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2676 match tuple_type.sty {
2677 ty::TyTuple(arg_types) if arg_types.len() != args.len() => {
2678 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2679 expected_arg_tys = &[];
2680 self.err_args(args.len())
2682 ty::TyTuple(arg_types) => {
2683 expected_arg_tys = match expected_arg_tys.get(0) {
2684 Some(&ty) => match ty.sty {
2685 ty::TyTuple(ref tys) => &tys,
2693 span_err!(tcx.sess, sp, E0059,
2694 "cannot use call notation; the first type parameter \
2695 for the function trait is neither a tuple nor unit");
2696 expected_arg_tys = &[];
2697 self.err_args(args.len())
2700 } else if expected_arg_count == supplied_arg_count {
2702 } else if variadic {
2703 if supplied_arg_count >= expected_arg_count {
2706 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2707 expected_arg_tys = &[];
2708 self.err_args(supplied_arg_count)
2711 // is the missing argument of type `()`?
2712 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2713 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2714 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2715 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2719 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2721 expected_arg_tys = &[];
2722 self.err_args(supplied_arg_count)
2724 // If there is no expectation, expect formal_tys.
2725 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2731 debug!("check_argument_types: formal_tys={:?}",
2732 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2734 // Check the arguments.
2735 // We do this in a pretty awful way: first we typecheck any arguments
2736 // that are not closures, then we typecheck the closures. This is so
2737 // that we have more information about the types of arguments when we
2738 // typecheck the functions. This isn't really the right way to do this.
2739 for &check_closures in &[false, true] {
2740 debug!("check_closures={}", check_closures);
2742 // More awful hacks: before we check argument types, try to do
2743 // an "opportunistic" vtable resolution of any trait bounds on
2744 // the call. This helps coercions.
2746 self.select_obligations_where_possible(false);
2749 // For variadic functions, we don't have a declared type for all of
2750 // the arguments hence we only do our usual type checking with
2751 // the arguments who's types we do know.
2752 let t = if variadic {
2754 } else if tuple_arguments == TupleArguments {
2759 for (i, arg) in args.iter().take(t).enumerate() {
2760 // Warn only for the first loop (the "no closures" one).
2761 // Closure arguments themselves can't be diverging, but
2762 // a previous argument can, e.g. `foo(panic!(), || {})`.
2763 if !check_closures {
2764 self.warn_if_unreachable(arg.id, arg.span, "expression");
2767 let is_closure = match arg.node {
2768 hir::ExprKind::Closure(..) => true,
2772 if is_closure != check_closures {
2776 debug!("checking the argument");
2777 let formal_ty = formal_tys[i];
2779 // The special-cased logic below has three functions:
2780 // 1. Provide as good of an expected type as possible.
2781 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2783 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2785 // 2. Coerce to the most detailed type that could be coerced
2786 // to, which is `expected_ty` if `rvalue_hint` returns an
2787 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2788 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2789 // We're processing function arguments so we definitely want to use
2790 // two-phase borrows.
2791 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2793 // 3. Relate the expected type and the formal one,
2794 // if the expected type was used for the coercion.
2795 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2799 // We also need to make sure we at least write the ty of the other
2800 // arguments which we skipped above.
2802 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2803 use structured_errors::{VariadicError, StructuredDiagnostic};
2804 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2807 for arg in args.iter().skip(expected_arg_count) {
2808 let arg_ty = self.check_expr(&arg);
2810 // There are a few types which get autopromoted when passed via varargs
2811 // in C but we just error out instead and require explicit casts.
2812 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2814 ty::TyFloat(ast::FloatTy::F32) => {
2815 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2817 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2818 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2820 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2821 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2823 ty::TyFnDef(..) => {
2824 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2825 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2826 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2834 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2835 (0..len).map(|_| self.tcx.types.err).collect()
2838 // AST fragment checking
2841 expected: Expectation<'tcx>)
2847 ast::LitKind::Str(..) => tcx.mk_static_str(),
2848 ast::LitKind::ByteStr(ref v) => {
2849 tcx.mk_imm_ref(tcx.types.re_static,
2850 tcx.mk_array(tcx.types.u8, v.len() as u64))
2852 ast::LitKind::Byte(_) => tcx.types.u8,
2853 ast::LitKind::Char(_) => tcx.types.char,
2854 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2855 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2856 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2857 let opt_ty = expected.to_option(self).and_then(|ty| {
2859 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2860 ty::TyChar => Some(tcx.types.u8),
2861 ty::TyRawPtr(..) => Some(tcx.types.usize),
2862 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2866 opt_ty.unwrap_or_else(
2867 || tcx.mk_int_var(self.next_int_var_id()))
2869 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2870 ast::LitKind::FloatUnsuffixed(_) => {
2871 let opt_ty = expected.to_option(self).and_then(|ty| {
2873 ty::TyFloat(_) => Some(ty),
2877 opt_ty.unwrap_or_else(
2878 || tcx.mk_float_var(self.next_float_var_id()))
2880 ast::LitKind::Bool(_) => tcx.types.bool
2884 fn check_expr_eq_type(&self,
2885 expr: &'gcx hir::Expr,
2886 expected: Ty<'tcx>) {
2887 let ty = self.check_expr_with_hint(expr, expected);
2888 self.demand_eqtype(expr.span, expected, ty);
2891 pub fn check_expr_has_type_or_error(&self,
2892 expr: &'gcx hir::Expr,
2893 expected: Ty<'tcx>) -> Ty<'tcx> {
2894 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2897 fn check_expr_meets_expectation_or_error(&self,
2898 expr: &'gcx hir::Expr,
2899 expected: Expectation<'tcx>) -> Ty<'tcx> {
2900 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2901 let mut ty = self.check_expr_with_expectation(expr, expected);
2903 // While we don't allow *arbitrary* coercions here, we *do* allow
2904 // coercions from ! to `expected`.
2906 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2907 "expression with never type wound up being adjusted");
2908 let adj_ty = self.next_diverging_ty_var(
2909 TypeVariableOrigin::AdjustmentType(expr.span));
2910 self.apply_adjustments(expr, vec![Adjustment {
2911 kind: Adjust::NeverToAny,
2917 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2918 // Add help to type error if this is an `if` condition with an assignment
2919 match (expected, &expr.node) {
2920 (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs)) => {
2921 let msg = "try comparing for equality";
2922 if let (Ok(left), Ok(right)) = (
2923 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2924 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2926 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2938 fn check_expr_coercable_to_type(&self,
2939 expr: &'gcx hir::Expr,
2940 expected: Ty<'tcx>) -> Ty<'tcx> {
2941 let ty = self.check_expr_with_hint(expr, expected);
2942 // checks don't need two phase
2943 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2946 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2947 expected: Ty<'tcx>) -> Ty<'tcx> {
2948 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2951 fn check_expr_with_expectation(&self,
2952 expr: &'gcx hir::Expr,
2953 expected: Expectation<'tcx>) -> Ty<'tcx> {
2954 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2957 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2958 self.check_expr_with_expectation(expr, NoExpectation)
2961 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2962 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2965 // determine the `self` type, using fresh variables for all variables
2966 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2967 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2969 pub fn impl_self_ty(&self,
2970 span: Span, // (potential) receiver for this impl
2972 -> TypeAndSubsts<'tcx> {
2973 let ity = self.tcx.type_of(did);
2974 debug!("impl_self_ty: ity={:?}", ity);
2976 let substs = self.fresh_substs_for_item(span, did);
2977 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2979 TypeAndSubsts { substs: substs, ty: substd_ty }
2982 /// Unifies the output type with the expected type early, for more coercions
2983 /// and forward type information on the input expressions.
2984 fn expected_inputs_for_expected_output(&self,
2986 expected_ret: Expectation<'tcx>,
2987 formal_ret: Ty<'tcx>,
2988 formal_args: &[Ty<'tcx>])
2990 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2991 let ret_ty = match expected_ret.only_has_type(self) {
2993 None => return Vec::new()
2995 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2996 // Attempt to apply a subtyping relationship between the formal
2997 // return type (likely containing type variables if the function
2998 // is polymorphic) and the expected return type.
2999 // No argument expectations are produced if unification fails.
3000 let origin = self.misc(call_span);
3001 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3003 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3004 // to identity so the resulting type is not constrained.
3007 // Process any obligations locally as much as
3008 // we can. We don't care if some things turn
3009 // out unconstrained or ambiguous, as we're
3010 // just trying to get hints here.
3011 self.save_and_restore_in_snapshot_flag(|_| {
3012 let mut fulfill = TraitEngine::new(self.tcx);
3013 for obligation in ok.obligations {
3014 fulfill.register_predicate_obligation(self, obligation);
3016 fulfill.select_where_possible(self)
3017 }).map_err(|_| ())?;
3019 Err(_) => return Err(()),
3022 // Record all the argument types, with the substitutions
3023 // produced from the above subtyping unification.
3024 Ok(formal_args.iter().map(|ty| {
3025 self.resolve_type_vars_if_possible(ty)
3027 }).unwrap_or(Vec::new());
3028 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3029 formal_args, formal_ret,
3030 expect_args, expected_ret);
3034 // Checks a method call.
3035 fn check_method_call(&self,
3036 expr: &'gcx hir::Expr,
3037 segment: &hir::PathSegment,
3039 args: &'gcx [hir::Expr],
3040 expected: Expectation<'tcx>,
3041 needs: Needs) -> Ty<'tcx> {
3042 let rcvr = &args[0];
3043 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3044 // no need to check for bot/err -- callee does that
3045 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3047 let method = match self.lookup_method(rcvr_t,
3053 self.write_method_call(expr.hir_id, method);
3057 if segment.ident.name != keywords::Invalid.name() {
3058 self.report_method_error(span,
3069 // Call the generic checker.
3070 self.check_method_argument_types(span,
3078 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3082 .unwrap_or_else(|| span_bug!(return_expr.span,
3083 "check_return_expr called outside fn body"));
3085 let ret_ty = ret_coercion.borrow().expected_ty();
3086 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3087 ret_coercion.borrow_mut()
3089 &self.cause(return_expr.span,
3090 ObligationCauseCode::ReturnType(return_expr.id)),
3096 // A generic function for checking the then and else in an if
3098 fn check_then_else(&self,
3099 cond_expr: &'gcx hir::Expr,
3100 then_expr: &'gcx hir::Expr,
3101 opt_else_expr: Option<&'gcx hir::Expr>,
3103 expected: Expectation<'tcx>) -> Ty<'tcx> {
3104 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3105 let cond_diverges = self.diverges.get();
3106 self.diverges.set(Diverges::Maybe);
3108 let expected = expected.adjust_for_branches(self);
3109 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3110 let then_diverges = self.diverges.get();
3111 self.diverges.set(Diverges::Maybe);
3113 // We've already taken the expected type's preferences
3114 // into account when typing the `then` branch. To figure
3115 // out the initial shot at a LUB, we thus only consider
3116 // `expected` if it represents a *hard* constraint
3117 // (`only_has_type`); otherwise, we just go with a
3118 // fresh type variable.
3119 let coerce_to_ty = expected.coercion_target_type(self, sp);
3120 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3122 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3123 coerce.coerce(self, &if_cause, then_expr, then_ty);
3125 if let Some(else_expr) = opt_else_expr {
3126 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3127 let else_diverges = self.diverges.get();
3129 coerce.coerce(self, &if_cause, else_expr, else_ty);
3131 // We won't diverge unless both branches do (or the condition does).
3132 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3134 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3135 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3137 // If the condition is false we can't diverge.
3138 self.diverges.set(cond_diverges);
3141 let result_ty = coerce.complete(self);
3142 if cond_ty.references_error() {
3149 // Check field access expressions
3150 fn check_field(&self,
3151 expr: &'gcx hir::Expr,
3153 base: &'gcx hir::Expr,
3154 field: ast::Ident) -> Ty<'tcx> {
3155 let expr_t = self.check_expr_with_needs(base, needs);
3156 let expr_t = self.structurally_resolved_type(base.span,
3158 let mut private_candidate = None;
3159 let mut autoderef = self.autoderef(expr.span, expr_t);
3160 while let Some((base_t, _)) = autoderef.next() {
3162 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3163 debug!("struct named {:?}", base_t);
3164 let (ident, def_scope) =
3165 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3166 let fields = &base_def.non_enum_variant().fields;
3167 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3168 let field = &fields[index];
3169 let field_ty = self.field_ty(expr.span, field, substs);
3170 // Save the index of all fields regardless of their visibility in case
3171 // of error recovery.
3172 self.write_field_index(expr.id, index);
3173 if field.vis.is_accessible_from(def_scope, self.tcx) {
3174 let adjustments = autoderef.adjust_steps(needs);
3175 self.apply_adjustments(base, adjustments);
3176 autoderef.finalize();
3178 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3181 private_candidate = Some((base_def.did, field_ty));
3184 ty::TyTuple(ref tys) => {
3185 let fstr = field.as_str();
3186 if let Ok(index) = fstr.parse::<usize>() {
3187 if fstr == index.to_string() {
3188 if let Some(field_ty) = tys.get(index) {
3189 let adjustments = autoderef.adjust_steps(needs);
3190 self.apply_adjustments(base, adjustments);
3191 autoderef.finalize();
3193 self.write_field_index(expr.id, index);
3202 autoderef.unambiguous_final_ty();
3204 if let Some((did, field_ty)) = private_candidate {
3205 let struct_path = self.tcx().item_path_str(did);
3206 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3207 "field `{}` of struct `{}` is private",
3208 field, struct_path);
3209 // Also check if an accessible method exists, which is often what is meant.
3210 if self.method_exists(field, expr_t, expr.id, false) {
3211 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3215 } else if field.name == keywords::Invalid.name() {
3216 self.tcx().types.err
3217 } else if self.method_exists(field, expr_t, expr.id, true) {
3218 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3219 "attempted to take value of method `{}` on type `{}`",
3221 .help("maybe a `()` to call it is missing?")
3223 self.tcx().types.err
3225 if !expr_t.is_primitive_ty() {
3226 let mut err = self.no_such_field_err(field.span, field, expr_t);
3229 ty::TyAdt(def, _) if !def.is_enum() => {
3230 if let Some(suggested_field_name) =
3231 Self::suggest_field_name(def.non_enum_variant(),
3232 &field.as_str(), vec![]) {
3233 err.span_label(field.span,
3234 format!("did you mean `{}`?", suggested_field_name));
3236 err.span_label(field.span, "unknown field");
3237 let struct_variant_def = def.non_enum_variant();
3238 let field_names = self.available_field_names(struct_variant_def);
3239 if !field_names.is_empty() {
3240 err.note(&format!("available fields are: {}",
3241 self.name_series_display(field_names)));
3245 ty::TyRawPtr(..) => {
3246 let base = self.tcx.hir.node_to_pretty_string(base.id);
3247 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3248 let suggestion = format!("(*{}).{}", base, field);
3249 err.span_suggestion(field.span, &msg, suggestion);
3255 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3256 "`{}` is a primitive type and therefore doesn't have fields",
3259 self.tcx().types.err
3263 // Return an hint about the closest match in field names
3264 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3266 skip: Vec<LocalInternedString>)
3268 let names = variant.fields.iter().filter_map(|field| {
3269 // ignore already set fields and private fields from non-local crates
3270 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3271 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3274 Some(&field.ident.name)
3278 find_best_match_for_name(names, field, None)
3281 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3282 let mut available = Vec::new();
3283 for field in variant.fields.iter() {
3284 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3285 if field.vis.is_accessible_from(def_scope, self.tcx) {
3286 available.push(field.ident.name);
3292 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3293 // dynamic limit, to never omit just one field
3294 let limit = if names.len() == 6 { 6 } else { 5 };
3295 let mut display = names.iter().take(limit)
3296 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3297 if names.len() > limit {
3298 display = format!("{} ... and {} others", display, names.len() - limit);
3303 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3304 -> DiagnosticBuilder {
3305 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3306 "no field `{}` on type `{}`",
3310 fn report_unknown_field(&self,
3312 variant: &'tcx ty::VariantDef,
3314 skip_fields: &[hir::Field],
3316 let mut err = self.type_error_struct_with_diag(
3318 |actual| match ty.sty {
3319 ty::TyAdt(adt, ..) if adt.is_enum() => {
3320 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3321 "{} `{}::{}` has no field named `{}`",
3322 kind_name, actual, variant.name, field.ident)
3325 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3326 "{} `{}` has no field named `{}`",
3327 kind_name, actual, field.ident)
3331 // prevent all specified fields from being suggested
3332 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3333 if let Some(field_name) = Self::suggest_field_name(variant,
3334 &field.ident.as_str(),
3335 skip_fields.collect()) {
3336 err.span_label(field.ident.span,
3337 format!("field does not exist - did you mean `{}`?", field_name));
3340 ty::TyAdt(adt, ..) => {
3342 err.span_label(field.ident.span,
3343 format!("`{}::{}` does not have this field",
3346 err.span_label(field.ident.span,
3347 format!("`{}` does not have this field", ty));
3349 let available_field_names = self.available_field_names(variant);
3350 if !available_field_names.is_empty() {
3351 err.note(&format!("available fields are: {}",
3352 self.name_series_display(available_field_names)));
3355 _ => bug!("non-ADT passed to report_unknown_field")
3361 fn check_expr_struct_fields(&self,
3363 expected: Expectation<'tcx>,
3364 expr_id: ast::NodeId,
3366 variant: &'tcx ty::VariantDef,
3367 ast_fields: &'gcx [hir::Field],
3368 check_completeness: bool) -> bool {
3372 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3373 .get(0).cloned().unwrap_or(adt_ty);
3374 // re-link the regions that EIfEO can erase.
3375 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3377 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3378 &ty::TyAdt(adt, substs) => {
3379 (substs, adt.adt_kind(), adt.variant_descr())
3381 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3384 let mut remaining_fields = FxHashMap();
3385 for (i, field) in variant.fields.iter().enumerate() {
3386 remaining_fields.insert(field.ident.modern(), (i, field));
3389 let mut seen_fields = FxHashMap();
3391 let mut error_happened = false;
3393 // Typecheck each field.
3394 for field in ast_fields {
3395 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3396 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3397 seen_fields.insert(ident, field.span);
3398 self.write_field_index(field.id, i);
3400 // we don't look at stability attributes on
3401 // struct-like enums (yet...), but it's definitely not
3402 // a bug to have construct one.
3403 if adt_kind != ty::AdtKind::Enum {
3404 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3407 self.field_ty(field.span, v_field, substs)
3409 error_happened = true;
3410 if let Some(prev_span) = seen_fields.get(&ident) {
3411 let mut err = struct_span_err!(self.tcx.sess,
3414 "field `{}` specified more than once",
3417 err.span_label(field.ident.span, "used more than once");
3418 err.span_label(*prev_span, format!("first use of `{}`", ident));
3422 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3428 // Make sure to give a type to the field even if there's
3429 // an error, so we can continue typechecking
3430 self.check_expr_coercable_to_type(&field.expr, field_type);
3433 // Make sure the programmer specified correct number of fields.
3434 if kind_name == "union" {
3435 if ast_fields.len() != 1 {
3436 tcx.sess.span_err(span, "union expressions should have exactly one field");
3438 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3439 let len = remaining_fields.len();
3441 let mut displayable_field_names = remaining_fields
3443 .map(|ident| ident.as_str())
3444 .collect::<Vec<_>>();
3446 displayable_field_names.sort();
3448 let truncated_fields_error = if len <= 3 {
3451 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3454 let remaining_fields_names = displayable_field_names.iter().take(3)
3455 .map(|n| format!("`{}`", n))
3456 .collect::<Vec<_>>()
3459 struct_span_err!(tcx.sess, span, E0063,
3460 "missing field{} {}{} in initializer of `{}`",
3461 if remaining_fields.len() == 1 { "" } else { "s" },
3462 remaining_fields_names,
3463 truncated_fields_error,
3465 .span_label(span, format!("missing {}{}",
3466 remaining_fields_names,
3467 truncated_fields_error))
3473 fn check_struct_fields_on_error(&self,
3474 fields: &'gcx [hir::Field],
3475 base_expr: &'gcx Option<P<hir::Expr>>) {
3476 for field in fields {
3477 self.check_expr(&field.expr);
3481 self.check_expr(&base);
3487 pub fn check_struct_path(&self,
3489 node_id: ast::NodeId)
3490 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3491 let path_span = match *qpath {
3492 hir::QPath::Resolved(_, ref path) => path.span,
3493 hir::QPath::TypeRelative(ref qself, _) => qself.span
3495 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3496 let variant = match def {
3498 self.set_tainted_by_errors();
3501 Def::Variant(..) => {
3503 ty::TyAdt(adt, substs) => {
3504 Some((adt.variant_of_def(def), adt.did, substs))
3506 _ => bug!("unexpected type: {:?}", ty.sty)
3509 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3510 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3512 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3513 Some((adt.non_enum_variant(), adt.did, substs))
3518 _ => bug!("unexpected definition: {:?}", def)
3521 if let Some((variant, did, substs)) = variant {
3522 // Check bounds on type arguments used in the path.
3523 let bounds = self.instantiate_bounds(path_span, did, substs);
3524 let cause = traits::ObligationCause::new(path_span, self.body_id,
3525 traits::ItemObligation(did));
3526 self.add_obligations_for_parameters(cause, &bounds);
3530 struct_span_err!(self.tcx.sess, path_span, E0071,
3531 "expected struct, variant or union type, found {}",
3532 ty.sort_string(self.tcx))
3533 .span_label(path_span, "not a struct")
3539 fn check_expr_struct(&self,
3541 expected: Expectation<'tcx>,
3543 fields: &'gcx [hir::Field],
3544 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3546 // Find the relevant variant
3547 let (variant, struct_ty) =
3548 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3551 self.check_struct_fields_on_error(fields, base_expr);
3552 return self.tcx.types.err;
3555 let path_span = match *qpath {
3556 hir::QPath::Resolved(_, ref path) => path.span,
3557 hir::QPath::TypeRelative(ref qself, _) => qself.span
3560 // Prohibit struct expressions when non exhaustive flag is set.
3561 if let ty::TyAdt(adt, _) = struct_ty.sty {
3562 if !adt.did.is_local() && adt.is_non_exhaustive() {
3563 span_err!(self.tcx.sess, expr.span, E0639,
3564 "cannot create non-exhaustive {} using struct expression",
3565 adt.variant_descr());
3569 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3570 variant, fields, base_expr.is_none());
3571 if let &Some(ref base_expr) = base_expr {
3572 // If check_expr_struct_fields hit an error, do not attempt to populate
3573 // the fields with the base_expr. This could cause us to hit errors later
3574 // when certain fields are assumed to exist that in fact do not.
3575 if !error_happened {
3576 self.check_expr_has_type_or_error(base_expr, struct_ty);
3577 match struct_ty.sty {
3578 ty::TyAdt(adt, substs) if adt.is_struct() => {
3579 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3580 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3585 .fru_field_types_mut()
3586 .insert(expr.hir_id, fru_field_types);
3589 span_err!(self.tcx.sess, base_expr.span, E0436,
3590 "functional record update syntax requires a struct");
3595 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3601 /// If an expression has any sub-expressions that result in a type error,
3602 /// inspecting that expression's type with `ty.references_error()` will return
3603 /// true. Likewise, if an expression is known to diverge, inspecting its
3604 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3605 /// strict, _|_ can appear in the type of an expression that does not,
3606 /// itself, diverge: for example, fn() -> _|_.)
3607 /// Note that inspecting a type's structure *directly* may expose the fact
3608 /// that there are actually multiple representations for `TyError`, so avoid
3609 /// that when err needs to be handled differently.
3610 fn check_expr_with_expectation_and_needs(&self,
3611 expr: &'gcx hir::Expr,
3612 expected: Expectation<'tcx>,
3613 needs: Needs) -> Ty<'tcx> {
3614 debug!(">> typechecking: expr={:?} expected={:?}",
3617 // Warn for expressions after diverging siblings.
3618 self.warn_if_unreachable(expr.id, expr.span, "expression");
3620 // Hide the outer diverging and has_errors flags.
3621 let old_diverges = self.diverges.get();
3622 let old_has_errors = self.has_errors.get();
3623 self.diverges.set(Diverges::Maybe);
3624 self.has_errors.set(false);
3626 let ty = self.check_expr_kind(expr, expected, needs);
3628 // Warn for non-block expressions with diverging children.
3630 hir::ExprKind::Block(..) |
3631 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3632 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3634 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3637 // Any expression that produces a value of type `!` must have diverged
3639 self.diverges.set(self.diverges.get() | Diverges::Always);
3642 // Record the type, which applies it effects.
3643 // We need to do this after the warning above, so that
3644 // we don't warn for the diverging expression itself.
3645 self.write_ty(expr.hir_id, ty);
3647 // Combine the diverging and has_error flags.
3648 self.diverges.set(self.diverges.get() | old_diverges);
3649 self.has_errors.set(self.has_errors.get() | old_has_errors);
3651 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3652 debug!("... {:?}, expected is {:?}", ty, expected);
3657 fn check_expr_kind(&self,
3658 expr: &'gcx hir::Expr,
3659 expected: Expectation<'tcx>,
3660 needs: Needs) -> Ty<'tcx> {
3664 hir::ExprKind::Box(ref subexpr) => {
3665 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3667 ty::TyAdt(def, _) if def.is_box()
3668 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3672 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3673 tcx.mk_box(referent_ty)
3676 hir::ExprKind::Lit(ref lit) => {
3677 self.check_lit(&lit, expected)
3679 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3680 self.check_binop(expr, op, lhs, rhs)
3682 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3683 self.check_binop_assign(expr, op, lhs, rhs)
3685 hir::ExprKind::Unary(unop, ref oprnd) => {
3686 let expected_inner = match unop {
3687 hir::UnNot | hir::UnNeg => {
3694 let needs = match unop {
3695 hir::UnDeref => needs,
3698 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3702 if !oprnd_t.references_error() {
3703 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3706 if let Some(mt) = oprnd_t.builtin_deref(true) {
3708 } else if let Some(ok) = self.try_overloaded_deref(
3709 expr.span, oprnd_t, needs) {
3710 let method = self.register_infer_ok_obligations(ok);
3711 if let ty::TyRef(region, _, mutbl) = method.sig.inputs()[0].sty {
3712 let mutbl = match mutbl {
3713 hir::MutImmutable => AutoBorrowMutability::Immutable,
3714 hir::MutMutable => AutoBorrowMutability::Mutable {
3715 // (It shouldn't actually matter for unary ops whether
3716 // we enable two-phase borrows or not, since a unary
3717 // op has no additional operands.)
3718 allow_two_phase_borrow: AllowTwoPhase::No,
3721 self.apply_adjustments(oprnd, vec![Adjustment {
3722 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3723 target: method.sig.inputs()[0]
3726 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3727 self.write_method_call(expr.hir_id, method);
3729 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3730 "type `{}` cannot be dereferenced",
3732 oprnd_t = tcx.types.err;
3736 let result = self.check_user_unop(expr, oprnd_t, unop);
3737 // If it's builtin, we can reuse the type, this helps inference.
3738 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3743 let result = self.check_user_unop(expr, oprnd_t, unop);
3744 // If it's builtin, we can reuse the type, this helps inference.
3745 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3753 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3754 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3756 ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
3757 if self.is_place_expr(&oprnd) {
3758 // Places may legitimately have unsized types.
3759 // For example, dereferences of a fat pointer and
3760 // the last field of a struct can be unsized.
3763 Expectation::rvalue_hint(self, ty)
3769 let needs = Needs::maybe_mut_place(mutbl);
3770 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3772 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3773 if tm.ty.references_error() {
3776 // Note: at this point, we cannot say what the best lifetime
3777 // is to use for resulting pointer. We want to use the
3778 // shortest lifetime possible so as to avoid spurious borrowck
3779 // errors. Moreover, the longest lifetime will depend on the
3780 // precise details of the value whose address is being taken
3781 // (and how long it is valid), which we don't know yet until type
3782 // inference is complete.
3784 // Therefore, here we simply generate a region variable. The
3785 // region inferencer will then select the ultimate value.
3786 // Finally, borrowck is charged with guaranteeing that the
3787 // value whose address was taken can actually be made to live
3788 // as long as it needs to live.
3789 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3790 tcx.mk_ref(region, tm)
3793 hir::ExprKind::Path(ref qpath) => {
3794 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3795 let ty = if def != Def::Err {
3796 self.instantiate_value_path(segs, opt_ty, def, expr.span, id)
3798 self.set_tainted_by_errors();
3802 // We always require that the type provided as the value for
3803 // a type parameter outlives the moment of instantiation.
3804 let substs = self.tables.borrow().node_substs(expr.hir_id);
3805 self.add_wf_bounds(substs, expr);
3809 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3810 for output in outputs {
3811 self.check_expr(output);
3813 for input in inputs {
3814 self.check_expr(input);
3818 hir::ExprKind::Break(destination, ref expr_opt) => {
3819 if let Ok(target_id) = destination.target_id {
3821 if let Some(ref e) = *expr_opt {
3822 // If this is a break with a value, we need to type-check
3823 // the expression. Get an expected type from the loop context.
3824 let opt_coerce_to = {
3825 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3826 enclosing_breakables.find_breakable(target_id)
3829 .map(|coerce| coerce.expected_ty())
3832 // If the loop context is not a `loop { }`, then break with
3833 // a value is illegal, and `opt_coerce_to` will be `None`.
3834 // Just set expectation to error in that case.
3835 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3837 // Recurse without `enclosing_breakables` borrowed.
3838 e_ty = self.check_expr_with_hint(e, coerce_to);
3839 cause = self.misc(e.span);
3841 // Otherwise, this is a break *without* a value. That's
3842 // always legal, and is equivalent to `break ()`.
3843 e_ty = tcx.mk_nil();
3844 cause = self.misc(expr.span);
3847 // Now that we have type-checked `expr_opt`, borrow
3848 // the `enclosing_loops` field and let's coerce the
3849 // type of `expr_opt` into what is expected.
3850 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3851 let ctxt = enclosing_breakables.find_breakable(target_id);
3852 if let Some(ref mut coerce) = ctxt.coerce {
3853 if let Some(ref e) = *expr_opt {
3854 coerce.coerce(self, &cause, e, e_ty);
3856 assert!(e_ty.is_nil());
3857 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3860 // If `ctxt.coerce` is `None`, we can just ignore
3861 // the type of the expresison. This is because
3862 // either this was a break *without* a value, in
3863 // which case it is always a legal type (`()`), or
3864 // else an error would have been flagged by the
3865 // `loops` pass for using break with an expression
3866 // where you are not supposed to.
3867 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3870 ctxt.may_break = true;
3872 // the type of a `break` is always `!`, since it diverges
3875 // Otherwise, we failed to find the enclosing loop;
3876 // this can only happen if the `break` was not
3877 // inside a loop at all, which is caught by the
3878 // loop-checking pass.
3879 if self.tcx.sess.err_count() == 0 {
3880 self.tcx.sess.delay_span_bug(expr.span,
3881 "break was outside loop, but no error was emitted");
3884 // We still need to assign a type to the inner expression to
3885 // prevent the ICE in #43162.
3886 if let Some(ref e) = *expr_opt {
3887 self.check_expr_with_hint(e, tcx.types.err);
3889 // ... except when we try to 'break rust;'.
3890 // ICE this expression in particular (see #43162).
3891 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
3892 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3893 fatally_break_rust(self.tcx.sess);
3897 // There was an error, make typecheck fail
3902 hir::ExprKind::Continue(destination) => {
3903 if let Ok(_) = destination.target_id {
3906 // There was an error, make typecheck fail
3910 hir::ExprKind::Ret(ref expr_opt) => {
3911 if self.ret_coercion.is_none() {
3912 struct_span_err!(self.tcx.sess, expr.span, E0572,
3913 "return statement outside of function body").emit();
3914 } else if let Some(ref e) = *expr_opt {
3915 self.check_return_expr(e);
3917 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3918 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3919 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3923 hir::ExprKind::Assign(ref lhs, ref rhs) => {
3924 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3926 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3929 ExpectIfCondition => {
3930 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3931 expected error elsehwere");
3934 // Only check this if not in an `if` condition, as the
3935 // mistyped comparison help is more appropriate.
3936 if !self.is_place_expr(&lhs) {
3937 struct_span_err!(self.tcx.sess, expr.span, E0070,
3938 "invalid left-hand side expression")
3939 .span_label(expr.span, "left-hand of expression not valid")
3945 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3947 if lhs_ty.references_error() || rhs_ty.references_error() {
3953 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
3954 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3955 expr.span, expected)
3957 hir::ExprKind::While(ref cond, ref body, _) => {
3958 let ctxt = BreakableCtxt {
3959 // cannot use break with a value from a while loop
3961 may_break: false, // Will get updated if/when we find a `break`.
3964 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3965 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3966 let cond_diverging = self.diverges.get();
3967 self.check_block_no_value(&body);
3969 // We may never reach the body so it diverging means nothing.
3970 self.diverges.set(cond_diverging);
3974 // No way to know whether it's diverging because
3975 // of a `break` or an outer `break` or `return`.
3976 self.diverges.set(Diverges::Maybe);
3981 hir::ExprKind::Loop(ref body, _, source) => {
3982 let coerce = match source {
3983 // you can only use break with a value from a normal `loop { }`
3984 hir::LoopSource::Loop => {
3985 let coerce_to = expected.coercion_target_type(self, body.span);
3986 Some(CoerceMany::new(coerce_to))
3989 hir::LoopSource::WhileLet |
3990 hir::LoopSource::ForLoop => {
3995 let ctxt = BreakableCtxt {
3997 may_break: false, // Will get updated if/when we find a `break`.
4000 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4001 self.check_block_no_value(&body);
4005 // No way to know whether it's diverging because
4006 // of a `break` or an outer `break` or `return`.
4007 self.diverges.set(Diverges::Maybe);
4010 // If we permit break with a value, then result type is
4011 // the LUB of the breaks (possibly ! if none); else, it
4012 // is nil. This makes sense because infinite loops
4013 // (which would have type !) are only possible iff we
4014 // permit break with a value [1].
4015 if ctxt.coerce.is_none() && !ctxt.may_break {
4017 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4019 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
4021 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4022 self.check_match(expr, &discrim, arms, expected, match_src)
4024 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4025 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4027 hir::ExprKind::Block(ref body, _) => {
4028 self.check_block_with_expected(&body, expected)
4030 hir::ExprKind::Call(ref callee, ref args) => {
4031 self.check_call(expr, &callee, args, expected)
4033 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4034 self.check_method_call(expr, segment, span, args, expected, needs)
4036 hir::ExprKind::Cast(ref e, ref t) => {
4037 // Find the type of `e`. Supply hints based on the type we are casting to,
4039 let t_cast = self.to_ty(t);
4040 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4041 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4042 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4044 // Eagerly check for some obvious errors.
4045 if t_expr.references_error() || t_cast.references_error() {
4048 // Defer other checks until we're done type checking.
4049 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4050 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4052 deferred_cast_checks.push(cast_check);
4055 Err(ErrorReported) => {
4061 hir::ExprKind::Type(ref e, ref t) => {
4062 let ty = self.to_ty(&t);
4063 self.check_expr_eq_type(&e, ty);
4066 hir::ExprKind::Array(ref args) => {
4067 let uty = expected.to_option(self).and_then(|uty| {
4069 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4074 let element_ty = if !args.is_empty() {
4075 let coerce_to = uty.unwrap_or_else(
4076 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4077 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4078 assert_eq!(self.diverges.get(), Diverges::Maybe);
4080 let e_ty = self.check_expr_with_hint(e, coerce_to);
4081 let cause = self.misc(e.span);
4082 coerce.coerce(self, &cause, e, e_ty);
4084 coerce.complete(self)
4086 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4088 tcx.mk_array(element_ty, args.len() as u64)
4090 hir::ExprKind::Repeat(ref element, ref count) => {
4091 let count_def_id = tcx.hir.local_def_id(count.id);
4092 let param_env = ty::ParamEnv::empty();
4093 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4094 let instance = ty::Instance::resolve(
4100 let global_id = GlobalId {
4104 let count = tcx.const_eval(param_env.and(global_id));
4106 if let Err(ref err) = count {
4107 err.report_as_error(
4108 tcx.at(tcx.def_span(count_def_id)),
4109 "could not evaluate repeat length",
4113 let uty = match expected {
4114 ExpectHasType(uty) => {
4116 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4123 let (element_ty, t) = match uty {
4125 self.check_expr_coercable_to_type(&element, uty);
4129 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4130 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4135 if let Ok(count) = count {
4136 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4138 // For [foo, ..n] where n > 1, `foo` must have
4140 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4141 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4145 if element_ty.references_error() {
4147 } else if let Ok(count) = count {
4148 tcx.mk_ty(ty::TyArray(t, count))
4153 hir::ExprKind::Tup(ref elts) => {
4154 let flds = expected.only_has_type(self).and_then(|ty| {
4155 let ty = self.resolve_type_vars_with_obligations(ty);
4157 ty::TyTuple(ref flds) => Some(&flds[..]),
4162 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4163 let t = match flds {
4164 Some(ref fs) if i < fs.len() => {
4166 self.check_expr_coercable_to_type(&e, ety);
4170 self.check_expr_with_expectation(&e, NoExpectation)
4175 let tuple = tcx.mk_tup(elt_ts_iter);
4176 if tuple.references_error() {
4179 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4183 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4184 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4186 hir::ExprKind::Field(ref base, field) => {
4187 self.check_field(expr, needs, &base, field)
4189 hir::ExprKind::Index(ref base, ref idx) => {
4190 let base_t = self.check_expr_with_needs(&base, needs);
4191 let idx_t = self.check_expr(&idx);
4193 if base_t.references_error() {
4195 } else if idx_t.references_error() {
4198 let base_t = self.structurally_resolved_type(base.span, base_t);
4199 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4200 Some((index_ty, element_ty)) => {
4201 // two-phase not needed because index_ty is never mutable
4202 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4207 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4208 "cannot index into a value of type `{}`",
4210 // Try to give some advice about indexing tuples.
4211 if let ty::TyTuple(..) = base_t.sty {
4212 let mut needs_note = true;
4213 // If the index is an integer, we can show the actual
4214 // fixed expression:
4215 if let hir::ExprKind::Lit(ref lit) = idx.node {
4216 if let ast::LitKind::Int(i,
4217 ast::LitIntType::Unsuffixed) = lit.node {
4218 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4219 if let Ok(snip) = snip {
4220 err.span_suggestion(expr.span,
4221 "to access tuple elements, use",
4222 format!("{}.{}", snip, i));
4228 err.help("to access tuple elements, use tuple indexing \
4229 syntax (e.g. `tuple.0`)");
4238 hir::ExprKind::Yield(ref value) => {
4239 match self.yield_ty {
4241 self.check_expr_coercable_to_type(&value, ty);
4244 struct_span_err!(self.tcx.sess, expr.span, E0627,
4245 "yield statement outside of generator literal").emit();
4253 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4254 // The newly resolved definition is written into `type_dependent_defs`.
4255 fn finish_resolving_struct_path(&self,
4258 node_id: ast::NodeId)
4262 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4263 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4264 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4267 hir::QPath::TypeRelative(ref qself, ref segment) => {
4268 let ty = self.to_ty(qself);
4270 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4275 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4278 // Write back the new resolution.
4279 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4280 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4287 // Resolve associated value path into a base type and associated constant or method definition.
4288 // The newly resolved definition is written into `type_dependent_defs`.
4289 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4290 qpath: &'b hir::QPath,
4291 node_id: ast::NodeId,
4293 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4295 let (ty, item_segment) = match *qpath {
4296 hir::QPath::Resolved(ref opt_qself, ref path) => {
4298 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4299 &path.segments[..]);
4301 hir::QPath::TypeRelative(ref qself, ref segment) => {
4302 (self.to_ty(qself), segment)
4305 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4306 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4307 // Return directly on cache hit. This is useful to avoid doubly reporting
4308 // errors with default match binding modes. See #44614.
4309 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4311 let item_name = item_segment.ident;
4312 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4315 let def = match error {
4316 method::MethodError::PrivateMatch(def, _) => def,
4319 if item_name.name != keywords::Invalid.name() {
4320 self.report_method_error(span, ty, item_name, None, error, None);
4326 // Write back the new resolution.
4327 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4328 (def, Some(ty), slice::from_ref(&**item_segment))
4331 pub fn check_decl_initializer(&self,
4332 local: &'gcx hir::Local,
4333 init: &'gcx hir::Expr) -> Ty<'tcx>
4335 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4336 // for #42640 (default match binding modes).
4339 let ref_bindings = local.pat.contains_explicit_ref_binding();
4341 let local_ty = self.local_ty(init.span, local.id);
4342 if let Some(m) = ref_bindings {
4343 // Somewhat subtle: if we have a `ref` binding in the pattern,
4344 // we want to avoid introducing coercions for the RHS. This is
4345 // both because it helps preserve sanity and, in the case of
4346 // ref mut, for soundness (issue #23116). In particular, in
4347 // the latter case, we need to be clear that the type of the
4348 // referent for the reference that results is *equal to* the
4349 // type of the place it is referencing, and not some
4350 // supertype thereof.
4351 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4352 self.demand_eqtype(init.span, local_ty, init_ty);
4355 self.check_expr_coercable_to_type(init, local_ty)
4359 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4360 let t = self.local_ty(local.span, local.id);
4361 self.write_ty(local.hir_id, t);
4363 if let Some(ref init) = local.init {
4364 let init_ty = self.check_decl_initializer(local, &init);
4365 if init_ty.references_error() {
4366 self.write_ty(local.hir_id, init_ty);
4370 self.check_pat_walk(&local.pat, t,
4371 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4373 let pat_ty = self.node_ty(local.pat.hir_id);
4374 if pat_ty.references_error() {
4375 self.write_ty(local.hir_id, pat_ty);
4379 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4380 // Don't do all the complex logic below for DeclItem.
4382 hir::StmtKind::Decl(ref decl, _) => {
4384 hir::DeclKind::Local(_) => {}
4385 hir::DeclKind::Item(_) => {
4390 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4393 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4395 // Hide the outer diverging and has_errors flags.
4396 let old_diverges = self.diverges.get();
4397 let old_has_errors = self.has_errors.get();
4398 self.diverges.set(Diverges::Maybe);
4399 self.has_errors.set(false);
4402 hir::StmtKind::Decl(ref decl, _) => {
4404 hir::DeclKind::Local(ref l) => {
4405 self.check_decl_local(&l);
4407 hir::DeclKind::Item(_) => {/* ignore for now */}
4410 hir::StmtKind::Expr(ref expr, _) => {
4411 // Check with expected type of ()
4412 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4414 hir::StmtKind::Semi(ref expr, _) => {
4415 self.check_expr(&expr);
4419 // Combine the diverging and has_error flags.
4420 self.diverges.set(self.diverges.get() | old_diverges);
4421 self.has_errors.set(self.has_errors.get() | old_has_errors);
4424 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4425 let unit = self.tcx.mk_nil();
4426 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4428 // if the block produces a `!` value, that can always be
4429 // (effectively) coerced to unit.
4431 self.demand_suptype(blk.span, unit, ty);
4435 fn check_block_with_expected(&self,
4436 blk: &'gcx hir::Block,
4437 expected: Expectation<'tcx>) -> Ty<'tcx> {
4439 let mut fcx_ps = self.ps.borrow_mut();
4440 let unsafety_state = fcx_ps.recurse(blk);
4441 replace(&mut *fcx_ps, unsafety_state)
4444 // In some cases, blocks have just one exit, but other blocks
4445 // can be targeted by multiple breaks. This can happen both
4446 // with labeled blocks as well as when we desugar
4447 // a `do catch { ... }` expression.
4451 // 'a: { if true { break 'a Err(()); } Ok(()) }
4453 // Here we would wind up with two coercions, one from
4454 // `Err(())` and the other from the tail expression
4455 // `Ok(())`. If the tail expression is omitted, that's a
4456 // "forced unit" -- unless the block diverges, in which
4457 // case we can ignore the tail expression (e.g., `'a: {
4458 // break 'a 22; }` would not force the type of the block
4460 let tail_expr = blk.expr.as_ref();
4461 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4462 let coerce = if blk.targeted_by_break {
4463 CoerceMany::new(coerce_to_ty)
4465 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4466 Some(e) => slice::from_ref(e),
4469 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4472 let prev_diverges = self.diverges.get();
4473 let ctxt = BreakableCtxt {
4474 coerce: Some(coerce),
4478 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4479 for s in &blk.stmts {
4483 // check the tail expression **without** holding the
4484 // `enclosing_breakables` lock below.
4485 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4487 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4488 let ctxt = enclosing_breakables.find_breakable(blk.id);
4489 let coerce = ctxt.coerce.as_mut().unwrap();
4490 if let Some(tail_expr_ty) = tail_expr_ty {
4491 let tail_expr = tail_expr.unwrap();
4492 let cause = self.cause(tail_expr.span,
4493 ObligationCauseCode::BlockTailExpression(blk.id));
4499 // Subtle: if there is no explicit tail expression,
4500 // that is typically equivalent to a tail expression
4501 // of `()` -- except if the block diverges. In that
4502 // case, there is no value supplied from the tail
4503 // expression (assuming there are no other breaks,
4504 // this implies that the type of the block will be
4507 // #41425 -- label the implicit `()` as being the
4508 // "found type" here, rather than the "expected type".
4510 // #44579 -- if the block was recovered during parsing,
4511 // the type would be nonsensical and it is not worth it
4512 // to perform the type check, so we avoid generating the
4513 // diagnostic output.
4514 if !self.diverges.get().always() && !blk.recovered {
4515 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4516 if let Some(expected_ty) = expected.only_has_type(self) {
4517 self.consider_hint_about_removing_semicolon(blk,
4527 // If we can break from the block, then the block's exit is always reachable
4528 // (... as long as the entry is reachable) - regardless of the tail of the block.
4529 self.diverges.set(prev_diverges);
4532 let mut ty = ctxt.coerce.unwrap().complete(self);
4534 if self.has_errors.get() || ty.references_error() {
4535 ty = self.tcx.types.err
4538 self.write_ty(blk.hir_id, ty);
4540 *self.ps.borrow_mut() = prev;
4544 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4545 /// suggestion can be made, `None` otherwise.
4546 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4547 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4548 // `while` before reaching it, as block tail returns are not available in them.
4549 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4550 let parent = self.tcx.hir.get(fn_id);
4552 if let Node::NodeItem(&hir::Item {
4553 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4555 decl.clone().and_then(|decl| {
4556 // This is less than ideal, it will not suggest a return type span on any
4557 // method called `main`, regardless of whether it is actually the entry point,
4558 // but it will still present it as the reason for the expected type.
4559 Some((decl, name != Symbol::intern("main")))
4561 } else if let Node::NodeTraitItem(&hir::TraitItem {
4562 node: hir::TraitItemKind::Method(hir::MethodSig {
4566 decl.clone().and_then(|decl| {
4569 } else if let Node::NodeImplItem(&hir::ImplItem {
4570 node: hir::ImplItemKind::Method(hir::MethodSig {
4574 decl.clone().and_then(|decl| {
4585 /// On implicit return expressions with mismatched types, provide the following suggestions:
4587 /// - Point out the method's return type as the reason for the expected type
4588 /// - Possible missing semicolon
4589 /// - Possible missing return type if the return type is the default, and not `fn main()`
4590 pub fn suggest_mismatched_types_on_tail(&self,
4591 err: &mut DiagnosticBuilder<'tcx>,
4592 expression: &'gcx hir::Expr,
4596 blk_id: ast::NodeId) {
4597 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4598 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4599 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4601 self.suggest_ref_or_into(err, expression, expected, found);
4604 pub fn suggest_ref_or_into(
4606 err: &mut DiagnosticBuilder<'tcx>,
4611 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4612 err.span_suggestion(sp, msg, suggestion);
4613 } else if !self.check_for_cast(err, expr, found, expected) {
4614 let methods = self.get_conversion_methods(expr.span, expected, found);
4615 if let Ok(expr_text) = self.sess().codemap().span_to_snippet(expr.span) {
4616 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4617 .map(|(receiver, method)| format!("{}.{}()", receiver, method.ident))
4618 .collect::<Vec<_>>();
4619 if !suggestions.is_empty() {
4620 err.span_suggestions(expr.span, "try using a conversion method", suggestions);
4626 /// A common error is to forget to add a semicolon at the end of a block:
4630 /// bar_that_returns_u32()
4634 /// This routine checks if the return expression in a block would make sense on its own as a
4635 /// statement and the return type has been left as default or has been specified as `()`. If so,
4636 /// it suggests adding a semicolon.
4637 fn suggest_missing_semicolon(&self,
4638 err: &mut DiagnosticBuilder<'tcx>,
4639 expression: &'gcx hir::Expr,
4642 if expected.is_nil() {
4643 // `BlockTailExpression` only relevant if the tail expr would be
4644 // useful on its own.
4645 match expression.node {
4646 hir::ExprKind::Call(..) |
4647 hir::ExprKind::MethodCall(..) |
4648 hir::ExprKind::If(..) |
4649 hir::ExprKind::While(..) |
4650 hir::ExprKind::Loop(..) |
4651 hir::ExprKind::Match(..) |
4652 hir::ExprKind::Block(..) => {
4653 let sp = self.tcx.sess.codemap().next_point(cause_span);
4654 err.span_suggestion(sp,
4655 "try adding a semicolon",
4664 /// A possible error is to forget to add a return type that is needed:
4668 /// bar_that_returns_u32()
4672 /// This routine checks if the return type is left as default, the method is not part of an
4673 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4675 fn suggest_missing_return_type(&self,
4676 err: &mut DiagnosticBuilder<'tcx>,
4677 fn_decl: &hir::FnDecl,
4680 can_suggest: bool) {
4681 // Only suggest changing the return type for methods that
4682 // haven't set a return type at all (and aren't `fn main()` or an impl).
4683 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_nil()) {
4684 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4685 err.span_suggestion(span,
4686 "try adding a return type",
4688 self.resolve_type_vars_with_obligations(found)));
4690 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4691 err.span_label(span, "possibly return type missing here?");
4693 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4694 // `fn main()` must return `()`, do not suggest changing return type
4695 err.span_label(span, "expected `()` because of default return type");
4697 // expectation was caused by something else, not the default return
4698 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4699 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4700 // Only point to return type if the expected type is the return type, as if they
4701 // are not, the expectation must have been caused by something else.
4702 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4704 let ty = AstConv::ast_ty_to_ty(self, ty);
4705 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4706 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4707 if ty.sty == expected.sty {
4708 err.span_label(sp, format!("expected `{}` because of return type",
4716 /// A common error is to add an extra semicolon:
4719 /// fn foo() -> usize {
4724 /// This routine checks if the final statement in a block is an
4725 /// expression with an explicit semicolon whose type is compatible
4726 /// with `expected_ty`. If so, it suggests removing the semicolon.
4727 fn consider_hint_about_removing_semicolon(&self,
4728 blk: &'gcx hir::Block,
4729 expected_ty: Ty<'tcx>,
4730 err: &mut DiagnosticBuilder) {
4731 // Be helpful when the user wrote `{... expr;}` and
4732 // taking the `;` off is enough to fix the error.
4733 let last_stmt = match blk.stmts.last() {
4737 let last_expr = match last_stmt.node {
4738 hir::StmtKind::Semi(ref e, _) => e,
4741 let last_expr_ty = self.node_ty(last_expr.hir_id);
4742 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4745 let original_span = original_sp(last_stmt.span, blk.span);
4746 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4747 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4750 // Instantiates the given path, which must refer to an item with the given
4751 // number of type parameters and type.
4752 pub fn instantiate_value_path(&self,
4753 segments: &[hir::PathSegment],
4754 opt_self_ty: Option<Ty<'tcx>>,
4757 node_id: ast::NodeId)
4759 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4764 // We need to extract the type parameters supplied by the user in
4765 // the path `path`. Due to the current setup, this is a bit of a
4766 // tricky-process; the problem is that resolve only tells us the
4767 // end-point of the path resolution, and not the intermediate steps.
4768 // Luckily, we can (at least for now) deduce the intermediate steps
4769 // just from the end-point.
4771 // There are basically four cases to consider:
4773 // 1. Reference to a constructor of enum variant or struct:
4775 // struct Foo<T>(...)
4776 // enum E<T> { Foo(...) }
4778 // In these cases, the parameters are declared in the type
4781 // 2. Reference to a fn item or a free constant:
4785 // In this case, the path will again always have the form
4786 // `a::b::foo::<T>` where only the final segment should have
4787 // type parameters. However, in this case, those parameters are
4788 // declared on a value, and hence are in the `FnSpace`.
4790 // 3. Reference to a method or an associated constant:
4792 // impl<A> SomeStruct<A> {
4796 // Here we can have a path like
4797 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4798 // may appear in two places. The penultimate segment,
4799 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4800 // final segment, `foo::<B>` contains parameters in fn space.
4802 // 4. Reference to a local variable
4804 // Local variables can't have any type parameters.
4806 // The first step then is to categorize the segments appropriately.
4808 assert!(!segments.is_empty());
4810 let mut ufcs_associated = None;
4811 let mut type_segment = None;
4812 let mut fn_segment = None;
4814 // Case 1. Reference to a struct/variant constructor.
4815 Def::StructCtor(def_id, ..) |
4816 Def::VariantCtor(def_id, ..) => {
4817 // Everything but the final segment should have no
4818 // parameters at all.
4819 let mut generics = self.tcx.generics_of(def_id);
4820 if let Some(def_id) = generics.parent {
4821 // Variant and struct constructors use the
4822 // generics of their parent type definition.
4823 generics = self.tcx.generics_of(def_id);
4825 type_segment = Some((segments.last().unwrap(), generics));
4828 // Case 2. Reference to a top-level value.
4830 Def::Const(def_id) |
4831 Def::Static(def_id, _) => {
4832 fn_segment = Some((segments.last().unwrap(), self.tcx.generics_of(def_id)));
4835 // Case 3. Reference to a method or associated const.
4836 Def::Method(def_id) |
4837 Def::AssociatedConst(def_id) => {
4838 let container = self.tcx.associated_item(def_id).container;
4840 ty::TraitContainer(trait_did) => {
4841 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4843 ty::ImplContainer(_) => {}
4846 let generics = self.tcx.generics_of(def_id);
4847 if segments.len() >= 2 {
4848 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4849 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4851 // `<T>::assoc` will end up here, and so can `T::assoc`.
4852 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4853 ufcs_associated = Some((container, self_ty));
4855 fn_segment = Some((segments.last().unwrap(), generics));
4858 // Case 4. Local variable, no generics.
4859 Def::Local(..) | Def::Upvar(..) => {}
4861 _ => bug!("unexpected definition: {:?}", def),
4864 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4866 // Now that we have categorized what space the parameters for each
4867 // segment belong to, let's sort out the parameters that the user
4868 // provided (if any) into their appropriate spaces. We'll also report
4869 // errors if type parameters are provided in an inappropriate place.
4870 let poly_segments = type_segment.is_some() as usize +
4871 fn_segment.is_some() as usize;
4872 AstConv::prohibit_generics(self, &segments[..segments.len() - poly_segments]);
4875 Def::Local(nid) | Def::Upvar(nid, ..) => {
4876 let ty = self.local_ty(span, nid);
4877 let ty = self.normalize_associated_types_in(span, &ty);
4878 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4884 // Now we have to compare the types that the user *actually*
4885 // provided against the types that were *expected*. If the user
4886 // did not provide any types, then we want to substitute inference
4887 // variables. If the user provided some types, we may still need
4888 // to add defaults. If the user provided *too many* types, that's
4890 let supress_mismatch = self.check_impl_trait(span, fn_segment);
4891 self.check_generic_arg_count(span, &mut type_segment, false, supress_mismatch);
4892 self.check_generic_arg_count(span, &mut fn_segment, false, supress_mismatch);
4894 let (fn_start, has_self) = match (type_segment, fn_segment) {
4895 (_, Some((_, generics))) => {
4896 (generics.parent_count, generics.has_self)
4898 (Some((_, generics)), None) => {
4899 (generics.params.len(), generics.has_self)
4901 (None, None) => (0, false)
4903 // FIXME(varkor): Separating out the parameters is messy.
4904 let mut lifetimes_type_seg = vec![];
4905 let mut types_type_seg = vec![];
4906 let mut infer_types_type_seg = true;
4907 if let Some((seg, _)) = type_segment {
4908 if let Some(ref data) = seg.args {
4909 for arg in &data.args {
4911 GenericArg::Lifetime(lt) => lifetimes_type_seg.push(lt),
4912 GenericArg::Type(ty) => types_type_seg.push(ty),
4916 infer_types_type_seg = seg.infer_types;
4919 let mut lifetimes_fn_seg = vec![];
4920 let mut types_fn_seg = vec![];
4921 let mut infer_types_fn_seg = true;
4922 if let Some((seg, _)) = fn_segment {
4923 if let Some(ref data) = seg.args {
4924 for arg in &data.args {
4926 GenericArg::Lifetime(lt) => lifetimes_fn_seg.push(lt),
4927 GenericArg::Type(ty) => types_fn_seg.push(ty),
4931 infer_types_fn_seg = seg.infer_types;
4934 let substs = Substs::for_item(self.tcx, def.def_id(), |param, substs| {
4935 let mut i = param.index as usize;
4937 let (segment, lifetimes, types, infer_types) = if i < fn_start {
4938 if let GenericParamDefKind::Type { .. } = param.kind {
4939 // Handle Self first, so we can adjust the index to match the AST.
4940 if has_self && i == 0 {
4941 return opt_self_ty.map(|ty| ty.into()).unwrap_or_else(|| {
4942 self.var_for_def(span, param)
4946 i -= has_self as usize;
4947 (type_segment, &lifetimes_type_seg, &types_type_seg, infer_types_type_seg)
4950 (fn_segment, &lifetimes_fn_seg, &types_fn_seg, infer_types_fn_seg)
4954 GenericParamDefKind::Lifetime => {
4955 if let Some(lifetime) = lifetimes.get(i) {
4956 AstConv::ast_region_to_region(self, lifetime, Some(param)).into()
4958 self.re_infer(span, Some(param)).unwrap().into()
4961 GenericParamDefKind::Type { .. } => {
4962 // Skip over the lifetimes in the same segment.
4963 if let Some((_, generics)) = segment {
4964 i -= generics.own_counts().lifetimes;
4967 let has_default = match param.kind {
4968 GenericParamDefKind::Type { has_default, .. } => has_default,
4972 if let Some(ast_ty) = types.get(i) {
4973 // A provided type parameter.
4974 self.to_ty(ast_ty).into()
4975 } else if !infer_types && has_default {
4976 // No type parameter provided, but a default exists.
4977 let default = self.tcx.type_of(param.def_id);
4980 default.subst_spanned(self.tcx, substs, Some(span))
4983 // No type parameters were provided, we can infer all.
4984 // This can also be reached in some error cases:
4985 // We prefer to use inference variables instead of
4986 // TyError to let type inference recover somewhat.
4987 self.var_for_def(span, param)
4993 // The things we are substituting into the type should not contain
4994 // escaping late-bound regions, and nor should the base type scheme.
4995 let ty = self.tcx.type_of(def.def_id());
4996 assert!(!substs.has_escaping_regions());
4997 assert!(!ty.has_escaping_regions());
4999 // Add all the obligations that are required, substituting and
5000 // normalized appropriately.
5001 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
5002 self.add_obligations_for_parameters(
5003 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
5006 // Substitute the values for the type parameters into the type of
5007 // the referenced item.
5008 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5010 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
5011 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5012 // is inherent, there is no `Self` parameter, instead, the impl needs
5013 // type parameters, which we can infer by unifying the provided `Self`
5014 // with the substituted impl type.
5015 let ty = self.tcx.type_of(impl_def_id);
5017 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5018 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5019 Ok(ok) => self.register_infer_ok_obligations(ok),
5022 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5029 self.check_rustc_args_require_const(def.def_id(), node_id, span);
5031 debug!("instantiate_value_path: type of {:?} is {:?}",
5034 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
5038 fn check_rustc_args_require_const(&self,
5040 node_id: ast::NodeId,
5042 // We're only interested in functions tagged with
5043 // #[rustc_args_required_const], so ignore anything that's not.
5044 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5048 // If our calling expression is indeed the function itself, we're good!
5049 // If not, generate an error that this can only be called directly.
5050 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5051 Node::NodeExpr(expr) => {
5053 hir::ExprKind::Call(ref callee, ..) => {
5054 if callee.id == node_id {
5064 self.tcx.sess.span_err(span, "this function can only be invoked \
5065 directly, not through a function pointer");
5068 /// Report errors if the provided parameters are too few or too many.
5069 fn check_generic_arg_count(&self,
5071 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
5072 is_method_call: bool,
5073 supress_mismatch_error: bool) {
5074 let (lifetimes, types, infer_types, bindings) = segment.map_or(
5075 (vec![], vec![], true, &[][..]),
5077 s.args.as_ref().map_or(
5078 (vec![], vec![], s.infer_types, &[][..]),
5080 let (mut lifetimes, mut types) = (vec![], vec![]);
5081 data.args.iter().for_each(|arg| match arg {
5082 GenericArg::Lifetime(lt) => lifetimes.push(lt),
5083 GenericArg::Type(ty) => types.push(ty),
5085 (lifetimes, types, s.infer_types, &data.bindings[..])
5090 // Check provided parameters.
5091 let ((ty_required, ty_accepted), lt_accepted) =
5092 segment.map_or(((0, 0), 0), |(_, generics)| {
5098 let mut lt_accepted = 0;
5099 let mut ty_params = ParamRange { required: 0, accepted: 0 };
5100 for param in &generics.params {
5102 GenericParamDefKind::Lifetime => lt_accepted += 1,
5103 GenericParamDefKind::Type { has_default, .. } => {
5104 ty_params.accepted += 1;
5106 ty_params.required += 1;
5111 if generics.parent.is_none() && generics.has_self {
5112 ty_params.required -= 1;
5113 ty_params.accepted -= 1;
5116 ((ty_params.required, ty_params.accepted), lt_accepted)
5119 let count_type_params = |n| {
5120 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
5122 let expected_text = count_type_params(ty_accepted);
5123 let actual_text = count_type_params(types.len());
5124 if let Some((mut err, span)) = if types.len() > ty_accepted {
5125 // To prevent derived errors to accumulate due to extra
5126 // type parameters, we force instantiate_value_path to
5127 // use inference variables instead of the provided types.
5129 let span = types[ty_accepted].span;
5130 Some((struct_span_err!(self.tcx.sess, span, E0087,
5131 "too many type parameters provided: \
5132 expected at most {}, found {}",
5133 expected_text, actual_text), span))
5134 } else if types.len() < ty_required && !infer_types && !supress_mismatch_error {
5135 Some((struct_span_err!(self.tcx.sess, span, E0089,
5136 "too few type parameters provided: \
5137 expected {}, found {}",
5138 expected_text, actual_text), span))
5142 err.span_label(span, format!("expected {}", expected_text)).emit();
5145 if !bindings.is_empty() {
5146 AstConv::prohibit_projection(self, bindings[0].span);
5149 let infer_lifetimes = lifetimes.len() == 0;
5150 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
5151 let has_late_bound_lifetime_defs =
5152 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
5153 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
5154 // Report this as a lint only if no error was reported previously.
5155 let primary_msg = "cannot specify lifetime arguments explicitly \
5156 if late bound lifetime parameters are present";
5157 let note_msg = "the late bound lifetime parameter is introduced here";
5158 if !is_method_call && (lifetimes.len() > lt_accepted ||
5159 lifetimes.len() < lt_accepted && !infer_lifetimes) {
5160 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
5161 err.span_note(span_late, note_msg);
5165 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
5166 multispan.push_span_label(span_late, note_msg.to_string());
5167 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
5168 lifetimes[0].id, multispan, primary_msg);
5173 let count_lifetime_params = |n| {
5174 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
5176 let expected_text = count_lifetime_params(lt_accepted);
5177 let actual_text = count_lifetime_params(lifetimes.len());
5178 if let Some((mut err, span)) = if lifetimes.len() > lt_accepted {
5179 let span = lifetimes[lt_accepted].span;
5180 Some((struct_span_err!(self.tcx.sess, span, E0088,
5181 "too many lifetime parameters provided: \
5182 expected at most {}, found {}",
5183 expected_text, actual_text), span))
5184 } else if lifetimes.len() < lt_accepted && !infer_lifetimes {
5185 Some((struct_span_err!(self.tcx.sess, span, E0090,
5186 "too few lifetime parameters provided: \
5187 expected {}, found {}",
5188 expected_text, actual_text), span))
5192 err.span_label(span, format!("expected {}", expected_text)).emit();
5196 /// Report error if there is an explicit type parameter when using `impl Trait`.
5197 fn check_impl_trait(&self,
5199 segment: Option<(&hir::PathSegment, &ty::Generics)>)
5201 let segment = segment.map(|(path_segment, generics)| {
5202 let explicit = !path_segment.infer_types;
5203 let impl_trait = generics.params.iter().any(|param| match param.kind {
5204 ty::GenericParamDefKind::Type {
5205 synthetic: Some(hir::SyntheticTyParamKind::ImplTrait), ..
5210 if explicit && impl_trait {
5211 let mut err = struct_span_err! {
5215 "cannot provide explicit type parameters when `impl Trait` is \
5216 used in argument position."
5225 segment.unwrap_or(false)
5228 // Resolves `typ` by a single level if `typ` is a type variable.
5229 // If no resolution is possible, then an error is reported.
5230 // Numeric inference variables may be left unresolved.
5231 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5232 let ty = self.resolve_type_vars_with_obligations(ty);
5233 if !ty.is_ty_var() {
5236 if !self.is_tainted_by_errors() {
5237 self.need_type_info_err((**self).body_id, sp, ty)
5238 .note("type must be known at this point")
5241 self.demand_suptype(sp, self.tcx.types.err, ty);
5246 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5247 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5248 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5251 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5252 index = enclosing_breakables.stack.len();
5253 enclosing_breakables.by_id.insert(id, index);
5254 enclosing_breakables.stack.push(ctxt);
5258 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5259 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5260 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5261 enclosing_breakables.stack.pop().expect("missing breakable context")
5267 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5268 generics: &ty::Generics,
5270 let own_counts = generics.own_counts();
5271 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5273 if own_counts.types == 0 {
5276 // Make a vector of booleans initially false, set to true when used.
5277 let mut types_used = vec![false; own_counts.types];
5279 for leaf_ty in ty.walk() {
5280 if let ty::TyParam(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5281 debug!("Found use of ty param num {}", idx);
5282 types_used[idx as usize - own_counts.lifetimes] = true;
5283 } else if let ty::TyError = leaf_ty.sty {
5284 // If there is already another error, do not emit
5285 // an error for not using a type Parameter.
5286 assert!(tcx.sess.err_count() > 0);
5291 let types = generics.params.iter().filter(|param| match param.kind {
5292 ty::GenericParamDefKind::Type { .. } => true,
5295 for (&used, param) in types_used.iter().zip(types) {
5297 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5298 let span = tcx.hir.span(id);
5299 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5300 .span_label(span, "unused type parameter")
5306 fn fatally_break_rust(sess: &Session) {
5307 let handler = sess.diagnostic();
5308 handler.span_bug_no_panic(
5310 "It looks like you're trying to break rust; would you like some ICE?",
5312 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5313 handler.note_without_error(
5314 "we would appreciate a joke overview: \
5315 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5317 handler.note_without_error(&format!("rustc {} running on {}",
5318 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5319 ::session::config::host_triple(),