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 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
  59 #![feature(bindings_after_at)]
  60 #![feature(bool_to_option)]
  61 #![feature(box_syntax)]
  62 #![feature(crate_visibility_modifier)]
  63 #![feature(format_args_capture)]
  64 #![feature(in_band_lifetimes)]
  65 #![feature(is_sorted)]
  66 #![feature(nll)]
  67 #![cfg_attr(bootstrap, feature(or_patterns))]
  68 #![feature(try_blocks)]
  69 #![feature(never_type)]
  70 #![feature(slice_partition_dedup)]
  71 #![feature(control_flow_enum)]
  72 #![recursion_limit = "256"]
  73
  74 #[macro_use]
  75 extern crate tracing;
  76
  77 #[macro_use]
  78 extern crate rustc_middle;
  79
  80 // These are used by Clippy.
  81 pub mod check;
  82 pub mod expr_use_visitor;
  83
  84 mod astconv;
  85 mod bounds;
  86 mod check_unused;
  87 mod coherence;
  88 mod collect;
  89 mod constrained_generic_params;
  90 mod errors;
  91 mod impl_wf_check;
  92 mod mem_categorization;
  93 mod outlives;
  94 mod structured_errors;
  95 mod variance;
  96
  97 use rustc_errors::{struct_span_err, ErrorReported};
  98 use rustc_hir as hir;
  99 use rustc_hir::def_id::{LocalDefId, LOCAL_CRATE};
 100 use rustc_hir::Node;
 101 use rustc_infer::infer::{InferOk, TyCtxtInferExt};
 102 use rustc_infer::traits::TraitEngineExt as _;
 103 use rustc_middle::middle;
 104 use rustc_middle::ty::query::Providers;
 105 use rustc_middle::ty::{self, Ty, TyCtxt};
 106 use rustc_middle::util;
 107 use rustc_session::config::EntryFnType;
 108 use rustc_span::{symbol::sym, Span, DUMMY_SP};
 109 use rustc_target::spec::abi::Abi;
 110 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
 111 use rustc_trait_selection::traits::{
 112     ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt as _,
 113 };
 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     match (decl.c_variadic, abi) {
 122         // The function has the correct calling convention, or isn't a "C-variadic" function.
 123         (false, _) | (true, Abi::C { .. }) | (true, Abi::Cdecl) => {}
 124         // The function is a "C-variadic" function with an incorrect calling convention.
 125         (true, _) => {
 126             let mut err = struct_span_err!(
 127                 tcx.sess,
 128                 span,
 129                 E0045,
 130                 "C-variadic function must have C or cdecl calling convention"
 131             );
 132             err.span_label(span, "C-variadics require C or cdecl calling convention").emit();
 133         }
 134     }
 135 }
 136
 137 fn require_same_types<'tcx>(
 138     tcx: TyCtxt<'tcx>,
 139     cause: &ObligationCause<'tcx>,
 140     expected: Ty<'tcx>,
 141     actual: Ty<'tcx>,
 142 ) -> bool {
 143     tcx.infer_ctxt().enter(|ref infcx| {
 144         let param_env = ty::ParamEnv::empty();
 145         let mut fulfill_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
 146         match infcx.at(&cause, param_env).eq(expected, actual) {
 147             Ok(InferOk { obligations, .. }) => {
 148                 fulfill_cx.register_predicate_obligations(infcx, obligations);
 149             }
 150             Err(err) => {
 151                 infcx.report_mismatched_types(cause, expected, actual, err).emit();
 152                 return false;
 153             }
 154         }
 155
 156         match fulfill_cx.select_all_or_error(infcx) {
 157             Ok(()) => true,
 158             Err(errors) => {
 159                 infcx.report_fulfillment_errors(&errors, None, false);
 160                 false
 161             }
 162         }
 163     })
 164 }
 165
 166 fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: LocalDefId) {
 167     let main_id = tcx.hir().local_def_id_to_hir_id(main_def_id);
 168     let main_span = tcx.def_span(main_def_id);
 169     let main_t = tcx.type_of(main_def_id);
 170     match main_t.kind() {
 171         ty::FnDef(..) => {
 172             if let Some(Node::Item(it)) = tcx.hir().find(main_id) {
 173                 if let hir::ItemKind::Fn(ref sig, ref generics, _) = it.kind {
 174                     let mut error = false;
 175                     if !generics.params.is_empty() {
 176                         let msg = "`main` function is not allowed to have generic \
 177                                    parameters"
 178                             .to_owned();
 179                         let label = "`main` cannot have generic parameters".to_string();
 180                         struct_span_err!(tcx.sess, generics.span, E0131, "{}", msg)
 181                             .span_label(generics.span, label)
 182                             .emit();
 183                         error = true;
 184                     }
 185                     if let Some(sp) = generics.where_clause.span() {
 186                         struct_span_err!(
 187                             tcx.sess,
 188                             sp,
 189                             E0646,
 190                             "`main` function is not allowed to have a `where` clause"
 191                         )
 192                         .span_label(sp, "`main` cannot have a `where` clause")
 193                         .emit();
 194                         error = true;
 195                     }
 196                     if let hir::IsAsync::Async = sig.header.asyncness {
 197                         let span = tcx.sess.source_map().guess_head_span(it.span);
 198                         struct_span_err!(
 199                             tcx.sess,
 200                             span,
 201                             E0752,
 202                             "`main` function is not allowed to be `async`"
 203                         )
 204                         .span_label(span, "`main` function is not allowed to be `async`")
 205                         .emit();
 206                         error = true;
 207                     }
 208
 209                     let attrs = tcx.hir().attrs(main_id);
 210                     for attr in attrs {
 211                         if tcx.sess.check_name(attr, sym::track_caller) {
 212                             tcx.sess
 213                                 .struct_span_err(
 214                                     attr.span,
 215                                     "`main` function is not allowed to be `#[track_caller]`",
 216                                 )
 217                                 .span_label(
 218                                     main_span,
 219                                     "`main` function is not allowed to be `#[track_caller]`",
 220                                 )
 221                                 .emit();
 222                             error = true;
 223                         }
 224                     }
 225
 226                     if error {
 227                         return;
 228                     }
 229                 }
 230             }
 231
 232             let actual = tcx.fn_sig(main_def_id);
 233             let expected_return_type = if tcx.lang_items().termination().is_some() {
 234                 // we take the return type of the given main function, the real check is done
 235                 // in `check_fn`
 236                 actual.output()
 237             } else {
 238                 // standard () main return type
 239                 ty::Binder::dummy(tcx.mk_unit())
 240             };
 241
 242             let se_ty = tcx.mk_fn_ptr(expected_return_type.map_bound(|expected_return_type| {
 243                 tcx.mk_fn_sig(
 244                     iter::empty(),
 245                     expected_return_type,
 246                     false,
 247                     hir::Unsafety::Normal,
 248                     Abi::Rust,
 249                 )
 250             }));
 251
 252             require_same_types(
 253                 tcx,
 254                 &ObligationCause::new(main_span, main_id, ObligationCauseCode::MainFunctionType),
 255                 se_ty,
 256                 tcx.mk_fn_ptr(actual),
 257             );
 258         }
 259         _ => {
 260             span_bug!(main_span, "main has a non-function type: found `{}`", main_t);
 261         }
 262     }
 263 }
 264
 265 fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: LocalDefId) {
 266     let start_id = tcx.hir().local_def_id_to_hir_id(start_def_id);
 267     let start_span = tcx.def_span(start_def_id);
 268     let start_t = tcx.type_of(start_def_id);
 269     match start_t.kind() {
 270         ty::FnDef(..) => {
 271             if let Some(Node::Item(it)) = tcx.hir().find(start_id) {
 272                 if let hir::ItemKind::Fn(ref sig, ref generics, _) = it.kind {
 273                     let mut error = false;
 274                     if !generics.params.is_empty() {
 275                         struct_span_err!(
 276                             tcx.sess,
 277                             generics.span,
 278                             E0132,
 279                             "start function is not allowed to have type parameters"
 280                         )
 281                         .span_label(generics.span, "start function cannot have type parameters")
 282                         .emit();
 283                         error = true;
 284                     }
 285                     if let Some(sp) = generics.where_clause.span() {
 286                         struct_span_err!(
 287                             tcx.sess,
 288                             sp,
 289                             E0647,
 290                             "start function is not allowed to have a `where` clause"
 291                         )
 292                         .span_label(sp, "start function cannot have a `where` clause")
 293                         .emit();
 294                         error = true;
 295                     }
 296                     if let hir::IsAsync::Async = sig.header.asyncness {
 297                         let span = tcx.sess.source_map().guess_head_span(it.span);
 298                         struct_span_err!(
 299                             tcx.sess,
 300                             span,
 301                             E0752,
 302                             "`start` is not allowed to be `async`"
 303                         )
 304                         .span_label(span, "`start` is not allowed to be `async`")
 305                         .emit();
 306                         error = true;
 307                     }
 308
 309                     let attrs = tcx.hir().attrs(start_id);
 310                     for attr in attrs {
 311                         if tcx.sess.check_name(attr, sym::track_caller) {
 312                             tcx.sess
 313                                 .struct_span_err(
 314                                     attr.span,
 315                                     "`start` is not allowed to be `#[track_caller]`",
 316                                 )
 317                                 .span_label(
 318                                     start_span,
 319                                     "`start` is not allowed to be `#[track_caller]`",
 320                                 )
 321                                 .emit();
 322                             error = true;
 323                         }
 324                     }
 325
 326                     if error {
 327                         return;
 328                     }
 329                 }
 330             }
 331
 332             let se_ty = tcx.mk_fn_ptr(ty::Binder::dummy(tcx.mk_fn_sig(
 333                 [tcx.types.isize, tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))].iter().cloned(),
 334                 tcx.types.isize,
 335                 false,
 336                 hir::Unsafety::Normal,
 337                 Abi::Rust,
 338             )));
 339
 340             require_same_types(
 341                 tcx,
 342                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 343                 se_ty,
 344                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)),
 345             );
 346         }
 347         _ => {
 348             span_bug!(start_span, "start has a non-function type: found `{}`", start_t);
 349         }
 350     }
 351 }
 352
 353 fn check_for_entry_fn(tcx: TyCtxt<'_>) {
 354     match tcx.entry_fn(LOCAL_CRATE) {
 355         Some((def_id, EntryFnType::Main)) => check_main_fn_ty(tcx, def_id),
 356         Some((def_id, EntryFnType::Start)) => check_start_fn_ty(tcx, def_id),
 357         _ => {}
 358     }
 359 }
 360
 361 pub fn provide(providers: &mut Providers) {
 362     collect::provide(providers);
 363     coherence::provide(providers);
 364     check::provide(providers);
 365     variance::provide(providers);
 366     outlives::provide(providers);
 367     impl_wf_check::provide(providers);
 368 }
 369
 370 pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> {
 371     let _prof_timer = tcx.sess.timer("type_check_crate");
 372
 373     // this ensures that later parts of type checking can assume that items
 374     // have valid types and not error
 375     // FIXME(matthewjasper) We shouldn't need to use `track_errors`.
 376     tcx.sess.track_errors(|| {
 377         tcx.sess.time("type_collecting", || {
 378             for &module in tcx.hir().krate().modules.keys() {
 379                 tcx.ensure().collect_mod_item_types(module);
 380             }
 381         });
 382     })?;
 383
 384     if tcx.features().rustc_attrs {
 385         tcx.sess.track_errors(|| {
 386             tcx.sess.time("outlives_testing", || outlives::test::test_inferred_outlives(tcx));
 387         })?;
 388     }
 389
 390     tcx.sess.track_errors(|| {
 391         tcx.sess.time("impl_wf_inference", || impl_wf_check::impl_wf_check(tcx));
 392     })?;
 393
 394     tcx.sess.track_errors(|| {
 395         tcx.sess.time("coherence_checking", || coherence::check_coherence(tcx));
 396     })?;
 397
 398     if tcx.features().rustc_attrs {
 399         tcx.sess.track_errors(|| {
 400             tcx.sess.time("variance_testing", || variance::test::test_variance(tcx));
 401         })?;
 402     }
 403
 404     tcx.sess.track_errors(|| {
 405         tcx.sess.time("wf_checking", || check::check_wf_new(tcx));
 406     })?;
 407
 408     // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync.
 409     tcx.sess.time("item_types_checking", || {
 410         for &module in tcx.hir().krate().modules.keys() {
 411             tcx.ensure().check_mod_item_types(module);
 412         }
 413     });
 414
 415     tcx.sess.time("item_bodies_checking", || tcx.typeck_item_bodies(LOCAL_CRATE));
 416
 417     check_unused::check_crate(tcx);
 418     check_for_entry_fn(tcx);
 419
 420     if tcx.sess.err_count() == 0 { Ok(()) } else { Err(ErrorReported) }
 421 }
 422
 423 /// A quasi-deprecated helper used in rustdoc and clippy to get
 424 /// the type from a HIR node.
 425 pub fn hir_ty_to_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'_>) -> Ty<'tcx> {
 426     // In case there are any projections, etc., find the "environment"
 427     // def-ID that will be used to determine the traits/predicates in
 428     // scope.  This is derived from the enclosing item-like thing.
 429     let env_node_id = tcx.hir().get_parent_item(hir_ty.hir_id);
 430     let env_def_id = tcx.hir().local_def_id(env_node_id);
 431     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 432     item_cx.to_ty(hir_ty)
 433 }
 434
 435 pub fn hir_trait_to_predicates<'tcx>(
 436     tcx: TyCtxt<'tcx>,
 437     hir_trait: &hir::TraitRef<'_>,
 438     self_ty: Ty<'tcx>,
 439 ) -> Bounds<'tcx> {
 440     // In case there are any projections, etc., find the "environment"
 441     // def-ID that will be used to determine the traits/predicates in
 442     // scope.  This is derived from the enclosing item-like thing.
 443     let env_hir_id = tcx.hir().get_parent_item(hir_trait.hir_ref_id);
 444     let env_def_id = tcx.hir().local_def_id(env_hir_id);
 445     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 446     let mut bounds = Bounds::default();
 447     let _ = <dyn AstConv<'_>>::instantiate_poly_trait_ref_inner(
 448         &item_cx,
 449         hir_trait,
 450         DUMMY_SP,
 451         hir::Constness::NotConst,
 452         self_ty,
 453         &mut bounds,
 454         true,
 455     );
 456
 457     bounds
 458 }