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 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
862 fcx.check_expr_coercable_to_type(&body.value, expected_type);
867 // All type checking constraints were added, try to fallback unsolved variables.
868 fcx.select_obligations_where_possible(false);
869 let mut fallback_has_occurred = false;
870 for ty in &fcx.unsolved_variables() {
871 fallback_has_occurred |= fcx.fallback_if_possible(ty);
873 fcx.select_obligations_where_possible(fallback_has_occurred);
875 // Even though coercion casts provide type hints, we check casts after fallback for
876 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
879 // Closure and generater analysis may run after fallback
880 // because they don't constrain other type variables.
881 fcx.closure_analyze(body);
882 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
883 fcx.resolve_generator_interiors(def_id);
884 fcx.select_all_obligations_or_error();
886 if fn_decl.is_some() {
887 fcx.regionck_fn(id, body);
889 fcx.regionck_expr(body);
892 fcx.resolve_type_vars_in_body(body)
895 // Consistency check our TypeckTables instance can hold all ItemLocalIds
896 // it will need to hold.
897 assert_eq!(tables.local_id_root,
898 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
902 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
903 if !tcx.sess.target.target.is_abi_supported(abi) {
904 struct_span_err!(tcx.sess, span, E0570,
905 "The ABI `{}` is not supported for the current target", abi).emit()
909 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
910 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
913 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
914 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
917 // infer the variable's type
918 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
919 self.fcx.locals.borrow_mut().insert(nid, var_ty);
923 // take type that the user specified
924 self.fcx.locals.borrow_mut().insert(nid, typ);
931 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
932 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
933 NestedVisitorMap::None
936 // Add explicitly-declared locals.
937 fn visit_local(&mut self, local: &'gcx hir::Local) {
938 let o_ty = match local.ty {
940 let o_ty = self.fcx.to_ty(&ty);
942 let c_ty = self.fcx.inh.infcx.canonicalize_response(&o_ty);
943 debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, c_ty);
944 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
950 self.assign(local.span, local.id, o_ty);
952 debug!("Local variable {:?} is assigned type {}",
954 self.fcx.ty_to_string(
955 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
956 intravisit::walk_local(self, local);
959 // Add pattern bindings.
960 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
961 if let PatKind::Binding(_, _, ident, _) = p.node {
962 let var_ty = self.assign(p.span, p.id, None);
964 self.fcx.require_type_is_sized(var_ty, p.span,
965 traits::VariableType(p.id));
967 debug!("Pattern binding {} is assigned to {} with type {:?}",
969 self.fcx.ty_to_string(
970 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
973 intravisit::walk_pat(self, p);
976 // Don't descend into the bodies of nested closures
977 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
978 _: hir::BodyId, _: Span, _: ast::NodeId) { }
981 /// When `check_fn` is invoked on a generator (i.e., a body that
982 /// includes yield), it returns back some information about the yield
984 struct GeneratorTypes<'tcx> {
985 /// Type of value that is yielded.
986 yield_ty: ty::Ty<'tcx>,
988 /// Types that are captured (see `GeneratorInterior` for more).
989 interior: ty::Ty<'tcx>,
991 /// Indicates if the generator is movable or static (immovable)
992 movability: hir::GeneratorMovability,
995 /// Helper used for fns and closures. Does the grungy work of checking a function
996 /// body and returns the function context used for that purpose, since in the case of a fn item
997 /// there is still a bit more to do.
1000 /// * inherited: other fields inherited from the enclosing fn (if any)
1001 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1002 param_env: ty::ParamEnv<'tcx>,
1003 fn_sig: ty::FnSig<'tcx>,
1004 decl: &'gcx hir::FnDecl,
1006 body: &'gcx hir::Body,
1007 can_be_generator: Option<hir::GeneratorMovability>)
1008 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1010 let mut fn_sig = fn_sig.clone();
1012 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1014 // Create the function context. This is either derived from scratch or,
1015 // in the case of closures, based on the outer context.
1016 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1017 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1019 let declared_ret_ty = fn_sig.output();
1020 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1021 let revealed_ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &declared_ret_ty);
1022 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1023 fn_sig = fcx.tcx.mk_fn_sig(
1024 fn_sig.inputs().iter().cloned(),
1031 let span = body.value.span;
1033 if body.is_generator && can_be_generator.is_some() {
1034 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1035 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1036 fcx.yield_ty = Some(yield_ty);
1039 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1041 // Add formal parameters.
1042 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1043 // Check the pattern.
1044 fcx.check_pat_walk(&arg.pat, arg_ty,
1045 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1047 // Check that argument is Sized.
1048 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1049 // for simple cases like `fn foo(x: Trait)`,
1050 // where we would error once on the parameter as a whole, and once on the binding `x`.
1051 if arg.pat.simple_ident().is_none() {
1052 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1055 fcx.write_ty(arg.hir_id, arg_ty);
1058 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1059 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1061 fcx.check_return_expr(&body.value);
1063 // We insert the deferred_generator_interiors entry after visiting the body.
1064 // This ensures that all nested generators appear before the entry of this generator.
1065 // resolve_generator_interiors relies on this property.
1066 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1067 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1068 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1069 Some(GeneratorTypes {
1070 yield_ty: fcx.yield_ty.unwrap(),
1072 movability: can_be_generator.unwrap(),
1078 // Finalize the return check by taking the LUB of the return types
1079 // we saw and assigning it to the expected return type. This isn't
1080 // really expected to fail, since the coercions would have failed
1081 // earlier when trying to find a LUB.
1083 // However, the behavior around `!` is sort of complex. In the
1084 // event that the `actual_return_ty` comes back as `!`, that
1085 // indicates that the fn either does not return or "returns" only
1086 // values of type `!`. In this case, if there is an expected
1087 // return type that is *not* `!`, that should be ok. But if the
1088 // return type is being inferred, we want to "fallback" to `!`:
1090 // let x = move || panic!();
1092 // To allow for that, I am creating a type variable with diverging
1093 // fallback. This was deemed ever so slightly better than unifying
1094 // the return value with `!` because it allows for the caller to
1095 // make more assumptions about the return type (e.g., they could do
1097 // let y: Option<u32> = Some(x());
1099 // which would then cause this return type to become `u32`, not
1101 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1102 let mut actual_return_ty = coercion.complete(&fcx);
1103 if actual_return_ty.is_never() {
1104 actual_return_ty = fcx.next_diverging_ty_var(
1105 TypeVariableOrigin::DivergingFn(span));
1107 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1109 // Check that the main return type implements the termination trait.
1110 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1111 if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() {
1114 config::EntryFnType::Main => {
1115 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1116 let trait_ref = ty::TraitRef::new(term_id, substs);
1117 let return_ty_span = decl.output.span();
1118 let cause = traits::ObligationCause::new(
1119 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1121 inherited.register_predicate(
1122 traits::Obligation::new(
1123 cause, param_env, trait_ref.to_predicate()));
1125 config::EntryFnType::Start => {},
1131 // Check that a function marked as `#[panic_implementation]` has signature `fn(&PanicInfo) -> !`
1132 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1133 if panic_impl_did == fcx.tcx.hir.local_def_id(fn_id) {
1134 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1135 if declared_ret_ty.sty != ty::TyNever {
1136 fcx.tcx.sess.span_err(
1138 "return type should be `!`",
1142 let inputs = fn_sig.inputs();
1143 let span = fcx.tcx.hir.span(fn_id);
1144 if inputs.len() == 1 {
1145 let arg_is_panic_info = match inputs[0].sty {
1146 ty::TyRef(region, ty, mutbl) => match ty.sty {
1147 ty::TyAdt(ref adt, _) => {
1148 adt.did == panic_info_did &&
1149 mutbl == hir::Mutability::MutImmutable &&
1150 *region != RegionKind::ReStatic
1157 if !arg_is_panic_info {
1158 fcx.tcx.sess.span_err(
1159 decl.inputs[0].span,
1160 "argument should be `&PanicInfo`",
1164 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1165 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1166 if !generics.params.is_empty() {
1167 fcx.tcx.sess.span_err(
1169 "`#[panic_implementation]` function should have no type \
1176 fcx.tcx.sess.span_err(span, "function should have one argument");
1179 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1184 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1185 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1186 if alloc_error_handler_did == fcx.tcx.hir.local_def_id(fn_id) {
1187 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1188 if declared_ret_ty.sty != ty::TyNever {
1189 fcx.tcx.sess.span_err(
1191 "return type should be `!`",
1195 let inputs = fn_sig.inputs();
1196 let span = fcx.tcx.hir.span(fn_id);
1197 if inputs.len() == 1 {
1198 let arg_is_alloc_layout = match inputs[0].sty {
1199 ty::TyAdt(ref adt, _) => {
1200 adt.did == alloc_layout_did
1205 if !arg_is_alloc_layout {
1206 fcx.tcx.sess.span_err(
1207 decl.inputs[0].span,
1208 "argument should be `Layout`",
1212 if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
1213 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1214 if !generics.params.is_empty() {
1215 fcx.tcx.sess.span_err(
1217 "`#[alloc_error_handler]` function should have no type \
1224 fcx.tcx.sess.span_err(span, "function should have one argument");
1227 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1235 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1238 let def_id = tcx.hir.local_def_id(id);
1239 let def = tcx.adt_def(def_id);
1240 def.destructor(tcx); // force the destructor to be evaluated
1241 check_representable(tcx, span, def_id);
1243 if def.repr.simd() {
1244 check_simd(tcx, span, def_id);
1247 check_transparent(tcx, span, def_id);
1248 check_packed(tcx, span, def_id);
1251 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1254 let def_id = tcx.hir.local_def_id(id);
1255 let def = tcx.adt_def(def_id);
1256 def.destructor(tcx); // force the destructor to be evaluated
1257 check_representable(tcx, span, def_id);
1259 check_packed(tcx, span, def_id);
1262 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1263 debug!("check_item_type(it.id={}, it.name={})",
1265 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1266 let _indenter = indenter();
1268 // Consts can play a role in type-checking, so they are included here.
1269 hir::ItemKind::Static(..) => {
1270 let def_id = tcx.hir.local_def_id(it.id);
1271 tcx.typeck_tables_of(def_id);
1272 maybe_check_static_with_link_section(tcx, def_id, it.span);
1274 hir::ItemKind::Const(..) => {
1275 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1277 hir::ItemKind::Enum(ref enum_definition, _) => {
1280 &enum_definition.variants,
1283 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1284 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1285 debug!("ItemKind::Impl {} with id {}", it.name, it.id);
1286 let impl_def_id = tcx.hir.local_def_id(it.id);
1287 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1288 check_impl_items_against_trait(tcx,
1293 let trait_def_id = impl_trait_ref.def_id;
1294 check_on_unimplemented(tcx, trait_def_id, it);
1297 hir::ItemKind::Trait(..) => {
1298 let def_id = tcx.hir.local_def_id(it.id);
1299 check_on_unimplemented(tcx, def_id, it);
1301 hir::ItemKind::Struct(..) => {
1302 check_struct(tcx, it.id, it.span);
1304 hir::ItemKind::Union(..) => {
1305 check_union(tcx, it.id, it.span);
1307 hir::ItemKind::Existential(..) |
1308 hir::ItemKind::Ty(..) => {
1309 let def_id = tcx.hir.local_def_id(it.id);
1310 let pty_ty = tcx.type_of(def_id);
1311 let generics = tcx.generics_of(def_id);
1312 check_bounds_are_used(tcx, &generics, pty_ty);
1314 hir::ItemKind::ForeignMod(ref m) => {
1315 check_abi(tcx, it.span, m.abi);
1317 if m.abi == Abi::RustIntrinsic {
1318 for item in &m.items {
1319 intrinsic::check_intrinsic_type(tcx, item);
1321 } else if m.abi == Abi::PlatformIntrinsic {
1322 for item in &m.items {
1323 intrinsic::check_platform_intrinsic_type(tcx, item);
1326 for item in &m.items {
1327 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1328 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1329 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1330 "foreign items may not have type parameters");
1331 err.span_label(item.span, "can't have type parameters");
1332 // FIXME: once we start storing spans for type arguments, turn this into a
1334 err.help("use specialization instead of type parameters by replacing them \
1335 with concrete types like `u32`");
1339 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1340 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1345 _ => {/* nothing to do */ }
1349 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1350 // Only restricted on wasm32 target for now
1351 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1355 // If `#[link_section]` is missing, then nothing to verify
1356 let attrs = tcx.codegen_fn_attrs(id);
1357 if attrs.link_section.is_none() {
1361 // For the wasm32 target statics with #[link_section] are placed into custom
1362 // sections of the final output file, but this isn't link custom sections of
1363 // other executable formats. Namely we can only embed a list of bytes,
1364 // nothing with pointers to anything else or relocations. If any relocation
1365 // show up, reject them here.
1366 let instance = ty::Instance::mono(tcx, id);
1367 let cid = GlobalId {
1371 let param_env = ty::ParamEnv::reveal_all();
1372 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1373 let alloc = tcx.const_value_to_allocation(static_);
1374 if alloc.relocations.len() != 0 {
1375 let msg = "statics with a custom `#[link_section]` must be a \
1376 simple list of bytes on the wasm target with no \
1377 extra levels of indirection such as references";
1378 tcx.sess.span_err(span, msg);
1383 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1384 trait_def_id: DefId,
1386 let item_def_id = tcx.hir.local_def_id(item.id);
1387 // an error would be reported if this fails.
1388 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1391 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1392 impl_item: &hir::ImplItem,
1395 let mut err = struct_span_err!(
1396 tcx.sess, impl_item.span, E0520,
1397 "`{}` specializes an item from a parent `impl`, but \
1398 that item is not marked `default`",
1400 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1403 match tcx.span_of_impl(parent_impl) {
1405 err.span_label(span, "parent `impl` is here");
1406 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1410 err.note(&format!("parent implementation is in crate `{}`", cname));
1417 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1418 trait_def: &ty::TraitDef,
1419 trait_item: &ty::AssociatedItem,
1421 impl_item: &hir::ImplItem)
1423 let ancestors = trait_def.ancestors(tcx, impl_id);
1425 let kind = match impl_item.node {
1426 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1427 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1428 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1429 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1432 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).skip(1).next()
1433 .map(|node_item| node_item.map(|parent| parent.defaultness));
1435 if let Some(parent) = parent {
1436 if tcx.impl_item_is_final(&parent) {
1437 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1443 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1446 impl_trait_ref: ty::TraitRef<'tcx>,
1447 impl_item_refs: &[hir::ImplItemRef]) {
1448 let impl_span = tcx.sess.codemap().def_span(impl_span);
1450 // If the trait reference itself is erroneous (so the compilation is going
1451 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1452 // isn't populated for such impls.
1453 if impl_trait_ref.references_error() { return; }
1455 // Locate trait definition and items
1456 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1457 let mut overridden_associated_type = None;
1459 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1461 // Check existing impl methods to see if they are both present in trait
1462 // and compatible with trait signature
1463 for impl_item in impl_items() {
1464 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1465 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1466 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1467 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1469 // Not compatible, but needed for the error message
1470 tcx.associated_items(impl_trait_ref.def_id)
1471 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1474 // Check that impl definition matches trait definition
1475 if let Some(ty_trait_item) = ty_trait_item {
1476 match impl_item.node {
1477 hir::ImplItemKind::Const(..) => {
1478 // Find associated const definition.
1479 if ty_trait_item.kind == ty::AssociatedKind::Const {
1480 compare_const_impl(tcx,
1486 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1487 "item `{}` is an associated const, \
1488 which doesn't match its trait `{}`",
1491 err.span_label(impl_item.span, "does not match trait");
1492 // We can only get the spans from local trait definition
1493 // Same for E0324 and E0325
1494 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1495 err.span_label(trait_span, "item in trait");
1500 hir::ImplItemKind::Method(..) => {
1501 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1502 if ty_trait_item.kind == ty::AssociatedKind::Method {
1503 compare_impl_method(tcx,
1510 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1511 "item `{}` is an associated method, \
1512 which doesn't match its trait `{}`",
1515 err.span_label(impl_item.span, "does not match trait");
1516 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1517 err.span_label(trait_span, "item in trait");
1522 hir::ImplItemKind::Existential(..) |
1523 hir::ImplItemKind::Type(_) => {
1524 if ty_trait_item.kind == ty::AssociatedKind::Type {
1525 if ty_trait_item.defaultness.has_value() {
1526 overridden_associated_type = Some(impl_item);
1529 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1530 "item `{}` is an associated type, \
1531 which doesn't match its trait `{}`",
1534 err.span_label(impl_item.span, "does not match trait");
1535 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1536 err.span_label(trait_span, "item in trait");
1543 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1547 // Check for missing items from trait
1548 let mut missing_items = Vec::new();
1549 let mut invalidated_items = Vec::new();
1550 let associated_type_overridden = overridden_associated_type.is_some();
1551 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1552 let is_implemented = trait_def.ancestors(tcx, impl_id)
1553 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1555 .map(|node_item| !node_item.node.is_from_trait())
1558 if !is_implemented && !tcx.impl_is_default(impl_id) {
1559 if !trait_item.defaultness.has_value() {
1560 missing_items.push(trait_item);
1561 } else if associated_type_overridden {
1562 invalidated_items.push(trait_item.ident);
1567 if !missing_items.is_empty() {
1568 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1569 "not all trait items implemented, missing: `{}`",
1570 missing_items.iter()
1571 .map(|trait_item| trait_item.ident.to_string())
1572 .collect::<Vec<_>>().join("`, `"));
1573 err.span_label(impl_span, format!("missing `{}` in implementation",
1574 missing_items.iter()
1575 .map(|trait_item| trait_item.ident.to_string())
1576 .collect::<Vec<_>>().join("`, `")));
1577 for trait_item in missing_items {
1578 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1579 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1581 err.note_trait_signature(trait_item.ident.to_string(),
1582 trait_item.signature(&tcx));
1588 if !invalidated_items.is_empty() {
1589 let invalidator = overridden_associated_type.unwrap();
1590 span_err!(tcx.sess, invalidator.span, E0399,
1591 "the following trait items need to be reimplemented \
1592 as `{}` was overridden: `{}`",
1594 invalidated_items.iter()
1595 .map(|name| name.to_string())
1596 .collect::<Vec<_>>().join("`, `"))
1600 /// Checks whether a type can be represented in memory. In particular, it
1601 /// identifies types that contain themselves without indirection through a
1602 /// pointer, which would mean their size is unbounded.
1603 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1607 let rty = tcx.type_of(item_def_id);
1609 // Check that it is possible to represent this type. This call identifies
1610 // (1) types that contain themselves and (2) types that contain a different
1611 // recursive type. It is only necessary to throw an error on those that
1612 // contain themselves. For case 2, there must be an inner type that will be
1613 // caught by case 1.
1614 match rty.is_representable(tcx, sp) {
1615 Representability::SelfRecursive(spans) => {
1616 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1618 err.span_label(span, "recursive without indirection");
1623 Representability::Representable | Representability::ContainsRecursive => (),
1628 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1629 let t = tcx.type_of(def_id);
1631 ty::TyAdt(def, substs) if def.is_struct() => {
1632 let fields = &def.non_enum_variant().fields;
1633 if fields.is_empty() {
1634 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1637 let e = fields[0].ty(tcx, substs);
1638 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1639 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1640 .span_label(sp, "SIMD elements must have the same type")
1645 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1646 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1648 span_err!(tcx.sess, sp, E0077,
1649 "SIMD vector element type should be machine type");
1658 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1659 let repr = tcx.adt_def(def_id).repr;
1661 for attr in tcx.get_attrs(def_id).iter() {
1662 for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
1663 if let attr::ReprPacked(pack) = r {
1664 if pack != repr.pack {
1665 struct_span_err!(tcx.sess, sp, E0634,
1666 "type has conflicting packed representation hints").emit();
1672 struct_span_err!(tcx.sess, sp, E0587,
1673 "type has conflicting packed and align representation hints").emit();
1675 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1676 struct_span_err!(tcx.sess, sp, E0588,
1677 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1682 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1684 stack: &mut Vec<DefId>) -> bool {
1685 let t = tcx.type_of(def_id);
1686 if stack.contains(&def_id) {
1687 debug!("check_packed_inner: {:?} is recursive", t);
1691 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1692 if tcx.adt_def(def.did).repr.align > 0 {
1695 // push struct def_id before checking fields
1697 for field in &def.non_enum_variant().fields {
1698 let f = field.ty(tcx, substs);
1700 ty::TyAdt(def, _) => {
1701 if check_packed_inner(tcx, def.did, stack) {
1708 // only need to pop if not early out
1716 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1717 let adt = tcx.adt_def(def_id);
1718 if !adt.repr.transparent() {
1722 // For each field, figure out if it's known to be a ZST and align(1)
1723 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1724 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1725 let param_env = tcx.param_env(field.did);
1726 let layout = tcx.layout_of(param_env.and(ty));
1727 // We are currently checking the type this field came from, so it must be local
1728 let span = tcx.hir.span_if_local(field.did).unwrap();
1729 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1730 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1734 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1735 let non_zst_count = non_zst_fields.clone().count();
1736 if non_zst_count != 1 {
1737 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1738 struct_span_err!(tcx.sess, sp, E0690,
1739 "transparent struct needs exactly one non-zero-sized field, but has {}",
1741 .span_note(field_spans, "non-zero-sized field")
1744 for &(span, zst, align1) in &field_infos {
1746 span_err!(tcx.sess, span, E0691,
1747 "zero-sized field in transparent struct has alignment larger than 1");
1752 #[allow(trivial_numeric_casts)]
1753 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1755 vs: &'tcx [hir::Variant],
1757 let def_id = tcx.hir.local_def_id(id);
1758 let def = tcx.adt_def(def_id);
1759 def.destructor(tcx); // force the destructor to be evaluated
1762 let attributes = tcx.get_attrs(def_id);
1763 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1765 tcx.sess, attr.span, E0084,
1766 "unsupported representation for zero-variant enum")
1767 .span_label(sp, "zero-variant enum")
1772 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1773 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1774 if !tcx.features().repr128 {
1775 emit_feature_err(&tcx.sess.parse_sess,
1778 GateIssue::Language,
1779 "repr with 128-bit type is unstable");
1784 if let Some(ref e) = v.node.disr_expr {
1785 tcx.typeck_tables_of(tcx.hir.local_def_id(e.id));
1789 let mut disr_vals: Vec<Discr<'tcx>> = Vec::new();
1790 for (discr, v) in def.discriminants(tcx).zip(vs) {
1791 // Check for duplicate discriminant values
1792 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1793 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1794 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1795 let i_span = match variant_i.node.disr_expr {
1796 Some(ref expr) => tcx.hir.span(expr.id),
1797 None => tcx.hir.span(variant_i_node_id)
1799 let span = match v.node.disr_expr {
1800 Some(ref expr) => tcx.hir.span(expr.id),
1803 struct_span_err!(tcx.sess, span, E0081,
1804 "discriminant value `{}` already exists", disr_vals[i])
1805 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1806 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1809 disr_vals.push(discr);
1812 check_representable(tcx, sp, def_id);
1815 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1816 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1818 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1819 -> ty::GenericPredicates<'tcx>
1822 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1823 let item_id = tcx.hir.ty_param_owner(node_id);
1824 let item_def_id = tcx.hir.local_def_id(item_id);
1825 let generics = tcx.generics_of(item_def_id);
1826 let index = generics.param_def_id_to_index[&def_id];
1827 ty::GenericPredicates {
1829 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1831 ty::Predicate::Trait(ref data) => {
1832 data.skip_binder().self_ty().is_param(index)
1836 }).cloned().collect()
1840 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1841 -> Option<ty::Region<'tcx>> {
1843 Some(def) => infer::EarlyBoundRegion(span, def.name),
1844 None => infer::MiscVariable(span)
1846 Some(self.next_region_var(v))
1849 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1850 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1853 fn ty_infer_for_def(&self,
1854 ty_param_def: &ty::GenericParamDef,
1855 span: Span) -> Ty<'tcx> {
1856 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1862 fn projected_ty_from_poly_trait_ref(&self,
1865 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1868 let (trait_ref, _) =
1869 self.replace_late_bound_regions_with_fresh_var(
1871 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1874 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1877 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1878 if ty.has_escaping_regions() {
1879 ty // FIXME: normalization and escaping regions
1881 self.normalize_associated_types_in(span, &ty)
1885 fn set_tainted_by_errors(&self) {
1886 self.infcx.set_tainted_by_errors()
1889 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1890 self.write_ty(hir_id, ty)
1894 /// Controls whether the arguments are tupled. This is used for the call
1897 /// Tupling means that all call-side arguments are packed into a tuple and
1898 /// passed as a single parameter. For example, if tupling is enabled, this
1901 /// fn f(x: (isize, isize))
1903 /// Can be called as:
1910 #[derive(Clone, Eq, PartialEq)]
1911 enum TupleArgumentsFlag {
1916 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1917 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1918 param_env: ty::ParamEnv<'tcx>,
1919 body_id: ast::NodeId)
1920 -> FnCtxt<'a, 'gcx, 'tcx> {
1924 err_count_on_creation: inh.tcx.sess.err_count(),
1927 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1928 ast::CRATE_NODE_ID)),
1929 diverges: Cell::new(Diverges::Maybe),
1930 has_errors: Cell::new(false),
1931 enclosing_breakables: RefCell::new(EnclosingBreakables {
1939 pub fn sess(&self) -> &Session {
1943 pub fn err_count_since_creation(&self) -> usize {
1944 self.tcx.sess.err_count() - self.err_count_on_creation
1947 /// Produce warning on the given node, if the current point in the
1948 /// function is unreachable, and there hasn't been another warning.
1949 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1950 if self.diverges.get() == Diverges::Always {
1951 self.diverges.set(Diverges::WarnedAlways);
1953 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1955 self.tcx().lint_node(
1956 lint::builtin::UNREACHABLE_CODE,
1958 &format!("unreachable {}", kind));
1964 code: ObligationCauseCode<'tcx>)
1965 -> ObligationCause<'tcx> {
1966 ObligationCause::new(span, self.body_id, code)
1969 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1970 self.cause(span, ObligationCauseCode::MiscObligation)
1973 /// Resolves type variables in `ty` if possible. Unlike the infcx
1974 /// version (resolve_type_vars_if_possible), this version will
1975 /// also select obligations if it seems useful, in an effort
1976 /// to get more type information.
1977 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1978 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1980 // No TyInfer()? Nothing needs doing.
1981 if !ty.has_infer_types() {
1982 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1986 // If `ty` is a type variable, see whether we already know what it is.
1987 ty = self.resolve_type_vars_if_possible(&ty);
1988 if !ty.has_infer_types() {
1989 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1993 // If not, try resolving pending obligations as much as
1994 // possible. This can help substantially when there are
1995 // indirect dependencies that don't seem worth tracking
1997 self.select_obligations_where_possible(false);
1998 ty = self.resolve_type_vars_if_possible(&ty);
2000 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2004 fn record_deferred_call_resolution(&self,
2005 closure_def_id: DefId,
2006 r: DeferredCallResolution<'gcx, 'tcx>) {
2007 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2008 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
2011 fn remove_deferred_call_resolutions(&self,
2012 closure_def_id: DefId)
2013 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2015 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2016 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2019 pub fn tag(&self) -> String {
2020 let self_ptr: *const FnCtxt = self;
2021 format!("{:?}", self_ptr)
2024 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
2025 match self.locals.borrow().get(&nid) {
2028 span_bug!(span, "no type for local variable {}",
2029 self.tcx.hir.node_to_string(nid));
2035 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2036 debug!("write_ty({:?}, {:?}) in fcx {}",
2037 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2038 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2040 if ty.references_error() {
2041 self.has_errors.set(true);
2042 self.set_tainted_by_errors();
2046 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2047 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
2048 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2051 // The NodeId and the ItemLocalId must identify the same item. We just pass
2052 // both of them for consistency checking.
2053 pub fn write_method_call(&self,
2055 method: MethodCallee<'tcx>) {
2058 .type_dependent_defs_mut()
2059 .insert(hir_id, Def::Method(method.def_id));
2060 self.write_substs(hir_id, method.substs);
2063 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2064 if !substs.is_noop() {
2065 debug!("write_substs({:?}, {:?}) in fcx {}",
2070 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2074 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2075 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2081 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2082 Entry::Vacant(entry) => { entry.insert(adj); },
2083 Entry::Occupied(mut entry) => {
2084 debug!(" - composing on top of {:?}", entry.get());
2085 match (&entry.get()[..], &adj[..]) {
2086 // Applying any adjustment on top of a NeverToAny
2087 // is a valid NeverToAny adjustment, because it can't
2089 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2091 Adjustment { kind: Adjust::Deref(_), .. },
2092 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2094 Adjustment { kind: Adjust::Deref(_), .. },
2095 .. // Any following adjustments are allowed.
2097 // A reborrow has no effect before a dereference.
2099 // FIXME: currently we never try to compose autoderefs
2100 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2102 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2103 expr, entry.get(), adj)
2105 *entry.get_mut() = adj;
2110 /// Basically whenever we are converting from a type scheme into
2111 /// the fn body space, we always want to normalize associated
2112 /// types as well. This function combines the two.
2113 fn instantiate_type_scheme<T>(&self,
2115 substs: &Substs<'tcx>,
2118 where T : TypeFoldable<'tcx>
2120 let value = value.subst(self.tcx, substs);
2121 let result = self.normalize_associated_types_in(span, &value);
2122 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2129 /// As `instantiate_type_scheme`, but for the bounds found in a
2130 /// generic type scheme.
2131 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2132 -> ty::InstantiatedPredicates<'tcx> {
2133 let bounds = self.tcx.predicates_of(def_id);
2134 let result = bounds.instantiate(self.tcx, substs);
2135 let result = self.normalize_associated_types_in(span, &result);
2136 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2143 /// Replace the anonymized types from the return value of the
2144 /// function with type variables and records the `AnonTypeMap` for
2145 /// later use during writeback. See
2146 /// `InferCtxt::instantiate_anon_types` for more details.
2147 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
2152 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
2154 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
2159 let (value, anon_type_map) = self.register_infer_ok_obligations(
2160 self.instantiate_anon_types(
2168 let mut anon_types = self.anon_types.borrow_mut();
2169 for (ty, decl) in anon_type_map {
2170 let old_value = anon_types.insert(ty, decl);
2171 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2177 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2178 where T : TypeFoldable<'tcx>
2180 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2183 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2185 where T : TypeFoldable<'tcx>
2187 self.inh.partially_normalize_associated_types_in(span,
2193 pub fn require_type_meets(&self,
2196 code: traits::ObligationCauseCode<'tcx>,
2199 self.register_bound(
2202 traits::ObligationCause::new(span, self.body_id, code));
2205 pub fn require_type_is_sized(&self,
2208 code: traits::ObligationCauseCode<'tcx>)
2210 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2211 self.require_type_meets(ty, span, code, lang_item);
2214 pub fn register_bound(&self,
2217 cause: traits::ObligationCause<'tcx>)
2219 self.fulfillment_cx.borrow_mut()
2220 .register_bound(self, self.param_env, ty, def_id, cause);
2223 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2224 let t = AstConv::ast_ty_to_ty(self, ast_t);
2225 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2229 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2230 match self.tables.borrow().node_types().get(id) {
2232 None if self.is_tainted_by_errors() => self.tcx.types.err,
2234 let node_id = self.tcx.hir.hir_to_node_id(id);
2235 bug!("no type for node {}: {} in fcx {}",
2236 node_id, self.tcx.hir.node_to_string(node_id),
2242 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2243 /// outlive the region `r`.
2244 pub fn register_wf_obligation(&self,
2247 code: traits::ObligationCauseCode<'tcx>)
2249 // WF obligations never themselves fail, so no real need to give a detailed cause:
2250 let cause = traits::ObligationCause::new(span, self.body_id, code);
2251 self.register_predicate(traits::Obligation::new(cause,
2253 ty::Predicate::WellFormed(ty)));
2256 /// Registers obligations that all types appearing in `substs` are well-formed.
2257 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2259 for ty in substs.types() {
2260 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2264 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2265 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2266 /// trait/region obligations.
2268 /// For example, if there is a function:
2271 /// fn foo<'a,T:'a>(...)
2274 /// and a reference:
2280 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2281 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2282 pub fn add_obligations_for_parameters(&self,
2283 cause: traits::ObligationCause<'tcx>,
2284 predicates: &ty::InstantiatedPredicates<'tcx>)
2286 assert!(!predicates.has_escaping_regions());
2288 debug!("add_obligations_for_parameters(predicates={:?})",
2291 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2292 self.register_predicate(obligation);
2296 // FIXME(arielb1): use this instead of field.ty everywhere
2297 // Only for fields! Returns <none> for methods>
2298 // Indifferent to privacy flags
2299 pub fn field_ty(&self,
2301 field: &'tcx ty::FieldDef,
2302 substs: &Substs<'tcx>)
2305 self.normalize_associated_types_in(span,
2306 &field.ty(self.tcx, substs))
2309 fn check_casts(&self) {
2310 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2311 for cast in deferred_cast_checks.drain(..) {
2316 fn resolve_generator_interiors(&self, def_id: DefId) {
2317 let mut generators = self.deferred_generator_interiors.borrow_mut();
2318 for (body_id, interior) in generators.drain(..) {
2319 self.select_obligations_where_possible(false);
2320 generator_interior::resolve_interior(self, def_id, body_id, interior);
2324 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2325 // Non-numerics get replaced with ! or () (depending on whether
2326 // feature(never_type) is enabled, unconstrained ints with i32,
2327 // unconstrained floats with f64.
2328 // Fallback becomes very dubious if we have encountered type-checking errors.
2329 // In that case, fallback to TyError.
2330 // The return value indicates whether fallback has occured.
2331 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2332 use rustc::ty::error::UnconstrainedNumeric::Neither;
2333 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2335 assert!(ty.is_ty_infer());
2336 let fallback = match self.type_is_unconstrained_numeric(ty) {
2337 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2338 UnconstrainedInt => self.tcx.types.i32,
2339 UnconstrainedFloat => self.tcx.types.f64,
2340 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2341 Neither => return false,
2343 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2344 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2348 fn select_all_obligations_or_error(&self) {
2349 debug!("select_all_obligations_or_error");
2350 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2351 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2355 /// Select as many obligations as we can at present.
2356 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2357 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2360 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2365 fn is_place_expr(&self, expr: &hir::Expr) -> bool {
2367 hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
2369 Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
2374 hir::ExprKind::Type(ref e, _) => {
2375 self.is_place_expr(e)
2378 hir::ExprKind::Unary(hir::UnDeref, _) |
2379 hir::ExprKind::Field(..) |
2380 hir::ExprKind::Index(..) => {
2384 // Partially qualified paths in expressions can only legally
2385 // refer to associated items which are always rvalues.
2386 hir::ExprKind::Path(hir::QPath::TypeRelative(..)) |
2388 hir::ExprKind::Call(..) |
2389 hir::ExprKind::MethodCall(..) |
2390 hir::ExprKind::Struct(..) |
2391 hir::ExprKind::Tup(..) |
2392 hir::ExprKind::If(..) |
2393 hir::ExprKind::Match(..) |
2394 hir::ExprKind::Closure(..) |
2395 hir::ExprKind::Block(..) |
2396 hir::ExprKind::Repeat(..) |
2397 hir::ExprKind::Array(..) |
2398 hir::ExprKind::Break(..) |
2399 hir::ExprKind::Continue(..) |
2400 hir::ExprKind::Ret(..) |
2401 hir::ExprKind::While(..) |
2402 hir::ExprKind::Loop(..) |
2403 hir::ExprKind::Assign(..) |
2404 hir::ExprKind::InlineAsm(..) |
2405 hir::ExprKind::AssignOp(..) |
2406 hir::ExprKind::Lit(_) |
2407 hir::ExprKind::Unary(..) |
2408 hir::ExprKind::Box(..) |
2409 hir::ExprKind::AddrOf(..) |
2410 hir::ExprKind::Binary(..) |
2411 hir::ExprKind::Yield(..) |
2412 hir::ExprKind::Cast(..) => {
2418 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2419 /// returns a type of `&T`, but the actual type we assign to the
2420 /// *expression* is `T`. So this function just peels off the return
2421 /// type by one layer to yield `T`.
2422 fn make_overloaded_place_return_type(&self,
2423 method: MethodCallee<'tcx>)
2424 -> ty::TypeAndMut<'tcx>
2426 // extract method return type, which will be &T;
2427 let ret_ty = method.sig.output();
2429 // method returns &T, but the type as visible to user is T, so deref
2430 ret_ty.builtin_deref(true).unwrap()
2433 fn lookup_indexing(&self,
2435 base_expr: &'gcx hir::Expr,
2439 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2441 // FIXME(#18741) -- this is almost but not quite the same as the
2442 // autoderef that normal method probing does. They could likely be
2445 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2446 let mut result = None;
2447 while result.is_none() && autoderef.next().is_some() {
2448 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2450 autoderef.finalize();
2454 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2455 /// (and otherwise adjust) `base_expr`, looking for a type which either
2456 /// supports builtin indexing or overloaded indexing.
2457 /// This loop implements one step in that search; the autoderef loop
2458 /// is implemented by `lookup_indexing`.
2459 fn try_index_step(&self,
2461 base_expr: &hir::Expr,
2462 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2465 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2467 let adjusted_ty = autoderef.unambiguous_final_ty();
2468 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2475 for &unsize in &[false, true] {
2476 let mut self_ty = adjusted_ty;
2478 // We only unsize arrays here.
2479 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2480 self_ty = self.tcx.mk_slice(element_ty);
2486 // If some lookup succeeds, write callee into table and extract index/element
2487 // type from the method signature.
2488 // If some lookup succeeded, install method in table
2489 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2490 let method = self.try_overloaded_place_op(
2491 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2493 let result = method.map(|ok| {
2494 debug!("try_index_step: success, using overloaded indexing");
2495 let method = self.register_infer_ok_obligations(ok);
2497 let mut adjustments = autoderef.adjust_steps(needs);
2498 if let ty::TyRef(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2499 let mutbl = match r_mutbl {
2500 hir::MutImmutable => AutoBorrowMutability::Immutable,
2501 hir::MutMutable => AutoBorrowMutability::Mutable {
2502 // Indexing can be desugared to a method call,
2503 // so maybe we could use two-phase here.
2504 // See the documentation of AllowTwoPhase for why that's
2505 // not the case today.
2506 allow_two_phase_borrow: AllowTwoPhase::No,
2509 adjustments.push(Adjustment {
2510 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2511 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2518 adjustments.push(Adjustment {
2519 kind: Adjust::Unsize,
2520 target: method.sig.inputs()[0]
2523 self.apply_adjustments(base_expr, adjustments);
2525 self.write_method_call(expr.hir_id, method);
2526 (input_ty, self.make_overloaded_place_return_type(method).ty)
2528 if result.is_some() {
2536 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2537 let (tr, name) = match (op, is_mut) {
2538 (PlaceOp::Deref, false) =>
2539 (self.tcx.lang_items().deref_trait(), "deref"),
2540 (PlaceOp::Deref, true) =>
2541 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2542 (PlaceOp::Index, false) =>
2543 (self.tcx.lang_items().index_trait(), "index"),
2544 (PlaceOp::Index, true) =>
2545 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2547 (tr, ast::Ident::from_str(name))
2550 fn try_overloaded_place_op(&self,
2553 arg_tys: &[Ty<'tcx>],
2556 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2558 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2564 // Try Mut first, if needed.
2565 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2566 let method = match (needs, mut_tr) {
2567 (Needs::MutPlace, Some(trait_did)) => {
2568 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2573 // Otherwise, fall back to the immutable version.
2574 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2575 let method = match (method, imm_tr) {
2576 (None, Some(trait_did)) => {
2577 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2579 (method, _) => method,
2585 fn check_method_argument_types(&self,
2588 method: Result<MethodCallee<'tcx>, ()>,
2589 args_no_rcvr: &'gcx [hir::Expr],
2590 tuple_arguments: TupleArgumentsFlag,
2591 expected: Expectation<'tcx>)
2593 let has_error = match method {
2595 method.substs.references_error() || method.sig.references_error()
2600 let err_inputs = self.err_args(args_no_rcvr.len());
2602 let err_inputs = match tuple_arguments {
2603 DontTupleArguments => err_inputs,
2604 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2607 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2608 false, tuple_arguments, None);
2609 return self.tcx.types.err;
2612 let method = method.unwrap();
2613 // HACK(eddyb) ignore self in the definition (see above).
2614 let expected_arg_tys = self.expected_inputs_for_expected_output(
2617 method.sig.output(),
2618 &method.sig.inputs()[1..]
2620 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2621 args_no_rcvr, method.sig.variadic, tuple_arguments,
2622 self.tcx.hir.span_if_local(method.def_id));
2626 /// Generic function that factors out common logic from function calls,
2627 /// method calls and overloaded operators.
2628 fn check_argument_types(&self,
2631 fn_inputs: &[Ty<'tcx>],
2632 mut expected_arg_tys: &[Ty<'tcx>],
2633 args: &'gcx [hir::Expr],
2635 tuple_arguments: TupleArgumentsFlag,
2636 def_span: Option<Span>) {
2639 // Grab the argument types, supplying fresh type variables
2640 // if the wrong number of arguments were supplied
2641 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2647 // All the input types from the fn signature must outlive the call
2648 // so as to validate implied bounds.
2649 for &fn_input_ty in fn_inputs {
2650 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2653 let expected_arg_count = fn_inputs.len();
2655 let param_count_error = |expected_count: usize,
2660 let mut err = tcx.sess.struct_span_err_with_code(sp,
2661 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2662 if variadic {"at least "} else {""},
2664 if expected_count == 1 {""} else {"s"},
2666 if arg_count == 1 {" was"} else {"s were"}),
2667 DiagnosticId::Error(error_code.to_owned()));
2669 if let Some(def_s) = def_span.map(|sp| tcx.sess.codemap().def_span(sp)) {
2670 err.span_label(def_s, "defined here");
2673 let sugg_span = tcx.sess.codemap().end_point(expr_sp);
2674 // remove closing `)` from the span
2675 let sugg_span = sugg_span.shrink_to_lo();
2676 err.span_suggestion(
2678 "expected the unit value `()`; create it with empty parentheses",
2679 String::from("()"));
2681 err.span_label(sp, format!("expected {}{} parameter{}",
2682 if variadic {"at least "} else {""},
2684 if expected_count == 1 {""} else {"s"}));
2689 let formal_tys = if tuple_arguments == TupleArguments {
2690 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2691 match tuple_type.sty {
2692 ty::TyTuple(arg_types) if arg_types.len() != args.len() => {
2693 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2694 expected_arg_tys = &[];
2695 self.err_args(args.len())
2697 ty::TyTuple(arg_types) => {
2698 expected_arg_tys = match expected_arg_tys.get(0) {
2699 Some(&ty) => match ty.sty {
2700 ty::TyTuple(ref tys) => &tys,
2708 span_err!(tcx.sess, sp, E0059,
2709 "cannot use call notation; the first type parameter \
2710 for the function trait is neither a tuple nor unit");
2711 expected_arg_tys = &[];
2712 self.err_args(args.len())
2715 } else if expected_arg_count == supplied_arg_count {
2717 } else if variadic {
2718 if supplied_arg_count >= expected_arg_count {
2721 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2722 expected_arg_tys = &[];
2723 self.err_args(supplied_arg_count)
2726 // is the missing argument of type `()`?
2727 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2728 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2729 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2730 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2734 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2736 expected_arg_tys = &[];
2737 self.err_args(supplied_arg_count)
2739 // If there is no expectation, expect formal_tys.
2740 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2746 debug!("check_argument_types: formal_tys={:?}",
2747 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2749 // Check the arguments.
2750 // We do this in a pretty awful way: first we typecheck any arguments
2751 // that are not closures, then we typecheck the closures. This is so
2752 // that we have more information about the types of arguments when we
2753 // typecheck the functions. This isn't really the right way to do this.
2754 for &check_closures in &[false, true] {
2755 debug!("check_closures={}", check_closures);
2757 // More awful hacks: before we check argument types, try to do
2758 // an "opportunistic" vtable resolution of any trait bounds on
2759 // the call. This helps coercions.
2761 self.select_obligations_where_possible(false);
2764 // For variadic functions, we don't have a declared type for all of
2765 // the arguments hence we only do our usual type checking with
2766 // the arguments who's types we do know.
2767 let t = if variadic {
2769 } else if tuple_arguments == TupleArguments {
2774 for (i, arg) in args.iter().take(t).enumerate() {
2775 // Warn only for the first loop (the "no closures" one).
2776 // Closure arguments themselves can't be diverging, but
2777 // a previous argument can, e.g. `foo(panic!(), || {})`.
2778 if !check_closures {
2779 self.warn_if_unreachable(arg.id, arg.span, "expression");
2782 let is_closure = match arg.node {
2783 hir::ExprKind::Closure(..) => true,
2787 if is_closure != check_closures {
2791 debug!("checking the argument");
2792 let formal_ty = formal_tys[i];
2794 // The special-cased logic below has three functions:
2795 // 1. Provide as good of an expected type as possible.
2796 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
2798 let checked_ty = self.check_expr_with_expectation(&arg, expected);
2800 // 2. Coerce to the most detailed type that could be coerced
2801 // to, which is `expected_ty` if `rvalue_hint` returns an
2802 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2803 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
2804 // We're processing function arguments so we definitely want to use
2805 // two-phase borrows.
2806 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
2808 // 3. Relate the expected type and the formal one,
2809 // if the expected type was used for the coercion.
2810 self.demand_suptype(arg.span, formal_ty, coerce_ty);
2814 // We also need to make sure we at least write the ty of the other
2815 // arguments which we skipped above.
2817 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2818 use structured_errors::{VariadicError, StructuredDiagnostic};
2819 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2822 for arg in args.iter().skip(expected_arg_count) {
2823 let arg_ty = self.check_expr(&arg);
2825 // There are a few types which get autopromoted when passed via varargs
2826 // in C but we just error out instead and require explicit casts.
2827 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2829 ty::TyFloat(ast::FloatTy::F32) => {
2830 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2832 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2833 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2835 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2836 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2838 ty::TyFnDef(..) => {
2839 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2840 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2841 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
2849 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2850 (0..len).map(|_| self.tcx.types.err).collect()
2853 // AST fragment checking
2856 expected: Expectation<'tcx>)
2862 ast::LitKind::Str(..) => tcx.mk_static_str(),
2863 ast::LitKind::ByteStr(ref v) => {
2864 tcx.mk_imm_ref(tcx.types.re_static,
2865 tcx.mk_array(tcx.types.u8, v.len() as u64))
2867 ast::LitKind::Byte(_) => tcx.types.u8,
2868 ast::LitKind::Char(_) => tcx.types.char,
2869 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2870 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2871 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2872 let opt_ty = expected.to_option(self).and_then(|ty| {
2874 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2875 ty::TyChar => Some(tcx.types.u8),
2876 ty::TyRawPtr(..) => Some(tcx.types.usize),
2877 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2881 opt_ty.unwrap_or_else(
2882 || tcx.mk_int_var(self.next_int_var_id()))
2884 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2885 ast::LitKind::FloatUnsuffixed(_) => {
2886 let opt_ty = expected.to_option(self).and_then(|ty| {
2888 ty::TyFloat(_) => Some(ty),
2892 opt_ty.unwrap_or_else(
2893 || tcx.mk_float_var(self.next_float_var_id()))
2895 ast::LitKind::Bool(_) => tcx.types.bool
2899 fn check_expr_eq_type(&self,
2900 expr: &'gcx hir::Expr,
2901 expected: Ty<'tcx>) {
2902 let ty = self.check_expr_with_hint(expr, expected);
2903 self.demand_eqtype(expr.span, expected, ty);
2906 pub fn check_expr_has_type_or_error(&self,
2907 expr: &'gcx hir::Expr,
2908 expected: Ty<'tcx>) -> Ty<'tcx> {
2909 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2912 fn check_expr_meets_expectation_or_error(&self,
2913 expr: &'gcx hir::Expr,
2914 expected: Expectation<'tcx>) -> Ty<'tcx> {
2915 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2916 let mut ty = self.check_expr_with_expectation(expr, expected);
2918 // While we don't allow *arbitrary* coercions here, we *do* allow
2919 // coercions from ! to `expected`.
2921 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2922 "expression with never type wound up being adjusted");
2923 let adj_ty = self.next_diverging_ty_var(
2924 TypeVariableOrigin::AdjustmentType(expr.span));
2925 self.apply_adjustments(expr, vec![Adjustment {
2926 kind: Adjust::NeverToAny,
2932 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2933 // Add help to type error if this is an `if` condition with an assignment
2934 match (expected, &expr.node) {
2935 (ExpectIfCondition, &hir::ExprKind::Assign(ref lhs, ref rhs)) => {
2936 let msg = "try comparing for equality";
2937 if let (Ok(left), Ok(right)) = (
2938 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2939 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2941 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2953 fn check_expr_coercable_to_type(&self,
2954 expr: &'gcx hir::Expr,
2955 expected: Ty<'tcx>) -> Ty<'tcx> {
2956 let ty = self.check_expr_with_hint(expr, expected);
2957 // checks don't need two phase
2958 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
2961 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2962 expected: Ty<'tcx>) -> Ty<'tcx> {
2963 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2966 fn check_expr_with_expectation(&self,
2967 expr: &'gcx hir::Expr,
2968 expected: Expectation<'tcx>) -> Ty<'tcx> {
2969 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
2972 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2973 self.check_expr_with_expectation(expr, NoExpectation)
2976 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
2977 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
2980 // determine the `self` type, using fresh variables for all variables
2981 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2982 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2984 pub fn impl_self_ty(&self,
2985 span: Span, // (potential) receiver for this impl
2987 -> TypeAndSubsts<'tcx> {
2988 let ity = self.tcx.type_of(did);
2989 debug!("impl_self_ty: ity={:?}", ity);
2991 let substs = self.fresh_substs_for_item(span, did);
2992 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2994 TypeAndSubsts { substs: substs, ty: substd_ty }
2997 /// Unifies the output type with the expected type early, for more coercions
2998 /// and forward type information on the input expressions.
2999 fn expected_inputs_for_expected_output(&self,
3001 expected_ret: Expectation<'tcx>,
3002 formal_ret: Ty<'tcx>,
3003 formal_args: &[Ty<'tcx>])
3005 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3006 let ret_ty = match expected_ret.only_has_type(self) {
3008 None => return Vec::new()
3010 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3011 // Attempt to apply a subtyping relationship between the formal
3012 // return type (likely containing type variables if the function
3013 // is polymorphic) and the expected return type.
3014 // No argument expectations are produced if unification fails.
3015 let origin = self.misc(call_span);
3016 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3018 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3019 // to identity so the resulting type is not constrained.
3022 // Process any obligations locally as much as
3023 // we can. We don't care if some things turn
3024 // out unconstrained or ambiguous, as we're
3025 // just trying to get hints here.
3026 self.save_and_restore_in_snapshot_flag(|_| {
3027 let mut fulfill = TraitEngine::new(self.tcx);
3028 for obligation in ok.obligations {
3029 fulfill.register_predicate_obligation(self, obligation);
3031 fulfill.select_where_possible(self)
3032 }).map_err(|_| ())?;
3034 Err(_) => return Err(()),
3037 // Record all the argument types, with the substitutions
3038 // produced from the above subtyping unification.
3039 Ok(formal_args.iter().map(|ty| {
3040 self.resolve_type_vars_if_possible(ty)
3042 }).unwrap_or(Vec::new());
3043 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3044 formal_args, formal_ret,
3045 expect_args, expected_ret);
3049 // Checks a method call.
3050 fn check_method_call(&self,
3051 expr: &'gcx hir::Expr,
3052 segment: &hir::PathSegment,
3054 args: &'gcx [hir::Expr],
3055 expected: Expectation<'tcx>,
3056 needs: Needs) -> Ty<'tcx> {
3057 let rcvr = &args[0];
3058 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3059 // no need to check for bot/err -- callee does that
3060 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3062 let method = match self.lookup_method(rcvr_t,
3068 self.write_method_call(expr.hir_id, method);
3072 if segment.ident.name != keywords::Invalid.name() {
3073 self.report_method_error(span,
3084 // Call the generic checker.
3085 self.check_method_argument_types(span,
3093 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3097 .unwrap_or_else(|| span_bug!(return_expr.span,
3098 "check_return_expr called outside fn body"));
3100 let ret_ty = ret_coercion.borrow().expected_ty();
3101 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3102 ret_coercion.borrow_mut()
3104 &self.cause(return_expr.span,
3105 ObligationCauseCode::ReturnType(return_expr.id)),
3111 // A generic function for checking the then and else in an if
3113 fn check_then_else(&self,
3114 cond_expr: &'gcx hir::Expr,
3115 then_expr: &'gcx hir::Expr,
3116 opt_else_expr: Option<&'gcx hir::Expr>,
3118 expected: Expectation<'tcx>) -> Ty<'tcx> {
3119 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3120 let cond_diverges = self.diverges.get();
3121 self.diverges.set(Diverges::Maybe);
3123 let expected = expected.adjust_for_branches(self);
3124 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3125 let then_diverges = self.diverges.get();
3126 self.diverges.set(Diverges::Maybe);
3128 // We've already taken the expected type's preferences
3129 // into account when typing the `then` branch. To figure
3130 // out the initial shot at a LUB, we thus only consider
3131 // `expected` if it represents a *hard* constraint
3132 // (`only_has_type`); otherwise, we just go with a
3133 // fresh type variable.
3134 let coerce_to_ty = expected.coercion_target_type(self, sp);
3135 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3137 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
3138 coerce.coerce(self, &if_cause, then_expr, then_ty);
3140 if let Some(else_expr) = opt_else_expr {
3141 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3142 let else_diverges = self.diverges.get();
3144 coerce.coerce(self, &if_cause, else_expr, else_ty);
3146 // We won't diverge unless both branches do (or the condition does).
3147 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3149 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3150 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3152 // If the condition is false we can't diverge.
3153 self.diverges.set(cond_diverges);
3156 let result_ty = coerce.complete(self);
3157 if cond_ty.references_error() {
3164 // Check field access expressions
3165 fn check_field(&self,
3166 expr: &'gcx hir::Expr,
3168 base: &'gcx hir::Expr,
3169 field: ast::Ident) -> Ty<'tcx> {
3170 let expr_t = self.check_expr_with_needs(base, needs);
3171 let expr_t = self.structurally_resolved_type(base.span,
3173 let mut private_candidate = None;
3174 let mut autoderef = self.autoderef(expr.span, expr_t);
3175 while let Some((base_t, _)) = autoderef.next() {
3177 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
3178 debug!("struct named {:?}", base_t);
3179 let (ident, def_scope) =
3180 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3181 let fields = &base_def.non_enum_variant().fields;
3182 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3183 let field = &fields[index];
3184 let field_ty = self.field_ty(expr.span, field, substs);
3185 // Save the index of all fields regardless of their visibility in case
3186 // of error recovery.
3187 self.write_field_index(expr.id, index);
3188 if field.vis.is_accessible_from(def_scope, self.tcx) {
3189 let adjustments = autoderef.adjust_steps(needs);
3190 self.apply_adjustments(base, adjustments);
3191 autoderef.finalize();
3193 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3196 private_candidate = Some((base_def.did, field_ty));
3199 ty::TyTuple(ref tys) => {
3200 let fstr = field.as_str();
3201 if let Ok(index) = fstr.parse::<usize>() {
3202 if fstr == index.to_string() {
3203 if let Some(field_ty) = tys.get(index) {
3204 let adjustments = autoderef.adjust_steps(needs);
3205 self.apply_adjustments(base, adjustments);
3206 autoderef.finalize();
3208 self.write_field_index(expr.id, index);
3217 autoderef.unambiguous_final_ty();
3219 if let Some((did, field_ty)) = private_candidate {
3220 let struct_path = self.tcx().item_path_str(did);
3221 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3222 "field `{}` of struct `{}` is private",
3223 field, struct_path);
3224 // Also check if an accessible method exists, which is often what is meant.
3225 if self.method_exists(field, expr_t, expr.id, false) {
3226 err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field));
3230 } else if field.name == keywords::Invalid.name() {
3231 self.tcx().types.err
3232 } else if self.method_exists(field, expr_t, expr.id, true) {
3233 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3234 "attempted to take value of method `{}` on type `{}`",
3236 .help("maybe a `()` to call it is missing?")
3238 self.tcx().types.err
3240 if !expr_t.is_primitive_ty() {
3241 let mut err = self.no_such_field_err(field.span, field, expr_t);
3244 ty::TyAdt(def, _) if !def.is_enum() => {
3245 if let Some(suggested_field_name) =
3246 Self::suggest_field_name(def.non_enum_variant(),
3247 &field.as_str(), vec![]) {
3248 err.span_label(field.span,
3249 format!("did you mean `{}`?", suggested_field_name));
3251 err.span_label(field.span, "unknown field");
3252 let struct_variant_def = def.non_enum_variant();
3253 let field_names = self.available_field_names(struct_variant_def);
3254 if !field_names.is_empty() {
3255 err.note(&format!("available fields are: {}",
3256 self.name_series_display(field_names)));
3260 ty::TyRawPtr(..) => {
3261 let base = self.tcx.hir.node_to_pretty_string(base.id);
3262 let msg = format!("`{}` is a native pointer; try dereferencing it", base);
3263 let suggestion = format!("(*{}).{}", base, field);
3264 err.span_suggestion(field.span, &msg, suggestion);
3270 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3271 "`{}` is a primitive type and therefore doesn't have fields",
3274 self.tcx().types.err
3278 // Return an hint about the closest match in field names
3279 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3281 skip: Vec<LocalInternedString>)
3283 let names = variant.fields.iter().filter_map(|field| {
3284 // ignore already set fields and private fields from non-local crates
3285 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3286 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3289 Some(&field.ident.name)
3293 find_best_match_for_name(names, field, None)
3296 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3297 let mut available = Vec::new();
3298 for field in variant.fields.iter() {
3299 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3300 if field.vis.is_accessible_from(def_scope, self.tcx) {
3301 available.push(field.ident.name);
3307 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3308 // dynamic limit, to never omit just one field
3309 let limit = if names.len() == 6 { 6 } else { 5 };
3310 let mut display = names.iter().take(limit)
3311 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3312 if names.len() > limit {
3313 display = format!("{} ... and {} others", display, names.len() - limit);
3318 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3319 -> DiagnosticBuilder {
3320 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3321 "no field `{}` on type `{}`",
3325 fn report_unknown_field(&self,
3327 variant: &'tcx ty::VariantDef,
3329 skip_fields: &[hir::Field],
3331 let mut err = self.type_error_struct_with_diag(
3333 |actual| match ty.sty {
3334 ty::TyAdt(adt, ..) if adt.is_enum() => {
3335 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3336 "{} `{}::{}` has no field named `{}`",
3337 kind_name, actual, variant.name, field.ident)
3340 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3341 "{} `{}` has no field named `{}`",
3342 kind_name, actual, field.ident)
3346 // prevent all specified fields from being suggested
3347 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3348 if let Some(field_name) = Self::suggest_field_name(variant,
3349 &field.ident.as_str(),
3350 skip_fields.collect()) {
3351 err.span_label(field.ident.span,
3352 format!("field does not exist - did you mean `{}`?", field_name));
3355 ty::TyAdt(adt, ..) => {
3357 err.span_label(field.ident.span,
3358 format!("`{}::{}` does not have this field",
3361 err.span_label(field.ident.span,
3362 format!("`{}` does not have this field", ty));
3364 let available_field_names = self.available_field_names(variant);
3365 if !available_field_names.is_empty() {
3366 err.note(&format!("available fields are: {}",
3367 self.name_series_display(available_field_names)));
3370 _ => bug!("non-ADT passed to report_unknown_field")
3376 fn check_expr_struct_fields(&self,
3378 expected: Expectation<'tcx>,
3379 expr_id: ast::NodeId,
3381 variant: &'tcx ty::VariantDef,
3382 ast_fields: &'gcx [hir::Field],
3383 check_completeness: bool) -> bool {
3387 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3388 .get(0).cloned().unwrap_or(adt_ty);
3389 // re-link the regions that EIfEO can erase.
3390 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3392 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3393 &ty::TyAdt(adt, substs) => {
3394 (substs, adt.adt_kind(), adt.variant_descr())
3396 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3399 let mut remaining_fields = FxHashMap();
3400 for (i, field) in variant.fields.iter().enumerate() {
3401 remaining_fields.insert(field.ident.modern(), (i, field));
3404 let mut seen_fields = FxHashMap();
3406 let mut error_happened = false;
3408 // Typecheck each field.
3409 for field in ast_fields {
3410 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3411 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3412 seen_fields.insert(ident, field.span);
3413 self.write_field_index(field.id, i);
3415 // we don't look at stability attributes on
3416 // struct-like enums (yet...), but it's definitely not
3417 // a bug to have construct one.
3418 if adt_kind != ty::AdtKind::Enum {
3419 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3422 self.field_ty(field.span, v_field, substs)
3424 error_happened = true;
3425 if let Some(prev_span) = seen_fields.get(&ident) {
3426 let mut err = struct_span_err!(self.tcx.sess,
3429 "field `{}` specified more than once",
3432 err.span_label(field.ident.span, "used more than once");
3433 err.span_label(*prev_span, format!("first use of `{}`", ident));
3437 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3443 // Make sure to give a type to the field even if there's
3444 // an error, so we can continue typechecking
3445 self.check_expr_coercable_to_type(&field.expr, field_type);
3448 // Make sure the programmer specified correct number of fields.
3449 if kind_name == "union" {
3450 if ast_fields.len() != 1 {
3451 tcx.sess.span_err(span, "union expressions should have exactly one field");
3453 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3454 let len = remaining_fields.len();
3456 let mut displayable_field_names = remaining_fields
3458 .map(|ident| ident.as_str())
3459 .collect::<Vec<_>>();
3461 displayable_field_names.sort();
3463 let truncated_fields_error = if len <= 3 {
3466 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3469 let remaining_fields_names = displayable_field_names.iter().take(3)
3470 .map(|n| format!("`{}`", n))
3471 .collect::<Vec<_>>()
3474 struct_span_err!(tcx.sess, span, E0063,
3475 "missing field{} {}{} in initializer of `{}`",
3476 if remaining_fields.len() == 1 { "" } else { "s" },
3477 remaining_fields_names,
3478 truncated_fields_error,
3480 .span_label(span, format!("missing {}{}",
3481 remaining_fields_names,
3482 truncated_fields_error))
3488 fn check_struct_fields_on_error(&self,
3489 fields: &'gcx [hir::Field],
3490 base_expr: &'gcx Option<P<hir::Expr>>) {
3491 for field in fields {
3492 self.check_expr(&field.expr);
3496 self.check_expr(&base);
3502 pub fn check_struct_path(&self,
3504 node_id: ast::NodeId)
3505 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3506 let path_span = match *qpath {
3507 hir::QPath::Resolved(_, ref path) => path.span,
3508 hir::QPath::TypeRelative(ref qself, _) => qself.span
3510 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3511 let variant = match def {
3513 self.set_tainted_by_errors();
3516 Def::Variant(..) => {
3518 ty::TyAdt(adt, substs) => {
3519 Some((adt.variant_of_def(def), adt.did, substs))
3521 _ => bug!("unexpected type: {:?}", ty.sty)
3524 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3525 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3527 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3528 Some((adt.non_enum_variant(), adt.did, substs))
3533 _ => bug!("unexpected definition: {:?}", def)
3536 if let Some((variant, did, substs)) = variant {
3537 // Check bounds on type arguments used in the path.
3538 let bounds = self.instantiate_bounds(path_span, did, substs);
3539 let cause = traits::ObligationCause::new(path_span, self.body_id,
3540 traits::ItemObligation(did));
3541 self.add_obligations_for_parameters(cause, &bounds);
3545 struct_span_err!(self.tcx.sess, path_span, E0071,
3546 "expected struct, variant or union type, found {}",
3547 ty.sort_string(self.tcx))
3548 .span_label(path_span, "not a struct")
3554 fn check_expr_struct(&self,
3556 expected: Expectation<'tcx>,
3558 fields: &'gcx [hir::Field],
3559 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3561 // Find the relevant variant
3562 let (variant, struct_ty) =
3563 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3566 self.check_struct_fields_on_error(fields, base_expr);
3567 return self.tcx.types.err;
3570 let path_span = match *qpath {
3571 hir::QPath::Resolved(_, ref path) => path.span,
3572 hir::QPath::TypeRelative(ref qself, _) => qself.span
3575 // Prohibit struct expressions when non exhaustive flag is set.
3576 if let ty::TyAdt(adt, _) = struct_ty.sty {
3577 if !adt.did.is_local() && adt.is_non_exhaustive() {
3578 span_err!(self.tcx.sess, expr.span, E0639,
3579 "cannot create non-exhaustive {} using struct expression",
3580 adt.variant_descr());
3584 let error_happened = self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span,
3585 variant, fields, base_expr.is_none());
3586 if let &Some(ref base_expr) = base_expr {
3587 // If check_expr_struct_fields hit an error, do not attempt to populate
3588 // the fields with the base_expr. This could cause us to hit errors later
3589 // when certain fields are assumed to exist that in fact do not.
3590 if !error_happened {
3591 self.check_expr_has_type_or_error(base_expr, struct_ty);
3592 match struct_ty.sty {
3593 ty::TyAdt(adt, substs) if adt.is_struct() => {
3594 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3595 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3600 .fru_field_types_mut()
3601 .insert(expr.hir_id, fru_field_types);
3604 span_err!(self.tcx.sess, base_expr.span, E0436,
3605 "functional record update syntax requires a struct");
3610 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3616 /// If an expression has any sub-expressions that result in a type error,
3617 /// inspecting that expression's type with `ty.references_error()` will return
3618 /// true. Likewise, if an expression is known to diverge, inspecting its
3619 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3620 /// strict, _|_ can appear in the type of an expression that does not,
3621 /// itself, diverge: for example, fn() -> _|_.)
3622 /// Note that inspecting a type's structure *directly* may expose the fact
3623 /// that there are actually multiple representations for `TyError`, so avoid
3624 /// that when err needs to be handled differently.
3625 fn check_expr_with_expectation_and_needs(&self,
3626 expr: &'gcx hir::Expr,
3627 expected: Expectation<'tcx>,
3628 needs: Needs) -> Ty<'tcx> {
3629 debug!(">> typechecking: expr={:?} expected={:?}",
3632 // Warn for expressions after diverging siblings.
3633 self.warn_if_unreachable(expr.id, expr.span, "expression");
3635 // Hide the outer diverging and has_errors flags.
3636 let old_diverges = self.diverges.get();
3637 let old_has_errors = self.has_errors.get();
3638 self.diverges.set(Diverges::Maybe);
3639 self.has_errors.set(false);
3641 let ty = self.check_expr_kind(expr, expected, needs);
3643 // Warn for non-block expressions with diverging children.
3645 hir::ExprKind::Block(..) |
3646 hir::ExprKind::Loop(..) | hir::ExprKind::While(..) |
3647 hir::ExprKind::If(..) | hir::ExprKind::Match(..) => {}
3649 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3652 // Any expression that produces a value of type `!` must have diverged
3654 self.diverges.set(self.diverges.get() | Diverges::Always);
3657 // Record the type, which applies it effects.
3658 // We need to do this after the warning above, so that
3659 // we don't warn for the diverging expression itself.
3660 self.write_ty(expr.hir_id, ty);
3662 // Combine the diverging and has_error flags.
3663 self.diverges.set(self.diverges.get() | old_diverges);
3664 self.has_errors.set(self.has_errors.get() | old_has_errors);
3666 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3667 debug!("... {:?}, expected is {:?}", ty, expected);
3672 fn check_expr_kind(&self,
3673 expr: &'gcx hir::Expr,
3674 expected: Expectation<'tcx>,
3675 needs: Needs) -> Ty<'tcx> {
3679 hir::ExprKind::Box(ref subexpr) => {
3680 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3682 ty::TyAdt(def, _) if def.is_box()
3683 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3687 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3688 tcx.mk_box(referent_ty)
3691 hir::ExprKind::Lit(ref lit) => {
3692 self.check_lit(&lit, expected)
3694 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
3695 self.check_binop(expr, op, lhs, rhs)
3697 hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3698 self.check_binop_assign(expr, op, lhs, rhs)
3700 hir::ExprKind::Unary(unop, ref oprnd) => {
3701 let expected_inner = match unop {
3702 hir::UnNot | hir::UnNeg => {
3709 let needs = match unop {
3710 hir::UnDeref => needs,
3713 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3717 if !oprnd_t.references_error() {
3718 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3721 if let Some(mt) = oprnd_t.builtin_deref(true) {
3723 } else if let Some(ok) = self.try_overloaded_deref(
3724 expr.span, oprnd_t, needs) {
3725 let method = self.register_infer_ok_obligations(ok);
3726 if let ty::TyRef(region, _, mutbl) = method.sig.inputs()[0].sty {
3727 let mutbl = match mutbl {
3728 hir::MutImmutable => AutoBorrowMutability::Immutable,
3729 hir::MutMutable => AutoBorrowMutability::Mutable {
3730 // (It shouldn't actually matter for unary ops whether
3731 // we enable two-phase borrows or not, since a unary
3732 // op has no additional operands.)
3733 allow_two_phase_borrow: AllowTwoPhase::No,
3736 self.apply_adjustments(oprnd, vec![Adjustment {
3737 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3738 target: method.sig.inputs()[0]
3741 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3742 self.write_method_call(expr.hir_id, method);
3744 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3745 "type `{}` cannot be dereferenced",
3747 oprnd_t = tcx.types.err;
3751 let result = self.check_user_unop(expr, oprnd_t, unop);
3752 // If it's builtin, we can reuse the type, this helps inference.
3753 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3758 let result = self.check_user_unop(expr, oprnd_t, unop);
3759 // If it's builtin, we can reuse the type, this helps inference.
3760 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3768 hir::ExprKind::AddrOf(mutbl, ref oprnd) => {
3769 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3771 ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
3772 if self.is_place_expr(&oprnd) {
3773 // Places may legitimately have unsized types.
3774 // For example, dereferences of a fat pointer and
3775 // the last field of a struct can be unsized.
3778 Expectation::rvalue_hint(self, ty)
3784 let needs = Needs::maybe_mut_place(mutbl);
3785 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
3787 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3788 if tm.ty.references_error() {
3791 // Note: at this point, we cannot say what the best lifetime
3792 // is to use for resulting pointer. We want to use the
3793 // shortest lifetime possible so as to avoid spurious borrowck
3794 // errors. Moreover, the longest lifetime will depend on the
3795 // precise details of the value whose address is being taken
3796 // (and how long it is valid), which we don't know yet until type
3797 // inference is complete.
3799 // Therefore, here we simply generate a region variable. The
3800 // region inferencer will then select the ultimate value.
3801 // Finally, borrowck is charged with guaranteeing that the
3802 // value whose address was taken can actually be made to live
3803 // as long as it needs to live.
3804 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3805 tcx.mk_ref(region, tm)
3808 hir::ExprKind::Path(ref qpath) => {
3809 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
3810 let ty = if def != Def::Err {
3811 self.instantiate_value_path(segs, opt_ty, def, expr.span, id)
3813 self.set_tainted_by_errors();
3817 // We always require that the type provided as the value for
3818 // a type parameter outlives the moment of instantiation.
3819 let substs = self.tables.borrow().node_substs(expr.hir_id);
3820 self.add_wf_bounds(substs, expr);
3824 hir::ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
3825 for output in outputs {
3826 self.check_expr(output);
3828 for input in inputs {
3829 self.check_expr(input);
3833 hir::ExprKind::Break(destination, ref expr_opt) => {
3834 if let Ok(target_id) = destination.target_id {
3836 if let Some(ref e) = *expr_opt {
3837 // If this is a break with a value, we need to type-check
3838 // the expression. Get an expected type from the loop context.
3839 let opt_coerce_to = {
3840 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3841 enclosing_breakables.find_breakable(target_id)
3844 .map(|coerce| coerce.expected_ty())
3847 // If the loop context is not a `loop { }`, then break with
3848 // a value is illegal, and `opt_coerce_to` will be `None`.
3849 // Just set expectation to error in that case.
3850 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3852 // Recurse without `enclosing_breakables` borrowed.
3853 e_ty = self.check_expr_with_hint(e, coerce_to);
3854 cause = self.misc(e.span);
3856 // Otherwise, this is a break *without* a value. That's
3857 // always legal, and is equivalent to `break ()`.
3858 e_ty = tcx.mk_nil();
3859 cause = self.misc(expr.span);
3862 // Now that we have type-checked `expr_opt`, borrow
3863 // the `enclosing_loops` field and let's coerce the
3864 // type of `expr_opt` into what is expected.
3865 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3866 let ctxt = enclosing_breakables.find_breakable(target_id);
3867 if let Some(ref mut coerce) = ctxt.coerce {
3868 if let Some(ref e) = *expr_opt {
3869 coerce.coerce(self, &cause, e, e_ty);
3871 assert!(e_ty.is_nil());
3872 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3875 // If `ctxt.coerce` is `None`, we can just ignore
3876 // the type of the expresison. This is because
3877 // either this was a break *without* a value, in
3878 // which case it is always a legal type (`()`), or
3879 // else an error would have been flagged by the
3880 // `loops` pass for using break with an expression
3881 // where you are not supposed to.
3882 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3885 ctxt.may_break = true;
3887 // the type of a `break` is always `!`, since it diverges
3890 // Otherwise, we failed to find the enclosing loop;
3891 // this can only happen if the `break` was not
3892 // inside a loop at all, which is caught by the
3893 // loop-checking pass.
3894 if self.tcx.sess.err_count() == 0 {
3895 self.tcx.sess.delay_span_bug(expr.span,
3896 "break was outside loop, but no error was emitted");
3899 // We still need to assign a type to the inner expression to
3900 // prevent the ICE in #43162.
3901 if let Some(ref e) = *expr_opt {
3902 self.check_expr_with_hint(e, tcx.types.err);
3904 // ... except when we try to 'break rust;'.
3905 // ICE this expression in particular (see #43162).
3906 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = e.node {
3907 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
3908 fatally_break_rust(self.tcx.sess);
3912 // There was an error, make typecheck fail
3917 hir::ExprKind::Continue(destination) => {
3918 if destination.target_id.is_ok() {
3921 // There was an error, make typecheck fail
3925 hir::ExprKind::Ret(ref expr_opt) => {
3926 if self.ret_coercion.is_none() {
3927 struct_span_err!(self.tcx.sess, expr.span, E0572,
3928 "return statement outside of function body").emit();
3929 } else if let Some(ref e) = *expr_opt {
3930 self.check_return_expr(e);
3932 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3933 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3934 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3938 hir::ExprKind::Assign(ref lhs, ref rhs) => {
3939 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
3941 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3944 ExpectIfCondition => {
3945 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3946 expected error elsehwere");
3949 // Only check this if not in an `if` condition, as the
3950 // mistyped comparison help is more appropriate.
3951 if !self.is_place_expr(&lhs) {
3952 struct_span_err!(self.tcx.sess, expr.span, E0070,
3953 "invalid left-hand side expression")
3954 .span_label(expr.span, "left-hand of expression not valid")
3960 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3962 if lhs_ty.references_error() || rhs_ty.references_error() {
3968 hir::ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
3969 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3970 expr.span, expected)
3972 hir::ExprKind::While(ref cond, ref body, _) => {
3973 let ctxt = BreakableCtxt {
3974 // cannot use break with a value from a while loop
3976 may_break: false, // Will get updated if/when we find a `break`.
3979 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3980 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3981 let cond_diverging = self.diverges.get();
3982 self.check_block_no_value(&body);
3984 // We may never reach the body so it diverging means nothing.
3985 self.diverges.set(cond_diverging);
3989 // No way to know whether it's diverging because
3990 // of a `break` or an outer `break` or `return`.
3991 self.diverges.set(Diverges::Maybe);
3996 hir::ExprKind::Loop(ref body, _, source) => {
3997 let coerce = match source {
3998 // you can only use break with a value from a normal `loop { }`
3999 hir::LoopSource::Loop => {
4000 let coerce_to = expected.coercion_target_type(self, body.span);
4001 Some(CoerceMany::new(coerce_to))
4004 hir::LoopSource::WhileLet |
4005 hir::LoopSource::ForLoop => {
4010 let ctxt = BreakableCtxt {
4012 may_break: false, // Will get updated if/when we find a `break`.
4015 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4016 self.check_block_no_value(&body);
4020 // No way to know whether it's diverging because
4021 // of a `break` or an outer `break` or `return`.
4022 self.diverges.set(Diverges::Maybe);
4025 // If we permit break with a value, then result type is
4026 // the LUB of the breaks (possibly ! if none); else, it
4027 // is nil. This makes sense because infinite loops
4028 // (which would have type !) are only possible iff we
4029 // permit break with a value [1].
4030 if ctxt.coerce.is_none() && !ctxt.may_break {
4032 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4034 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
4036 hir::ExprKind::Match(ref discrim, ref arms, match_src) => {
4037 self.check_match(expr, &discrim, arms, expected, match_src)
4039 hir::ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4040 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4042 hir::ExprKind::Block(ref body, _) => {
4043 self.check_block_with_expected(&body, expected)
4045 hir::ExprKind::Call(ref callee, ref args) => {
4046 self.check_call(expr, &callee, args, expected)
4048 hir::ExprKind::MethodCall(ref segment, span, ref args) => {
4049 self.check_method_call(expr, segment, span, args, expected, needs)
4051 hir::ExprKind::Cast(ref e, ref t) => {
4052 // Find the type of `e`. Supply hints based on the type we are casting to,
4054 let t_cast = self.to_ty(t);
4055 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4056 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4057 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4059 // Eagerly check for some obvious errors.
4060 if t_expr.references_error() || t_cast.references_error() {
4063 // Defer other checks until we're done type checking.
4064 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4065 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4067 deferred_cast_checks.push(cast_check);
4070 Err(ErrorReported) => {
4076 hir::ExprKind::Type(ref e, ref t) => {
4077 let ty = self.to_ty(&t);
4078 self.check_expr_eq_type(&e, ty);
4081 hir::ExprKind::Array(ref args) => {
4082 let uty = expected.to_option(self).and_then(|uty| {
4084 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4089 let element_ty = if !args.is_empty() {
4090 let coerce_to = uty.unwrap_or_else(
4091 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4092 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4093 assert_eq!(self.diverges.get(), Diverges::Maybe);
4095 let e_ty = self.check_expr_with_hint(e, coerce_to);
4096 let cause = self.misc(e.span);
4097 coerce.coerce(self, &cause, e, e_ty);
4099 coerce.complete(self)
4101 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4103 tcx.mk_array(element_ty, args.len() as u64)
4105 hir::ExprKind::Repeat(ref element, ref count) => {
4106 let count_def_id = tcx.hir.local_def_id(count.id);
4107 let param_env = ty::ParamEnv::empty();
4108 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4109 let instance = ty::Instance::resolve(
4115 let global_id = GlobalId {
4119 let count = tcx.const_eval(param_env.and(global_id));
4121 if let Err(ref err) = count {
4122 err.report_as_error(
4123 tcx.at(tcx.def_span(count_def_id)),
4124 "could not evaluate repeat length",
4128 let uty = match expected {
4129 ExpectHasType(uty) => {
4131 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
4138 let (element_ty, t) = match uty {
4140 self.check_expr_coercable_to_type(&element, uty);
4144 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4145 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4150 if let Ok(count) = count {
4151 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4153 // For [foo, ..n] where n > 1, `foo` must have
4155 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4156 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4160 if element_ty.references_error() {
4162 } else if let Ok(count) = count {
4163 tcx.mk_ty(ty::TyArray(t, count))
4168 hir::ExprKind::Tup(ref elts) => {
4169 let flds = expected.only_has_type(self).and_then(|ty| {
4170 let ty = self.resolve_type_vars_with_obligations(ty);
4172 ty::TyTuple(ref flds) => Some(&flds[..]),
4177 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4178 let t = match flds {
4179 Some(ref fs) if i < fs.len() => {
4181 self.check_expr_coercable_to_type(&e, ety);
4185 self.check_expr_with_expectation(&e, NoExpectation)
4190 let tuple = tcx.mk_tup(elt_ts_iter);
4191 if tuple.references_error() {
4194 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4198 hir::ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4199 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4201 hir::ExprKind::Field(ref base, field) => {
4202 self.check_field(expr, needs, &base, field)
4204 hir::ExprKind::Index(ref base, ref idx) => {
4205 let base_t = self.check_expr_with_needs(&base, needs);
4206 let idx_t = self.check_expr(&idx);
4208 if base_t.references_error() {
4210 } else if idx_t.references_error() {
4213 let base_t = self.structurally_resolved_type(base.span, base_t);
4214 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4215 Some((index_ty, element_ty)) => {
4216 // two-phase not needed because index_ty is never mutable
4217 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4222 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4223 "cannot index into a value of type `{}`",
4225 // Try to give some advice about indexing tuples.
4226 if let ty::TyTuple(..) = base_t.sty {
4227 let mut needs_note = true;
4228 // If the index is an integer, we can show the actual
4229 // fixed expression:
4230 if let hir::ExprKind::Lit(ref lit) = idx.node {
4231 if let ast::LitKind::Int(i,
4232 ast::LitIntType::Unsuffixed) = lit.node {
4233 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4234 if let Ok(snip) = snip {
4235 err.span_suggestion(expr.span,
4236 "to access tuple elements, use",
4237 format!("{}.{}", snip, i));
4243 err.help("to access tuple elements, use tuple indexing \
4244 syntax (e.g. `tuple.0`)");
4253 hir::ExprKind::Yield(ref value) => {
4254 match self.yield_ty {
4256 self.check_expr_coercable_to_type(&value, ty);
4259 struct_span_err!(self.tcx.sess, expr.span, E0627,
4260 "yield statement outside of generator literal").emit();
4268 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4269 // The newly resolved definition is written into `type_dependent_defs`.
4270 fn finish_resolving_struct_path(&self,
4273 node_id: ast::NodeId)
4277 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4278 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4279 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4282 hir::QPath::TypeRelative(ref qself, ref segment) => {
4283 let ty = self.to_ty(qself);
4285 let def = if let hir::TyKind::Path(hir::QPath::Resolved(_, ref path)) = qself.node {
4290 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4293 // Write back the new resolution.
4294 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4295 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4302 // Resolve associated value path into a base type and associated constant or method definition.
4303 // The newly resolved definition is written into `type_dependent_defs`.
4304 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4305 qpath: &'b hir::QPath,
4306 node_id: ast::NodeId,
4308 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4310 let (ty, item_segment) = match *qpath {
4311 hir::QPath::Resolved(ref opt_qself, ref path) => {
4313 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4314 &path.segments[..]);
4316 hir::QPath::TypeRelative(ref qself, ref segment) => {
4317 (self.to_ty(qself), segment)
4320 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4321 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4322 // Return directly on cache hit. This is useful to avoid doubly reporting
4323 // errors with default match binding modes. See #44614.
4324 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4326 let item_name = item_segment.ident;
4327 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4330 let def = match error {
4331 method::MethodError::PrivateMatch(def, _) => def,
4334 if item_name.name != keywords::Invalid.name() {
4335 self.report_method_error(span, ty, item_name, None, error, None);
4341 // Write back the new resolution.
4342 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4343 (def, Some(ty), slice::from_ref(&**item_segment))
4346 pub fn check_decl_initializer(&self,
4347 local: &'gcx hir::Local,
4348 init: &'gcx hir::Expr) -> Ty<'tcx>
4350 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4351 // for #42640 (default match binding modes).
4354 let ref_bindings = local.pat.contains_explicit_ref_binding();
4356 let local_ty = self.local_ty(init.span, local.id);
4357 if let Some(m) = ref_bindings {
4358 // Somewhat subtle: if we have a `ref` binding in the pattern,
4359 // we want to avoid introducing coercions for the RHS. This is
4360 // both because it helps preserve sanity and, in the case of
4361 // ref mut, for soundness (issue #23116). In particular, in
4362 // the latter case, we need to be clear that the type of the
4363 // referent for the reference that results is *equal to* the
4364 // type of the place it is referencing, and not some
4365 // supertype thereof.
4366 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4367 self.demand_eqtype(init.span, local_ty, init_ty);
4370 self.check_expr_coercable_to_type(init, local_ty)
4374 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4375 let t = self.local_ty(local.span, local.id);
4376 self.write_ty(local.hir_id, t);
4378 if let Some(ref init) = local.init {
4379 let init_ty = self.check_decl_initializer(local, &init);
4380 if init_ty.references_error() {
4381 self.write_ty(local.hir_id, init_ty);
4385 self.check_pat_walk(&local.pat, t,
4386 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4388 let pat_ty = self.node_ty(local.pat.hir_id);
4389 if pat_ty.references_error() {
4390 self.write_ty(local.hir_id, pat_ty);
4394 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4395 // Don't do all the complex logic below for DeclItem.
4397 hir::StmtKind::Decl(ref decl, _) => {
4399 hir::DeclKind::Local(_) => {}
4400 hir::DeclKind::Item(_) => {
4405 hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4408 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4410 // Hide the outer diverging and has_errors flags.
4411 let old_diverges = self.diverges.get();
4412 let old_has_errors = self.has_errors.get();
4413 self.diverges.set(Diverges::Maybe);
4414 self.has_errors.set(false);
4417 hir::StmtKind::Decl(ref decl, _) => {
4419 hir::DeclKind::Local(ref l) => {
4420 self.check_decl_local(&l);
4422 hir::DeclKind::Item(_) => {/* ignore for now */}
4425 hir::StmtKind::Expr(ref expr, _) => {
4426 // Check with expected type of ()
4427 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4429 hir::StmtKind::Semi(ref expr, _) => {
4430 self.check_expr(&expr);
4434 // Combine the diverging and has_error flags.
4435 self.diverges.set(self.diverges.get() | old_diverges);
4436 self.has_errors.set(self.has_errors.get() | old_has_errors);
4439 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4440 let unit = self.tcx.mk_nil();
4441 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4443 // if the block produces a `!` value, that can always be
4444 // (effectively) coerced to unit.
4446 self.demand_suptype(blk.span, unit, ty);
4450 fn check_block_with_expected(&self,
4451 blk: &'gcx hir::Block,
4452 expected: Expectation<'tcx>) -> Ty<'tcx> {
4454 let mut fcx_ps = self.ps.borrow_mut();
4455 let unsafety_state = fcx_ps.recurse(blk);
4456 replace(&mut *fcx_ps, unsafety_state)
4459 // In some cases, blocks have just one exit, but other blocks
4460 // can be targeted by multiple breaks. This can happen both
4461 // with labeled blocks as well as when we desugar
4462 // a `do catch { ... }` expression.
4466 // 'a: { if true { break 'a Err(()); } Ok(()) }
4468 // Here we would wind up with two coercions, one from
4469 // `Err(())` and the other from the tail expression
4470 // `Ok(())`. If the tail expression is omitted, that's a
4471 // "forced unit" -- unless the block diverges, in which
4472 // case we can ignore the tail expression (e.g., `'a: {
4473 // break 'a 22; }` would not force the type of the block
4475 let tail_expr = blk.expr.as_ref();
4476 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4477 let coerce = if blk.targeted_by_break {
4478 CoerceMany::new(coerce_to_ty)
4480 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4481 Some(e) => slice::from_ref(e),
4484 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4487 let prev_diverges = self.diverges.get();
4488 let ctxt = BreakableCtxt {
4489 coerce: Some(coerce),
4493 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4494 for s in &blk.stmts {
4498 // check the tail expression **without** holding the
4499 // `enclosing_breakables` lock below.
4500 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4502 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4503 let ctxt = enclosing_breakables.find_breakable(blk.id);
4504 let coerce = ctxt.coerce.as_mut().unwrap();
4505 if let Some(tail_expr_ty) = tail_expr_ty {
4506 let tail_expr = tail_expr.unwrap();
4507 let cause = self.cause(tail_expr.span,
4508 ObligationCauseCode::BlockTailExpression(blk.id));
4514 // Subtle: if there is no explicit tail expression,
4515 // that is typically equivalent to a tail expression
4516 // of `()` -- except if the block diverges. In that
4517 // case, there is no value supplied from the tail
4518 // expression (assuming there are no other breaks,
4519 // this implies that the type of the block will be
4522 // #41425 -- label the implicit `()` as being the
4523 // "found type" here, rather than the "expected type".
4525 // #44579 -- if the block was recovered during parsing,
4526 // the type would be nonsensical and it is not worth it
4527 // to perform the type check, so we avoid generating the
4528 // diagnostic output.
4529 if !self.diverges.get().always() && !blk.recovered {
4530 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4531 if let Some(expected_ty) = expected.only_has_type(self) {
4532 self.consider_hint_about_removing_semicolon(blk,
4542 // If we can break from the block, then the block's exit is always reachable
4543 // (... as long as the entry is reachable) - regardless of the tail of the block.
4544 self.diverges.set(prev_diverges);
4547 let mut ty = ctxt.coerce.unwrap().complete(self);
4549 if self.has_errors.get() || ty.references_error() {
4550 ty = self.tcx.types.err
4553 self.write_ty(blk.hir_id, ty);
4555 *self.ps.borrow_mut() = prev;
4559 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4560 /// suggestion can be made, `None` otherwise.
4561 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4562 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4563 // `while` before reaching it, as block tail returns are not available in them.
4564 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4565 let parent = self.tcx.hir.get(fn_id);
4567 if let Node::NodeItem(&hir::Item {
4568 name, node: hir::ItemKind::Fn(ref decl, ..), ..
4570 decl.clone().and_then(|decl| {
4571 // This is less than ideal, it will not suggest a return type span on any
4572 // method called `main`, regardless of whether it is actually the entry point,
4573 // but it will still present it as the reason for the expected type.
4574 Some((decl, name != Symbol::intern("main")))
4576 } else if let Node::NodeTraitItem(&hir::TraitItem {
4577 node: hir::TraitItemKind::Method(hir::MethodSig {
4581 decl.clone().and_then(|decl| {
4584 } else if let Node::NodeImplItem(&hir::ImplItem {
4585 node: hir::ImplItemKind::Method(hir::MethodSig {
4589 decl.clone().and_then(|decl| {
4600 /// On implicit return expressions with mismatched types, provide the following suggestions:
4602 /// - Point out the method's return type as the reason for the expected type
4603 /// - Possible missing semicolon
4604 /// - Possible missing return type if the return type is the default, and not `fn main()`
4605 pub fn suggest_mismatched_types_on_tail(&self,
4606 err: &mut DiagnosticBuilder<'tcx>,
4607 expression: &'gcx hir::Expr,
4611 blk_id: ast::NodeId) {
4612 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4613 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4614 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4616 self.suggest_ref_or_into(err, expression, expected, found);
4619 pub fn suggest_ref_or_into(
4621 err: &mut DiagnosticBuilder<'tcx>,
4626 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4627 err.span_suggestion(sp, msg, suggestion);
4628 } else if !self.check_for_cast(err, expr, found, expected) {
4629 let methods = self.get_conversion_methods(expr.span, expected, found);
4630 if let Ok(expr_text) = self.sess().codemap().span_to_snippet(expr.span) {
4631 let suggestions = iter::repeat(expr_text).zip(methods.iter())
4632 .filter_map(|(receiver, method)| {
4633 let method_call = format!(".{}()", method.ident);
4634 if receiver.ends_with(&method_call) {
4635 None // do not suggest code that is already there (#53348)
4637 Some(format!("{}{}", receiver, method_call))
4639 }) .collect::<Vec<_>>();
4640 if !suggestions.is_empty() {
4641 err.span_suggestions(expr.span, "try using a conversion method", suggestions);
4647 /// A common error is to forget to add a semicolon at the end of a block:
4651 /// bar_that_returns_u32()
4655 /// This routine checks if the return expression in a block would make sense on its own as a
4656 /// statement and the return type has been left as default or has been specified as `()`. If so,
4657 /// it suggests adding a semicolon.
4658 fn suggest_missing_semicolon(&self,
4659 err: &mut DiagnosticBuilder<'tcx>,
4660 expression: &'gcx hir::Expr,
4663 if expected.is_nil() {
4664 // `BlockTailExpression` only relevant if the tail expr would be
4665 // useful on its own.
4666 match expression.node {
4667 hir::ExprKind::Call(..) |
4668 hir::ExprKind::MethodCall(..) |
4669 hir::ExprKind::If(..) |
4670 hir::ExprKind::While(..) |
4671 hir::ExprKind::Loop(..) |
4672 hir::ExprKind::Match(..) |
4673 hir::ExprKind::Block(..) => {
4674 let sp = self.tcx.sess.codemap().next_point(cause_span);
4675 err.span_suggestion(sp,
4676 "try adding a semicolon",
4685 /// A possible error is to forget to add a return type that is needed:
4689 /// bar_that_returns_u32()
4693 /// This routine checks if the return type is left as default, the method is not part of an
4694 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4696 fn suggest_missing_return_type(&self,
4697 err: &mut DiagnosticBuilder<'tcx>,
4698 fn_decl: &hir::FnDecl,
4701 can_suggest: bool) {
4702 // Only suggest changing the return type for methods that
4703 // haven't set a return type at all (and aren't `fn main()` or an impl).
4704 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_nil()) {
4705 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4706 err.span_suggestion(span,
4707 "try adding a return type",
4709 self.resolve_type_vars_with_obligations(found)));
4711 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4712 err.span_label(span, "possibly return type missing here?");
4714 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4715 // `fn main()` must return `()`, do not suggest changing return type
4716 err.span_label(span, "expected `()` because of default return type");
4718 // expectation was caused by something else, not the default return
4719 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => {}
4720 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4721 // Only point to return type if the expected type is the return type, as if they
4722 // are not, the expectation must have been caused by something else.
4723 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4725 let ty = AstConv::ast_ty_to_ty(self, ty);
4726 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4727 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4728 if ty.sty == expected.sty {
4729 err.span_label(sp, format!("expected `{}` because of return type",
4737 /// A common error is to add an extra semicolon:
4740 /// fn foo() -> usize {
4745 /// This routine checks if the final statement in a block is an
4746 /// expression with an explicit semicolon whose type is compatible
4747 /// with `expected_ty`. If so, it suggests removing the semicolon.
4748 fn consider_hint_about_removing_semicolon(&self,
4749 blk: &'gcx hir::Block,
4750 expected_ty: Ty<'tcx>,
4751 err: &mut DiagnosticBuilder) {
4752 // Be helpful when the user wrote `{... expr;}` and
4753 // taking the `;` off is enough to fix the error.
4754 let last_stmt = match blk.stmts.last() {
4758 let last_expr = match last_stmt.node {
4759 hir::StmtKind::Semi(ref e, _) => e,
4762 let last_expr_ty = self.node_ty(last_expr.hir_id);
4763 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4766 let original_span = original_sp(last_stmt.span, blk.span);
4767 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4768 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4771 // Instantiates the given path, which must refer to an item with the given
4772 // number of type parameters and type.
4773 pub fn instantiate_value_path(&self,
4774 segments: &[hir::PathSegment],
4775 opt_self_ty: Option<Ty<'tcx>>,
4778 node_id: ast::NodeId)
4780 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4785 // We need to extract the type parameters supplied by the user in
4786 // the path `path`. Due to the current setup, this is a bit of a
4787 // tricky-process; the problem is that resolve only tells us the
4788 // end-point of the path resolution, and not the intermediate steps.
4789 // Luckily, we can (at least for now) deduce the intermediate steps
4790 // just from the end-point.
4792 // There are basically four cases to consider:
4794 // 1. Reference to a constructor of enum variant or struct:
4796 // struct Foo<T>(...)
4797 // enum E<T> { Foo(...) }
4799 // In these cases, the parameters are declared in the type
4802 // 2. Reference to a fn item or a free constant:
4806 // In this case, the path will again always have the form
4807 // `a::b::foo::<T>` where only the final segment should have
4808 // type parameters. However, in this case, those parameters are
4809 // declared on a value, and hence are in the `FnSpace`.
4811 // 3. Reference to a method or an associated constant:
4813 // impl<A> SomeStruct<A> {
4817 // Here we can have a path like
4818 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4819 // may appear in two places. The penultimate segment,
4820 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4821 // final segment, `foo::<B>` contains parameters in fn space.
4823 // 4. Reference to a local variable
4825 // Local variables can't have any type parameters.
4827 // The first step then is to categorize the segments appropriately.
4829 assert!(!segments.is_empty());
4831 let mut ufcs_associated = None;
4832 let mut type_segment = None;
4833 let mut fn_segment = None;
4835 // Case 1. Reference to a struct/variant constructor.
4836 Def::StructCtor(def_id, ..) |
4837 Def::VariantCtor(def_id, ..) => {
4838 // Everything but the final segment should have no
4839 // parameters at all.
4840 let mut generics = self.tcx.generics_of(def_id);
4841 if let Some(def_id) = generics.parent {
4842 // Variant and struct constructors use the
4843 // generics of their parent type definition.
4844 generics = self.tcx.generics_of(def_id);
4846 type_segment = Some((segments.last().unwrap(), generics));
4849 // Case 2. Reference to a top-level value.
4851 Def::Const(def_id) |
4852 Def::Static(def_id, _) => {
4853 fn_segment = Some((segments.last().unwrap(), self.tcx.generics_of(def_id)));
4856 // Case 3. Reference to a method or associated const.
4857 Def::Method(def_id) |
4858 Def::AssociatedConst(def_id) => {
4859 let container = self.tcx.associated_item(def_id).container;
4861 ty::TraitContainer(trait_did) => {
4862 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4864 ty::ImplContainer(_) => {}
4867 let generics = self.tcx.generics_of(def_id);
4868 if segments.len() >= 2 {
4869 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4870 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4872 // `<T>::assoc` will end up here, and so can `T::assoc`.
4873 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4874 ufcs_associated = Some((container, self_ty));
4876 fn_segment = Some((segments.last().unwrap(), generics));
4879 // Case 4. Local variable, no generics.
4880 Def::Local(..) | Def::Upvar(..) => {}
4882 _ => bug!("unexpected definition: {:?}", def),
4885 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4887 // Now that we have categorized what space the parameters for each
4888 // segment belong to, let's sort out the parameters that the user
4889 // provided (if any) into their appropriate spaces. We'll also report
4890 // errors if type parameters are provided in an inappropriate place.
4891 let poly_segments = type_segment.is_some() as usize +
4892 fn_segment.is_some() as usize;
4893 AstConv::prohibit_generics(self, &segments[..segments.len() - poly_segments]);
4896 Def::Local(nid) | Def::Upvar(nid, ..) => {
4897 let ty = self.local_ty(span, nid);
4898 let ty = self.normalize_associated_types_in(span, &ty);
4899 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4905 // Now we have to compare the types that the user *actually*
4906 // provided against the types that were *expected*. If the user
4907 // did not provide any types, then we want to substitute inference
4908 // variables. If the user provided some types, we may still need
4909 // to add defaults. If the user provided *too many* types, that's
4911 let supress_mismatch = self.check_impl_trait(span, fn_segment);
4912 self.check_generic_arg_count(span, &mut type_segment, false, supress_mismatch);
4913 self.check_generic_arg_count(span, &mut fn_segment, false, supress_mismatch);
4915 let (fn_start, has_self) = match (type_segment, fn_segment) {
4916 (_, Some((_, generics))) => {
4917 (generics.parent_count, generics.has_self)
4919 (Some((_, generics)), None) => {
4920 (generics.params.len(), generics.has_self)
4922 (None, None) => (0, false)
4924 // FIXME(varkor): Separating out the parameters is messy.
4925 let mut lifetimes_type_seg = vec![];
4926 let mut types_type_seg = vec![];
4927 let mut infer_types_type_seg = true;
4928 if let Some((seg, _)) = type_segment {
4929 if let Some(ref data) = seg.args {
4930 for arg in &data.args {
4932 GenericArg::Lifetime(lt) => lifetimes_type_seg.push(lt),
4933 GenericArg::Type(ty) => types_type_seg.push(ty),
4937 infer_types_type_seg = seg.infer_types;
4940 let mut lifetimes_fn_seg = vec![];
4941 let mut types_fn_seg = vec![];
4942 let mut infer_types_fn_seg = true;
4943 if let Some((seg, _)) = fn_segment {
4944 if let Some(ref data) = seg.args {
4945 for arg in &data.args {
4947 GenericArg::Lifetime(lt) => lifetimes_fn_seg.push(lt),
4948 GenericArg::Type(ty) => types_fn_seg.push(ty),
4952 infer_types_fn_seg = seg.infer_types;
4955 let substs = Substs::for_item(self.tcx, def.def_id(), |param, substs| {
4956 let mut i = param.index as usize;
4958 let (segment, lifetimes, types, infer_types) = if i < fn_start {
4959 if let GenericParamDefKind::Type { .. } = param.kind {
4960 // Handle Self first, so we can adjust the index to match the AST.
4961 if has_self && i == 0 {
4962 return opt_self_ty.map(|ty| ty.into()).unwrap_or_else(|| {
4963 self.var_for_def(span, param)
4967 i -= has_self as usize;
4968 (type_segment, &lifetimes_type_seg, &types_type_seg, infer_types_type_seg)
4971 (fn_segment, &lifetimes_fn_seg, &types_fn_seg, infer_types_fn_seg)
4975 GenericParamDefKind::Lifetime => {
4976 if let Some(lifetime) = lifetimes.get(i) {
4977 AstConv::ast_region_to_region(self, lifetime, Some(param)).into()
4979 self.re_infer(span, Some(param)).unwrap().into()
4982 GenericParamDefKind::Type { .. } => {
4983 // Skip over the lifetimes in the same segment.
4984 if let Some((_, generics)) = segment {
4985 i -= generics.own_counts().lifetimes;
4988 let has_default = match param.kind {
4989 GenericParamDefKind::Type { has_default, .. } => has_default,
4993 if let Some(ast_ty) = types.get(i) {
4994 // A provided type parameter.
4995 self.to_ty(ast_ty).into()
4996 } else if !infer_types && has_default {
4997 // No type parameter provided, but a default exists.
4998 let default = self.tcx.type_of(param.def_id);
5001 default.subst_spanned(self.tcx, substs, Some(span))
5004 // No type parameters were provided, we can infer all.
5005 // This can also be reached in some error cases:
5006 // We prefer to use inference variables instead of
5007 // TyError to let type inference recover somewhat.
5008 self.var_for_def(span, param)
5014 // The things we are substituting into the type should not contain
5015 // escaping late-bound regions, and nor should the base type scheme.
5016 let ty = self.tcx.type_of(def.def_id());
5017 assert!(!substs.has_escaping_regions());
5018 assert!(!ty.has_escaping_regions());
5020 // Add all the obligations that are required, substituting and
5021 // normalized appropriately.
5022 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
5023 self.add_obligations_for_parameters(
5024 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
5027 // Substitute the values for the type parameters into the type of
5028 // the referenced item.
5029 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5031 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
5032 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5033 // is inherent, there is no `Self` parameter, instead, the impl needs
5034 // type parameters, which we can infer by unifying the provided `Self`
5035 // with the substituted impl type.
5036 let ty = self.tcx.type_of(impl_def_id);
5038 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5039 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5040 Ok(ok) => self.register_infer_ok_obligations(ok),
5043 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5050 self.check_rustc_args_require_const(def.def_id(), node_id, span);
5052 debug!("instantiate_value_path: type of {:?} is {:?}",
5055 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
5059 fn check_rustc_args_require_const(&self,
5061 node_id: ast::NodeId,
5063 // We're only interested in functions tagged with
5064 // #[rustc_args_required_const], so ignore anything that's not.
5065 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5069 // If our calling expression is indeed the function itself, we're good!
5070 // If not, generate an error that this can only be called directly.
5071 match self.tcx.hir.get(self.tcx.hir.get_parent_node(node_id)) {
5072 Node::NodeExpr(expr) => {
5074 hir::ExprKind::Call(ref callee, ..) => {
5075 if callee.id == node_id {
5085 self.tcx.sess.span_err(span, "this function can only be invoked \
5086 directly, not through a function pointer");
5089 /// Report errors if the provided parameters are too few or too many.
5090 fn check_generic_arg_count(&self,
5092 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
5093 is_method_call: bool,
5094 supress_mismatch_error: bool) {
5095 let (lifetimes, types, infer_types, bindings) = segment.map_or(
5096 (vec![], vec![], true, &[][..]),
5098 s.args.as_ref().map_or(
5099 (vec![], vec![], s.infer_types, &[][..]),
5101 let (mut lifetimes, mut types) = (vec![], vec![]);
5102 data.args.iter().for_each(|arg| match arg {
5103 GenericArg::Lifetime(lt) => lifetimes.push(lt),
5104 GenericArg::Type(ty) => types.push(ty),
5106 (lifetimes, types, s.infer_types, &data.bindings[..])
5111 // Check provided parameters.
5112 let ((ty_required, ty_accepted), lt_accepted) =
5113 segment.map_or(((0, 0), 0), |(_, generics)| {
5119 let mut lt_accepted = 0;
5120 let mut ty_params = ParamRange { required: 0, accepted: 0 };
5121 for param in &generics.params {
5123 GenericParamDefKind::Lifetime => lt_accepted += 1,
5124 GenericParamDefKind::Type { has_default, .. } => {
5125 ty_params.accepted += 1;
5127 ty_params.required += 1;
5132 if generics.parent.is_none() && generics.has_self {
5133 ty_params.required -= 1;
5134 ty_params.accepted -= 1;
5137 ((ty_params.required, ty_params.accepted), lt_accepted)
5140 let count_type_params = |n| {
5141 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
5143 let expected_text = count_type_params(ty_accepted);
5144 let actual_text = count_type_params(types.len());
5145 if let Some((mut err, span)) = if types.len() > ty_accepted {
5146 // To prevent derived errors to accumulate due to extra
5147 // type parameters, we force instantiate_value_path to
5148 // use inference variables instead of the provided types.
5150 let span = types[ty_accepted].span;
5151 Some((struct_span_err!(self.tcx.sess, span, E0087,
5152 "too many type parameters provided: \
5153 expected at most {}, found {}",
5154 expected_text, actual_text), span))
5155 } else if types.len() < ty_required && !infer_types && !supress_mismatch_error {
5156 Some((struct_span_err!(self.tcx.sess, span, E0089,
5157 "too few type parameters provided: \
5158 expected {}, found {}",
5159 expected_text, actual_text), span))
5163 self.set_tainted_by_errors(); // #53251
5164 err.span_label(span, format!("expected {}", expected_text)).emit();
5167 if !bindings.is_empty() {
5168 AstConv::prohibit_projection(self, bindings[0].span);
5171 let infer_lifetimes = lifetimes.len() == 0;
5172 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
5173 let has_late_bound_lifetime_defs =
5174 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
5175 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
5176 // Report this as a lint only if no error was reported previously.
5177 let primary_msg = "cannot specify lifetime arguments explicitly \
5178 if late bound lifetime parameters are present";
5179 let note_msg = "the late bound lifetime parameter is introduced here";
5180 if !is_method_call && (lifetimes.len() > lt_accepted ||
5181 lifetimes.len() < lt_accepted && !infer_lifetimes) {
5182 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
5183 err.span_note(span_late, note_msg);
5187 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
5188 multispan.push_span_label(span_late, note_msg.to_string());
5189 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
5190 lifetimes[0].id, multispan, primary_msg);
5195 let count_lifetime_params = |n| {
5196 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
5198 let expected_text = count_lifetime_params(lt_accepted);
5199 let actual_text = count_lifetime_params(lifetimes.len());
5200 if let Some((mut err, span)) = if lifetimes.len() > lt_accepted {
5201 let span = lifetimes[lt_accepted].span;
5202 Some((struct_span_err!(self.tcx.sess, span, E0088,
5203 "too many lifetime parameters provided: \
5204 expected at most {}, found {}",
5205 expected_text, actual_text), span))
5206 } else if lifetimes.len() < lt_accepted && !infer_lifetimes {
5207 Some((struct_span_err!(self.tcx.sess, span, E0090,
5208 "too few lifetime parameters provided: \
5209 expected {}, found {}",
5210 expected_text, actual_text), span))
5214 err.span_label(span, format!("expected {}", expected_text)).emit();
5218 /// Report error if there is an explicit type parameter when using `impl Trait`.
5219 fn check_impl_trait(&self,
5221 segment: Option<(&hir::PathSegment, &ty::Generics)>)
5223 let segment = segment.map(|(path_segment, generics)| {
5224 let explicit = !path_segment.infer_types;
5225 let impl_trait = generics.params.iter().any(|param| match param.kind {
5226 ty::GenericParamDefKind::Type {
5227 synthetic: Some(hir::SyntheticTyParamKind::ImplTrait), ..
5232 if explicit && impl_trait {
5233 let mut err = struct_span_err! {
5237 "cannot provide explicit type parameters when `impl Trait` is \
5238 used in argument position."
5247 segment.unwrap_or(false)
5250 // Resolves `typ` by a single level if `typ` is a type variable.
5251 // If no resolution is possible, then an error is reported.
5252 // Numeric inference variables may be left unresolved.
5253 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5254 let ty = self.resolve_type_vars_with_obligations(ty);
5255 if !ty.is_ty_var() {
5258 if !self.is_tainted_by_errors() {
5259 self.need_type_info_err((**self).body_id, sp, ty)
5260 .note("type must be known at this point")
5263 self.demand_suptype(sp, self.tcx.types.err, ty);
5268 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5269 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5270 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5273 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5274 index = enclosing_breakables.stack.len();
5275 enclosing_breakables.by_id.insert(id, index);
5276 enclosing_breakables.stack.push(ctxt);
5280 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5281 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5282 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5283 enclosing_breakables.stack.pop().expect("missing breakable context")
5289 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5290 generics: &ty::Generics,
5292 let own_counts = generics.own_counts();
5293 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5295 if own_counts.types == 0 {
5298 // Make a vector of booleans initially false, set to true when used.
5299 let mut types_used = vec![false; own_counts.types];
5301 for leaf_ty in ty.walk() {
5302 if let ty::TyParam(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5303 debug!("Found use of ty param num {}", idx);
5304 types_used[idx as usize - own_counts.lifetimes] = true;
5305 } else if let ty::TyError = leaf_ty.sty {
5306 // If there is already another error, do not emit
5307 // an error for not using a type Parameter.
5308 assert!(tcx.sess.err_count() > 0);
5313 let types = generics.params.iter().filter(|param| match param.kind {
5314 ty::GenericParamDefKind::Type { .. } => true,
5317 for (&used, param) in types_used.iter().zip(types) {
5319 let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
5320 let span = tcx.hir.span(id);
5321 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5322 .span_label(span, "unused type parameter")
5328 fn fatally_break_rust(sess: &Session) {
5329 let handler = sess.diagnostic();
5330 handler.span_bug_no_panic(
5332 "It looks like you're trying to break rust; would you like some ICE?",
5334 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5335 handler.note_without_error(
5336 "we would appreciate a joke overview: \
5337 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5339 handler.note_without_error(&format!("rustc {} running on {}",
5340 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5341 ::session::config::host_triple(),