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