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
::source_map
::DUMMY_SP
;
125 use rustc_span
::symbol
::{kw, Ident}
;
126 use rustc_span
::{self, BytePos, MultiSpan, Span}
;
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
);
503 &hir
::Generics
::empty(),
510 check_abi(tcx
, span
, fn_sig
.abi());
512 // Compute the fty from point of view of inside the fn.
513 let fn_sig
= tcx
.liberate_late_bound_regions(def_id
.to_def_id(), fn_sig
);
514 let fn_sig
= inh
.normalize_associated_types_in(
521 let fn_sig
= fixup_opaque_types(tcx
, fn_sig
);
523 let fcx
= check_fn(&inh
, param_env
, fn_sig
, decl
, id
, body
, None
).0;
526 let fcx
= FnCtxt
::new(&inh
, param_env
, body
.value
.hir_id
);
527 let expected_type
= body_ty
528 .and_then(|ty
| match ty
.kind
{
529 hir
::TyKind
::Infer
=> Some(AstConv
::ast_ty_to_ty(&fcx
, ty
)),
532 .unwrap_or_else(|| match tcx
.hir().get(id
) {
533 Node
::AnonConst(_
) => match tcx
.hir().get(tcx
.hir().get_parent_node(id
)) {
534 Node
::Expr(&hir
::Expr
{
535 kind
: hir
::ExprKind
::ConstBlock(ref anon_const
),
537 }) if anon_const
.hir_id
== id
=> fcx
.next_ty_var(TypeVariableOrigin
{
538 kind
: TypeVariableOriginKind
::TypeInference
,
546 let expected_type
= fcx
.normalize_associated_types_in(body
.value
.span
, expected_type
);
547 fcx
.require_type_is_sized(expected_type
, body
.value
.span
, traits
::ConstSized
);
549 let revealed_ty
= if tcx
.features().impl_trait_in_bindings
{
550 fcx
.instantiate_opaque_types_from_value(id
, expected_type
, body
.value
.span
)
555 // Gather locals in statics (because of block expressions).
556 GatherLocalsVisitor
::new(&fcx
, id
).visit_body(body
);
558 fcx
.check_expr_coercable_to_type(&body
.value
, revealed_ty
, None
);
560 fcx
.write_ty(id
, revealed_ty
);
565 // All type checking constraints were added, try to fallback unsolved variables.
566 fcx
.select_obligations_where_possible(false, |_
| {}
);
567 let mut fallback_has_occurred
= false;
569 // We do fallback in two passes, to try to generate
570 // better error messages.
571 // The first time, we do *not* replace opaque types.
572 for ty
in &fcx
.unsolved_variables() {
573 fallback_has_occurred
|= fcx
.fallback_if_possible(ty
, FallbackMode
::NoOpaque
);
575 // We now see if we can make progress. This might
576 // cause us to unify inference variables for opaque types,
577 // since we may have unified some other type variables
578 // during the first phase of fallback.
579 // This means that we only replace inference variables with their underlying
580 // opaque types as a last resort.
582 // In code like this:
585 // type MyType = impl Copy;
586 // fn produce() -> MyType { true }
587 // fn bad_produce() -> MyType { panic!() }
590 // we want to unify the opaque inference variable in `bad_produce`
591 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
592 // This will produce a nice error message about conflicting concrete
593 // types for `MyType`.
595 // If we had tried to fallback the opaque inference variable to `MyType`,
596 // we will generate a confusing type-check error that does not explicitly
597 // refer to opaque types.
598 fcx
.select_obligations_where_possible(fallback_has_occurred
, |_
| {}
);
600 // We now run fallback again, but this time we allow it to replace
601 // unconstrained opaque type variables, in addition to performing
602 // other kinds of fallback.
603 for ty
in &fcx
.unsolved_variables() {
604 fallback_has_occurred
|= fcx
.fallback_if_possible(ty
, FallbackMode
::All
);
607 // See if we can make any more progress.
608 fcx
.select_obligations_where_possible(fallback_has_occurred
, |_
| {}
);
610 // Even though coercion casts provide type hints, we check casts after fallback for
611 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
614 // Closure and generator analysis may run after fallback
615 // because they don't constrain other type variables.
616 fcx
.closure_analyze(body
);
617 assert
!(fcx
.deferred_call_resolutions
.borrow().is_empty());
618 fcx
.resolve_generator_interiors(def_id
.to_def_id());
620 for (ty
, span
, code
) in fcx
.deferred_sized_obligations
.borrow_mut().drain(..) {
621 let ty
= fcx
.normalize_ty(span
, ty
);
622 fcx
.require_type_is_sized(ty
, span
, code
);
625 fcx
.select_all_obligations_or_error();
627 if fn_decl
.is_some() {
628 fcx
.regionck_fn(id
, body
);
630 fcx
.regionck_expr(body
);
633 fcx
.resolve_type_vars_in_body(body
)
636 // Consistency check our TypeckResults instance can hold all ItemLocalIds
637 // it will need to hold.
638 assert_eq
!(typeck_results
.hir_owner
, id
.owner
);
643 /// When `check_fn` is invoked on a generator (i.e., a body that
644 /// includes yield), it returns back some information about the yield
646 struct GeneratorTypes
<'tcx
> {
647 /// Type of generator argument / values returned by `yield`.
650 /// Type of value that is yielded.
653 /// Types that are captured (see `GeneratorInterior` for more).
656 /// Indicates if the generator is movable or static (immovable).
657 movability
: hir
::Movability
,
660 /// Given a `DefId` for an opaque type in return position, find its parent item's return
662 fn get_owner_return_paths(
665 ) -> Option
<(hir
::HirId
, ReturnsVisitor
<'tcx
>)> {
666 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
667 let id
= tcx
.hir().get_parent_item(hir_id
);
671 .and_then(|(hir_id
, node
)| node
.body_id().map(|b
| (hir_id
, b
)))
672 .map(|(hir_id
, body_id
)| {
673 let body
= tcx
.hir().body(body_id
);
674 let mut visitor
= ReturnsVisitor
::default();
675 visitor
.visit_body(body
);
680 /// Emit an error for recursive opaque types in a `let` binding.
681 fn binding_opaque_type_cycle_error(
685 partially_expanded_type
: Ty
<'tcx
>,
687 let mut err
= struct_span_err
!(tcx
.sess
, span
, E0720
, "cannot resolve opaque type");
688 err
.span_label(span
, "cannot resolve opaque type");
689 // Find the owner that declared this `impl Trait` type.
690 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
691 let mut prev_hir_id
= hir_id
;
692 let mut hir_id
= tcx
.hir().get_parent_node(hir_id
);
693 while let Some(node
) = tcx
.hir().find(hir_id
) {
695 hir
::Node
::Local(hir
::Local
{
699 source
: hir
::LocalSource
::Normal
,
702 err
.span_label(pat
.span
, "this binding might not have a concrete type");
703 err
.span_suggestion_verbose(
704 ty
.span
.shrink_to_hi(),
705 "set the binding to a value for a concrete type to be resolved",
706 " = /* value */".to_string(),
707 Applicability
::HasPlaceholders
,
710 hir
::Node
::Local(hir
::Local
{
712 source
: hir
::LocalSource
::Normal
,
715 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
717 tcx
.typeck(tcx
.hir().local_def_id(tcx
.hir().get_parent_item(hir_id
)));
718 if let Some(ty
) = typeck_results
.node_type_opt(expr
.hir_id
) {
722 "this is of type `{}`, which doesn't constrain \
723 `{}` enough to arrive to a concrete type",
724 ty
, partially_expanded_type
731 if prev_hir_id
== hir_id
{
734 prev_hir_id
= hir_id
;
735 hir_id
= tcx
.hir().get_parent_node(hir_id
);
740 // Forbid defining intrinsics in Rust code,
741 // as they must always be defined by the compiler.
742 fn fn_maybe_err(tcx
: TyCtxt
<'_
>, sp
: Span
, abi
: Abi
) {
743 if let Abi
::RustIntrinsic
| Abi
::PlatformIntrinsic
= abi
{
744 tcx
.sess
.span_err(sp
, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
748 fn maybe_check_static_with_link_section(tcx
: TyCtxt
<'_
>, id
: LocalDefId
, span
: Span
) {
749 // Only restricted on wasm32 target for now
750 if !tcx
.sess
.opts
.target_triple
.triple().starts_with("wasm32") {
754 // If `#[link_section]` is missing, then nothing to verify
755 let attrs
= tcx
.codegen_fn_attrs(id
);
756 if attrs
.link_section
.is_none() {
760 // For the wasm32 target statics with `#[link_section]` are placed into custom
761 // sections of the final output file, but this isn't link custom sections of
762 // other executable formats. Namely we can only embed a list of bytes,
763 // nothing with pointers to anything else or relocations. If any relocation
764 // show up, reject them here.
765 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
766 // the consumer's responsibility to ensure all bytes that have been read
767 // have defined values.
768 match tcx
.eval_static_initializer(id
.to_def_id()) {
770 if alloc
.relocations().len() != 0 {
771 let msg
= "statics with a custom `#[link_section]` must be a \
772 simple list of bytes on the wasm target with no \
773 extra levels of indirection such as references";
774 tcx
.sess
.span_err(span
, msg
);
781 fn report_forbidden_specialization(
783 impl_item
: &hir
::ImplItem
<'_
>,
786 let mut err
= struct_span_err
!(
790 "`{}` specializes an item from a parent `impl`, but \
791 that item is not marked `default`",
794 err
.span_label(impl_item
.span
, format
!("cannot specialize default item `{}`", impl_item
.ident
));
796 match tcx
.span_of_impl(parent_impl
) {
798 err
.span_label(span
, "parent `impl` is here");
800 "to specialize, `{}` in the parent `impl` must be marked `default`",
805 err
.note(&format
!("parent implementation is in crate `{}`", cname
));
812 fn missing_items_err(
815 missing_items
: &[ty
::AssocItem
],
816 full_impl_span
: Span
,
818 let missing_items_msg
= missing_items
820 .map(|trait_item
| trait_item
.ident
.to_string())
824 let mut err
= struct_span_err
!(
828 "not all trait items implemented, missing: `{}`",
831 err
.span_label(impl_span
, format
!("missing `{}` in implementation", missing_items_msg
));
833 // `Span` before impl block closing brace.
834 let hi
= full_impl_span
.hi() - BytePos(1);
835 // Point at the place right before the closing brace of the relevant `impl` to suggest
836 // adding the associated item at the end of its body.
837 let sugg_sp
= full_impl_span
.with_lo(hi
).with_hi(hi
);
838 // Obtain the level of indentation ending in `sugg_sp`.
839 let indentation
= tcx
.sess
.source_map().span_to_margin(sugg_sp
).unwrap_or(0);
840 // Make the whitespace that will make the suggestion have the right indentation.
841 let padding
: String
= (0..indentation
).map(|_
| " ").collect();
843 for trait_item
in missing_items
{
844 let snippet
= suggestion_signature(&trait_item
, tcx
);
845 let code
= format
!("{}{}\n{}", padding
, snippet
, padding
);
846 let msg
= format
!("implement the missing item: `{}`", snippet
);
847 let appl
= Applicability
::HasPlaceholders
;
848 if let Some(span
) = tcx
.hir().span_if_local(trait_item
.def_id
) {
849 err
.span_label(span
, format
!("`{}` from trait", trait_item
.ident
));
850 err
.tool_only_span_suggestion(sugg_sp
, &msg
, code
, appl
);
852 err
.span_suggestion_hidden(sugg_sp
, &msg
, code
, appl
);
858 /// Resugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.
859 fn bounds_from_generic_predicates
<'tcx
>(
861 predicates
: ty
::GenericPredicates
<'tcx
>,
862 ) -> (String
, String
) {
863 let mut types
: FxHashMap
<Ty
<'tcx
>, Vec
<DefId
>> = FxHashMap
::default();
864 let mut projections
= vec
![];
865 for (predicate
, _
) in predicates
.predicates
{
866 debug
!("predicate {:?}", predicate
);
867 let bound_predicate
= predicate
.kind();
868 match bound_predicate
.skip_binder() {
869 ty
::PredicateKind
::Trait(trait_predicate
, _
) => {
870 let entry
= types
.entry(trait_predicate
.self_ty()).or_default();
871 let def_id
= trait_predicate
.def_id();
872 if Some(def_id
) != tcx
.lang_items().sized_trait() {
873 // Type params are `Sized` by default, do not add that restriction to the list
874 // if it is a positive requirement.
875 entry
.push(trait_predicate
.def_id());
878 ty
::PredicateKind
::Projection(projection_pred
) => {
879 projections
.push(bound_predicate
.rebind(projection_pred
));
884 let generics
= if types
.is_empty() {
891 .filter_map(|t
| match t
.kind() {
892 ty
::Param(_
) => Some(t
.to_string()),
893 // Avoid suggesting the following:
894 // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
901 let mut where_clauses
= vec
![];
902 for (ty
, bounds
) in types
{
903 for bound
in &bounds
{
904 where_clauses
.push(format
!("{}: {}", ty
, tcx
.def_path_str(*bound
)));
907 for projection
in &projections
{
908 let p
= projection
.skip_binder();
909 // FIXME: this is not currently supported syntax, we should be looking at the `types` and
910 // insert the associated types where they correspond, but for now let's be "lazy" and
911 // propose this instead of the following valid resugaring:
912 // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
913 where_clauses
.push(format
!("{} = {}", tcx
.def_path_str(p
.projection_ty
.item_def_id
), p
.ty
));
915 let where_clauses
= if where_clauses
.is_empty() {
918 format
!(" where {}", where_clauses
.join(", "))
920 (generics
, where_clauses
)
923 /// Return placeholder code for the given function.
924 fn fn_sig_suggestion
<'tcx
>(
926 sig
: ty
::FnSig
<'tcx
>,
928 predicates
: ty
::GenericPredicates
<'tcx
>,
929 assoc
: &ty
::AssocItem
,
936 Some(match ty
.kind() {
937 ty
::Param(_
) if assoc
.fn_has_self_parameter
&& i
== 0 => "self".to_string(),
938 ty
::Ref(reg
, ref_ty
, mutability
) if i
== 0 => {
939 let reg
= match &format
!("{}", reg
)[..] {
940 "'_" | "" => String
::new(),
941 reg
=> format
!("{} ", reg
),
943 if assoc
.fn_has_self_parameter
{
944 match ref_ty
.kind() {
945 ty
::Param(param
) if param
.name
== kw
::SelfUpper
=> {
946 format
!("&{}{}self", reg
, mutability
.prefix_str())
949 _
=> format
!("self: {}", ty
),
956 if assoc
.fn_has_self_parameter
&& i
== 0 {
957 format
!("self: {}", ty
)
964 .chain(std
::iter
::once(if sig
.c_variadic { Some("...".to_string()) }
else { None }
))
965 .filter_map(|arg
| arg
)
966 .collect
::<Vec
<String
>>()
968 let output
= sig
.output();
969 let output
= if !output
.is_unit() { format!(" -> {}
", output) } else { String::new() };
971 let unsafety = sig.unsafety.prefix_str();
972 let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
974 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
975 // not be present in the `fn` definition, not will we account for renamed
976 // lifetimes between the `impl` and the `trait`, but this should be good enough to
977 // fill in a significant portion of the missing code, and other subsequent
978 // suggestions can help the user fix the code.
980 "{}
fn {}{}
({}
){}{} {{ todo!() }
}",
981 unsafety, ident, generics, args, output, where_clauses
985 /// Return placeholder code for the given associated item.
986 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
987 /// structured suggestion.
988 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
990 ty::AssocKind::Fn => {
991 // We skip the binder here because the binder would deanonymize all
992 // late-bound regions, and we don't want method signatures to show up
993 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
994 // regions just fine, showing `fn(&MyType)`.
997 tcx.fn_sig(assoc.def_id).skip_binder(),
999 tcx.predicates_of(assoc.def_id),
1003 ty::AssocKind::Type => format!("type {}
= Type
;", assoc.ident),
1004 ty::AssocKind::Const => {
1005 let ty = tcx.type_of(assoc.def_id);
1006 let val = expr::ty_kind_suggestion(ty).unwrap_or("value
");
1007 format!("const {}
: {}
= {}
;", assoc.ident, ty, val)
1012 /// Emit an error when encountering more or less than one variant in a transparent enum.
1013 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1014 let variant_spans: Vec<_> = adt
1017 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
1019 let msg = format!("needs exactly one variant
, but has {}
", adt.variants.len(),);
1020 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent
enum {}
", msg);
1021 err.span_label(sp, &msg);
1022 if let [start @ .., end] = &*variant_spans {
1023 for variant_span in start {
1024 err.span_label(*variant_span, "");
1026 err.span_label(*end, &format!("too many variants
in `{}`
", tcx.def_path_str(did)));
1031 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1033 fn bad_non_zero_sized_fields<'tcx>(
1035 adt: &'tcx ty::AdtDef,
1037 field_spans: impl Iterator<Item = Span>,
1040 let msg = format!("needs exactly one non
-zero
-sized field
, but has {}
", field_count);
1041 let mut err = struct_span_err!(
1045 "{}transparent {} {}
",
1046 if adt.is_enum() { "the variant of a " } else { "" },
1050 err.span_label(sp, &msg);
1051 for sp in field_spans {
1052 err.span_label(sp, "this field is non
-zero
-sized
");
1057 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) {
1062 "expected unit
struct, unit variant or constant
, found {}{}
",
1064 tcx.sess.source_map().span_to_snippet(span).map_or(String::new(), |s| format!(" `{}`
", s)),
1069 /// Controls whether the arguments are tupled. This is used for the call
1072 /// Tupling means that all call-side arguments are packed into a tuple and
1073 /// passed as a single parameter. For example, if tupling is enabled, this
1076 /// fn f(x: (isize, isize))
1078 /// Can be called as:
1085 #[derive(Clone, Eq, PartialEq)]
1086 enum TupleArgumentsFlag {
1091 /// Controls how we perform fallback for unconstrained
1094 /// Do not fallback type variables to opaque types.
1096 /// Perform all possible kinds of fallback, including
1097 /// turning type variables to opaque types.
1101 /// A wrapper for `InferCtxt`'s `in_progress_typeck_results` field.
1102 #[derive(Copy, Clone)]
1103 struct MaybeInProgressTables<'a, 'tcx> {
1104 maybe_typeck_results: Option<&'a RefCell<ty::TypeckResults<'tcx>>>,
1107 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
1108 fn borrow(self) -> Ref<'a, ty::TypeckResults<'tcx>> {
1109 match self.maybe_typeck_results {
1110 Some(typeck_results) => typeck_results.borrow(),
1112 "MaybeInProgressTables
: inh
/fcx
.typeck_results
.borrow() with no typeck results
"
1117 fn borrow_mut(self) -> RefMut<'a, ty::TypeckResults<'tcx>> {
1118 match self.maybe_typeck_results {
1119 Some(typeck_results) => typeck_results.borrow_mut(),
1121 "MaybeInProgressTables
: inh
/fcx
.typeck_results
.borrow_mut() with no typeck results
"
1127 struct CheckItemTypesVisitor<'tcx> {
1131 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
1132 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
1133 check_item_type(self.tcx, i);
1135 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
1136 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
1137 fn visit_foreign_item(&mut self, _: &'tcx hir::ForeignItem<'tcx>) {}
1140 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
1141 debug_assert!(crate_num == LOCAL_CRATE);
1142 tcx.par_body_owners(|body_owner_def_id| {
1143 tcx.ensure().typeck(body_owner_def_id);
1147 fn fatally_break_rust(sess: &Session) {
1148 let handler = sess.diagnostic();
1149 handler.span_bug_no_panic(
1151 "It looks like you're trying to
break rust
; would you like some ICE?
",
1153 handler.note_without_error("the compiler expectedly panicked
. this is a feature
.");
1154 handler.note_without_error(
1155 "we would appreciate a joke overview
: \
1156 https
://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
1158 handler
.note_without_error(&format
!(
1159 "rustc {} running on {}",
1160 option_env
!("CFG_VERSION").unwrap_or("unknown_version"),
1161 config
::host_triple(),
1165 fn potentially_plural_count(count
: usize, word
: &str) -> String
{
1166 format
!("{} {}{}", count
, word
, pluralize
!(count
))