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