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 use astconv::{AstConv, Bounds};
 118 pub use collect::checked_type_of;
 119
 120 pub struct TypeAndSubsts<'tcx> {
 121     substs: SubstsRef<'tcx>,
 122     ty: Ty<'tcx>,
 123 }
 124
 125 fn check_type_alias_enum_variants_enabled<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
 126                                                           span: Span) {
 127     if !tcx.features().type_alias_enum_variants {
 128         let mut err = tcx.sess.struct_span_err(
 129             span,
 130             "enum variants on type aliases are experimental"
 131         );
 132         if nightly_options::is_nightly_build() {
 133             help!(&mut err,
 134                 "add `#![feature(type_alias_enum_variants)]` to the \
 135                 crate attributes to enable");
 136         }
 137         err.emit();
 138     }
 139 }
 140
 141 fn require_c_abi_if_c_variadic(tcx: TyCtxt<'_, '_, '_>,
 142                                decl: &hir::FnDecl,
 143                                abi: Abi,
 144                                span: Span) {
 145     if decl.c_variadic && !(abi == Abi::C || abi == Abi::Cdecl) {
 146         let mut err = struct_span_err!(tcx.sess, span, E0045,
 147             "C-variadic function must have C or cdecl calling convention");
 148         err.span_label(span, "C-variadics require C or cdecl calling convention").emit();
 149     }
 150 }
 151
 152 fn require_same_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 153                                 cause: &ObligationCause<'tcx>,
 154                                 expected: Ty<'tcx>,
 155                                 actual: Ty<'tcx>)
 156                                 -> bool {
 157     tcx.infer_ctxt().enter(|ref infcx| {
 158         let param_env = ty::ParamEnv::empty();
 159         let mut fulfill_cx = TraitEngine::new(infcx.tcx);
 160         match infcx.at(&cause, param_env).eq(expected, actual) {
 161             Ok(InferOk { obligations, .. }) => {
 162                 fulfill_cx.register_predicate_obligations(infcx, obligations);
 163             }
 164             Err(err) => {
 165                 infcx.report_mismatched_types(cause, expected, actual, err).emit();
 166                 return false;
 167             }
 168         }
 169
 170         match fulfill_cx.select_all_or_error(infcx) {
 171             Ok(()) => true,
 172             Err(errors) => {
 173                 infcx.report_fulfillment_errors(&errors, None, false);
 174                 false
 175             }
 176         }
 177     })
 178 }
 179
 180 fn check_main_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, main_def_id: DefId) {
 181     let main_id = tcx.hir().as_local_hir_id(main_def_id).unwrap();
 182     let main_span = tcx.def_span(main_def_id);
 183     let main_t = tcx.type_of(main_def_id);
 184     match main_t.sty {
 185         ty::FnDef(..) => {
 186             if let Some(Node::Item(it)) = tcx.hir().find_by_hir_id(main_id) {
 187                 if let hir::ItemKind::Fn(.., ref generics, _) = it.node {
 188                     let mut error = false;
 189                     if !generics.params.is_empty() {
 190                         let msg = "`main` function is not allowed to have generic \
 191                                    parameters".to_owned();
 192                         let label = "`main` cannot have generic parameters".to_string();
 193                         struct_span_err!(tcx.sess, generics.span, E0131, "{}", msg)
 194                             .span_label(generics.span, label)
 195                             .emit();
 196                         error = true;
 197                     }
 198                     if let Some(sp) = generics.where_clause.span() {
 199                         struct_span_err!(tcx.sess, sp, E0646,
 200                             "`main` function is not allowed to have a `where` clause")
 201                             .span_label(sp, "`main` cannot have a `where` clause")
 202                             .emit();
 203                         error = true;
 204                     }
 205                     if error {
 206                         return;
 207                     }
 208                 }
 209             }
 210
 211             let actual = tcx.fn_sig(main_def_id);
 212             let expected_return_type = if tcx.lang_items().termination().is_some() {
 213                 // we take the return type of the given main function, the real check is done
 214                 // in `check_fn`
 215                 actual.output().skip_binder()
 216             } else {
 217                 // standard () main return type
 218                 tcx.mk_unit()
 219             };
 220
 221             let se_ty = tcx.mk_fn_ptr(ty::Binder::bind(
 222                 tcx.mk_fn_sig(
 223                     iter::empty(),
 224                     expected_return_type,
 225                     false,
 226                     hir::Unsafety::Normal,
 227                     Abi::Rust
 228                 )
 229             ));
 230
 231             require_same_types(
 232                 tcx,
 233                 &ObligationCause::new(main_span, main_id, ObligationCauseCode::MainFunctionType),
 234                 se_ty,
 235                 tcx.mk_fn_ptr(actual));
 236         }
 237         _ => {
 238             span_bug!(main_span,
 239                       "main has a non-function type: found `{}`",
 240                       main_t);
 241         }
 242     }
 243 }
 244
 245 fn check_start_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, start_def_id: DefId) {
 246     let start_id = tcx.hir().as_local_hir_id(start_def_id).unwrap();
 247     let start_span = tcx.def_span(start_def_id);
 248     let start_t = tcx.type_of(start_def_id);
 249     match start_t.sty {
 250         ty::FnDef(..) => {
 251             if let Some(Node::Item(it)) = tcx.hir().find_by_hir_id(start_id) {
 252                 if let hir::ItemKind::Fn(.., ref generics, _) = it.node {
 253                     let mut error = false;
 254                     if !generics.params.is_empty() {
 255                         struct_span_err!(tcx.sess, generics.span, E0132,
 256                             "start function is not allowed to have type parameters")
 257                             .span_label(generics.span,
 258                                         "start function cannot have type parameters")
 259                             .emit();
 260                         error = true;
 261                     }
 262                     if let Some(sp) = generics.where_clause.span() {
 263                         struct_span_err!(tcx.sess, sp, E0647,
 264                             "start function is not allowed to have a `where` clause")
 265                             .span_label(sp, "start function cannot have a `where` clause")
 266                             .emit();
 267                         error = true;
 268                     }
 269                     if error {
 270                         return;
 271                     }
 272                 }
 273             }
 274
 275             let se_ty = tcx.mk_fn_ptr(ty::Binder::bind(
 276                 tcx.mk_fn_sig(
 277                     [
 278                         tcx.types.isize,
 279                         tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))
 280                     ].iter().cloned(),
 281                     tcx.types.isize,
 282                     false,
 283                     hir::Unsafety::Normal,
 284                     Abi::Rust
 285                 )
 286             ));
 287
 288             require_same_types(
 289                 tcx,
 290                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 291                 se_ty,
 292                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)));
 293         }
 294         _ => {
 295             span_bug!(start_span,
 296                       "start has a non-function type: found `{}`",
 297                       start_t);
 298         }
 299     }
 300 }
 301
 302 fn check_for_entry_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 303     match tcx.entry_fn(LOCAL_CRATE) {
 304         Some((def_id, EntryFnType::Main)) => check_main_fn_ty(tcx, def_id),
 305         Some((def_id, EntryFnType::Start)) => check_start_fn_ty(tcx, def_id),
 306         _ => {}
 307     }
 308 }
 309
 310 pub fn provide(providers: &mut Providers<'_>) {
 311     collect::provide(providers);
 312     coherence::provide(providers);
 313     check::provide(providers);
 314     variance::provide(providers);
 315     outlives::provide(providers);
 316     impl_wf_check::provide(providers);
 317 }
 318
 319 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
 320                              -> Result<(), ErrorReported>
 321 {
 322     tcx.sess.profiler(|p| p.start_activity("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     tcx.sess.track_errors(|| {
 327         time(tcx.sess, "type collecting", || {
 328             for &module in tcx.hir().krate().modules.keys() {
 329                 tcx.ensure().collect_mod_item_types(tcx.hir().local_def_id(module));
 330             }
 331         });
 332     })?;
 333
 334     if tcx.features().rustc_attrs {
 335         tcx.sess.track_errors(|| {
 336             time(tcx.sess, "outlives testing", ||
 337                 outlives::test::test_inferred_outlives(tcx));
 338         })?;
 339     }
 340
 341     tcx.sess.track_errors(|| {
 342         time(tcx.sess, "impl wf inference", ||
 343              impl_wf_check::impl_wf_check(tcx));
 344     })?;
 345
 346     tcx.sess.track_errors(|| {
 347       time(tcx.sess, "coherence checking", ||
 348           coherence::check_coherence(tcx));
 349     })?;
 350
 351     if tcx.features().rustc_attrs {
 352         tcx.sess.track_errors(|| {
 353             time(tcx.sess, "variance testing", ||
 354                 variance::test::test_variance(tcx));
 355         })?;
 356     }
 357
 358     time(tcx.sess, "wf checking", || check::check_wf_new(tcx))?;
 359
 360     time(tcx.sess, "item-types checking", || {
 361         for &module in tcx.hir().krate().modules.keys() {
 362             tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
 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("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 clippy 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>, Bounds<'tcx>) {
 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 bounds = Bounds::default();
 402     let (principal, _) = AstConv::instantiate_poly_trait_ref_inner(
 403         &item_cx, hir_trait, tcx.types.err, &mut bounds, true
 404     );
 405
 406     (principal, bounds)
 407 }
 408
 409 __build_diagnostic_array! { librustc_typeck, DIAGNOSTICS }