5 Within the check phase of type check, we check each item one at a time
6 (bodies of function expressions are checked as part of the containing
7 function). Inference is used to supply types wherever they are unknown.
9 By far the most complex case is checking the body of a function. This
10 can be broken down into several distinct phases:
12 - gather: creates type variables to represent the type of each local
13 variable and pattern binding.
15 - main: the main pass does the lion's share of the work: it
16 determines the types of all expressions, resolves
17 methods, checks for most invalid conditions, and so forth. In
18 some cases, where a type is unknown, it may create a type or region
19 variable and use that as the type of an expression.
21 In the process of checking, various constraints will be placed on
22 these type variables through the subtyping relationships requested
23 through the `demand` module. The `infer` module is in charge
24 of resolving those constraints.
26 - regionck: after main is complete, the regionck pass goes over all
27 types looking for regions and making sure that they did not escape
28 into places they are not in scope. This may also influence the
29 final assignments of the various region variables if there is some
32 - writeback: writes the final types within a function body, replacing
33 type variables with their final inferred types. These final types
34 are written into the `tcx.node_types` table, which should *never* contain
35 any reference to a type variable.
39 While type checking a function, the intermediate types for the
40 expressions, blocks, and so forth contained within the function are
41 stored in `fcx.node_types` and `fcx.node_substs`. These types
42 may contain unresolved type variables. After type checking is
43 complete, the functions in the writeback module are used to take the
44 types from this table, resolve them, and then write them into their
45 permanent home in the type context `tcx`.
47 This means that during inferencing you should use `fcx.write_ty()`
48 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
49 nodes within the function.
51 The types of top-level items, which never contain unbound type
52 variables, are stored directly into the `tcx` typeck_results.
54 N.B., a type variable is not the same thing as a type parameter. A
55 type variable is an instance of a type parameter. That is,
56 given a generic function `fn foo<T>(t: T)`, while checking the
57 function `foo`, the type `ty_param(0)` refers to the type `T`, which
58 is treated in abstract. However, when `foo()` is called, `T` will be
59 substituted for a fresh type variable `N`. This variable will
60 eventually be resolved to some concrete type (which might itself be
80 mod generator_interior
;
93 check_abi
, check_fn
, check_impl_item_well_formed
, check_item_well_formed
, check_mod_item_types
,
94 check_trait_item_well_formed
,
96 pub use check
::{check_item_type, check_wf_new}
;
97 pub use diverges
::Diverges
;
98 pub use expectation
::Expectation
;
100 pub use inherited
::{Inherited, InheritedBuilder}
;
102 use crate::astconv
::AstConv
;
103 use crate::check
::gather_locals
::GatherLocalsVisitor
;
104 use rustc_data_structures
::fx
::{FxHashMap, FxHashSet}
;
105 use rustc_errors
::{pluralize, struct_span_err, Applicability}
;
106 use rustc_hir
as hir
;
107 use rustc_hir
::def
::Res
;
108 use rustc_hir
::def_id
::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}
;
109 use rustc_hir
::intravisit
::Visitor
;
110 use rustc_hir
::itemlikevisit
::ItemLikeVisitor
;
111 use rustc_hir
::{HirIdMap, ImplicitSelfKind, Node}
;
112 use rustc_index
::bit_set
::BitSet
;
113 use rustc_index
::vec
::Idx
;
114 use rustc_infer
::infer
::type_variable
::{TypeVariableOrigin, TypeVariableOriginKind}
;
115 use rustc_middle
::ty
::fold
::{TypeFoldable, TypeFolder}
;
116 use rustc_middle
::ty
::query
::Providers
;
117 use rustc_middle
::ty
::subst
::GenericArgKind
;
118 use rustc_middle
::ty
::subst
::{InternalSubsts, Subst, SubstsRef}
;
119 use rustc_middle
::ty
::WithConstness
;
120 use rustc_middle
::ty
::{self, RegionKind, Ty, TyCtxt, UserType}
;
121 use rustc_session
::config
;
122 use rustc_session
::parse
::feature_err
;
123 use rustc_session
::Session
;
124 use rustc_span
::symbol
::{kw, Ident}
;
125 use rustc_span
::{self, BytePos, MultiSpan, Span}
;
126 use rustc_span
::{source_map::DUMMY_SP, sym}
;
127 use rustc_target
::abi
::VariantIdx
;
128 use rustc_target
::spec
::abi
::Abi
;
129 use rustc_trait_selection
::traits
;
130 use rustc_trait_selection
::traits
::error_reporting
::recursive_type_with_infinite_size_error
;
131 use rustc_trait_selection
::traits
::error_reporting
::suggestions
::ReturnsVisitor
;
133 use std
::cell
::{Ref, RefCell, RefMut}
;
135 use crate::require_c_abi_if_c_variadic
;
136 use crate::util
::common
::indenter
;
138 use self::coercion
::DynamicCoerceMany
;
139 pub use self::Expectation
::*;
142 macro_rules
! type_error_struct
{
143 ($session
:expr
, $span
:expr
, $typ
:expr
, $code
:ident
, $
($message
:tt
)*) => ({
144 if $typ
.references_error() {
145 $session
.diagnostic().struct_dummy()
147 rustc_errors
::struct_span_err
!($session
, $span
, $code
, $
($message
)*)
152 /// The type of a local binding, including the revealed type for anon types.
153 #[derive(Copy, Clone, Debug)]
154 pub struct LocalTy
<'tcx
> {
156 revealed_ty
: Ty
<'tcx
>,
159 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
166 fn maybe_mut_place(m
: hir
::Mutability
) -> Self {
168 hir
::Mutability
::Mut
=> Needs
::MutPlace
,
169 hir
::Mutability
::Not
=> Needs
::None
,
174 #[derive(Copy, Clone)]
175 pub struct UnsafetyState
{
177 pub unsafety
: hir
::Unsafety
,
178 pub unsafe_push_count
: u32,
183 pub fn function(unsafety
: hir
::Unsafety
, def
: hir
::HirId
) -> UnsafetyState
{
184 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
187 pub fn recurse(self, blk
: &hir
::Block
<'_
>) -> UnsafetyState
{
188 use hir
::BlockCheckMode
;
189 match self.unsafety
{
190 // If this unsafe, then if the outer function was already marked as
191 // unsafe we shouldn't attribute the unsafe'ness to the block. This
192 // way the block can be warned about instead of ignoring this
193 // extraneous block (functions are never warned about).
194 hir
::Unsafety
::Unsafe
if self.from_fn
=> self,
197 let (unsafety
, def
, count
) = match blk
.rules
{
198 BlockCheckMode
::PushUnsafeBlock(..) => {
199 (unsafety
, blk
.hir_id
, self.unsafe_push_count
.checked_add(1).unwrap())
201 BlockCheckMode
::PopUnsafeBlock(..) => {
202 (unsafety
, blk
.hir_id
, self.unsafe_push_count
.checked_sub(1).unwrap())
204 BlockCheckMode
::UnsafeBlock(..) => {
205 (hir
::Unsafety
::Unsafe
, blk
.hir_id
, self.unsafe_push_count
)
207 BlockCheckMode
::DefaultBlock
=> (unsafety
, self.def
, self.unsafe_push_count
),
209 UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false }
215 #[derive(Debug, Copy, Clone)]
221 pub struct BreakableCtxt
<'tcx
> {
224 // this is `null` for loops where break with a value is illegal,
225 // such as `while`, `for`, and `while let`
226 coerce
: Option
<DynamicCoerceMany
<'tcx
>>,
229 pub struct EnclosingBreakables
<'tcx
> {
230 stack
: Vec
<BreakableCtxt
<'tcx
>>,
231 by_id
: HirIdMap
<usize>,
234 impl<'tcx
> EnclosingBreakables
<'tcx
> {
235 fn find_breakable(&mut self, target_id
: hir
::HirId
) -> &mut BreakableCtxt
<'tcx
> {
236 self.opt_find_breakable(target_id
).unwrap_or_else(|| {
237 bug
!("could not find enclosing breakable with id {}", target_id
);
241 fn opt_find_breakable(&mut self, target_id
: hir
::HirId
) -> Option
<&mut BreakableCtxt
<'tcx
>> {
242 match self.by_id
.get(&target_id
) {
243 Some(ix
) => Some(&mut self.stack
[*ix
]),
249 pub fn provide(providers
: &mut Providers
) {
250 method
::provide(providers
);
251 *providers
= Providers
{
255 diagnostic_only_typeck
,
259 check_item_well_formed
,
260 check_trait_item_well_formed
,
261 check_impl_item_well_formed
,
262 check_mod_item_types
,
267 fn adt_destructor(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> Option
<ty
::Destructor
> {
268 tcx
.calculate_dtor(def_id
, dropck
::check_drop_impl
)
271 /// If this `DefId` is a "primary tables entry", returns
272 /// `Some((body_id, header, decl))` with information about
273 /// its body-id, fn-header and fn-decl (if any). Otherwise,
276 /// If this function returns `Some`, then `typeck_results(def_id)` will
277 /// succeed; if it returns `None`, then `typeck_results(def_id)` may or
278 /// may not succeed. In some cases where this function returns `None`
279 /// (notably closures), `typeck_results(def_id)` would wind up
280 /// redirecting to the owning function.
284 ) -> Option
<(hir
::BodyId
, Option
<&hir
::Ty
<'_
>>, Option
<&hir
::FnHeader
>, Option
<&hir
::FnDecl
<'_
>>)> {
285 match tcx
.hir().get(id
) {
286 Node
::Item(item
) => match item
.kind
{
287 hir
::ItemKind
::Const(ref ty
, body
) | hir
::ItemKind
::Static(ref ty
, _
, body
) => {
288 Some((body
, Some(ty
), None
, None
))
290 hir
::ItemKind
::Fn(ref sig
, .., body
) => {
291 Some((body
, None
, Some(&sig
.header
), Some(&sig
.decl
)))
295 Node
::TraitItem(item
) => match item
.kind
{
296 hir
::TraitItemKind
::Const(ref ty
, Some(body
)) => Some((body
, Some(ty
), None
, None
)),
297 hir
::TraitItemKind
::Fn(ref sig
, hir
::TraitFn
::Provided(body
)) => {
298 Some((body
, None
, Some(&sig
.header
), Some(&sig
.decl
)))
302 Node
::ImplItem(item
) => match item
.kind
{
303 hir
::ImplItemKind
::Const(ref ty
, body
) => Some((body
, Some(ty
), None
, None
)),
304 hir
::ImplItemKind
::Fn(ref sig
, body
) => {
305 Some((body
, None
, Some(&sig
.header
), Some(&sig
.decl
)))
309 Node
::AnonConst(constant
) => Some((constant
.body
, None
, None
, None
)),
314 fn has_typeck_results(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> bool
{
315 // Closures' typeck results come from their outermost function,
316 // as they are part of the same "inference environment".
317 let outer_def_id
= tcx
.closure_base_def_id(def_id
);
318 if outer_def_id
!= def_id
{
319 return tcx
.has_typeck_results(outer_def_id
);
322 if let Some(def_id
) = def_id
.as_local() {
323 let id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
324 primary_body_of(tcx
, id
).is_some()
330 fn used_trait_imports(tcx
: TyCtxt
<'_
>, def_id
: LocalDefId
) -> &FxHashSet
<LocalDefId
> {
331 &*tcx
.typeck(def_id
).used_trait_imports
334 /// Inspects the substs of opaque types, replacing any inference variables
335 /// with proper generic parameter from the identity substs.
337 /// This is run after we normalize the function signature, to fix any inference
338 /// variables introduced by the projection of associated types. This ensures that
339 /// any opaque types used in the signature continue to refer to generic parameters,
340 /// allowing them to be considered for defining uses in the function body
342 /// For example, consider this code.
347 /// fn use_it(self) -> Self::MyItem
349 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
350 /// type MyItem = impl Iterator<Item = I>;
351 /// fn use_it(self) -> Self::MyItem {
357 /// When we normalize the signature of `use_it` from the impl block,
358 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
359 /// However, this projection result may contain inference variables, due
360 /// to the way that projection works. We didn't have any inference variables
361 /// in the signature to begin with - leaving them in will cause us to incorrectly
362 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
363 /// variables back to the actual generic parameters, we will correctly see that
364 /// we have a defining use of `MyItem`
365 fn fixup_opaque_types
<'tcx
, T
>(tcx
: TyCtxt
<'tcx
>, val
: T
) -> T
367 T
: TypeFoldable
<'tcx
>,
369 struct FixupFolder
<'tcx
> {
373 impl<'tcx
> TypeFolder
<'tcx
> for FixupFolder
<'tcx
> {
374 fn tcx
<'a
>(&'a
self) -> TyCtxt
<'tcx
> {
378 fn fold_ty(&mut self, ty
: Ty
<'tcx
>) -> Ty
<'tcx
> {
380 ty
::Opaque(def_id
, substs
) => {
381 debug
!("fixup_opaque_types: found type {:?}", ty
);
382 // Here, we replace any inference variables that occur within
383 // the substs of an opaque type. By definition, any type occurring
384 // in the substs has a corresponding generic parameter, which is what
385 // we replace it with.
386 // This replacement is only run on the function signature, so any
387 // inference variables that we come across must be the rust of projection
388 // (there's no other way for a user to get inference variables into
389 // a function signature).
390 if ty
.needs_infer() {
391 let new_substs
= InternalSubsts
::for_item(self.tcx
, def_id
, |param
, _
| {
392 let old_param
= substs
[param
.index
as usize];
393 match old_param
.unpack() {
394 GenericArgKind
::Type(old_ty
) => {
395 if let ty
::Infer(_
) = old_ty
.kind() {
396 // Replace inference type with a generic parameter
397 self.tcx
.mk_param_from_def(param
)
399 old_param
.fold_with(self)
402 GenericArgKind
::Const(old_const
) => {
403 if let ty
::ConstKind
::Infer(_
) = old_const
.val
{
404 // This should never happen - we currently do not support
405 // 'const projections', e.g.:
406 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
407 // which should be the only way for us to end up with a const inference
408 // variable after projection. If Rust ever gains support for this kind
409 // of projection, this should *probably* be changed to
410 // `self.tcx.mk_param_from_def(param)`
412 "Found infer const: `{:?}` in opaque type: {:?}",
417 old_param
.fold_with(self)
420 GenericArgKind
::Lifetime(old_region
) => {
421 if let RegionKind
::ReVar(_
) = old_region
{
422 self.tcx
.mk_param_from_def(param
)
424 old_param
.fold_with(self)
429 let new_ty
= self.tcx
.mk_opaque(def_id
, new_substs
);
430 debug
!("fixup_opaque_types: new type: {:?}", new_ty
);
436 _
=> ty
.super_fold_with(self),
441 debug
!("fixup_opaque_types({:?})", val
);
442 val
.fold_with(&mut FixupFolder { tcx }
)
445 fn typeck_const_arg
<'tcx
>(
447 (did
, param_did
): (LocalDefId
, DefId
),
448 ) -> &ty
::TypeckResults
<'tcx
> {
449 let fallback
= move || tcx
.type_of(param_did
);
450 typeck_with_fallback(tcx
, did
, fallback
)
453 fn typeck
<'tcx
>(tcx
: TyCtxt
<'tcx
>, def_id
: LocalDefId
) -> &ty
::TypeckResults
<'tcx
> {
454 if let Some(param_did
) = tcx
.opt_const_param_of(def_id
) {
455 tcx
.typeck_const_arg((def_id
, param_did
))
457 let fallback
= move || tcx
.type_of(def_id
.to_def_id());
458 typeck_with_fallback(tcx
, def_id
, fallback
)
462 /// Used only to get `TypeckResults` for type inference during error recovery.
463 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
464 fn diagnostic_only_typeck
<'tcx
>(tcx
: TyCtxt
<'tcx
>, def_id
: LocalDefId
) -> &ty
::TypeckResults
<'tcx
> {
465 let fallback
= move || {
466 let span
= tcx
.hir().span(tcx
.hir().local_def_id_to_hir_id(def_id
));
467 tcx
.ty_error_with_message(span
, "diagnostic only typeck table used")
469 typeck_with_fallback(tcx
, def_id
, fallback
)
472 fn typeck_with_fallback
<'tcx
>(
475 fallback
: impl Fn() -> Ty
<'tcx
> + 'tcx
,
476 ) -> &'tcx ty
::TypeckResults
<'tcx
> {
477 // Closures' typeck results come from their outermost function,
478 // as they are part of the same "inference environment".
479 let outer_def_id
= tcx
.closure_base_def_id(def_id
.to_def_id()).expect_local();
480 if outer_def_id
!= def_id
{
481 return tcx
.typeck(outer_def_id
);
484 let id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
485 let span
= tcx
.hir().span(id
);
487 // Figure out what primary body this item has.
488 let (body_id
, body_ty
, fn_header
, fn_decl
) = primary_body_of(tcx
, id
).unwrap_or_else(|| {
489 span_bug
!(span
, "can't type-check body of {:?}", def_id
);
491 let body
= tcx
.hir().body(body_id
);
493 let typeck_results
= Inherited
::build(tcx
, def_id
).enter(|inh
| {
494 let param_env
= tcx
.param_env(def_id
);
495 let fcx
= if let (Some(header
), Some(decl
)) = (fn_header
, fn_decl
) {
496 let fn_sig
= if crate::collect
::get_infer_ret_ty(&decl
.output
).is_some() {
497 let fcx
= FnCtxt
::new(&inh
, param_env
, body
.value
.hir_id
);
498 <dyn AstConv
<'_
>>::ty_of_fn(
503 &hir
::Generics
::empty(),
511 check_abi(tcx
, span
, fn_sig
.abi());
513 // Compute the fty from point of view of inside the fn.
514 let fn_sig
= tcx
.liberate_late_bound_regions(def_id
.to_def_id(), fn_sig
);
515 let fn_sig
= inh
.normalize_associated_types_in(
522 let fn_sig
= fixup_opaque_types(tcx
, fn_sig
);
524 let fcx
= check_fn(&inh
, param_env
, fn_sig
, decl
, id
, body
, None
).0;
527 let fcx
= FnCtxt
::new(&inh
, param_env
, body
.value
.hir_id
);
528 let expected_type
= body_ty
529 .and_then(|ty
| match ty
.kind
{
530 hir
::TyKind
::Infer
=> Some(<dyn AstConv
<'_
>>::ast_ty_to_ty(&fcx
, ty
)),
533 .unwrap_or_else(|| match tcx
.hir().get(id
) {
534 Node
::AnonConst(_
) => match tcx
.hir().get(tcx
.hir().get_parent_node(id
)) {
535 Node
::Expr(&hir
::Expr
{
536 kind
: hir
::ExprKind
::ConstBlock(ref anon_const
),
538 }) if anon_const
.hir_id
== id
=> fcx
.next_ty_var(TypeVariableOrigin
{
539 kind
: TypeVariableOriginKind
::TypeInference
,
547 let expected_type
= fcx
.normalize_associated_types_in(body
.value
.span
, expected_type
);
548 fcx
.require_type_is_sized(expected_type
, body
.value
.span
, traits
::ConstSized
);
550 let revealed_ty
= fcx
.instantiate_opaque_types_from_value(
554 Some(sym
::impl_trait_in_bindings
),
557 // Gather locals in statics (because of block expressions).
558 GatherLocalsVisitor
::new(&fcx
, id
).visit_body(body
);
560 fcx
.check_expr_coercable_to_type(&body
.value
, revealed_ty
, None
);
562 fcx
.write_ty(id
, revealed_ty
);
567 // All type checking constraints were added, try to fallback unsolved variables.
568 fcx
.select_obligations_where_possible(false, |_
| {}
);
569 let mut fallback_has_occurred
= false;
571 // We do fallback in two passes, to try to generate
572 // better error messages.
573 // The first time, we do *not* replace opaque types.
574 for ty
in &fcx
.unsolved_variables() {
575 fallback_has_occurred
|= fcx
.fallback_if_possible(ty
, FallbackMode
::NoOpaque
);
577 // We now see if we can make progress. This might
578 // cause us to unify inference variables for opaque types,
579 // since we may have unified some other type variables
580 // during the first phase of fallback.
581 // This means that we only replace inference variables with their underlying
582 // opaque types as a last resort.
584 // In code like this:
587 // type MyType = impl Copy;
588 // fn produce() -> MyType { true }
589 // fn bad_produce() -> MyType { panic!() }
592 // we want to unify the opaque inference variable in `bad_produce`
593 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
594 // This will produce a nice error message about conflicting concrete
595 // types for `MyType`.
597 // If we had tried to fallback the opaque inference variable to `MyType`,
598 // we will generate a confusing type-check error that does not explicitly
599 // refer to opaque types.
600 fcx
.select_obligations_where_possible(fallback_has_occurred
, |_
| {}
);
602 // We now run fallback again, but this time we allow it to replace
603 // unconstrained opaque type variables, in addition to performing
604 // other kinds of fallback.
605 for ty
in &fcx
.unsolved_variables() {
606 fallback_has_occurred
|= fcx
.fallback_if_possible(ty
, FallbackMode
::All
);
609 // See if we can make any more progress.
610 fcx
.select_obligations_where_possible(fallback_has_occurred
, |_
| {}
);
612 // Even though coercion casts provide type hints, we check casts after fallback for
613 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
616 // Closure and generator analysis may run after fallback
617 // because they don't constrain other type variables.
618 fcx
.closure_analyze(body
);
619 assert
!(fcx
.deferred_call_resolutions
.borrow().is_empty());
620 fcx
.resolve_generator_interiors(def_id
.to_def_id());
622 for (ty
, span
, code
) in fcx
.deferred_sized_obligations
.borrow_mut().drain(..) {
623 let ty
= fcx
.normalize_ty(span
, ty
);
624 fcx
.require_type_is_sized(ty
, span
, code
);
627 fcx
.select_all_obligations_or_error();
629 if fn_decl
.is_some() {
630 fcx
.regionck_fn(id
, body
);
632 fcx
.regionck_expr(body
);
635 fcx
.resolve_type_vars_in_body(body
)
638 // Consistency check our TypeckResults instance can hold all ItemLocalIds
639 // it will need to hold.
640 assert_eq
!(typeck_results
.hir_owner
, id
.owner
);
645 /// When `check_fn` is invoked on a generator (i.e., a body that
646 /// includes yield), it returns back some information about the yield
648 struct GeneratorTypes
<'tcx
> {
649 /// Type of generator argument / values returned by `yield`.
652 /// Type of value that is yielded.
655 /// Types that are captured (see `GeneratorInterior` for more).
658 /// Indicates if the generator is movable or static (immovable).
659 movability
: hir
::Movability
,
662 /// Given a `DefId` for an opaque type in return position, find its parent item's return
664 fn get_owner_return_paths(
667 ) -> Option
<(hir
::HirId
, ReturnsVisitor
<'tcx
>)> {
668 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
669 let id
= tcx
.hir().get_parent_item(hir_id
);
673 .and_then(|(hir_id
, node
)| node
.body_id().map(|b
| (hir_id
, b
)))
674 .map(|(hir_id
, body_id
)| {
675 let body
= tcx
.hir().body(body_id
);
676 let mut visitor
= ReturnsVisitor
::default();
677 visitor
.visit_body(body
);
682 /// Emit an error for recursive opaque types in a `let` binding.
683 fn binding_opaque_type_cycle_error(
687 partially_expanded_type
: Ty
<'tcx
>,
689 let mut err
= struct_span_err
!(tcx
.sess
, span
, E0720
, "cannot resolve opaque type");
690 err
.span_label(span
, "cannot resolve opaque type");
691 // Find the owner that declared this `impl Trait` type.
692 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
693 let mut prev_hir_id
= hir_id
;
694 let mut hir_id
= tcx
.hir().get_parent_node(hir_id
);
695 while let Some(node
) = tcx
.hir().find(hir_id
) {
697 hir
::Node
::Local(hir
::Local
{
701 source
: hir
::LocalSource
::Normal
,
704 err
.span_label(pat
.span
, "this binding might not have a concrete type");
705 err
.span_suggestion_verbose(
706 ty
.span
.shrink_to_hi(),
707 "set the binding to a value for a concrete type to be resolved",
708 " = /* value */".to_string(),
709 Applicability
::HasPlaceholders
,
712 hir
::Node
::Local(hir
::Local
{
714 source
: hir
::LocalSource
::Normal
,
717 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
719 tcx
.typeck(tcx
.hir().local_def_id(tcx
.hir().get_parent_item(hir_id
)));
720 if let Some(ty
) = typeck_results
.node_type_opt(expr
.hir_id
) {
724 "this is of type `{}`, which doesn't constrain \
725 `{}` enough to arrive to a concrete type",
726 ty
, partially_expanded_type
733 if prev_hir_id
== hir_id
{
736 prev_hir_id
= hir_id
;
737 hir_id
= tcx
.hir().get_parent_node(hir_id
);
742 // Forbid defining intrinsics in Rust code,
743 // as they must always be defined by the compiler.
744 fn fn_maybe_err(tcx
: TyCtxt
<'_
>, sp
: Span
, abi
: Abi
) {
745 if let Abi
::RustIntrinsic
| Abi
::PlatformIntrinsic
= abi
{
746 tcx
.sess
.span_err(sp
, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
750 fn maybe_check_static_with_link_section(tcx
: TyCtxt
<'_
>, id
: LocalDefId
, span
: Span
) {
751 // Only restricted on wasm32 target for now
752 if !tcx
.sess
.opts
.target_triple
.triple().starts_with("wasm32") {
756 // If `#[link_section]` is missing, then nothing to verify
757 let attrs
= tcx
.codegen_fn_attrs(id
);
758 if attrs
.link_section
.is_none() {
762 // For the wasm32 target statics with `#[link_section]` are placed into custom
763 // sections of the final output file, but this isn't link custom sections of
764 // other executable formats. Namely we can only embed a list of bytes,
765 // nothing with pointers to anything else or relocations. If any relocation
766 // show up, reject them here.
767 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
768 // the consumer's responsibility to ensure all bytes that have been read
769 // have defined values.
770 match tcx
.eval_static_initializer(id
.to_def_id()) {
772 if alloc
.relocations().len() != 0 {
773 let msg
= "statics with a custom `#[link_section]` must be a \
774 simple list of bytes on the wasm target with no \
775 extra levels of indirection such as references";
776 tcx
.sess
.span_err(span
, msg
);
783 fn report_forbidden_specialization(
785 impl_item
: &hir
::ImplItem
<'_
>,
788 let mut err
= struct_span_err
!(
792 "`{}` specializes an item from a parent `impl`, but \
793 that item is not marked `default`",
796 err
.span_label(impl_item
.span
, format
!("cannot specialize default item `{}`", impl_item
.ident
));
798 match tcx
.span_of_impl(parent_impl
) {
800 err
.span_label(span
, "parent `impl` is here");
802 "to specialize, `{}` in the parent `impl` must be marked `default`",
807 err
.note(&format
!("parent implementation is in crate `{}`", cname
));
814 fn missing_items_err(
817 missing_items
: &[ty
::AssocItem
],
818 full_impl_span
: Span
,
820 let missing_items_msg
= missing_items
822 .map(|trait_item
| trait_item
.ident
.to_string())
826 let mut err
= struct_span_err
!(
830 "not all trait items implemented, missing: `{}`",
833 err
.span_label(impl_span
, format
!("missing `{}` in implementation", missing_items_msg
));
835 // `Span` before impl block closing brace.
836 let hi
= full_impl_span
.hi() - BytePos(1);
837 // Point at the place right before the closing brace of the relevant `impl` to suggest
838 // adding the associated item at the end of its body.
839 let sugg_sp
= full_impl_span
.with_lo(hi
).with_hi(hi
);
840 // Obtain the level of indentation ending in `sugg_sp`.
841 let indentation
= tcx
.sess
.source_map().span_to_margin(sugg_sp
).unwrap_or(0);
842 // Make the whitespace that will make the suggestion have the right indentation.
843 let padding
: String
= std
::iter
::repeat(" ").take(indentation
).collect();
845 for trait_item
in missing_items
{
846 let snippet
= suggestion_signature(&trait_item
, tcx
);
847 let code
= format
!("{}{}\n{}", padding
, snippet
, padding
);
848 let msg
= format
!("implement the missing item: `{}`", snippet
);
849 let appl
= Applicability
::HasPlaceholders
;
850 if let Some(span
) = tcx
.hir().span_if_local(trait_item
.def_id
) {
851 err
.span_label(span
, format
!("`{}` from trait", trait_item
.ident
));
852 err
.tool_only_span_suggestion(sugg_sp
, &msg
, code
, appl
);
854 err
.span_suggestion_hidden(sugg_sp
, &msg
, code
, appl
);
860 /// Resugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.
861 fn bounds_from_generic_predicates
<'tcx
>(
863 predicates
: ty
::GenericPredicates
<'tcx
>,
864 ) -> (String
, String
) {
865 let mut types
: FxHashMap
<Ty
<'tcx
>, Vec
<DefId
>> = FxHashMap
::default();
866 let mut projections
= vec
![];
867 for (predicate
, _
) in predicates
.predicates
{
868 debug
!("predicate {:?}", predicate
);
869 let bound_predicate
= predicate
.kind();
870 match bound_predicate
.skip_binder() {
871 ty
::PredicateKind
::Trait(trait_predicate
, _
) => {
872 let entry
= types
.entry(trait_predicate
.self_ty()).or_default();
873 let def_id
= trait_predicate
.def_id();
874 if Some(def_id
) != tcx
.lang_items().sized_trait() {
875 // Type params are `Sized` by default, do not add that restriction to the list
876 // if it is a positive requirement.
877 entry
.push(trait_predicate
.def_id());
880 ty
::PredicateKind
::Projection(projection_pred
) => {
881 projections
.push(bound_predicate
.rebind(projection_pred
));
886 let generics
= if types
.is_empty() {
893 .filter_map(|t
| match t
.kind() {
894 ty
::Param(_
) => Some(t
.to_string()),
895 // Avoid suggesting the following:
896 // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
903 let mut where_clauses
= vec
![];
904 for (ty
, bounds
) in types
{
905 for bound
in &bounds
{
906 where_clauses
.push(format
!("{}: {}", ty
, tcx
.def_path_str(*bound
)));
909 for projection
in &projections
{
910 let p
= projection
.skip_binder();
911 // FIXME: this is not currently supported syntax, we should be looking at the `types` and
912 // insert the associated types where they correspond, but for now let's be "lazy" and
913 // propose this instead of the following valid resugaring:
914 // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
915 where_clauses
.push(format
!("{} = {}", tcx
.def_path_str(p
.projection_ty
.item_def_id
), p
.ty
));
917 let where_clauses
= if where_clauses
.is_empty() {
920 format
!(" where {}", where_clauses
.join(", "))
922 (generics
, where_clauses
)
925 /// Return placeholder code for the given function.
926 fn fn_sig_suggestion
<'tcx
>(
928 sig
: ty
::FnSig
<'tcx
>,
930 predicates
: ty
::GenericPredicates
<'tcx
>,
931 assoc
: &ty
::AssocItem
,
938 Some(match ty
.kind() {
939 ty
::Param(_
) if assoc
.fn_has_self_parameter
&& i
== 0 => "self".to_string(),
940 ty
::Ref(reg
, ref_ty
, mutability
) if i
== 0 => {
941 let reg
= match &format
!("{}", reg
)[..] {
942 "'_" | "" => String
::new(),
943 reg
=> format
!("{} ", reg
),
945 if assoc
.fn_has_self_parameter
{
946 match ref_ty
.kind() {
947 ty
::Param(param
) if param
.name
== kw
::SelfUpper
=> {
948 format
!("&{}{}self", reg
, mutability
.prefix_str())
951 _
=> format
!("self: {}", ty
),
958 if assoc
.fn_has_self_parameter
&& i
== 0 {
959 format
!("self: {}", ty
)
966 .chain(std
::iter
::once(if sig
.c_variadic { Some("...".to_string()) }
else { None }
))
967 .filter_map(|arg
| arg
)
968 .collect
::<Vec
<String
>>()
970 let output
= sig
.output();
971 let output
= if !output
.is_unit() { format!(" -> {}
", output) } else { String::new() };
973 let unsafety = sig.unsafety.prefix_str();
974 let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
976 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
977 // not be present in the `fn` definition, not will we account for renamed
978 // lifetimes between the `impl` and the `trait`, but this should be good enough to
979 // fill in a significant portion of the missing code, and other subsequent
980 // suggestions can help the user fix the code.
982 "{}
fn {}{}
({}
){}{} {{ todo!() }
}",
983 unsafety, ident, generics, args, output, where_clauses
987 /// Return placeholder code for the given associated item.
988 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
989 /// structured suggestion.
990 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
992 ty::AssocKind::Fn => {
993 // We skip the binder here because the binder would deanonymize all
994 // late-bound regions, and we don't want method signatures to show up
995 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
996 // regions just fine, showing `fn(&MyType)`.
999 tcx.fn_sig(assoc.def_id).skip_binder(),
1001 tcx.predicates_of(assoc.def_id),
1005 ty::AssocKind::Type => format!("type {}
= Type
;", assoc.ident),
1006 ty::AssocKind::Const => {
1007 let ty = tcx.type_of(assoc.def_id);
1008 let val = expr::ty_kind_suggestion(ty).unwrap_or("value
");
1009 format!("const {}
: {}
= {}
;", assoc.ident, ty, val)
1014 /// Emit an error when encountering more or less than one variant in a transparent enum.
1015 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1016 let variant_spans: Vec<_> = adt
1019 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
1021 let msg = format!("needs exactly one variant
, but has {}
", adt.variants.len(),);
1022 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent
enum {}
", msg);
1023 err.span_label(sp, &msg);
1024 if let [start @ .., end] = &*variant_spans {
1025 for variant_span in start {
1026 err.span_label(*variant_span, "");
1028 err.span_label(*end, &format!("too many variants
in `{}`
", tcx.def_path_str(did)));
1033 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1035 fn bad_non_zero_sized_fields<'tcx>(
1037 adt: &'tcx ty::AdtDef,
1039 field_spans: impl Iterator<Item = Span>,
1042 let msg = format!("needs exactly one non
-zero
-sized field
, but has {}
", field_count);
1043 let mut err = struct_span_err!(
1047 "{}transparent {} {}
",
1048 if adt.is_enum() { "the variant of a " } else { "" },
1052 err.span_label(sp, &msg);
1053 for sp in field_spans {
1054 err.span_label(sp, "this field is non
-zero
-sized
");
1059 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) {
1064 "expected unit
struct, unit variant or constant
, found {}{}
",
1068 .span_to_snippet(span)
1069 .map_or_else(|_| String::new(), |s| format!(" `{}`
", s)),
1074 /// Controls whether the arguments are tupled. This is used for the call
1077 /// Tupling means that all call-side arguments are packed into a tuple and
1078 /// passed as a single parameter. For example, if tupling is enabled, this
1081 /// fn f(x: (isize, isize))
1083 /// Can be called as:
1090 #[derive(Clone, Eq, PartialEq)]
1091 enum TupleArgumentsFlag {
1096 /// Controls how we perform fallback for unconstrained
1099 /// Do not fallback type variables to opaque types.
1101 /// Perform all possible kinds of fallback, including
1102 /// turning type variables to opaque types.
1106 /// A wrapper for `InferCtxt`'s `in_progress_typeck_results` field.
1107 #[derive(Copy, Clone)]
1108 struct MaybeInProgressTables<'a, 'tcx> {
1109 maybe_typeck_results: Option<&'a RefCell<ty::TypeckResults<'tcx>>>,
1112 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
1113 fn borrow(self) -> Ref<'a, ty::TypeckResults<'tcx>> {
1114 match self.maybe_typeck_results {
1115 Some(typeck_results) => typeck_results.borrow(),
1117 "MaybeInProgressTables
: inh
/fcx
.typeck_results
.borrow() with no typeck results
"
1122 fn borrow_mut(self) -> RefMut<'a, ty::TypeckResults<'tcx>> {
1123 match self.maybe_typeck_results {
1124 Some(typeck_results) => typeck_results.borrow_mut(),
1126 "MaybeInProgressTables
: inh
/fcx
.typeck_results
.borrow_mut() with no typeck results
"
1132 struct CheckItemTypesVisitor<'tcx> {
1136 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
1137 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
1138 check_item_type(self.tcx, i);
1140 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
1141 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
1142 fn visit_foreign_item(&mut self, _: &'tcx hir::ForeignItem<'tcx>) {}
1145 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
1146 debug_assert!(crate_num == LOCAL_CRATE);
1147 tcx.par_body_owners(|body_owner_def_id| {
1148 tcx.ensure().typeck(body_owner_def_id);
1152 fn fatally_break_rust(sess: &Session) {
1153 let handler = sess.diagnostic();
1154 handler.span_bug_no_panic(
1156 "It looks like you're trying to
break rust
; would you like some ICE?
",
1158 handler.note_without_error("the compiler expectedly panicked
. this is a feature
.");
1159 handler.note_without_error(
1160 "we would appreciate a joke overview
: \
1161 https
://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
1163 handler
.note_without_error(&format
!(
1164 "rustc {} running on {}",
1165 option_env
!("CFG_VERSION").unwrap_or("unknown_version"),
1166 config
::host_triple(),
1170 fn potentially_plural_count(count
: usize, word
: &str) -> String
{
1171 format
!("{} {}{}", count
, word
, pluralize
!(count
))