compiler/rustc_passes/src/entry.rs

   1 use rustc_ast::{entry::EntryPointType, Attribute};
   2 use rustc_errors::struct_span_err;
   3 use rustc_hir::def::DefKind;
   4 use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_ID, LOCAL_CRATE};
   5 use rustc_hir::{ItemId, Node, CRATE_HIR_ID};
   6 use rustc_middle::ty::query::Providers;
   7 use rustc_middle::ty::{DefIdTree, TyCtxt};
   8 use rustc_session::config::{CrateType, EntryFnType};
   9 use rustc_session::parse::feature_err;
  10 use rustc_span::symbol::sym;
  11 use rustc_span::{Span, Symbol, DUMMY_SP};
  12
  13 struct EntryContext<'tcx> {
  14     tcx: TyCtxt<'tcx>,
  15
  16     /// The function that has attribute named `main`.
  17     attr_main_fn: Option<(LocalDefId, Span)>,
  18
  19     /// The function that has the attribute 'start' on it.
  20     start_fn: Option<(LocalDefId, Span)>,
  21
  22     /// The functions that one might think are `main` but aren't, e.g.
  23     /// main functions not defined at the top level. For diagnostics.
  24     non_main_fns: Vec<Span>,
  25 }
  26
  27 fn entry_fn(tcx: TyCtxt<'_>, (): ()) -> Option<(DefId, EntryFnType)> {
  28     let any_exe = tcx.sess.crate_types().iter().any(|ty| *ty == CrateType::Executable);
  29     if !any_exe {
  30         // No need to find a main function.
  31         return None;
  32     }
  33
  34     // If the user wants no main function at all, then stop here.
  35     if tcx.sess.contains_name(&tcx.hir().attrs(CRATE_HIR_ID), sym::no_main) {
  36         return None;
  37     }
  38
  39     let mut ctxt =
  40         EntryContext { tcx, attr_main_fn: None, start_fn: None, non_main_fns: Vec::new() };
  41
  42     for id in tcx.hir().items() {
  43         find_item(id, &mut ctxt);
  44     }
  45
  46     configure_main(tcx, &ctxt)
  47 }
  48
  49 // Beware, this is duplicated in `librustc_builtin_macros/test_harness.rs`
  50 // (with `ast::Item`), so make sure to keep them in sync.
  51 // A small optimization was added so that hir::Item is fetched only when needed.
  52 // An equivalent optimization was not applied to the duplicated code in test_harness.rs.
  53 fn entry_point_type(ctxt: &EntryContext<'_>, id: ItemId, at_root: bool) -> EntryPointType {
  54     let attrs = ctxt.tcx.hir().attrs(id.hir_id());
  55     if ctxt.tcx.sess.contains_name(attrs, sym::start) {
  56         EntryPointType::Start
  57     } else if ctxt.tcx.sess.contains_name(attrs, sym::rustc_main) {
  58         EntryPointType::RustcMainAttr
  59     } else {
  60         if let Some(name) = ctxt.tcx.opt_item_name(id.def_id.to_def_id())
  61             && name == sym::main {
  62             if at_root {
  63                 // This is a top-level function so can be `main`.
  64                 EntryPointType::MainNamed
  65             } else {
  66                 EntryPointType::OtherMain
  67             }
  68         } else {
  69             EntryPointType::None
  70         }
  71     }
  72 }
  73
  74 fn err_if_attr_found(ctxt: &EntryContext<'_>, attrs: &[Attribute], sym: Symbol) {
  75     if let Some(attr) = ctxt.tcx.sess.find_by_name(attrs, sym) {
  76         ctxt.tcx
  77             .sess
  78             .struct_span_err(
  79                 attr.span,
  80                 &format!("`{}` attribute can only be used on functions", sym),
  81             )
  82             .emit();
  83     }
  84 }
  85
  86 fn find_item(id: ItemId, ctxt: &mut EntryContext<'_>) {
  87     let at_root = ctxt.tcx.opt_local_parent(id.def_id) == Some(CRATE_DEF_ID);
  88
  89     match entry_point_type(ctxt, id, at_root) {
  90         EntryPointType::None => (),
  91         _ if !matches!(ctxt.tcx.def_kind(id.def_id), DefKind::Fn) => {
  92             let attrs = ctxt.tcx.hir().attrs(id.hir_id());
  93             err_if_attr_found(ctxt, attrs, sym::start);
  94             err_if_attr_found(ctxt, attrs, sym::rustc_main);
  95         }
  96         EntryPointType::MainNamed => (),
  97         EntryPointType::OtherMain => {
  98             ctxt.non_main_fns.push(ctxt.tcx.def_span(id.def_id));
  99         }
 100         EntryPointType::RustcMainAttr => {
 101             if ctxt.attr_main_fn.is_none() {
 102                 ctxt.attr_main_fn = Some((id.def_id, ctxt.tcx.def_span(id.def_id.to_def_id())));
 103             } else {
 104                 struct_span_err!(
 105                     ctxt.tcx.sess,
 106                     ctxt.tcx.def_span(id.def_id.to_def_id()),
 107                     E0137,
 108                     "multiple functions with a `#[rustc_main]` attribute"
 109                 )
 110                 .span_label(
 111                     ctxt.tcx.def_span(id.def_id.to_def_id()),
 112                     "additional `#[rustc_main]` function",
 113                 )
 114                 .span_label(ctxt.attr_main_fn.unwrap().1, "first `#[rustc_main]` function")
 115                 .emit();
 116             }
 117         }
 118         EntryPointType::Start => {
 119             if ctxt.start_fn.is_none() {
 120                 ctxt.start_fn = Some((id.def_id, ctxt.tcx.def_span(id.def_id.to_def_id())));
 121             } else {
 122                 struct_span_err!(
 123                     ctxt.tcx.sess,
 124                     ctxt.tcx.def_span(id.def_id.to_def_id()),
 125                     E0138,
 126                     "multiple `start` functions"
 127                 )
 128                 .span_label(ctxt.start_fn.unwrap().1, "previous `#[start]` function here")
 129                 .span_label(ctxt.tcx.def_span(id.def_id.to_def_id()), "multiple `start` functions")
 130                 .emit();
 131             }
 132         }
 133     }
 134 }
 135
 136 fn configure_main(tcx: TyCtxt<'_>, visitor: &EntryContext<'_>) -> Option<(DefId, EntryFnType)> {
 137     if let Some((def_id, _)) = visitor.start_fn {
 138         Some((def_id.to_def_id(), EntryFnType::Start))
 139     } else if let Some((def_id, _)) = visitor.attr_main_fn {
 140         Some((def_id.to_def_id(), EntryFnType::Main))
 141     } else {
 142         if let Some(main_def) = tcx.resolutions(()).main_def && let Some(def_id) = main_def.opt_fn_def_id() {
 143             // non-local main imports are handled below
 144             if let Some(def_id) = def_id.as_local() && matches!(tcx.hir().find_by_def_id(def_id), Some(Node::ForeignItem(_))) {
 145                 tcx.sess
 146                     .struct_span_err(
 147                         tcx.def_span(def_id),
 148                         "the `main` function cannot be declared in an `extern` block",
 149                     )
 150                     .emit();
 151                 return None;
 152             }
 153
 154             if main_def.is_import && !tcx.features().imported_main {
 155                 let span = main_def.span;
 156                 feature_err(
 157                     &tcx.sess.parse_sess,
 158                     sym::imported_main,
 159                     span,
 160                     "using an imported function as entry point `main` is experimental",
 161                 )
 162                 .emit();
 163             }
 164             return Some((def_id, EntryFnType::Main));
 165         }
 166         no_main_err(tcx, visitor);
 167         None
 168     }
 169 }
 170
 171 fn no_main_err(tcx: TyCtxt<'_>, visitor: &EntryContext<'_>) {
 172     let sp = tcx.def_span(CRATE_DEF_ID);
 173     if *tcx.sess.parse_sess.reached_eof.borrow() {
 174         // There's an unclosed brace that made the parser reach `Eof`, we shouldn't complain about
 175         // the missing `fn main()` then as it might have been hidden inside an unclosed block.
 176         tcx.sess.delay_span_bug(sp, "`main` not found, but expected unclosed brace error");
 177         return;
 178     }
 179
 180     // There is no main function.
 181     let mut err = struct_span_err!(
 182         tcx.sess,
 183         DUMMY_SP,
 184         E0601,
 185         "`main` function not found in crate `{}`",
 186         tcx.crate_name(LOCAL_CRATE)
 187     );
 188     let filename = &tcx.sess.local_crate_source_file;
 189     let note = if !visitor.non_main_fns.is_empty() {
 190         for &span in &visitor.non_main_fns {
 191             err.span_note(span, "here is a function named `main`");
 192         }
 193         err.note("you have one or more functions named `main` not defined at the crate level");
 194         err.help("consider moving the `main` function definitions");
 195         // There were some functions named `main` though. Try to give the user a hint.
 196         format!(
 197             "the main function must be defined at the crate level{}",
 198             filename.as_ref().map(|f| format!(" (in `{}`)", f.display())).unwrap_or_default()
 199         )
 200     } else if let Some(filename) = filename {
 201         format!("consider adding a `main` function to `{}`", filename.display())
 202     } else {
 203         String::from("consider adding a `main` function at the crate level")
 204     };
 205     // The file may be empty, which leads to the diagnostic machinery not emitting this
 206     // note. This is a relatively simple way to detect that case and emit a span-less
 207     // note instead.
 208     if tcx.sess.source_map().lookup_line(sp.hi()).is_ok() {
 209         err.set_span(sp.shrink_to_hi());
 210         err.span_label(sp.shrink_to_hi(), &note);
 211     } else {
 212         err.note(&note);
 213     }
 214
 215     if let Some(main_def) = tcx.resolutions(()).main_def && main_def.opt_fn_def_id().is_none(){
 216         // There is something at `crate::main`, but it is not a function definition.
 217         err.span_label(main_def.span, "non-function item at `crate::main` is found");
 218     }
 219
 220     if tcx.sess.teach(&err.get_code().unwrap()) {
 221         err.note(
 222             "If you don't know the basics of Rust, you can go look to the Rust Book \
 223                   to get started: https://doc.rust-lang.org/book/",
 224         );
 225     }
 226     err.emit();
 227 }
 228
 229 pub fn provide(providers: &mut Providers) {
 230     *providers = Providers { entry_fn, ..*providers };
 231 }