compiler/rustc_typeck/src/lib.rs

   1 /*!
   2
   3 # typeck
   4
   5 The type checker is responsible for:
   6
   7 1. Determining the type of each expression.
   8 2. Resolving methods and traits.
   9 3. Guaranteeing that most type rules are met. ("Most?", you say, "why most?"
  10    Well, dear reader, read on.)
  11
  12 The main entry point is [`check_crate()`]. Type checking operates in
  13 several major phases:
  14
  15 1. The collect phase first passes over all items and determines their
  16    type, without examining their "innards".
  17
  18 2. Variance inference then runs to compute the variance of each parameter.
  19
  20 3. Coherence checks for overlapping or orphaned impls.
  21
  22 4. Finally, the check phase then checks function bodies and so forth.
  23    Within the check phase, we check each function body one at a time
  24    (bodies of function expressions are checked as part of the
  25    containing function).  Inference is used to supply types wherever
  26    they are unknown. The actual checking of a function itself has
  27    several phases (check, regionck, writeback), as discussed in the
  28    documentation for the [`check`] module.
  29
  30 The type checker is defined into various submodules which are documented
  31 independently:
  32
  33 - astconv: converts the AST representation of types
  34   into the `ty` representation.
  35
  36 - collect: computes the types of each top-level item and enters them into
  37   the `tcx.types` table for later use.
  38
  39 - coherence: enforces coherence rules, builds some tables.
  40
  41 - variance: variance inference
  42
  43 - outlives: outlives inference
  44
  45 - check: walks over function bodies and type checks them, inferring types for
  46   local variables, type parameters, etc as necessary.
  47
  48 - infer: finds the types to use for each type variable such that
  49   all subtyping and assignment constraints are met.  In essence, the check
  50   module specifies the constraints, and the infer module solves them.
  51
  52 ## Note
  53
  54 This API is completely unstable and subject to change.
  55
  56 */
  57
  58 #![allow(rustc::potential_query_instability)]
  59 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
  60 #![feature(box_patterns)]
  61 #![feature(control_flow_enum)]
  62 #![feature(drain_filter)]
  63 #![feature(hash_drain_filter)]
  64 #![feature(if_let_guard)]
  65 #![feature(is_sorted)]
  66 #![feature(iter_intersperse)]
  67 #![feature(label_break_value)]
  68 #![feature(let_chains)]
  69 #![feature(let_else)]
  70 #![feature(min_specialization)]
  71 #![feature(never_type)]
  72 #![feature(once_cell)]
  73 #![feature(slice_partition_dedup)]
  74 #![feature(try_blocks)]
  75 #![recursion_limit = "256"]
  76
  77 #[macro_use]
  78 extern crate tracing;
  79
  80 #[macro_use]
  81 extern crate rustc_middle;
  82
  83 // These are used by Clippy.
  84 pub mod check;
  85 pub mod expr_use_visitor;
  86
  87 mod astconv;
  88 mod bounds;
  89 mod check_unused;
  90 mod coherence;
  91 mod collect;
  92 mod constrained_generic_params;
  93 mod errors;
  94 pub mod hir_wf_check;
  95 mod impl_wf_check;
  96 mod mem_categorization;
  97 mod outlives;
  98 mod structured_errors;
  99 mod variance;
 100
 101 use rustc_errors::{struct_span_err, ErrorGuaranteed};
 102 use rustc_hir as hir;
 103 use rustc_hir::def_id::DefId;
 104 use rustc_hir::{Node, CRATE_HIR_ID};
 105 use rustc_infer::infer::{InferOk, TyCtxtInferExt};
 106 use rustc_infer::traits::TraitEngineExt as _;
 107 use rustc_middle::middle;
 108 use rustc_middle::ty::query::Providers;
 109 use rustc_middle::ty::{self, Ty, TyCtxt};
 110 use rustc_middle::util;
 111 use rustc_session::config::EntryFnType;
 112 use rustc_span::{symbol::sym, Span, DUMMY_SP};
 113 use rustc_target::spec::abi::Abi;
 114 use rustc_trait_selection::infer::InferCtxtExt;
 115 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
 116 use rustc_trait_selection::traits::{
 117     self, ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt as _,
 118 };
 119
 120 use std::iter;
 121
 122 use astconv::AstConv;
 123 use bounds::Bounds;
 124
 125 fn require_c_abi_if_c_variadic(tcx: TyCtxt<'_>, decl: &hir::FnDecl<'_>, abi: Abi, span: Span) {
 126     match (decl.c_variadic, abi) {
 127         // The function has the correct calling convention, or isn't a "C-variadic" function.
 128         (false, _) | (true, Abi::C { .. }) | (true, Abi::Cdecl { .. }) => {}
 129         // The function is a "C-variadic" function with an incorrect calling convention.
 130         (true, _) => {
 131             let mut err = struct_span_err!(
 132                 tcx.sess,
 133                 span,
 134                 E0045,
 135                 "C-variadic function must have C or cdecl calling convention"
 136             );
 137             err.span_label(span, "C-variadics require C or cdecl calling convention").emit();
 138         }
 139     }
 140 }
 141
 142 fn require_same_types<'tcx>(
 143     tcx: TyCtxt<'tcx>,
 144     cause: &ObligationCause<'tcx>,
 145     expected: Ty<'tcx>,
 146     actual: Ty<'tcx>,
 147 ) -> bool {
 148     tcx.infer_ctxt().enter(|ref infcx| {
 149         let param_env = ty::ParamEnv::empty();
 150         let mut fulfill_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
 151         match infcx.at(cause, param_env).eq(expected, actual) {
 152             Ok(InferOk { obligations, .. }) => {
 153                 fulfill_cx.register_predicate_obligations(infcx, obligations);
 154             }
 155             Err(err) => {
 156                 infcx.report_mismatched_types(cause, expected, actual, err).emit();
 157                 return false;
 158             }
 159         }
 160
 161         match fulfill_cx.select_all_or_error(infcx).as_slice() {
 162             [] => true,
 163             errors => {
 164                 infcx.report_fulfillment_errors(errors, None, false);
 165                 false
 166             }
 167         }
 168     })
 169 }
 170
 171 fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: DefId) {
 172     let main_fnsig = tcx.fn_sig(main_def_id);
 173     let main_span = tcx.def_span(main_def_id);
 174
 175     fn main_fn_diagnostics_hir_id(tcx: TyCtxt<'_>, def_id: DefId, sp: Span) -> hir::HirId {
 176         if let Some(local_def_id) = def_id.as_local() {
 177             let hir_id = tcx.hir().local_def_id_to_hir_id(local_def_id);
 178             let hir_type = tcx.type_of(local_def_id);
 179             if !matches!(hir_type.kind(), ty::FnDef(..)) {
 180                 span_bug!(sp, "main has a non-function type: found `{}`", hir_type);
 181             }
 182             hir_id
 183         } else {
 184             CRATE_HIR_ID
 185         }
 186     }
 187
 188     fn main_fn_generics_params_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 189         if !def_id.is_local() {
 190             return None;
 191         }
 192         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 193         match tcx.hir().find(hir_id) {
 194             Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, ref generics, _), .. })) => {
 195                 if !generics.params.is_empty() {
 196                     Some(generics.span)
 197                 } else {
 198                     None
 199                 }
 200             }
 201             _ => {
 202                 span_bug!(tcx.def_span(def_id), "main has a non-function type");
 203             }
 204         }
 205     }
 206
 207     fn main_fn_where_clauses_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 208         if !def_id.is_local() {
 209             return None;
 210         }
 211         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 212         match tcx.hir().find(hir_id) {
 213             Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, ref generics, _), .. })) => {
 214                 Some(generics.where_clause_span)
 215             }
 216             _ => {
 217                 span_bug!(tcx.def_span(def_id), "main has a non-function type");
 218             }
 219         }
 220     }
 221
 222     fn main_fn_asyncness_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 223         if !def_id.is_local() {
 224             return None;
 225         }
 226         Some(tcx.def_span(def_id))
 227     }
 228
 229     fn main_fn_return_type_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 230         if !def_id.is_local() {
 231             return None;
 232         }
 233         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 234         match tcx.hir().find(hir_id) {
 235             Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(ref fn_sig, _, _), .. })) => {
 236                 Some(fn_sig.decl.output.span())
 237             }
 238             _ => {
 239                 span_bug!(tcx.def_span(def_id), "main has a non-function type");
 240             }
 241         }
 242     }
 243
 244     let mut error = false;
 245     let main_diagnostics_hir_id = main_fn_diagnostics_hir_id(tcx, main_def_id, main_span);
 246     let main_fn_generics = tcx.generics_of(main_def_id);
 247     let main_fn_predicates = tcx.predicates_of(main_def_id);
 248     if main_fn_generics.count() != 0 || !main_fnsig.bound_vars().is_empty() {
 249         let generics_param_span = main_fn_generics_params_span(tcx, main_def_id);
 250         let msg = "`main` function is not allowed to have generic \
 251             parameters";
 252         let mut diag =
 253             struct_span_err!(tcx.sess, generics_param_span.unwrap_or(main_span), E0131, "{}", msg);
 254         if let Some(generics_param_span) = generics_param_span {
 255             let label = "`main` cannot have generic parameters".to_string();
 256             diag.span_label(generics_param_span, label);
 257         }
 258         diag.emit();
 259         error = true;
 260     } else if !main_fn_predicates.predicates.is_empty() {
 261         // generics may bring in implicit predicates, so we skip this check if generics is present.
 262         let generics_where_clauses_span = main_fn_where_clauses_span(tcx, main_def_id);
 263         let mut diag = struct_span_err!(
 264             tcx.sess,
 265             generics_where_clauses_span.unwrap_or(main_span),
 266             E0646,
 267             "`main` function is not allowed to have a `where` clause"
 268         );
 269         if let Some(generics_where_clauses_span) = generics_where_clauses_span {
 270             diag.span_label(generics_where_clauses_span, "`main` cannot have a `where` clause");
 271         }
 272         diag.emit();
 273         error = true;
 274     }
 275
 276     let main_asyncness = tcx.asyncness(main_def_id);
 277     if let hir::IsAsync::Async = main_asyncness {
 278         let mut diag = struct_span_err!(
 279             tcx.sess,
 280             main_span,
 281             E0752,
 282             "`main` function is not allowed to be `async`"
 283         );
 284         let asyncness_span = main_fn_asyncness_span(tcx, main_def_id);
 285         if let Some(asyncness_span) = asyncness_span {
 286             diag.span_label(asyncness_span, "`main` function is not allowed to be `async`");
 287         }
 288         diag.emit();
 289         error = true;
 290     }
 291
 292     for attr in tcx.get_attrs(main_def_id, sym::track_caller) {
 293         tcx.sess
 294             .struct_span_err(attr.span, "`main` function is not allowed to be `#[track_caller]`")
 295             .span_label(main_span, "`main` function is not allowed to be `#[track_caller]`")
 296             .emit();
 297         error = true;
 298     }
 299
 300     if error {
 301         return;
 302     }
 303
 304     let expected_return_type;
 305     if let Some(term_id) = tcx.lang_items().termination() {
 306         let return_ty = main_fnsig.output();
 307         let return_ty_span = main_fn_return_type_span(tcx, main_def_id).unwrap_or(main_span);
 308         if !return_ty.bound_vars().is_empty() {
 309             let msg = "`main` function return type is not allowed to have generic \
 310                     parameters"
 311                 .to_owned();
 312             struct_span_err!(tcx.sess, return_ty_span, E0131, "{}", msg).emit();
 313             error = true;
 314         }
 315         let return_ty = return_ty.skip_binder();
 316         tcx.infer_ctxt().enter(|infcx| {
 317             let cause = traits::ObligationCause::new(
 318                 return_ty_span,
 319                 main_diagnostics_hir_id,
 320                 ObligationCauseCode::MainFunctionType,
 321             );
 322             let mut fulfillment_cx = traits::FulfillmentContext::new();
 323             // normalize any potential projections in the return type, then add
 324             // any possible obligations to the fulfillment context.
 325             // HACK(ThePuzzlemaker) this feels symptomatic of a problem within
 326             // checking trait fulfillment, not this here. I'm not sure why it
 327             // works in the example in `fn test()` given in #88609? This also
 328             // probably isn't the best way to do this.
 329             let InferOk { value: norm_return_ty, obligations } = infcx
 330                 .partially_normalize_associated_types_in(
 331                     cause.clone(),
 332                     ty::ParamEnv::empty(),
 333                     return_ty,
 334                 );
 335             fulfillment_cx.register_predicate_obligations(&infcx, obligations);
 336             fulfillment_cx.register_bound(
 337                 &infcx,
 338                 ty::ParamEnv::empty(),
 339                 norm_return_ty,
 340                 term_id,
 341                 cause,
 342             );
 343             let errors = fulfillment_cx.select_all_or_error(&infcx);
 344             if !errors.is_empty() {
 345                 infcx.report_fulfillment_errors(&errors, None, false);
 346                 error = true;
 347             }
 348         });
 349         // now we can take the return type of the given main function
 350         expected_return_type = main_fnsig.output();
 351     } else {
 352         // standard () main return type
 353         expected_return_type = ty::Binder::dummy(tcx.mk_unit());
 354     }
 355
 356     if error {
 357         return;
 358     }
 359
 360     let se_ty = tcx.mk_fn_ptr(expected_return_type.map_bound(|expected_return_type| {
 361         tcx.mk_fn_sig(iter::empty(), expected_return_type, false, hir::Unsafety::Normal, Abi::Rust)
 362     }));
 363
 364     require_same_types(
 365         tcx,
 366         &ObligationCause::new(
 367             main_span,
 368             main_diagnostics_hir_id,
 369             ObligationCauseCode::MainFunctionType,
 370         ),
 371         se_ty,
 372         tcx.mk_fn_ptr(main_fnsig),
 373     );
 374 }
 375 fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: DefId) {
 376     let start_def_id = start_def_id.expect_local();
 377     let start_id = tcx.hir().local_def_id_to_hir_id(start_def_id);
 378     let start_span = tcx.def_span(start_def_id);
 379     let start_t = tcx.type_of(start_def_id);
 380     match start_t.kind() {
 381         ty::FnDef(..) => {
 382             if let Some(Node::Item(it)) = tcx.hir().find(start_id) {
 383                 if let hir::ItemKind::Fn(ref sig, ref generics, _) = it.kind {
 384                     let mut error = false;
 385                     if !generics.params.is_empty() {
 386                         struct_span_err!(
 387                             tcx.sess,
 388                             generics.span,
 389                             E0132,
 390                             "start function is not allowed to have type parameters"
 391                         )
 392                         .span_label(generics.span, "start function cannot have type parameters")
 393                         .emit();
 394                         error = true;
 395                     }
 396                     if generics.has_where_clause_predicates {
 397                         struct_span_err!(
 398                             tcx.sess,
 399                             generics.where_clause_span,
 400                             E0647,
 401                             "start function is not allowed to have a `where` clause"
 402                         )
 403                         .span_label(
 404                             generics.where_clause_span,
 405                             "start function cannot have a `where` clause",
 406                         )
 407                         .emit();
 408                         error = true;
 409                     }
 410                     if let hir::IsAsync::Async = sig.header.asyncness {
 411                         let span = tcx.def_span(it.def_id);
 412                         struct_span_err!(
 413                             tcx.sess,
 414                             span,
 415                             E0752,
 416                             "`start` is not allowed to be `async`"
 417                         )
 418                         .span_label(span, "`start` is not allowed to be `async`")
 419                         .emit();
 420                         error = true;
 421                     }
 422
 423                     let attrs = tcx.hir().attrs(start_id);
 424                     for attr in attrs {
 425                         if attr.has_name(sym::track_caller) {
 426                             tcx.sess
 427                                 .struct_span_err(
 428                                     attr.span,
 429                                     "`start` is not allowed to be `#[track_caller]`",
 430                                 )
 431                                 .span_label(
 432                                     start_span,
 433                                     "`start` is not allowed to be `#[track_caller]`",
 434                                 )
 435                                 .emit();
 436                             error = true;
 437                         }
 438                     }
 439
 440                     if error {
 441                         return;
 442                     }
 443                 }
 444             }
 445
 446             let se_ty = tcx.mk_fn_ptr(ty::Binder::dummy(tcx.mk_fn_sig(
 447                 [tcx.types.isize, tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))].iter().cloned(),
 448                 tcx.types.isize,
 449                 false,
 450                 hir::Unsafety::Normal,
 451                 Abi::Rust,
 452             )));
 453
 454             require_same_types(
 455                 tcx,
 456                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 457                 se_ty,
 458                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)),
 459             );
 460         }
 461         _ => {
 462             span_bug!(start_span, "start has a non-function type: found `{}`", start_t);
 463         }
 464     }
 465 }
 466
 467 fn check_for_entry_fn(tcx: TyCtxt<'_>) {
 468     match tcx.entry_fn(()) {
 469         Some((def_id, EntryFnType::Main)) => check_main_fn_ty(tcx, def_id),
 470         Some((def_id, EntryFnType::Start)) => check_start_fn_ty(tcx, def_id),
 471         _ => {}
 472     }
 473 }
 474
 475 pub fn provide(providers: &mut Providers) {
 476     collect::provide(providers);
 477     coherence::provide(providers);
 478     check::provide(providers);
 479     variance::provide(providers);
 480     outlives::provide(providers);
 481     impl_wf_check::provide(providers);
 482     hir_wf_check::provide(providers);
 483 }
 484
 485 pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
 486     let _prof_timer = tcx.sess.timer("type_check_crate");
 487
 488     // this ensures that later parts of type checking can assume that items
 489     // have valid types and not error
 490     // FIXME(matthewjasper) We shouldn't need to use `track_errors`.
 491     tcx.sess.track_errors(|| {
 492         tcx.sess.time("type_collecting", || {
 493             tcx.hir().for_each_module(|module| tcx.ensure().collect_mod_item_types(module))
 494         });
 495     })?;
 496
 497     if tcx.features().rustc_attrs {
 498         tcx.sess.track_errors(|| {
 499             tcx.sess.time("outlives_testing", || outlives::test::test_inferred_outlives(tcx));
 500         })?;
 501     }
 502
 503     tcx.sess.track_errors(|| {
 504         tcx.sess.time("impl_wf_inference", || {
 505             tcx.hir().for_each_module(|module| tcx.ensure().check_mod_impl_wf(module))
 506         });
 507     })?;
 508
 509     tcx.sess.track_errors(|| {
 510         tcx.sess.time("coherence_checking", || {
 511             for &trait_def_id in tcx.all_local_trait_impls(()).keys() {
 512                 tcx.ensure().coherent_trait(trait_def_id);
 513             }
 514
 515             // these queries are executed for side-effects (error reporting):
 516             tcx.ensure().crate_inherent_impls(());
 517             tcx.ensure().crate_inherent_impls_overlap_check(());
 518         });
 519     })?;
 520
 521     if tcx.features().rustc_attrs {
 522         tcx.sess.track_errors(|| {
 523             tcx.sess.time("variance_testing", || variance::test::test_variance(tcx));
 524         })?;
 525     }
 526
 527     tcx.sess.track_errors(|| {
 528         tcx.sess.time("wf_checking", || {
 529             tcx.hir().par_for_each_module(|module| tcx.ensure().check_mod_type_wf(module))
 530         });
 531     })?;
 532
 533     // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync.
 534     tcx.sess.time("item_types_checking", || {
 535         tcx.hir().for_each_module(|module| tcx.ensure().check_mod_item_types(module))
 536     });
 537
 538     tcx.sess.time("item_bodies_checking", || tcx.typeck_item_bodies(()));
 539
 540     check_unused::check_crate(tcx);
 541     check_for_entry_fn(tcx);
 542
 543     if let Some(reported) = tcx.sess.has_errors() { Err(reported) } else { Ok(()) }
 544 }
 545
 546 /// A quasi-deprecated helper used in rustdoc and clippy to get
 547 /// the type from a HIR node.
 548 pub fn hir_ty_to_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'_>) -> Ty<'tcx> {
 549     // In case there are any projections, etc., find the "environment"
 550     // def-ID that will be used to determine the traits/predicates in
 551     // scope.  This is derived from the enclosing item-like thing.
 552     let env_def_id = tcx.hir().get_parent_item(hir_ty.hir_id);
 553     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 554     <dyn AstConv<'_>>::ast_ty_to_ty(&item_cx, hir_ty)
 555 }
 556
 557 pub fn hir_trait_to_predicates<'tcx>(
 558     tcx: TyCtxt<'tcx>,
 559     hir_trait: &hir::TraitRef<'_>,
 560     self_ty: Ty<'tcx>,
 561 ) -> Bounds<'tcx> {
 562     // In case there are any projections, etc., find the "environment"
 563     // def-ID that will be used to determine the traits/predicates in
 564     // scope.  This is derived from the enclosing item-like thing.
 565     let env_def_id = tcx.hir().get_parent_item(hir_trait.hir_ref_id);
 566     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 567     let mut bounds = Bounds::default();
 568     let _ = <dyn AstConv<'_>>::instantiate_poly_trait_ref(
 569         &item_cx,
 570         hir_trait,
 571         DUMMY_SP,
 572         ty::BoundConstness::NotConst,
 573         self_ty,
 574         &mut bounds,
 575         true,
 576     );
 577
 578     bounds
 579 }