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