src/librustc_typeck/lib.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 /*!
  12
  13 typeck.rs, an introduction
  14
  15 The type checker is responsible for:
  16
  17 1. Determining the type of each expression
  18 2. Resolving methods and traits
  19 3. Guaranteeing that most type rules are met ("most?", you say, "why most?"
  20    Well, dear reader, read on)
  21
  22 The main entry point is `check_crate()`.  Type checking operates in
  23 several major phases:
  24
  25 1. The collect phase first passes over all items and determines their
  26    type, without examining their "innards".
  27
  28 2. Variance inference then runs to compute the variance of each parameter
  29
  30 3. Coherence checks for overlapping or orphaned impls
  31
  32 4. Finally, the check phase then checks function bodies and so forth.
  33    Within the check phase, we check each function body one at a time
  34    (bodies of function expressions are checked as part of the
  35    containing function).  Inference is used to supply types wherever
  36    they are unknown. The actual checking of a function itself has
  37    several phases (check, regionck, writeback), as discussed in the
  38    documentation for the `check` module.
  39
  40 The type checker is defined into various submodules which are documented
  41 independently:
  42
  43 - astconv: converts the AST representation of types
  44   into the `ty` representation
  45
  46 - collect: computes the types of each top-level item and enters them into
  47   the `tcx.types` table for later use
  48
  49 - coherence: enforces coherence rules, builds some tables
  50
  51 - variance: variance inference
  52
  53 - outlives: outlives inference
  54
  55 - check: walks over function bodies and type checks them, inferring types for
  56   local variables, type parameters, etc as necessary.
  57
  58 - infer: finds the types to use for each type variable such that
  59   all subtyping and assignment constraints are met.  In essence, the check
  60   module specifies the constraints, and the infer module solves them.
  61
  62 # Note
  63
  64 This API is completely unstable and subject to change.
  65
  66 */
  67
  68 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
  69       html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
  70       html_root_url = "https://doc.rust-lang.org/nightly/")]
  71 #![deny(warnings)]
  72
  73 #![allow(non_camel_case_types)]
  74
  75 #![feature(advanced_slice_patterns)]
  76 #![feature(box_patterns)]
  77 #![feature(box_syntax)]
  78 #![feature(conservative_impl_trait)]
  79 #![feature(copy_closures, clone_closures)]
  80 #![feature(crate_visibility_modifier)]
  81 #![feature(from_ref)]
  82 #![feature(match_default_bindings)]
  83 #![feature(never_type)]
  84 #![feature(option_filter)]
  85 #![feature(quote)]
  86 #![feature(refcell_replace_swap)]
  87 #![feature(rustc_diagnostic_macros)]
  88 #![feature(slice_patterns)]
  89
  90 #[macro_use] extern crate log;
  91 #[macro_use] extern crate syntax;
  92 extern crate syntax_pos;
  93
  94 extern crate arena;
  95 #[macro_use] extern crate rustc;
  96 extern crate rustc_platform_intrinsics as intrinsics;
  97 extern crate rustc_const_math;
  98 extern crate rustc_data_structures;
  99 extern crate rustc_errors as errors;
 100
 101 use rustc::hir;
 102 use rustc::lint;
 103 use rustc::middle;
 104 use rustc::session;
 105 use rustc::util;
 106
 107 use hir::map as hir_map;
 108 use rustc::infer::InferOk;
 109 use rustc::ty::subst::Substs;
 110 use rustc::ty::{self, Ty, TyCtxt};
 111 use rustc::ty::maps::Providers;
 112 use rustc::traits::{FulfillmentContext, ObligationCause, ObligationCauseCode, Reveal};
 113 use session::{CompileIncomplete, config};
 114 use util::common::time;
 115
 116 use syntax::ast;
 117 use syntax::abi::Abi;
 118 use syntax_pos::Span;
 119
 120 use std::iter;
 121
 122 // NB: This module needs to be declared first so diagnostics are
 123 // registered before they are used.
 124 mod diagnostics;
 125
 126 mod astconv;
 127 mod check;
 128 mod check_unused;
 129 mod coherence;
 130 mod collect;
 131 mod constrained_type_params;
 132 mod structured_errors;
 133 mod impl_wf_check;
 134 mod namespace;
 135 mod outlives;
 136 mod variance;
 137
 138 pub struct TypeAndSubsts<'tcx> {
 139     substs: &'tcx Substs<'tcx>,
 140     ty: Ty<'tcx>,
 141 }
 142
 143 fn require_c_abi_if_variadic(tcx: TyCtxt,
 144                              decl: &hir::FnDecl,
 145                              abi: Abi,
 146                              span: Span) {
 147     if decl.variadic && !(abi == Abi::C || abi == Abi::Cdecl) {
 148         let mut err = struct_span_err!(tcx.sess, span, E0045,
 149                   "variadic function must have C or cdecl calling convention");
 150         err.span_label(span, "variadics require C or cdecl calling convention").emit();
 151     }
 152 }
 153
 154 fn require_same_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 155                                 cause: &ObligationCause<'tcx>,
 156                                 expected: Ty<'tcx>,
 157                                 actual: Ty<'tcx>)
 158                                 -> bool {
 159     tcx.infer_ctxt().enter(|ref infcx| {
 160         let param_env = ty::ParamEnv::empty(Reveal::UserFacing);
 161         let mut fulfill_cx = FulfillmentContext::new();
 162         match infcx.at(&cause, param_env).eq(expected, actual) {
 163             Ok(InferOk { obligations, .. }) => {
 164                 fulfill_cx.register_predicate_obligations(infcx, obligations);
 165             }
 166             Err(err) => {
 167                 infcx.report_mismatched_types(cause, expected, actual, err).emit();
 168                 return false;
 169             }
 170         }
 171
 172         match fulfill_cx.select_all_or_error(infcx) {
 173             Ok(()) => true,
 174             Err(errors) => {
 175                 infcx.report_fulfillment_errors(&errors, None);
 176                 false
 177             }
 178         }
 179     })
 180 }
 181
 182 fn check_main_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 183                               main_id: ast::NodeId,
 184                               main_span: Span) {
 185     let main_def_id = tcx.hir.local_def_id(main_id);
 186     let main_t = tcx.type_of(main_def_id);
 187     match main_t.sty {
 188         ty::TyFnDef(..) => {
 189             match tcx.hir.find(main_id) {
 190                 Some(hir_map::NodeItem(it)) => {
 191                     match it.node {
 192                         hir::ItemFn(.., ref generics, _) => {
 193                             if !generics.params.is_empty() {
 194                                 struct_span_err!(tcx.sess, generics.span, E0131,
 195                                          "main function is not allowed to have type parameters")
 196                                     .span_label(generics.span,
 197                                                 "main cannot have type parameters")
 198                                     .emit();
 199                                 return;
 200                             }
 201                         }
 202                         _ => ()
 203                     }
 204                 }
 205                 _ => ()
 206             }
 207
 208             let actual = tcx.fn_sig(main_def_id);
 209             let expected_return_type = if tcx.lang_items().termination().is_some()
 210                 && tcx.sess.features.borrow().termination_trait {
 211                 // we take the return type of the given main function, the real check is done
 212                 // in `check_fn`
 213                 actual.output().skip_binder()
 214             } else {
 215                 // standard () main return type
 216                 tcx.mk_nil()
 217             };
 218
 219             let se_ty = tcx.mk_fn_ptr(ty::Binder(
 220                 tcx.mk_fn_sig(
 221                     iter::empty(),
 222                     expected_return_type,
 223                     false,
 224                     hir::Unsafety::Normal,
 225                     Abi::Rust
 226                 )
 227             ));
 228
 229             require_same_types(
 230                 tcx,
 231                 &ObligationCause::new(main_span, main_id, ObligationCauseCode::MainFunctionType),
 232                 se_ty,
 233                 tcx.mk_fn_ptr(actual));
 234         }
 235         _ => {
 236             span_bug!(main_span,
 237                       "main has a non-function type: found `{}`",
 238                       main_t);
 239         }
 240     }
 241 }
 242
 243 fn check_start_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 244                                start_id: ast::NodeId,
 245                                start_span: Span) {
 246     let start_def_id = tcx.hir.local_def_id(start_id);
 247     let start_t = tcx.type_of(start_def_id);
 248     match start_t.sty {
 249         ty::TyFnDef(..) => {
 250             match tcx.hir.find(start_id) {
 251                 Some(hir_map::NodeItem(it)) => {
 252                     match it.node {
 253                         hir::ItemFn(..,ref ps,_)
 254                         if !ps.params.is_empty() => {
 255                             struct_span_err!(tcx.sess, ps.span, E0132,
 256                                 "start function is not allowed to have type parameters")
 257                                 .span_label(ps.span,
 258                                             "start function cannot have type parameters")
 259                                 .emit();
 260                             return;
 261                         }
 262                         _ => ()
 263                     }
 264                 }
 265                 _ => ()
 266             }
 267
 268             let se_ty = tcx.mk_fn_ptr(ty::Binder(
 269                 tcx.mk_fn_sig(
 270                     [
 271                         tcx.types.isize,
 272                         tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))
 273                     ].iter().cloned(),
 274                     tcx.types.isize,
 275                     false,
 276                     hir::Unsafety::Normal,
 277                     Abi::Rust
 278                 )
 279             ));
 280
 281             require_same_types(
 282                 tcx,
 283                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 284                 se_ty,
 285                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)));
 286         }
 287         _ => {
 288             span_bug!(start_span,
 289                       "start has a non-function type: found `{}`",
 290                       start_t);
 291         }
 292     }
 293 }
 294
 295 fn check_for_entry_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 296     if let Some((id, sp)) = *tcx.sess.entry_fn.borrow() {
 297         match tcx.sess.entry_type.get() {
 298             Some(config::EntryMain) => check_main_fn_ty(tcx, id, sp),
 299             Some(config::EntryStart) => check_start_fn_ty(tcx, id, sp),
 300             Some(config::EntryNone) => {}
 301             None => bug!("entry function without a type")
 302         }
 303     }
 304 }
 305
 306 pub fn provide(providers: &mut Providers) {
 307     collect::provide(providers);
 308     coherence::provide(providers);
 309     check::provide(providers);
 310     variance::provide(providers);
 311     outlives::provide(providers);
 312 }
 313
 314 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
 315                              -> Result<(), CompileIncomplete>
 316 {
 317     let time_passes = tcx.sess.time_passes();
 318
 319     // this ensures that later parts of type checking can assume that items
 320     // have valid types and not error
 321     tcx.sess.track_errors(|| {
 322         time(time_passes, "type collecting", ||
 323              collect::collect_item_types(tcx));
 324
 325     })?;
 326
 327     tcx.sess.track_errors(|| {
 328         time(time_passes, "outlives testing", ||
 329             outlives::test::test_inferred_outlives(tcx));
 330     })?;
 331
 332     tcx.sess.track_errors(|| {
 333         time(time_passes, "impl wf inference", ||
 334              impl_wf_check::impl_wf_check(tcx));
 335     })?;
 336
 337     tcx.sess.track_errors(|| {
 338       time(time_passes, "coherence checking", ||
 339           coherence::check_coherence(tcx));
 340     })?;
 341
 342     tcx.sess.track_errors(|| {
 343         time(time_passes, "variance testing", ||
 344              variance::test::test_variance(tcx));
 345     })?;
 346
 347     time(time_passes, "wf checking", || check::check_wf_new(tcx))?;
 348
 349     time(time_passes, "item-types checking", || check::check_item_types(tcx))?;
 350
 351     time(time_passes, "item-bodies checking", || check::check_item_bodies(tcx))?;
 352
 353     check_unused::check_crate(tcx);
 354     check_for_entry_fn(tcx);
 355
 356     tcx.sess.compile_status()
 357 }
 358
 359 /// A quasi-deprecated helper used in rustdoc and save-analysis to get
 360 /// the type from a HIR node.
 361 pub fn hir_ty_to_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, '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(hir_ty.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     astconv::AstConv::ast_ty_to_ty(&item_cx, hir_ty)
 369 }
 370
 371 pub fn hir_trait_to_predicates<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, hir_trait: &hir::TraitRef)
 372         -> (ty::PolyTraitRef<'tcx>, Vec<ty::PolyProjectionPredicate<'tcx>>) {
 373     // In case there are any projections etc, find the "environment"
 374     // def-id that will be used to determine the traits/predicates in
 375     // scope.  This is derived from the enclosing item-like thing.
 376     let env_node_id = tcx.hir.get_parent(hir_trait.ref_id);
 377     let env_def_id = tcx.hir.local_def_id(env_node_id);
 378     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id);
 379     let mut projections = Vec::new();
 380     let principal = astconv::AstConv::instantiate_poly_trait_ref_inner(
 381         &item_cx, hir_trait, tcx.types.err, &mut projections, true
 382     );
 383     (principal, projections)
 384 }
 385
 386 __build_diagnostic_array! { librustc_typeck, DIAGNOSTICS }