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