bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Group some commonly passed together values into a struct

Browse source
This commit is contained in:
Oli Scherer 2022-12-07 08:42:21 +00:00
parent f5c601492e
commit 42f75f1e46
7 changed files with 77 additions and 119 deletions
Download patch file Download diff file Expand all files Collapse all files

64
compiler/rustc_driver/src/lib.rs
View file

@ -26,6 +26,7 @@ use rustc_errors::registry::{InvalidErrorCode, Registry};
use rustc_errors::{ErrorGuaranteed, PResult};
use rustc_feature::find_gated_cfg;
use rustc_hir::def_id::LOCAL_CRATE;
use rustc_interface::interface::CompilerIO;
use rustc_interface::util::{self, collect_crate_types, get_codegen_backend};
use rustc_interface::{interface, Queries};
use rustc_lint::LintStore;
@ -262,10 +263,8 @@ fn run_compiler(
let should_stop = print_crate_info(
&***compiler.codegen_backend(),
compiler.session(),
None,
compiler.output_dir(),
compiler.output_file(),
compiler.temps_dir(),
false,
compiler.io(),
);
if should_stop == Compilation::Stop {
@ -288,16 +287,14 @@ fn run_compiler(
interface::run_compiler(config, |compiler| {
let sess = compiler.session();
let should_stop = print_crate_info(
&***compiler.codegen_backend(),
sess,
Some(compiler.input()),
compiler.output_dir(),
compiler.output_file(),
compiler.temps_dir(),
)
let should_stop =
print_crate_info(&***compiler.codegen_backend(), sess, true, compiler.io())
.and_then(|| {
list_metadata(sess, &*compiler.codegen_backend().metadata_loader(), compiler.input())
list_metadata(
sess,
&*compiler.codegen_backend().metadata_loader(),
&compiler.io().input,
)
})
.and_then(|| try_process_rlink(sess, compiler));
@ -315,22 +312,15 @@ fn run_compiler(
queries.global_ctxt()?.enter(|tcx| {
pretty::print_after_hir_lowering(
tcx,
compiler.input(),
compiler.io(),
&*expanded_crate,
*ppm,
compiler.output_file().as_deref(),
);
Ok(())
})?;
} else {
let krate = queries.parse()?.steal();
pretty::print_after_parsing(
sess,
compiler.input(),
&krate,
*ppm,
compiler.output_file().as_deref(),
);
pretty::print_after_parsing(sess, compiler.io(), &krate, *ppm);
}
trace!("finished pretty-printing");
return early_exit();
@ -380,9 +370,9 @@ fn run_compiler(
save::process_crate(
tcx,
crate_name,
compiler.input(),
&compiler.io().input,
None,
DumpHandler::new(compiler.output_dir().as_deref(), crate_name),
DumpHandler::new(compiler.io().output_dir.as_deref(), crate_name),
)
});
}
@ -556,7 +546,7 @@ fn show_content_with_pager(content: &str) {
pub fn try_process_rlink(sess: &Session, compiler: &interface::Compiler) -> Compilation {
if sess.opts.unstable_opts.link_only {
if let Input::File(file) = compiler.input() {
if let Input::File(file) = &compiler.io().input {
// FIXME: #![crate_type] and #![crate_name] support not implemented yet
sess.init_crate_types(collect_crate_types(sess, &[]));
let outputs = compiler.build_output_filenames(sess, &[]);
@ -623,10 +613,8 @@ pub fn list_metadata(
fn print_crate_info(
codegen_backend: &dyn CodegenBackend,
sess: &Session,
input: Option<&Input>,
odir: &Option<PathBuf>,
ofile: &Option<PathBuf>,
temps_dir: &Option<PathBuf>,
parse_attrs: bool,
io: &CompilerIO,
) -> Compilation {
use rustc_session::config::PrintRequest::*;
// NativeStaticLibs and LinkArgs are special - printed during linking
@ -635,10 +623,8 @@ fn print_crate_info(
return Compilation::Continue;
}
let attrs = match input {
None => None,
Some(input) => {
let result = parse_crate_attrs(sess, input);
let attrs = if parse_attrs {
let result = parse_crate_attrs(sess, &io.input);
match result {
Ok(attrs) => Some(attrs),
Err(mut parse_error) => {
@ -646,7 +632,8 @@ fn print_crate_info(
return Compilation::Stop;
}
}
}
} else {
None
};
for req in &sess.opts.prints {
match *req {
@ -661,14 +648,9 @@ fn print_crate_info(
println!("{}", serde_json::to_string_pretty(&sess.target.to_json()).unwrap());
}
FileNames | CrateName => {
let input = input.unwrap_or_else(|| {
early_error(ErrorOutputType::default(), "no input file provided")
});
let attrs = attrs.as_ref().unwrap();
let t_outputs = rustc_interface::util::build_output_filenames(
input, odir, ofile, temps_dir, attrs, sess,
);
let id = rustc_session::output::find_crate_name(sess, attrs, input);
let t_outputs = rustc_interface::util::build_output_filenames(io, attrs, sess);
let id = rustc_session::output::find_crate_name(sess, attrs, &io.input);
if *req == PrintRequest::CrateName {
println!("{id}");
continue;

28
compiler/rustc_driver/src/pretty.rs
View file

@ -6,6 +6,7 @@ use rustc_ast_pretty::pprust;
use rustc_errors::ErrorGuaranteed;
use rustc_hir as hir;
use rustc_hir_pretty as pprust_hir;
use rustc_interface::interface::CompilerIO;
use rustc_middle::hir::map as hir_map;
use rustc_middle::mir::{write_mir_graphviz, write_mir_pretty};
use rustc_middle::ty::{self, TyCtxt};
@ -16,7 +17,7 @@ use rustc_span::FileName;
use std::cell::Cell;
use std::fmt::Write;
use std::path::Path;
use std::path::PathBuf;
pub use self::PpMode::*;
pub use self::PpSourceMode::*;
@ -358,7 +359,7 @@ fn get_source(input: &Input, sess: &Session) -> (String, FileName) {
(src, src_name)
}
fn write_or_print(out: &str, ofile: Option<&Path>, sess: &Session) {
fn write_or_print(out: &str, ofile: &Option<PathBuf>, sess: &Session) {
match ofile {
None => print!("{out}"),
Some(p) => {
@ -372,14 +373,8 @@ fn write_or_print(out: &str, ofile: Option<&Path>, sess: &Session) {
}
}
pub fn print_after_parsing(
sess: &Session,
input: &Input,
krate: &ast::Crate,
ppm: PpMode,
ofile: Option<&Path>,
) {
let (src, src_name) = get_source(input, sess);
pub fn print_after_parsing(sess: &Session, io: &CompilerIO, krate: &ast::Crate, ppm: PpMode) {
let (src, src_name) = get_source(&io.input, sess);
let out = match ppm {
Source(s) => {
@ -407,22 +402,21 @@ pub fn print_after_parsing(
_ => unreachable!(),
};
write_or_print(&out, ofile, sess);
write_or_print(&out, &io.output_file, sess);
}
pub fn print_after_hir_lowering<'tcx>(
tcx: TyCtxt<'tcx>,
input: &Input,
io: &CompilerIO,
krate: &ast::Crate,
ppm: PpMode,
ofile: Option<&Path>,
) {
if ppm.needs_analysis() {
abort_on_err(print_with_analysis(tcx, ppm, ofile), tcx.sess);
abort_on_err(print_with_analysis(tcx, ppm, &io.output_file), tcx.sess);
return;
}
let (src, src_name) = get_source(input, tcx.sess);
let (src, src_name) = get_source(&io.input, tcx.sess);
let out = match ppm {
Source(s) => {
@ -474,7 +468,7 @@ pub fn print_after_hir_lowering<'tcx>(
_ => unreachable!(),
};
write_or_print(&out, ofile, tcx.sess);
write_or_print(&out, &io.output_file, tcx.sess);
}
// In an ideal world, this would be a public function called by the driver after
@ -484,7 +478,7 @@ pub fn print_after_hir_lowering<'tcx>(
fn print_with_analysis(
tcx: TyCtxt<'_>,
ppm: PpMode,
ofile: Option<&Path>,
ofile: &Option<PathBuf>,
) -> Result<(), ErrorGuaranteed> {
tcx.analysis(())?;
let out = match ppm {

36
compiler/rustc_interface/src/interface.rs
View file

@ -35,15 +35,19 @@ pub type Result<T> = result::Result<T, ErrorGuaranteed>;
pub struct Compiler {
pub(crate) sess: Lrc<Session>,
codegen_backend: Lrc<Box<dyn CodegenBackend>>,
pub(crate) input: Input,
pub(crate) output_dir: Option<PathBuf>,
pub(crate) output_file: Option<PathBuf>,
pub(crate) temps_dir: Option<PathBuf>,
pub(crate) io: CompilerIO,
pub(crate) register_lints: Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>>,
pub(crate) override_queries:
Option<fn(&Session, &mut ty::query::Providers, &mut ty::query::ExternProviders)>,
}
pub struct CompilerIO {
pub input: Input,
pub output_dir: Option<PathBuf>,
pub output_file: Option<PathBuf>,
pub temps_dir: Option<PathBuf>,
}
impl Compiler {
pub fn session(&self) -> &Lrc<Session> {
&self.sess
@ -51,17 +55,8 @@ impl Compiler {
pub fn codegen_backend(&self) -> &Lrc<Box<dyn CodegenBackend>> {
&self.codegen_backend
}
pub fn input(&self) -> &Input {
&self.input
}
pub fn output_dir(&self) -> &Option<PathBuf> {
&self.output_dir
}
pub fn output_file(&self) -> &Option<PathBuf> {
&self.output_file
}
pub fn temps_dir(&self) -> &Option<PathBuf> {
&self.temps_dir
pub fn io(&self) -> &CompilerIO {
&self.io
}
pub fn register_lints(&self) -> &Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>> {
&self.register_lints
@ -71,14 +66,7 @@ impl Compiler {
sess: &Session,
attrs: &[ast::Attribute],
) -> OutputFilenames {
util::build_output_filenames(
&self.input,
&self.output_dir,
&self.output_file,
&self.temps_dir,
attrs,
sess,
)
util::build_output_filenames(&self.io, attrs, sess)
}
}
@ -305,10 +293,12 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
let compiler = Compiler {
sess: Lrc::new(sess),
codegen_backend: Lrc::new(codegen_backend),
io: CompilerIO {
input: config.input,
output_dir: config.output_dir,
output_file: config.output_file,
temps_dir,
},
register_lints: config.register_lints,
override_queries: config.override_queries,
};

17
compiler/rustc_interface/src/passes.rs
View file

@ -673,20 +673,13 @@ pub fn prepare_outputs(
let _timer = sess.timer("prepare_outputs");
// FIXME: rustdoc passes &[] instead of &krate.attrs here
let outputs = util::build_output_filenames(
&compiler.input,
&compiler.output_dir,
&compiler.output_file,
&compiler.temps_dir,
&krate.attrs,
sess,
);
let outputs = util::build_output_filenames(&compiler.io, &krate.attrs, sess);
let output_paths =
generated_output_paths(sess, &outputs, compiler.output_file.is_some(), crate_name);
generated_output_paths(sess, &outputs, compiler.io.output_file.is_some(), crate_name);
// Ensure the source file isn't accidentally overwritten during compilation.
if let Some(ref input_path) = compiler.input.opt_path() {
if let Some(ref input_path) = compiler.io.input.opt_path() {
if sess.opts.will_create_output_file() {
if output_contains_path(&output_paths, input_path) {
let reported = sess.emit_err(InputFileWouldBeOverWritten { path: input_path });
@ -700,7 +693,7 @@ pub fn prepare_outputs(
}
}
if let Some(ref dir) = compiler.temps_dir {
if let Some(ref dir) = compiler.io.temps_dir {
if fs::create_dir_all(dir).is_err() {
let reported = sess.emit_err(TempsDirError);
return Err(reported);
@ -713,7 +706,7 @@ pub fn prepare_outputs(
&& sess.opts.output_types.len() == 1;
if !only_dep_info {
if let Some(ref dir) = compiler.output_dir {
if let Some(ref dir) = compiler.io.output_dir {
if fs::create_dir_all(dir).is_err() {
let reported = sess.emit_err(OutDirError);
return Err(reported);

4
compiler/rustc_interface/src/queries.rs
View file

@ -129,7 +129,7 @@ impl<'tcx> Queries<'tcx> {
pub fn parse(&self) -> Result<QueryResult<'_, ast::Crate>> {
self.parse.compute(|| {
passes::parse(self.session(), &self.compiler.input)
passes::parse(self.session(), &self.compiler.io.input)
.map_err(|mut parse_error| parse_error.emit())
})
}
@ -165,7 +165,7 @@ impl<'tcx> Queries<'tcx> {
let parse_result = self.parse()?;
let krate = parse_result.borrow();
// parse `#[crate_name]` even if `--crate-name` was passed, to make sure it matches.
find_crate_name(self.session(), &krate.attrs, &self.compiler.input)
find_crate_name(self.session(), &krate.attrs, &self.compiler.io.input)
})
})
}

21
compiler/rustc_interface/src/util.rs
View file

@ -8,7 +8,7 @@ use rustc_parse::validate_attr;
use rustc_session as session;
use rustc_session::config::CheckCfg;
use rustc_session::config::{self, CrateType};
use rustc_session::config::{ErrorOutputType, Input, OutputFilenames};
use rustc_session::config::{ErrorOutputType, OutputFilenames};
use rustc_session::filesearch::sysroot_candidates;
use rustc_session::lint::{self, BuiltinLintDiagnostics, LintBuffer};
use rustc_session::parse::CrateConfig;
@ -25,6 +25,8 @@ use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::OnceLock;
use std::thread;
use crate::interface::CompilerIO;
/// Function pointer type that constructs a new CodegenBackend.
pub type MakeBackendFn = fn() -> Box<dyn CodegenBackend>;
@ -487,19 +489,16 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<C
}
pub fn build_output_filenames(
input: &Input,
odir: &Option<PathBuf>,
ofile: &Option<PathBuf>,
temps_dir: &Option<PathBuf>,
io: &CompilerIO,
attrs: &[ast::Attribute],
sess: &Session,
) -> OutputFilenames {
match *ofile {
match io.output_file {
None => {
// "-" as input file will cause the parser to read from stdin so we
// have to make up a name
// We want to toss everything after the final '.'
let dirpath = (*odir).as_ref().cloned().unwrap_or_default();
let dirpath = io.output_dir.clone().unwrap_or_default();
// If a crate name is present, we use it as the link name
let stem = sess
@ -507,13 +506,13 @@ pub fn build_output_filenames(
.crate_name
.clone()
.or_else(|| rustc_attr::find_crate_name(sess, attrs).map(|n| n.to_string()))
.unwrap_or_else(|| input.filestem().to_owned());
.unwrap_or_else(|| io.input.filestem().to_owned());
OutputFilenames::new(
dirpath,
stem,
None,
temps_dir.clone(),
io.temps_dir.clone(),
sess.opts.cg.extra_filename.clone(),
sess.opts.output_types.clone(),
)
@ -534,7 +533,7 @@ pub fn build_output_filenames(
}
Some(out_file.clone())
};
if *odir != None {
if io.output_dir != None {
sess.warn("ignoring --out-dir flag due to -o flag");
}
@ -542,7 +541,7 @@ pub fn build_output_filenames(
out_file.parent().unwrap_or_else(|| Path::new("")).to_path_buf(),
out_file.file_stem().unwrap_or_default().to_str().unwrap().to_string(),
ofile,
temps_dir.clone(),
io.temps_dir.clone(),
sess.opts.cg.extra_filename.clone(),
sess.opts.output_types.clone(),
)

2
src/tools/miri/src/bin/miri.rs
View file

@ -75,7 +75,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
let mut config = self.miri_config.clone();
// Add filename to `miri` arguments.
config.args.insert(0, compiler.input().filestem().to_string());
config.args.insert(0, compiler.io().input.filestem().to_string());
// Adjust working directory for interpretation.
if let Some(cwd) = env::var_os("MIRI_CWD") {