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
  72 #![allow(non_camel_case_types)]
  73
  74 #![cfg_attr(stage0, feature(dyn_trait))]
  75
  76 #![feature(box_patterns)]
  77 #![feature(box_syntax)]
  78 #![feature(crate_visibility_modifier)]
  79 #![feature(from_ref)]
  80 #![feature(exhaustive_patterns)]
  81 #![feature(quote)]
  82 #![feature(refcell_replace_swap)]
  83 #![feature(rustc_diagnostic_macros)]
  84 #![feature(slice_patterns)]
  85 #![feature(slice_sort_by_cached_key)]
  86 #![feature(never_type)]
  87
  88 #[macro_use] extern crate log;
  89 #[macro_use] extern crate syntax;
  90 extern crate syntax_pos;
  91
  92 extern crate arena;
  93 #[macro_use] extern crate rustc;
  94 extern crate rustc_platform_intrinsics as intrinsics;
  95 extern crate rustc_const_math;
  96 extern crate rustc_data_structures;
  97 extern crate rustc_errors as errors;
  98 extern crate rustc_target;
  99
 100 use rustc::hir;
 101 use rustc::lint;
 102 use rustc::middle;
 103 use rustc::session;
 104 use rustc::util;
 105
 106 use hir::map as hir_map;
 107 use rustc::infer::InferOk;
 108 use rustc::ty::subst::Substs;
 109 use rustc::ty::{self, Ty, TyCtxt};
 110 use rustc::ty::maps::Providers;
 111 use rustc::traits::{ObligationCause, ObligationCauseCode, TraitEngine};
 112 use session::{CompileIncomplete, config};
 113 use util::common::time;
 114
 115 use syntax::ast;
 116 use rustc_target::spec::abi::Abi;
 117 use syntax_pos::Span;
 118
 119 use std::iter;
 120
 121 // NB: This module needs to be declared first so diagnostics are
 122 // registered before they are used.
 123 mod diagnostics;
 124
 125 mod astconv;
 126 mod check;
 127 mod check_unused;
 128 mod coherence;
 129 mod collect;
 130 mod constrained_type_params;
 131 mod structured_errors;
 132 mod impl_wf_check;
 133 mod namespace;
 134 mod outlives;
 135 mod variance;
 136
 137 pub struct TypeAndSubsts<'tcx> {
 138     substs: &'tcx Substs<'tcx>,
 139     ty: Ty<'tcx>,
 140 }
 141
 142 fn require_c_abi_if_variadic(tcx: TyCtxt,
 143                              decl: &hir::FnDecl,
 144                              abi: Abi,
 145                              span: Span) {
 146     if decl.variadic && !(abi == Abi::C || abi == Abi::Cdecl) {
 147         let mut err = struct_span_err!(tcx.sess, span, E0045,
 148                   "variadic function must have C or cdecl calling convention");
 149         err.span_label(span, "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>,
 182                               main_id: ast::NodeId,
 183                               main_span: Span) {
 184     let main_def_id = tcx.hir.local_def_id(main_id);
 185     let main_t = tcx.type_of(main_def_id);
 186     match main_t.sty {
 187         ty::TyFnDef(..) => {
 188             match tcx.hir.find(main_id) {
 189                 Some(hir_map::NodeItem(it)) => {
 190                     match it.node {
 191                         hir::ItemFn(.., ref generics, _) => {
 192                             if !generics.params.is_empty() {
 193                                 struct_span_err!(tcx.sess, generics.span, E0131,
 194                                          "main function is not allowed to have type parameters")
 195                                     .span_label(generics.span,
 196                                                 "main cannot have type parameters")
 197                                     .emit();
 198                                 return;
 199                             }
 200                         }
 201                         _ => ()
 202                     }
 203                 }
 204                 _ => ()
 205             }
 206
 207             let actual = tcx.fn_sig(main_def_id);
 208             let expected_return_type = if tcx.lang_items().termination().is_some() {
 209                 // we take the return type of the given main function, the real check is done
 210                 // in `check_fn`
 211                 actual.output().skip_binder()
 212             } else {
 213                 // standard () main return type
 214                 tcx.mk_nil()
 215             };
 216
 217             let se_ty = tcx.mk_fn_ptr(ty::Binder::bind(
 218                 tcx.mk_fn_sig(
 219                     iter::empty(),
 220                     expected_return_type,
 221                     false,
 222                     hir::Unsafety::Normal,
 223                     Abi::Rust
 224                 )
 225             ));
 226
 227             require_same_types(
 228                 tcx,
 229                 &ObligationCause::new(main_span, main_id, ObligationCauseCode::MainFunctionType),
 230                 se_ty,
 231                 tcx.mk_fn_ptr(actual));
 232         }
 233         _ => {
 234             span_bug!(main_span,
 235                       "main has a non-function type: found `{}`",
 236                       main_t);
 237         }
 238     }
 239 }
 240
 241 fn check_start_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 242                                start_id: ast::NodeId,
 243                                start_span: Span) {
 244     let start_def_id = tcx.hir.local_def_id(start_id);
 245     let start_t = tcx.type_of(start_def_id);
 246     match start_t.sty {
 247         ty::TyFnDef(..) => {
 248             match tcx.hir.find(start_id) {
 249                 Some(hir_map::NodeItem(it)) => {
 250                     match it.node {
 251                         hir::ItemFn(..,ref ps,_)
 252                         if !ps.params.is_empty() => {
 253                             struct_span_err!(tcx.sess, ps.span, E0132,
 254                                 "start function is not allowed to have type parameters")
 255                                 .span_label(ps.span,
 256                                             "start function cannot have type parameters")
 257                                 .emit();
 258                             return;
 259                         }
 260                         _ => ()
 261                     }
 262                 }
 263                 _ => ()
 264             }
 265
 266             let se_ty = tcx.mk_fn_ptr(ty::Binder::bind(
 267                 tcx.mk_fn_sig(
 268                     [
 269                         tcx.types.isize,
 270                         tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))
 271                     ].iter().cloned(),
 272                     tcx.types.isize,
 273                     false,
 274                     hir::Unsafety::Normal,
 275                     Abi::Rust
 276                 )
 277             ));
 278
 279             require_same_types(
 280                 tcx,
 281                 &ObligationCause::new(start_span, start_id, ObligationCauseCode::StartFunctionType),
 282                 se_ty,
 283                 tcx.mk_fn_ptr(tcx.fn_sig(start_def_id)));
 284         }
 285         _ => {
 286             span_bug!(start_span,
 287                       "start has a non-function type: found `{}`",
 288                       start_t);
 289         }
 290     }
 291 }
 292
 293 fn check_for_entry_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 294     if let Some((id, sp, entry_type)) = *tcx.sess.entry_fn.borrow() {
 295         match entry_type {
 296             config::EntryMain => check_main_fn_ty(tcx, id, sp),
 297             config::EntryStart => check_start_fn_ty(tcx, id, sp),
 298         }
 299     }
 300 }
 301
 302 pub fn provide(providers: &mut Providers) {
 303     collect::provide(providers);
 304     coherence::provide(providers);
 305     check::provide(providers);
 306     variance::provide(providers);
 307     outlives::provide(providers);
 308 }
 309
 310 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
 311                              -> Result<(), CompileIncomplete>
 312 {
 313     // this ensures that later parts of type checking can assume that items
 314     // have valid types and not error
 315     tcx.sess.track_errors(|| {
 316         time(tcx.sess, "type collecting", ||
 317              collect::collect_item_types(tcx));
 318
 319     })?;
 320
 321     tcx.sess.track_errors(|| {
 322         time(tcx.sess, "outlives testing", ||
 323             outlives::test::test_inferred_outlives(tcx));
 324     })?;
 325
 326     tcx.sess.track_errors(|| {
 327         time(tcx.sess, "impl wf inference", ||
 328              impl_wf_check::impl_wf_check(tcx));
 329     })?;
 330
 331     tcx.sess.track_errors(|| {
 332       time(tcx.sess, "coherence checking", ||
 333           coherence::check_coherence(tcx));
 334     })?;
 335
 336     tcx.sess.track_errors(|| {
 337         time(tcx.sess, "variance testing", ||
 338              variance::test::test_variance(tcx));
 339     })?;
 340
 341     time(tcx.sess, "wf checking", || check::check_wf_new(tcx))?;
 342
 343     time(tcx.sess, "item-types checking", || check::check_item_types(tcx))?;
 344
 345     time(tcx.sess, "item-bodies checking", || check::check_item_bodies(tcx))?;
 346
 347     check_unused::check_crate(tcx);
 348     check_for_entry_fn(tcx);
 349
 350     tcx.sess.compile_status()
 351 }
 352
 353 /// A quasi-deprecated helper used in rustdoc and save-analysis to get
 354 /// the type from a HIR node.
 355 pub fn hir_ty_to_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, hir_ty: &hir::Ty) -> Ty<'tcx> {
 356     // In case there are any projections etc, find the "environment"
 357     // def-id that will be used to determine the traits/predicates in
 358     // scope.  This is derived from the enclosing item-like thing.
 359     let env_node_id = tcx.hir.get_parent(hir_ty.id);
 360     let env_def_id = tcx.hir.local_def_id(env_node_id);
 361     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id);
 362     astconv::AstConv::ast_ty_to_ty(&item_cx, hir_ty)
 363 }
 364
 365 pub fn hir_trait_to_predicates<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, hir_trait: &hir::TraitRef)
 366         -> (ty::PolyTraitRef<'tcx>, Vec<ty::PolyProjectionPredicate<'tcx>>) {
 367     // In case there are any projections etc, find the "environment"
 368     // def-id that will be used to determine the traits/predicates in
 369     // scope.  This is derived from the enclosing item-like thing.
 370     let env_node_id = tcx.hir.get_parent(hir_trait.ref_id);
 371     let env_def_id = tcx.hir.local_def_id(env_node_id);
 372     let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id);
 373     let mut projections = Vec::new();
 374     let principal = astconv::AstConv::instantiate_poly_trait_ref_inner(
 375         &item_cx, hir_trait, tcx.types.err, &mut projections, true
 376     );
 377     (principal, projections)
 378 }
 379
 380 __build_diagnostic_array! { librustc_typeck, DIAGNOSTICS }