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