another and were not previously instrumented.
17 files changed:
Hir(DefId),
// Represents different phases in the compiler.
Hir(DefId),
// Represents different phases in the compiler.
+ CrateReader,
+ CollectLanguageItems,
+ CheckStaticRecursion,
+ ResolveLifetimes,
+ RegionResolveCrate,
+ CheckLoops,
+ PluginRegistrar,
+ StabilityIndex,
CollectItem(DefId),
Coherence,
CollectItem(DefId),
Coherence,
+ EffectCheck,
+ Liveness,
+ Resolve,
+ EntryPoint,
+ CheckEntryFn,
CoherenceCheckImpl(DefId),
CoherenceOverlapCheck(DefId),
CoherenceOverlapCheckSpecial(DefId),
CoherenceCheckImpl(DefId),
CoherenceOverlapCheck(DefId),
CoherenceOverlapCheckSpecial(DefId),
//! `unsafe`.
use self::RootUnsafeContext::*;
//! `unsafe`.
use self::RootUnsafeContext::*;
use middle::def::Def;
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
use middle::def::Def;
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
}
pub fn check_crate(tcx: &ty::ctxt) {
}
pub fn check_crate(tcx: &ty::ctxt) {
+ let _task = tcx.dep_graph.in_task(DepNode::EffectCheck);
+
let mut visitor = EffectCheckVisitor {
tcx: tcx,
unsafe_context: UnsafeContext::new(SafeContext),
let mut visitor = EffectCheckVisitor {
tcx: tcx,
unsafe_context: UnsafeContext::new(SafeContext),
// except according to those terms.
// except according to those terms.
use front::map as ast_map;
use middle::def_id::{CRATE_DEF_INDEX};
use session::{config, Session};
use front::map as ast_map;
use middle::def_id::{CRATE_DEF_INDEX};
use session::{config, Session};
}
pub fn find_entry_point(session: &Session, ast_map: &ast_map::Map) {
}
pub fn find_entry_point(session: &Session, ast_map: &ast_map::Map) {
+ let _task = ast_map.dep_graph.in_task(DepNode::EntryPoint);
+
let any_exe = session.crate_types.borrow().iter().any(|ty| {
*ty == config::CrateTypeExecutable
});
let any_exe = session.crate_types.borrow().iter().any(|ty| {
*ty == config::CrateTypeExecutable
});
pub use self::LangItem::*;
pub use self::LangItem::*;
use front::map as hir_map;
use session::Session;
use middle::cstore::CrateStore;
use front::map as hir_map;
use session::Session;
use middle::cstore::CrateStore;
pub fn collect_language_items(session: &Session,
map: &hir_map::Map)
-> LanguageItems {
pub fn collect_language_items(session: &Session,
map: &hir_map::Map)
-> LanguageItems {
+ let _task = map.dep_graph.in_task(DepNode::CollectLanguageItems);
let krate: &hir::Crate = map.krate();
let mut collector = LanguageItemCollector::new(session, map);
collector.collect(krate);
let krate: &hir::Crate = map.krate();
let mut collector = LanguageItemCollector::new(session, map);
collector.collect(krate);
use self::LiveNodeKind::*;
use self::VarKind::*;
use self::LiveNodeKind::*;
use self::VarKind::*;
use middle::def::*;
use middle::pat_util;
use middle::ty;
use middle::def::*;
use middle::pat_util;
use middle::ty;
}
pub fn check_crate(tcx: &ty::ctxt) {
}
pub fn check_crate(tcx: &ty::ctxt) {
+ let _task = tcx.dep_graph.in_task(DepNode::Liveness);
tcx.map.krate().visit_all_items(&mut IrMaps::new(tcx));
tcx.sess.abort_if_errors();
}
tcx.map.krate().visit_all_items(&mut IrMaps::new(tcx));
tcx.sess.abort_if_errors();
}
//! Most of the documentation on regions can be found in
//! `middle/infer/region_inference/README.md`
//! Most of the documentation on regions can be found in
//! `middle/infer/region_inference/README.md`
use front::map as ast_map;
use session::Session;
use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
use front::map as ast_map;
use session::Session;
use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
-pub fn resolve_crate(sess: &Session, krate: &hir::Crate) -> RegionMaps {
+pub fn resolve_crate(sess: &Session, map: &ast_map::Map) -> RegionMaps {
+ let _task = map.dep_graph.in_task(DepNode::RegionResolveCrate);
+ let krate = map.krate();
+
let maps = RegionMaps {
code_extents: RefCell::new(vec![]),
code_extent_interner: RefCell::new(FnvHashMap()),
let maps = RegionMaps {
code_extents: RefCell::new(vec![]),
code_extent_interner: RefCell::new(FnvHashMap()),
pub use self::DefRegion::*;
use self::ScopeChain::*;
pub use self::DefRegion::*;
use self::ScopeChain::*;
+use dep_graph::DepNode;
+use front::map::Map;
use session::Session;
use middle::def::{Def, DefMap};
use middle::region;
use session::Session;
use middle::def::{Def, DefMap};
use middle::region;
static ROOT_SCOPE: ScopeChain<'static> = RootScope;
pub fn krate(sess: &Session,
static ROOT_SCOPE: ScopeChain<'static> = RootScope;
pub fn krate(sess: &Session,
def_map: &DefMap)
-> Result<NamedRegionMap, usize> {
def_map: &DefMap)
-> Result<NamedRegionMap, usize> {
+ let _task = hir_map.dep_graph.in_task(DepNode::ResolveLifetimes);
+ let krate = hir_map.krate();
let mut named_region_map = NodeMap();
try!(sess.track_errors(|| {
krate.visit_all_items(&mut LifetimeContext {
let mut named_region_map = NodeMap();
try!(sess.track_errors(|| {
krate.visit_all_items(&mut LifetimeContext {
pub use self::StabilityLevel::*;
use dep_graph::DepNode;
pub use self::StabilityLevel::*;
use dep_graph::DepNode;
+use front::map as hir_map;
use session::Session;
use lint;
use middle::cstore::{CrateStore, LOCAL_CRATE};
use session::Session;
use lint;
use middle::cstore::{CrateStore, LOCAL_CRATE};
use util::nodemap::{DefIdMap, FnvHashSet, FnvHashMap};
use rustc_front::hir;
use util::nodemap::{DefIdMap, FnvHashSet, FnvHashMap};
use rustc_front::hir;
-use rustc_front::hir::{Crate, Item, Generics, StructField, Variant};
+use rustc_front::hir::{Item, Generics, StructField, Variant};
use rustc_front::intravisit::{self, Visitor};
use std::mem::replace;
use rustc_front::intravisit::{self, Visitor};
use std::mem::replace;
impl<'tcx> Index<'tcx> {
/// Construct the stability index for a crate being compiled.
impl<'tcx> Index<'tcx> {
/// Construct the stability index for a crate being compiled.
- pub fn build(&mut self, tcx: &ty::ctxt<'tcx>, krate: &Crate, access_levels: &AccessLevels) {
+ pub fn build(&mut self, tcx: &ty::ctxt<'tcx>, access_levels: &AccessLevels) {
+ let _task = tcx.dep_graph.in_task(DepNode::StabilityIndex);
+ let krate = tcx.map.krate();
let mut annotator = Annotator {
tcx: tcx,
index: self,
let mut annotator = Annotator {
tcx: tcx,
index: self,
|v| intravisit::walk_crate(v, krate));
}
|v| intravisit::walk_crate(v, krate));
}
- pub fn new(krate: &Crate) -> Index<'tcx> {
+ pub fn new(hir_map: &hir_map::Map) -> Index<'tcx> {
+ let _task = hir_map.dep_graph.in_task(DepNode::StabilityIndex);
+ let krate = hir_map.krate();
+
let mut is_staged_api = false;
for attr in &krate.attrs {
if attr.name() == "stable" || attr.name() == "unstable" {
let mut is_staged_api = false;
for attr in &krate.attrs {
if attr.name() == "stable" || attr.name() == "unstable" {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use rustc::dep_graph::DepGraph;
use rustc::front;
use rustc::front::map as hir_map;
use rustc_mir as mir;
use rustc::front;
use rustc::front::map as hir_map;
use rustc_mir as mir;
let expanded_crate = assign_node_ids(sess, expanded_crate);
// Lower ast -> hir.
let lcx = LoweringContext::new(sess, Some(&expanded_crate));
let expanded_crate = assign_node_ids(sess, expanded_crate);
// Lower ast -> hir.
let lcx = LoweringContext::new(sess, Some(&expanded_crate));
+ let dep_graph = DepGraph::new(sess.opts.build_dep_graph);
let mut hir_forest = time(sess.time_passes(),
"lowering ast -> hir",
let mut hir_forest = time(sess.time_passes(),
"lowering ast -> hir",
- || hir_map::Forest::new(lower_crate(&lcx, &expanded_crate)));
+ || hir_map::Forest::new(lower_crate(&lcx, &expanded_crate),
+ dep_graph));
// Discard MTWT tables that aren't required past lowering to HIR.
if !sess.opts.debugging_opts.keep_mtwt_tables &&
// Discard MTWT tables that aren't required past lowering to HIR.
if !sess.opts.debugging_opts.keep_mtwt_tables &&
write_out_deps(sess, &outputs, &id);
write_out_deps(sess, &outputs, &id);
- controller_entry_point!(after_write_deps,
- sess,
- CompileState::state_after_write_deps(input,
- sess,
- outdir,
- &hir_map,
- &expanded_crate,
- &hir_map.krate(),
- &id[..],
- &lcx),
- Ok(()));
+ {
+ let _ignore = hir_map.dep_graph.in_ignore();
+ controller_entry_point!(after_write_deps,
+ sess,
+ CompileState::state_after_write_deps(input,
+ sess,
+ outdir,
+ &hir_map,
+ &expanded_crate,
+ &hir_map.krate(),
+ &id[..],
+ &lcx),
+ Ok(()));
+ }
time(sess.time_passes(), "attribute checking", || {
front::check_attr::check_crate(sess, &expanded_crate);
time(sess.time_passes(), "attribute checking", || {
front::check_attr::check_crate(sess, &expanded_crate);
control.make_glob_map,
|tcx, mir_map, analysis, result| {
{
control.make_glob_map,
|tcx, mir_map, analysis, result| {
{
+ // Eventually, we will want to track plugins.
+ let _ignore = tcx.dep_graph.in_ignore();
+
let state = CompileState::state_after_analysis(input,
&tcx.sess,
outdir,
let state = CompileState::state_after_analysis(input,
&tcx.sess,
outdir,
}
let time_passes = sess.time_passes();
}
let time_passes = sess.time_passes();
- let krate = hir_map.krate();
time(time_passes,
"external crate/lib resolution",
time(time_passes,
"external crate/lib resolution",
- || LocalCrateReader::new(sess, cstore, &hir_map).read_crates(krate));
+ || LocalCrateReader::new(sess, cstore, &hir_map).read_crates());
let lang_items = try!(time(time_passes, "language item collection", || {
sess.track_errors(|| {
let lang_items = try!(time(time_passes, "language item collection", || {
sess.track_errors(|| {
let named_region_map = try!(time(time_passes,
"lifetime resolution",
|| middle::resolve_lifetime::krate(sess,
let named_region_map = try!(time(time_passes,
"lifetime resolution",
|| middle::resolve_lifetime::krate(sess,
&def_map.borrow())));
time(time_passes,
&def_map.borrow())));
time(time_passes,
|| middle::entry::find_entry_point(sess, &hir_map));
sess.plugin_registrar_fn.set(time(time_passes, "looking for plugin registrar", || {
|| middle::entry::find_entry_point(sess, &hir_map));
sess.plugin_registrar_fn.set(time(time_passes, "looking for plugin registrar", || {
- plugin::build::find_plugin_registrar(sess.diagnostic(), krate)
+ plugin::build::find_plugin_registrar(sess.diagnostic(), &hir_map)
}));
let region_map = time(time_passes,
"region resolution",
}));
let region_map = time(time_passes,
"region resolution",
- || middle::region::resolve_crate(sess, krate));
+ || middle::region::resolve_crate(sess, &hir_map));
time(time_passes,
"loop checking",
time(time_passes,
"loop checking",
- || loops::check_crate(sess, krate));
+ || loops::check_crate(sess, &hir_map));
try!(time(time_passes,
"static item recursion checking",
try!(time(time_passes,
"static item recursion checking",
- || static_recursion::check_crate(sess, krate, &def_map.borrow(), &hir_map)));
+ || static_recursion::check_crate(sess, &def_map.borrow(), &hir_map)));
+
+ let index = stability::Index::new(&hir_map);
ty::ctxt::create_and_enter(sess,
arenas,
ty::ctxt::create_and_enter(sess,
arenas,
freevars,
region_map,
lang_items,
freevars,
region_map,
lang_items,
- stability::Index::new(krate),
|tcx| {
// passes are timed inside typeck
try_with_f!(typeck::check_crate(tcx, trait_map), (tcx, None, analysis));
|tcx| {
// passes are timed inside typeck
try_with_f!(typeck::check_crate(tcx, trait_map), (tcx, None, analysis));
// Do not move this check past lint
time(time_passes, "stability index", || {
// Do not move this check past lint
time(time_passes, "stability index", || {
- tcx.stability.borrow_mut().build(tcx, krate, &analysis.access_levels)
+ tcx.stability.borrow_mut().build(tcx, &analysis.access_levels)
use {driver, abort_on_err};
use {driver, abort_on_err};
+use rustc::dep_graph::DepGraph;
use rustc::middle::ty;
use rustc::middle::cfg;
use rustc::middle::cfg::graphviz::LabelledCFG;
use rustc::middle::ty;
use rustc::middle::cfg;
use rustc::middle::cfg::graphviz::LabelledCFG;
sess: sess,
ast_map: Some(ast_map.clone()),
};
sess: sess,
ast_map: Some(ast_map.clone()),
};
- f(&annotation, payload, &ast_map.forest.krate)
+ f(&annotation, payload, ast_map.forest.krate())
sess: sess,
ast_map: Some(ast_map.clone()),
};
sess: sess,
ast_map: Some(ast_map.clone()),
};
- f(&annotation, payload, &ast_map.forest.krate)
+ f(&annotation, payload, ast_map.forest.krate())
}
PpmTyped => {
abort_on_err(driver::phase_3_run_analysis_passes(sess,
}
PpmTyped => {
abort_on_err(driver::phase_3_run_analysis_passes(sess,
let _ignore = tcx.dep_graph.in_ignore();
f(&annotation,
payload,
let _ignore = tcx.dep_graph.in_ignore();
f(&annotation,
payload,
+ ast_map.forest.krate())
}), sess)
}
_ => panic!("Should use call_with_pp_support"),
}), sess)
}
_ => panic!("Should use call_with_pp_support"),
let mut hir_forest;
let lcx = LoweringContext::new(&sess, Some(&krate));
let arenas = ty::CtxtArenas::new();
let mut hir_forest;
let lcx = LoweringContext::new(&sess, Some(&krate));
let arenas = ty::CtxtArenas::new();
+ let dep_graph = DepGraph::new(false);
+ let _ignore = dep_graph.in_ignore();
let ast_map = if compute_ast_map {
let ast_map = if compute_ast_map {
- hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate));
+ hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate), dep_graph.clone());
let map = driver::make_map(&sess, &mut hir_forest);
Some(map)
} else {
let map = driver::make_map(&sess, &mut hir_forest);
Some(map)
} else {
//! # Standalone Tests for the Inference Module
use driver;
//! # Standalone Tests for the Inference Module
use driver;
+use rustc::dep_graph::DepGraph;
use rustc_lint;
use rustc_resolve as resolve;
use rustc_typeck::middle::lang_items;
use rustc_lint;
use rustc_resolve as resolve;
use rustc_typeck::middle::lang_items;
let krate = driver::assign_node_ids(&sess, krate);
let lcx = LoweringContext::new(&sess, Some(&krate));
let krate = driver::assign_node_ids(&sess, krate);
let lcx = LoweringContext::new(&sess, Some(&krate));
- let mut hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate));
+ let dep_graph = DepGraph::new(false);
+ let _ignore = dep_graph.in_ignore();
+ let mut hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate), dep_graph.clone());
let arenas = ty::CtxtArenas::new();
let ast_map = driver::make_map(&sess, &mut hir_forest);
let arenas = ty::CtxtArenas::new();
let ast_map = driver::make_map(&sess, &mut hir_forest);
- let krate = ast_map.krate();
// run just enough stuff to build a tcx:
let lang_items = lang_items::collect_language_items(&sess, &ast_map);
let resolve::CrateMap { def_map, freevars, .. } =
resolve::resolve_crate(&sess, &ast_map, resolve::MakeGlobMap::No);
// run just enough stuff to build a tcx:
let lang_items = lang_items::collect_language_items(&sess, &ast_map);
let resolve::CrateMap { def_map, freevars, .. } =
resolve::resolve_crate(&sess, &ast_map, resolve::MakeGlobMap::No);
- let named_region_map = resolve_lifetime::krate(&sess, krate, &def_map.borrow());
- let region_map = region::resolve_crate(&sess, krate);
+ let named_region_map = resolve_lifetime::krate(&sess, &ast_map, &def_map.borrow());
+ let region_map = region::resolve_crate(&sess, &ast_map);
+ let index = stability::Index::new(&ast_map);
ty::ctxt::create_and_enter(&sess,
&arenas,
def_map,
ty::ctxt::create_and_enter(&sess,
&arenas,
def_map,
freevars,
region_map,
lang_items,
freevars,
region_map,
lang_items,
- stability::Index::new(krate),
|tcx| {
let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, None);
body(Env { infcx: &infcx });
|tcx| {
let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, None);
body(Env { infcx: &infcx });
use loader::{self, CratePaths};
use rustc::back::svh::Svh;
use loader::{self, CratePaths};
use rustc::back::svh::Svh;
+use rustc::dep_graph::DepNode;
use rustc::session::{config, Session};
use rustc::session::search_paths::PathKind;
use rustc::middle::cstore::{CrateStore, validate_crate_name};
use rustc::session::{config, Session};
use rustc::session::search_paths::PathKind;
use rustc::middle::cstore::{CrateStore, validate_crate_name};
// Traverses an AST, reading all the information about use'd crates and
// extern libraries necessary for later resolving, typechecking, linking,
// etc.
// Traverses an AST, reading all the information about use'd crates and
// extern libraries necessary for later resolving, typechecking, linking,
// etc.
- pub fn read_crates(&mut self, krate: &hir::Crate) {
+ pub fn read_crates(&mut self) {
+ let _task = self.ast_map.dep_graph.in_task(DepNode::CrateReader);
+ let krate = self.ast_map.krate();
+
self.process_crate(krate);
krate.visit_all_items(self);
self.creader.inject_allocator_crate();
self.process_crate(krate);
krate.visit_all_items(self);
self.creader.inject_allocator_crate();
use rustc::session::Session;
use rustc::session::Session;
-use syntax::codemap::Span;
+use rustc::dep_graph::DepNode;
+use rustc::front::map::Map;
use rustc_front::intravisit::{self, Visitor};
use rustc_front::hir;
use rustc_front::intravisit::{self, Visitor};
use rustc_front::hir;
+use syntax::codemap::Span;
#[derive(Clone, Copy, PartialEq)]
enum Context {
#[derive(Clone, Copy, PartialEq)]
enum Context {
-pub fn check_crate(sess: &Session, krate: &hir::Crate) {
+pub fn check_crate(sess: &Session, map: &Map) {
+ let _task = map.dep_graph.in_task(DepNode::CheckLoops);
+ let krate = map.krate();
krate.visit_all_items(&mut CheckLoopVisitor { sess: sess, cx: Normal });
}
krate.visit_all_items(&mut CheckLoopVisitor { sess: sess, cx: Normal });
}
// This compiler pass detects constants that refer to themselves
// recursively.
// This compiler pass detects constants that refer to themselves
// recursively.
+use rustc::dep_graph::DepNode;
use rustc::front::map as ast_map;
use rustc::session::{Session, CompileResult};
use rustc::middle::def::{Def, DefMap};
use rustc::front::map as ast_map;
use rustc::session::{Session, CompileResult};
use rustc::middle::def::{Def, DefMap};
}
pub fn check_crate<'ast>(sess: &Session,
}
pub fn check_crate<'ast>(sess: &Session,
- krate: &'ast hir::Crate,
- ast_map: &ast_map::Map<'ast>) -> CompileResult {
+ ast_map: &ast_map::Map<'ast>)
+ -> CompileResult {
+ let _task = ast_map.dep_graph.in_task(DepNode::CheckStaticRecursion);
+
let mut visitor = CheckCrateVisitor {
sess: sess,
def_map: def_map,
let mut visitor = CheckCrateVisitor {
sess: sess,
def_map: def_map,
discriminant_map: RefCell::new(NodeMap()),
};
sess.track_errors(|| {
discriminant_map: RefCell::new(NodeMap()),
};
sess.track_errors(|| {
- krate.visit_all_items(&mut visitor);
+ ast_map.krate().visit_all_items(&mut visitor);
use syntax::attr;
use syntax::codemap::Span;
use syntax::errors;
use syntax::attr;
use syntax::codemap::Span;
use syntax::errors;
+use rustc::dep_graph::DepNode;
+use rustc::front::map::Map;
use rustc_front::intravisit::Visitor;
use rustc_front::hir;
use rustc_front::intravisit::Visitor;
use rustc_front::hir;
/// Find the function marked with `#[plugin_registrar]`, if any.
pub fn find_plugin_registrar(diagnostic: &errors::Handler,
/// Find the function marked with `#[plugin_registrar]`, if any.
pub fn find_plugin_registrar(diagnostic: &errors::Handler,
+ let _task = hir_map.dep_graph.in_task(DepNode::PluginRegistrar);
+ let krate = hir_map.krate();
+
let mut finder = RegistrarFinder { registrars: Vec::new() };
krate.visit_all_items(&mut finder);
let mut finder = RegistrarFinder { registrars: Vec::new() };
krate.visit_all_items(&mut finder);
use self::ParentLink::*;
use self::FallbackChecks::*;
use self::ParentLink::*;
use self::FallbackChecks::*;
+use rustc::dep_graph::DepNode;
use rustc::front::map as hir_map;
use rustc::session::Session;
use rustc::lint;
use rustc::front::map as hir_map;
use rustc::session::Session;
use rustc::lint;
ast_map: &'a hir_map::Map<'tcx>,
make_glob_map: MakeGlobMap)
-> CrateMap {
ast_map: &'a hir_map::Map<'tcx>,
make_glob_map: MakeGlobMap)
-> CrateMap {
+ // Currently, we ignore the name resolution data structures for
+ // the purposes of dependency tracking. Instead we will run name
+ // resolution and include its output in the hash of each item,
+ // much like we do for macro expansion. In other words, the hash
+ // reflects not just its contents but the results of name
+ // resolution on those contents. Hopefully we'll push this back at
+ // some point.
+ let _task = ast_map.dep_graph.in_task(DepNode::Resolve);
+
let krate = ast_map.krate();
let arenas = Resolver::arenas();
let mut resolver = create_resolver(session, ast_map, krate, make_glob_map, &arenas, None);
let krate = ast_map.krate();
let arenas = Resolver::arenas();
let mut resolver = create_resolver(session, ast_map, krate, make_glob_map, &arenas, None);
pub use rustc::session;
pub use rustc::util;
pub use rustc::session;
pub use rustc::util;
use front::map as hir_map;
use middle::def::Def;
use middle::infer::{self, TypeOrigin};
use front::map as hir_map;
use middle::def::Def;
use middle::infer::{self, TypeOrigin};
fn check_for_entry_fn(ccx: &CrateCtxt) {
let tcx = ccx.tcx;
fn check_for_entry_fn(ccx: &CrateCtxt) {
let tcx = ccx.tcx;
+ let _task = tcx.dep_graph.in_task(DepNode::CheckEntryFn);
match *tcx.sess.entry_fn.borrow() {
Some((id, sp)) => match tcx.sess.entry_type.get() {
Some(config::EntryMain) => check_main_fn_ty(ccx, id, sp),
match *tcx.sess.entry_fn.borrow() {
Some((id, sp)) => match tcx.sess.entry_type.get() {
Some(config::EntryMain) => check_main_fn_ty(ccx, id, sp),