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