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