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