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 #![allow(non_camel_case_types)]
  60 #![feature(bool_to_option)]
  61 #![feature(box_syntax)]
  62 #![feature(crate_visibility_modifier)]
  63 #![feature(in_band_lifetimes)]
  64 #![feature(nll)]
  65 #![feature(try_blocks)]
  66 #![feature(never_type)]
  67 #![recursion_limit = "256"]
  68
  69 #[macro_use]
  70 extern crate log;
  71
  72 #[macro_use]
  73 extern crate rustc;
  74
  75 // This is used by Clippy.
  76 pub mod expr_use_visitor;
  77
  78 mod astconv;
  79 mod check;
  80 mod check_unused;
  81 mod coherence;
  82 mod collect;
  83 mod constrained_generic_params;
  84 mod impl_wf_check;
  85 mod mem_categorization;
  86 mod namespace;
  87 mod outlives;
  88 mod structured_errors;
  89 mod variance;
  90
  91 use rustc::infer::InferOk;
  92 use rustc::lint;
  93 use rustc::middle;
  94 use rustc::session;
  95 use rustc::session::config::EntryFnType;
  96 use rustc::traits::{ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt};
  97 use rustc::ty::query::Providers;
  98 use rustc::ty::subst::SubstsRef;
  99 use rustc::ty::{self, Ty, TyCtxt};
 100 use rustc::util;
 101 use rustc::util::common::ErrorReported;
 102 use rustc_errors::struct_span_err;
 103 use rustc_hir as hir;
 104 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 105 use rustc_hir::Node;
 106 use rustc_span::{Span, DUMMY_SP};
 107 use rustc_target::spec::abi::Abi;
 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!(
 120             tcx.sess,
 121             span,
 122             E0045,
 123             "C-variadic function must have C or cdecl calling convention"
 124         );
 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.kind {
 166                     let mut error = false;
 167                     if !generics.params.is_empty() {
 168                         let msg = "`main` function is not allowed to have generic \
 169                                    parameters"
 170                             .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!(
 179                             tcx.sess,
 180                             sp,
 181                             E0646,
 182                             "`main` function is not allowed to have a `where` clause"
 183                         )
 184                         .span_label(sp, "`main` cannot have a `where` clause")
 185                         .emit();
 186                         error = true;
 187                     }
 188                     if error {
 189                         return;
 190                     }
 191                 }
 192             }
 193
 194             let actual = tcx.fn_sig(main_def_id);
 195             let expected_return_type = if tcx.lang_items().termination().is_some() {
 196                 // we take the return type of the given main function, the real check is done
 197                 // in `check_fn`
 198                 actual.output().skip_binder()
 199             } else {
 200                 // standard () main return type
 201                 tcx.mk_unit()
 202             };
 203
 204             let se_ty = tcx.mk_fn_ptr(ty::Binder::bind(tcx.mk_fn_sig(
 205                 iter::empty(),
 206                 expected_return_type,
 207                 false,
 208                 hir::Unsafety::Normal,
 209                 Abi::Rust,
 210             )));
 211
 212             require_same_types(
 213                 tcx,
 214                 &ObligationCause::new(main_span, main_id, ObligationCauseCode::MainFunctionType),
 215                 se_ty,
 216                 tcx.mk_fn_ptr(actual),
 217             );
 218         }
 219         _ => {
 220             span_bug!(main_span, "main has a non-function type: found `{}`", main_t);
 221         }
 222     }
 223 }
 224
 225 fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: DefId) {
 226     let start_id = tcx.hir().as_local_hir_id(start_def_id).unwrap();
 227     let start_span = tcx.def_span(start_def_id);
 228     let start_t = tcx.type_of(start_def_id);
 229     match start_t.kind {
 230         ty::FnDef(..) => {
 231             if let Some(Node::Item(it)) = tcx.hir().find(start_id) {
 232                 if let hir::ItemKind::Fn(.., ref generics, _) = it.kind {
 233                     let mut error = false;
 234                     if !generics.params.is_empty() {
 235                         struct_span_err!(
 236                             tcx.sess,
 237                             generics.span,
 238                             E0132,
 239                             "start function is not allowed to have type parameters"
 240                         )
 241                         .span_label(generics.span, "start function cannot have type parameters")
 242                         .emit();
 243                         error = true;
 244                     }
 245                     if let Some(sp) = generics.where_clause.span() {
 246                         struct_span_err!(
 247                             tcx.sess,
 248                             sp,
 249                             E0647,
 250                             "start function is not allowed to have a `where` clause"
 251                         )
 252                         .span_label(sp, "start function cannot have a `where` clause")
 253                         .emit();
 254                         error = true;
 255                     }
 256                     if error {
 257                         return;
 258                     }
 259                 }
 260             }
 261
 262             let se_ty = tcx.mk_fn_ptr(ty::Binder::bind(tcx.mk_fn_sig(
 263                 [tcx.types.isize, tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))].iter().cloned(),
 264                 tcx.types.isize,
 265                 false,
 266                 hir::Unsafety::Normal,
 267                 Abi::Rust,
 268             )));
 269
 270             require_same_types(
 271                 tcx,
 272                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 273                 se_ty,
 274                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)),
 275             );
 276         }
 277         _ => {
 278             span_bug!(start_span, "start has a non-function type: found `{}`", start_t);
 279         }
 280     }
 281 }
 282
 283 fn check_for_entry_fn(tcx: TyCtxt<'_>) {
 284     match tcx.entry_fn(LOCAL_CRATE) {
 285         Some((def_id, EntryFnType::Main)) => check_main_fn_ty(tcx, def_id),
 286         Some((def_id, EntryFnType::Start)) => check_start_fn_ty(tcx, def_id),
 287         _ => {}
 288     }
 289 }
 290
 291 pub fn provide(providers: &mut Providers<'_>) {
 292     collect::provide(providers);
 293     coherence::provide(providers);
 294     check::provide(providers);
 295     variance::provide(providers);
 296     outlives::provide(providers);
 297     impl_wf_check::provide(providers);
 298 }
 299
 300 pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> {
 301     let _prof_timer = tcx.sess.timer("type_check_crate");
 302
 303     // this ensures that later parts of type checking can assume that items
 304     // have valid types and not error
 305     // FIXME(matthewjasper) We shouldn't need to do this.
 306     tcx.sess.track_errors(|| {
 307         tcx.sess.time("type_collecting", || {
 308             for &module in tcx.hir().krate().modules.keys() {
 309                 tcx.ensure().collect_mod_item_types(tcx.hir().local_def_id(module));
 310             }
 311         });
 312     })?;
 313
 314     if tcx.features().rustc_attrs {
 315         tcx.sess.track_errors(|| {
 316             tcx.sess.time("outlives_testing", || outlives::test::test_inferred_outlives(tcx));
 317         })?;
 318     }
 319
 320     tcx.sess.track_errors(|| {
 321         tcx.sess.time("impl_wf_inference", || impl_wf_check::impl_wf_check(tcx));
 322     })?;
 323
 324     tcx.sess.track_errors(|| {
 325         tcx.sess.time("coherence_checking", || coherence::check_coherence(tcx));
 326     })?;
 327
 328     if tcx.features().rustc_attrs {
 329         tcx.sess.track_errors(|| {
 330             tcx.sess.time("variance_testing", || variance::test::test_variance(tcx));
 331         })?;
 332     }
 333
 334     tcx.sess.track_errors(|| {
 335         tcx.sess.time("wf_checking", || check::check_wf_new(tcx));
 336     })?;
 337
 338     tcx.sess.time("item_types_checking", || {
 339         for &module in tcx.hir().krate().modules.keys() {
 340             tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
 341         }
 342     });
 343
 344     tcx.sess.time("item_bodies_checking", || tcx.typeck_item_bodies(LOCAL_CRATE));
 345
 346     check_unused::check_crate(tcx);
 347     check_for_entry_fn(tcx);
 348
 349     if tcx.sess.err_count() == 0 { Ok(()) } else { Err(ErrorReported) }
 350 }
 351
 352 /// A quasi-deprecated helper used in rustdoc and clippy to get
 353 /// the type from a HIR node.
 354 pub fn hir_ty_to_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'_>) -> Ty<'tcx> {
 355     // In case there are any projections, etc., find the "environment"
 356     // def-ID that will be used to determine the traits/predicates in
 357     // scope.  This is derived from the enclosing item-like thing.
 358     let env_node_id = tcx.hir().get_parent_item(hir_ty.hir_id);
 359     let env_def_id = tcx.hir().local_def_id(env_node_id);
 360     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id);
 361
 362     astconv::AstConv::ast_ty_to_ty(&item_cx, hir_ty)
 363 }
 364
 365 pub fn hir_trait_to_predicates<'tcx>(
 366     tcx: TyCtxt<'tcx>,
 367     hir_trait: &hir::TraitRef<'_>,
 368 ) -> Bounds<'tcx> {
 369     // In case there are any projections, etc., find the "environment"
 370     // def-ID that will be used to determine the traits/predicates in
 371     // scope.  This is derived from the enclosing item-like thing.
 372     let env_hir_id = tcx.hir().get_parent_item(hir_trait.hir_ref_id);
 373     let env_def_id = tcx.hir().local_def_id(env_hir_id);
 374     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id);
 375     let mut bounds = Bounds::default();
 376     let _ = AstConv::instantiate_poly_trait_ref_inner(
 377         &item_cx,
 378         hir_trait,
 379         DUMMY_SP,
 380         hir::Constness::NotConst,
 381         tcx.types.err,
 382         &mut bounds,
 383         true,
 384     );
 385
 386     bounds
 387 }