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