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