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()
 230             } else {
 231                 // standard () main return type
 232                 ty::Binder::dummy(tcx.mk_unit())
 233             };
 234
 235             let se_ty = tcx.mk_fn_ptr(expected_return_type.map_bound(|expected_return_type| {
 236                 tcx.mk_fn_sig(
 237                     iter::empty(),
 238                     expected_return_type,
 239                     false,
 240                     hir::Unsafety::Normal,
 241                     Abi::Rust,
 242                 )
 243             }));
 244
 245             require_same_types(
 246                 tcx,
 247                 &ObligationCause::new(main_span, main_id, ObligationCauseCode::MainFunctionType),
 248                 se_ty,
 249                 tcx.mk_fn_ptr(actual),
 250             );
 251         }
 252         _ => {
 253             span_bug!(main_span, "main has a non-function type: found `{}`", main_t);
 254         }
 255     }
 256 }
 257
 258 fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: LocalDefId) {
 259     let start_id = tcx.hir().local_def_id_to_hir_id(start_def_id);
 260     let start_span = tcx.def_span(start_def_id);
 261     let start_t = tcx.type_of(start_def_id);
 262     match start_t.kind() {
 263         ty::FnDef(..) => {
 264             if let Some(Node::Item(it)) = tcx.hir().find(start_id) {
 265                 if let hir::ItemKind::Fn(ref sig, ref generics, _) = it.kind {
 266                     let mut error = false;
 267                     if !generics.params.is_empty() {
 268                         struct_span_err!(
 269                             tcx.sess,
 270                             generics.span,
 271                             E0132,
 272                             "start function is not allowed to have type parameters"
 273                         )
 274                         .span_label(generics.span, "start function cannot have type parameters")
 275                         .emit();
 276                         error = true;
 277                     }
 278                     if let Some(sp) = generics.where_clause.span() {
 279                         struct_span_err!(
 280                             tcx.sess,
 281                             sp,
 282                             E0647,
 283                             "start function is not allowed to have a `where` clause"
 284                         )
 285                         .span_label(sp, "start function cannot have a `where` clause")
 286                         .emit();
 287                         error = true;
 288                     }
 289                     if let hir::IsAsync::Async = sig.header.asyncness {
 290                         let span = tcx.sess.source_map().guess_head_span(it.span);
 291                         struct_span_err!(
 292                             tcx.sess,
 293                             span,
 294                             E0752,
 295                             "`start` is not allowed to be `async`"
 296                         )
 297                         .span_label(span, "`start` is not allowed to be `async`")
 298                         .emit();
 299                         error = true;
 300                     }
 301
 302                     for attr in it.attrs {
 303                         if tcx.sess.check_name(attr, sym::track_caller) {
 304                             tcx.sess
 305                                 .struct_span_err(
 306                                     attr.span,
 307                                     "`start` is not allowed to be `#[track_caller]`",
 308                                 )
 309                                 .span_label(
 310                                     start_span,
 311                                     "`start` is not allowed to be `#[track_caller]`",
 312                                 )
 313                                 .emit();
 314                             error = true;
 315                         }
 316                     }
 317
 318                     if error {
 319                         return;
 320                     }
 321                 }
 322             }
 323
 324             let se_ty = tcx.mk_fn_ptr(ty::Binder::dummy(tcx.mk_fn_sig(
 325                 [tcx.types.isize, tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))].iter().cloned(),
 326                 tcx.types.isize,
 327                 false,
 328                 hir::Unsafety::Normal,
 329                 Abi::Rust,
 330             )));
 331
 332             require_same_types(
 333                 tcx,
 334                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 335                 se_ty,
 336                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)),
 337             );
 338         }
 339         _ => {
 340             span_bug!(start_span, "start has a non-function type: found `{}`", start_t);
 341         }
 342     }
 343 }
 344
 345 fn check_for_entry_fn(tcx: TyCtxt<'_>) {
 346     match tcx.entry_fn(LOCAL_CRATE) {
 347         Some((def_id, EntryFnType::Main)) => check_main_fn_ty(tcx, def_id),
 348         Some((def_id, EntryFnType::Start)) => check_start_fn_ty(tcx, def_id),
 349         _ => {}
 350     }
 351 }
 352
 353 pub fn provide(providers: &mut Providers) {
 354     collect::provide(providers);
 355     coherence::provide(providers);
 356     check::provide(providers);
 357     variance::provide(providers);
 358     outlives::provide(providers);
 359     impl_wf_check::provide(providers);
 360 }
 361
 362 pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> {
 363     let _prof_timer = tcx.sess.timer("type_check_crate");
 364
 365     // this ensures that later parts of type checking can assume that items
 366     // have valid types and not error
 367     // FIXME(matthewjasper) We shouldn't need to use `track_errors`.
 368     tcx.sess.track_errors(|| {
 369         tcx.sess.time("type_collecting", || {
 370             for &module in tcx.hir().krate().modules.keys() {
 371                 tcx.ensure().collect_mod_item_types(tcx.hir().local_def_id(module));
 372             }
 373         });
 374     })?;
 375
 376     if tcx.features().rustc_attrs {
 377         tcx.sess.track_errors(|| {
 378             tcx.sess.time("outlives_testing", || outlives::test::test_inferred_outlives(tcx));
 379         })?;
 380     }
 381
 382     tcx.sess.track_errors(|| {
 383         tcx.sess.time("impl_wf_inference", || impl_wf_check::impl_wf_check(tcx));
 384     })?;
 385
 386     tcx.sess.track_errors(|| {
 387         tcx.sess.time("coherence_checking", || coherence::check_coherence(tcx));
 388     })?;
 389
 390     if tcx.features().rustc_attrs {
 391         tcx.sess.track_errors(|| {
 392             tcx.sess.time("variance_testing", || variance::test::test_variance(tcx));
 393         })?;
 394     }
 395
 396     tcx.sess.track_errors(|| {
 397         tcx.sess.time("wf_checking", || check::check_wf_new(tcx));
 398     })?;
 399
 400     // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync.
 401     tcx.sess.time("item_types_checking", || {
 402         for &module in tcx.hir().krate().modules.keys() {
 403             tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
 404         }
 405     });
 406
 407     tcx.sess.time("item_bodies_checking", || tcx.typeck_item_bodies(LOCAL_CRATE));
 408
 409     check_unused::check_crate(tcx);
 410     check_for_entry_fn(tcx);
 411
 412     if tcx.sess.err_count() == 0 { Ok(()) } else { Err(ErrorReported) }
 413 }
 414
 415 /// A quasi-deprecated helper used in rustdoc and clippy to get
 416 /// the type from a HIR node.
 417 pub fn hir_ty_to_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'_>) -> Ty<'tcx> {
 418     // In case there are any projections, etc., find the "environment"
 419     // def-ID that will be used to determine the traits/predicates in
 420     // scope.  This is derived from the enclosing item-like thing.
 421     let env_node_id = tcx.hir().get_parent_item(hir_ty.hir_id);
 422     let env_def_id = tcx.hir().local_def_id(env_node_id);
 423     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 424
 425     astconv::AstConv::ast_ty_to_ty(&item_cx, hir_ty)
 426 }
 427
 428 pub fn hir_trait_to_predicates<'tcx>(
 429     tcx: TyCtxt<'tcx>,
 430     hir_trait: &hir::TraitRef<'_>,
 431     self_ty: Ty<'tcx>,
 432 ) -> Bounds<'tcx> {
 433     // In case there are any projections, etc., find the "environment"
 434     // def-ID that will be used to determine the traits/predicates in
 435     // scope.  This is derived from the enclosing item-like thing.
 436     let env_hir_id = tcx.hir().get_parent_item(hir_trait.hir_ref_id);
 437     let env_def_id = tcx.hir().local_def_id(env_hir_id);
 438     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id());
 439     let mut bounds = Bounds::default();
 440     let _ = AstConv::instantiate_poly_trait_ref_inner(
 441         &item_cx,
 442         hir_trait,
 443         DUMMY_SP,
 444         hir::Constness::NotConst,
 445         self_ty,
 446         &mut bounds,
 447         true,
 448     );
 449
 450     bounds
 451 }