compiler/rustc_hir_analysis/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(let_chains)]
  68 #![feature(min_specialization)]
  69 #![feature(never_type)]
  70 #![feature(once_cell)]
  71 #![feature(slice_partition_dedup)]
  72 #![feature(try_blocks)]
  73 #![feature(is_some_and)]
  74 #![feature(type_alias_impl_trait)]
  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
  86 pub mod astconv;
  87 pub mod autoderef;
  88 mod bounds;
  89 mod check_unused;
  90 mod coherence;
  91 // FIXME: This module shouldn't be public.
  92 pub mod collect;
  93 mod constrained_generic_params;
  94 mod errors;
  95 pub mod hir_wf_check;
  96 mod impl_wf_check;
  97 mod outlives;
  98 pub 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_middle::middle;
 107 use rustc_middle::ty::query::Providers;
 108 use rustc_middle::ty::{self, Ty, TyCtxt};
 109 use rustc_middle::util;
 110 use rustc_session::{config::EntryFnType, parse::feature_err};
 111 use rustc_span::{symbol::sym, Span, DUMMY_SP};
 112 use rustc_target::spec::abi::Abi;
 113 use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
 114 use rustc_trait_selection::traits::{self, ObligationCause, ObligationCauseCode};
 115
 116 use std::iter;
 117 use std::ops::Not;
 118
 119 use astconv::AstConv;
 120 use bounds::Bounds;
 121
 122 fn require_c_abi_if_c_variadic(tcx: TyCtxt<'_>, decl: &hir::FnDecl<'_>, abi: Abi, span: Span) {
 123     const ERROR_HEAD: &str = "C-variadic function must have a compatible calling convention";
 124     const CONVENTIONS_UNSTABLE: &str = "`C`, `cdecl`, `win64`, `sysv64` or `efiapi`";
 125     const CONVENTIONS_STABLE: &str = "`C` or `cdecl`";
 126     const UNSTABLE_EXPLAIN: &str =
 127         "using calling conventions other than `C` or `cdecl` for varargs functions is unstable";
 128
 129     if !decl.c_variadic || matches!(abi, Abi::C { .. } | Abi::Cdecl { .. }) {
 130         return;
 131     }
 132
 133     let extended_abi_support = tcx.features().extended_varargs_abi_support;
 134     let conventions = match (extended_abi_support, abi.supports_varargs()) {
 135         // User enabled additional ABI support for varargs and function ABI matches those ones.
 136         (true, true) => return,
 137
 138         // Using this ABI would be ok, if the feature for additional ABI support was enabled.
 139         // Return CONVENTIONS_STABLE, because we want the other error to look the same.
 140         (false, true) => {
 141             feature_err(
 142                 &tcx.sess.parse_sess,
 143                 sym::extended_varargs_abi_support,
 144                 span,
 145                 UNSTABLE_EXPLAIN,
 146             )
 147             .emit();
 148             CONVENTIONS_STABLE
 149         }
 150
 151         (false, false) => CONVENTIONS_STABLE,
 152         (true, false) => CONVENTIONS_UNSTABLE,
 153     };
 154
 155     let mut err = struct_span_err!(tcx.sess, span, E0045, "{}, like {}", ERROR_HEAD, conventions);
 156     err.span_label(span, ERROR_HEAD).emit();
 157 }
 158
 159 fn require_same_types<'tcx>(
 160     tcx: TyCtxt<'tcx>,
 161     cause: &ObligationCause<'tcx>,
 162     expected: Ty<'tcx>,
 163     actual: Ty<'tcx>,
 164 ) -> bool {
 165     let infcx = &tcx.infer_ctxt().build();
 166     let param_env = ty::ParamEnv::empty();
 167     let errors = match infcx.at(cause, param_env).eq(expected, actual) {
 168         Ok(InferOk { obligations, .. }) => traits::fully_solve_obligations(infcx, obligations),
 169         Err(err) => {
 170             infcx.err_ctxt().report_mismatched_types(cause, expected, actual, err).emit();
 171             return false;
 172         }
 173     };
 174
 175     match &errors[..] {
 176         [] => true,
 177         errors => {
 178             infcx.err_ctxt().report_fulfillment_errors(errors, None);
 179             false
 180         }
 181     }
 182 }
 183
 184 fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: DefId) {
 185     let main_fnsig = tcx.fn_sig(main_def_id);
 186     let main_span = tcx.def_span(main_def_id);
 187
 188     fn main_fn_diagnostics_hir_id(tcx: TyCtxt<'_>, def_id: DefId, sp: Span) -> hir::HirId {
 189         if let Some(local_def_id) = def_id.as_local() {
 190             let hir_id = tcx.hir().local_def_id_to_hir_id(local_def_id);
 191             let hir_type = tcx.type_of(local_def_id);
 192             if !matches!(hir_type.kind(), ty::FnDef(..)) {
 193                 span_bug!(sp, "main has a non-function type: found `{}`", hir_type);
 194             }
 195             hir_id
 196         } else {
 197             CRATE_HIR_ID
 198         }
 199     }
 200
 201     fn main_fn_generics_params_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 202         if !def_id.is_local() {
 203             return None;
 204         }
 205         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 206         match tcx.hir().find(hir_id) {
 207             Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, generics, _), .. })) => {
 208                 generics.params.is_empty().not().then(|| generics.span)
 209             }
 210             _ => {
 211                 span_bug!(tcx.def_span(def_id), "main has a non-function type");
 212             }
 213         }
 214     }
 215
 216     fn main_fn_where_clauses_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 217         if !def_id.is_local() {
 218             return None;
 219         }
 220         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 221         match tcx.hir().find(hir_id) {
 222             Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, generics, _), .. })) => {
 223                 Some(generics.where_clause_span)
 224             }
 225             _ => {
 226                 span_bug!(tcx.def_span(def_id), "main has a non-function type");
 227             }
 228         }
 229     }
 230
 231     fn main_fn_asyncness_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 232         if !def_id.is_local() {
 233             return None;
 234         }
 235         Some(tcx.def_span(def_id))
 236     }
 237
 238     fn main_fn_return_type_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
 239         if !def_id.is_local() {
 240             return None;
 241         }
 242         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 243         match tcx.hir().find(hir_id) {
 244             Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(fn_sig, _, _), .. })) => {
 245                 Some(fn_sig.decl.output.span())
 246             }
 247             _ => {
 248                 span_bug!(tcx.def_span(def_id), "main has a non-function type");
 249             }
 250         }
 251     }
 252
 253     let mut error = false;
 254     let main_diagnostics_hir_id = main_fn_diagnostics_hir_id(tcx, main_def_id, main_span);
 255     let main_fn_generics = tcx.generics_of(main_def_id);
 256     let main_fn_predicates = tcx.predicates_of(main_def_id);
 257     if main_fn_generics.count() != 0 || !main_fnsig.bound_vars().is_empty() {
 258         let generics_param_span = main_fn_generics_params_span(tcx, main_def_id);
 259         let msg = "`main` function is not allowed to have generic \
 260             parameters";
 261         let mut diag =
 262             struct_span_err!(tcx.sess, generics_param_span.unwrap_or(main_span), E0131, "{}", msg);
 263         if let Some(generics_param_span) = generics_param_span {
 264             let label = "`main` cannot have generic parameters";
 265             diag.span_label(generics_param_span, label);
 266         }
 267         diag.emit();
 268         error = true;
 269     } else if !main_fn_predicates.predicates.is_empty() {
 270         // generics may bring in implicit predicates, so we skip this check if generics is present.
 271         let generics_where_clauses_span = main_fn_where_clauses_span(tcx, main_def_id);
 272         let mut diag = struct_span_err!(
 273             tcx.sess,
 274             generics_where_clauses_span.unwrap_or(main_span),
 275             E0646,
 276             "`main` function is not allowed to have a `where` clause"
 277         );
 278         if let Some(generics_where_clauses_span) = generics_where_clauses_span {
 279             diag.span_label(generics_where_clauses_span, "`main` cannot have a `where` clause");
 280         }
 281         diag.emit();
 282         error = true;
 283     }
 284
 285     let main_asyncness = tcx.asyncness(main_def_id);
 286     if let hir::IsAsync::Async = main_asyncness {
 287         let mut diag = struct_span_err!(
 288             tcx.sess,
 289             main_span,
 290             E0752,
 291             "`main` function is not allowed to be `async`"
 292         );
 293         let asyncness_span = main_fn_asyncness_span(tcx, main_def_id);
 294         if let Some(asyncness_span) = asyncness_span {
 295             diag.span_label(asyncness_span, "`main` function is not allowed to be `async`");
 296         }
 297         diag.emit();
 298         error = true;
 299     }
 300
 301     for attr in tcx.get_attrs(main_def_id, sym::track_caller) {
 302         tcx.sess
 303             .struct_span_err(attr.span, "`main` function is not allowed to be `#[track_caller]`")
 304             .span_label(main_span, "`main` function is not allowed to be `#[track_caller]`")
 305             .emit();
 306         error = true;
 307     }
 308
 309     if error {
 310         return;
 311     }
 312
 313     let expected_return_type;
 314     if let Some(term_did) = tcx.lang_items().termination() {
 315         let return_ty = main_fnsig.output();
 316         let return_ty_span = main_fn_return_type_span(tcx, main_def_id).unwrap_or(main_span);
 317         if !return_ty.bound_vars().is_empty() {
 318             let msg = "`main` function return type is not allowed to have generic \
 319                     parameters";
 320             struct_span_err!(tcx.sess, return_ty_span, E0131, "{}", msg).emit();
 321             error = true;
 322         }
 323         let return_ty = return_ty.skip_binder();
 324         let infcx = tcx.infer_ctxt().build();
 325         // Main should have no WC, so empty param env is OK here.
 326         let param_env = ty::ParamEnv::empty();
 327         let cause = traits::ObligationCause::new(
 328             return_ty_span,
 329             main_diagnostics_hir_id,
 330             ObligationCauseCode::MainFunctionType,
 331         );
 332         let ocx = traits::ObligationCtxt::new(&infcx);
 333         let norm_return_ty = ocx.normalize(&cause, param_env, return_ty);
 334         ocx.register_bound(cause, param_env, norm_return_ty, term_did);
 335         let errors = ocx.select_all_or_error();
 336         if !errors.is_empty() {
 337             infcx.err_ctxt().report_fulfillment_errors(&errors, None);
 338             error = true;
 339         }
 340         // now we can take the return type of the given main function
 341         expected_return_type = main_fnsig.output();
 342     } else {
 343         // standard () main return type
 344         expected_return_type = ty::Binder::dummy(tcx.mk_unit());
 345     }
 346
 347     if error {
 348         return;
 349     }
 350
 351     let se_ty = tcx.mk_fn_ptr(expected_return_type.map_bound(|expected_return_type| {
 352         tcx.mk_fn_sig(iter::empty(), expected_return_type, false, hir::Unsafety::Normal, Abi::Rust)
 353     }));
 354
 355     require_same_types(
 356         tcx,
 357         &ObligationCause::new(
 358             main_span,
 359             main_diagnostics_hir_id,
 360             ObligationCauseCode::MainFunctionType,
 361         ),
 362         se_ty,
 363         tcx.mk_fn_ptr(main_fnsig),
 364     );
 365 }
 366 fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: DefId) {
 367     let start_def_id = start_def_id.expect_local();
 368     let start_id = tcx.hir().local_def_id_to_hir_id(start_def_id);
 369     let start_span = tcx.def_span(start_def_id);
 370     let start_t = tcx.type_of(start_def_id);
 371     match start_t.kind() {
 372         ty::FnDef(..) => {
 373             if let Some(Node::Item(it)) = tcx.hir().find(start_id) {
 374                 if let hir::ItemKind::Fn(sig, generics, _) = &it.kind {
 375                     let mut error = false;
 376                     if !generics.params.is_empty() {
 377                         struct_span_err!(
 378                             tcx.sess,
 379                             generics.span,
 380                             E0132,
 381                             "start function is not allowed to have type parameters"
 382                         )
 383                         .span_label(generics.span, "start function cannot have type parameters")
 384                         .emit();
 385                         error = true;
 386                     }
 387                     if generics.has_where_clause_predicates {
 388                         struct_span_err!(
 389                             tcx.sess,
 390                             generics.where_clause_span,
 391                             E0647,
 392                             "start function is not allowed to have a `where` clause"
 393                         )
 394                         .span_label(
 395                             generics.where_clause_span,
 396                             "start function cannot have a `where` clause",
 397                         )
 398                         .emit();
 399                         error = true;
 400                     }
 401                     if let hir::IsAsync::Async = sig.header.asyncness {
 402                         let span = tcx.def_span(it.owner_id);
 403                         struct_span_err!(
 404                             tcx.sess,
 405                             span,
 406                             E0752,
 407                             "`start` is not allowed to be `async`"
 408                         )
 409                         .span_label(span, "`start` is not allowed to be `async`")
 410                         .emit();
 411                         error = true;
 412                     }
 413
 414                     let attrs = tcx.hir().attrs(start_id);
 415                     for attr in attrs {
 416                         if attr.has_name(sym::track_caller) {
 417                             tcx.sess
 418                                 .struct_span_err(
 419                                     attr.span,
 420                                     "`start` is not allowed to be `#[track_caller]`",
 421                                 )
 422                                 .span_label(
 423                                     start_span,
 424                                     "`start` is not allowed to be `#[track_caller]`",
 425                                 )
 426                                 .emit();
 427                             error = true;
 428                         }
 429                     }
 430
 431                     if error {
 432                         return;
 433                     }
 434                 }
 435             }
 436
 437             let se_ty = tcx.mk_fn_ptr(ty::Binder::dummy(tcx.mk_fn_sig(
 438                 [tcx.types.isize, tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))].iter().cloned(),
 439                 tcx.types.isize,
 440                 false,
 441                 hir::Unsafety::Normal,
 442                 Abi::Rust,
 443             )));
 444
 445             require_same_types(
 446                 tcx,
 447                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 448                 se_ty,
 449                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)),
 450             );
 451         }
 452         _ => {
 453             span_bug!(start_span, "start has a non-function type: found `{}`", start_t);
 454         }
 455     }
 456 }
 457
 458 fn check_for_entry_fn(tcx: TyCtxt<'_>) {
 459     match tcx.entry_fn(()) {
 460         Some((def_id, EntryFnType::Main { .. })) => check_main_fn_ty(tcx, def_id),
 461         Some((def_id, EntryFnType::Start)) => check_start_fn_ty(tcx, def_id),
 462         _ => {}
 463     }
 464 }
 465
 466 pub fn provide(providers: &mut Providers) {
 467     collect::provide(providers);
 468     coherence::provide(providers);
 469     check::provide(providers);
 470     variance::provide(providers);
 471     outlives::provide(providers);
 472     impl_wf_check::provide(providers);
 473     hir_wf_check::provide(providers);
 474 }
 475
 476 pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
 477     let _prof_timer = tcx.sess.timer("type_check_crate");
 478
 479     // this ensures that later parts of type checking can assume that items
 480     // have valid types and not error
 481     // FIXME(matthewjasper) We shouldn't need to use `track_errors`.
 482     tcx.sess.track_errors(|| {
 483         tcx.sess.time("type_collecting", || {
 484             tcx.hir().for_each_module(|module| tcx.ensure().collect_mod_item_types(module))
 485         });
 486     })?;
 487
 488     if tcx.features().rustc_attrs {
 489         tcx.sess.track_errors(|| {
 490             tcx.sess.time("outlives_testing", || outlives::test::test_inferred_outlives(tcx));
 491         })?;
 492     }
 493
 494     tcx.sess.track_errors(|| {
 495         tcx.sess.time("impl_wf_inference", || {
 496             tcx.hir().for_each_module(|module| tcx.ensure().check_mod_impl_wf(module))
 497         });
 498     })?;
 499
 500     tcx.sess.track_errors(|| {
 501         tcx.sess.time("coherence_checking", || {
 502             for &trait_def_id in tcx.all_local_trait_impls(()).keys() {
 503                 tcx.ensure().coherent_trait(trait_def_id);
 504             }
 505
 506             // these queries are executed for side-effects (error reporting):
 507             tcx.ensure().crate_inherent_impls(());
 508             tcx.ensure().crate_inherent_impls_overlap_check(());
 509         });
 510     })?;
 511
 512     if tcx.features().rustc_attrs {
 513         tcx.sess.track_errors(|| {
 514             tcx.sess.time("variance_testing", || variance::test::test_variance(tcx));
 515         })?;
 516     }
 517
 518     tcx.sess.track_errors(|| {
 519         tcx.sess.time("wf_checking", || {
 520             tcx.hir().par_for_each_module(|module| tcx.ensure().check_mod_type_wf(module))
 521         });
 522     })?;
 523
 524     // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync.
 525     tcx.sess.time("item_types_checking", || {
 526         tcx.hir().for_each_module(|module| tcx.ensure().check_mod_item_types(module))
 527     });
 528
 529     tcx.sess.time("item_bodies_checking", || tcx.typeck_item_bodies(()));
 530
 531     check_unused::check_crate(tcx);
 532     check_for_entry_fn(tcx);
 533
 534     if let Some(reported) = tcx.sess.has_errors() { Err(reported) } else { Ok(()) }
 535 }
 536
 537 /// A quasi-deprecated helper used in rustdoc and clippy to get
 538 /// the type from a HIR node.
 539 pub fn hir_ty_to_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'_>) -> Ty<'tcx> {
 540     // In case there are any projections, etc., find the "environment"
 541     // def-ID that will be used to determine the traits/predicates in
 542     // scope. This is derived from the enclosing item-like thing.
 543     let env_def_id = tcx.hir().get_parent_item(hir_ty.hir_id);
 544     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 545     item_cx.astconv().ast_ty_to_ty(hir_ty)
 546 }
 547
 548 pub fn hir_trait_to_predicates<'tcx>(
 549     tcx: TyCtxt<'tcx>,
 550     hir_trait: &hir::TraitRef<'_>,
 551     self_ty: Ty<'tcx>,
 552 ) -> Bounds<'tcx> {
 553     // In case there are any projections, etc., find the "environment"
 554     // def-ID that will be used to determine the traits/predicates in
 555     // scope. This is derived from the enclosing item-like thing.
 556     let env_def_id = tcx.hir().get_parent_item(hir_trait.hir_ref_id);
 557     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 558     let mut bounds = Bounds::default();
 559     let _ = &item_cx.astconv().instantiate_poly_trait_ref(
 560         hir_trait,
 561         DUMMY_SP,
 562         ty::BoundConstness::NotConst,
 563         self_ty,
 564         &mut bounds,
 565         true,
 566     );
 567
 568     bounds
 569 }