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