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(in_band_lifetimes)]
  67 #![feature(nll)]
  68 #![feature(rustc_diagnostic_macros)]
  69 #![feature(slice_patterns)]
  70 #![feature(never_type)]
  71 #![feature(inner_deref)]
  72
  73 #![recursion_limit="256"]
  74
  75 #![deny(rust_2018_idioms)]
  76 #![deny(internal)]
  77 #![deny(unused_lifetimes)]
  78
  79 #[macro_use] extern crate log;
  80 #[macro_use] extern crate syntax;
  81
  82 #[macro_use] extern crate rustc;
  83
  84 // N.B., this module needs to be declared first so diagnostics are
  85 // registered before they are used.
  86 mod error_codes;
  87
  88 mod astconv;
  89 mod check;
  90 mod check_unused;
  91 mod coherence;
  92 mod collect;
  93 mod constrained_generic_params;
  94 mod structured_errors;
  95 mod impl_wf_check;
  96 mod namespace;
  97 mod outlives;
  98 mod variance;
  99
 100 use rustc_target::spec::abi::Abi;
 101 use rustc::hir::{self, Node};
 102 use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 103 use rustc::infer::InferOk;
 104 use rustc::lint;
 105 use rustc::middle;
 106 use rustc::session;
 107 use rustc::util::common::ErrorReported;
 108 use rustc::session::config::{EntryFnType, nightly_options};
 109 use rustc::traits::{ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt};
 110 use rustc::ty::subst::SubstsRef;
 111 use rustc::ty::{self, Ty, TyCtxt};
 112 use rustc::ty::query::Providers;
 113 use rustc::util;
 114 use syntax_pos::Span;
 115 use util::common::time;
 116
 117 use std::iter;
 118
 119 use astconv::{AstConv, Bounds};
 120 pub use collect::checked_type_of;
 121
 122 pub struct TypeAndSubsts<'tcx> {
 123     substs: SubstsRef<'tcx>,
 124     ty: Ty<'tcx>,
 125 }
 126
 127 fn check_type_alias_enum_variants_enabled<'tcx>(tcx: TyCtxt<'tcx>, span: Span) {
 128     if !tcx.features().type_alias_enum_variants {
 129         let mut err = tcx.sess.struct_span_err(
 130             span,
 131             "enum variants on type aliases are experimental"
 132         );
 133         if nightly_options::is_nightly_build() {
 134             help!(&mut err,
 135                 "add `#![feature(type_alias_enum_variants)]` to the \
 136                 crate attributes to enable");
 137         }
 138         err.emit();
 139     }
 140 }
 141
 142 fn require_c_abi_if_c_variadic(tcx: TyCtxt<'_>, decl: &hir::FnDecl, abi: Abi, 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<'tcx>(
 151     tcx: TyCtxt<'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<'tcx>(tcx: TyCtxt<'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<'tcx>(tcx: TyCtxt<'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<'tcx>(tcx: TyCtxt<'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<'tcx>(tcx: TyCtxt<'tcx>) -> Result<(), ErrorReported> {
 319     tcx.sess.profiler(|p| p.start_activity("type-check crate"));
 320
 321     // this ensures that later parts of type checking can assume that items
 322     // have valid types and not error
 323     tcx.sess.track_errors(|| {
 324         time(tcx.sess, "type collecting", || {
 325             for &module in tcx.hir().krate().modules.keys() {
 326                 tcx.ensure().collect_mod_item_types(tcx.hir().local_def_id(module));
 327             }
 328         });
 329     })?;
 330
 331     if tcx.features().rustc_attrs {
 332         tcx.sess.track_errors(|| {
 333             time(tcx.sess, "outlives testing", ||
 334                 outlives::test::test_inferred_outlives(tcx));
 335         })?;
 336     }
 337
 338     tcx.sess.track_errors(|| {
 339         time(tcx.sess, "impl wf inference", ||
 340              impl_wf_check::impl_wf_check(tcx));
 341     })?;
 342
 343     tcx.sess.track_errors(|| {
 344       time(tcx.sess, "coherence checking", ||
 345           coherence::check_coherence(tcx));
 346     })?;
 347
 348     if tcx.features().rustc_attrs {
 349         tcx.sess.track_errors(|| {
 350             time(tcx.sess, "variance testing", ||
 351                 variance::test::test_variance(tcx));
 352         })?;
 353     }
 354
 355     time(tcx.sess, "wf checking", || check::check_wf_new(tcx))?;
 356
 357     time(tcx.sess, "item-types checking", || {
 358         for &module in tcx.hir().krate().modules.keys() {
 359             tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
 360         }
 361     });
 362
 363     time(tcx.sess, "item-bodies checking", || tcx.typeck_item_bodies(LOCAL_CRATE));
 364
 365     check_unused::check_crate(tcx);
 366     check_for_entry_fn(tcx);
 367
 368     tcx.sess.profiler(|p| p.end_activity("type-check crate"));
 369
 370     if tcx.sess.err_count() == 0 {
 371         Ok(())
 372     } else {
 373         Err(ErrorReported)
 374     }
 375 }
 376
 377 /// A quasi-deprecated helper used in rustdoc and clippy to get
 378 /// the type from a HIR node.
 379 pub fn hir_ty_to_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty) -> Ty<'tcx> {
 380     // In case there are any projections, etc., find the "environment"
 381     // def-ID that will be used to determine the traits/predicates in
 382     // scope.  This is derived from the enclosing item-like thing.
 383     let env_node_id = tcx.hir().get_parent_item(hir_ty.hir_id);
 384     let env_def_id = tcx.hir().local_def_id_from_hir_id(env_node_id);
 385     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id);
 386
 387     astconv::AstConv::ast_ty_to_ty(&item_cx, hir_ty)
 388 }
 389
 390 pub fn hir_trait_to_predicates<'tcx>(
 391     tcx: TyCtxt<'tcx>,
 392     hir_trait: &hir::TraitRef,
 393 ) -> (ty::PolyTraitRef<'tcx>, Bounds<'tcx>) {
 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 bounds = Bounds::default();
 401     let (principal, _) = AstConv::instantiate_poly_trait_ref_inner(
 402         &item_cx, hir_trait, tcx.types.err, &mut bounds, true
 403     );
 404
 405     (principal, bounds)
 406 }
 407
 408 __build_diagnostic_array! { librustc_typeck, DIAGNOSTICS }