dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Move compiler input and ouput paths into session

This commit is contained in:
Oli Scherer 2022-12-07 09:24:00 +00:00
parent 42f75f1e46
commit 9f5cd03153
15 changed files with 113 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs
View File

@ -68,7 +68,7 @@ impl DebugContext {
.working_dir
.to_string_lossy(FileNameDisplayPreference::Remapped)
.into_owned();
let (name, file_info) = match tcx.sess.local_crate_source_file.clone() {
let (name, file_info) = match tcx.sess.local_crate_source_file() {
Some(path) => {
let name = path.to_string_lossy().into_owned();
(name, None)

8
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
View File

@ -782,10 +782,10 @@ pub fn build_compile_unit_di_node<'ll, 'tcx>(
codegen_unit_name: &str,
debug_context: &CodegenUnitDebugContext<'ll, 'tcx>,
) -> &'ll DIDescriptor {
let mut name_in_debuginfo = match tcx.sess.local_crate_source_file {
Some(ref path) => path.clone(),
None => PathBuf::from(tcx.crate_name(LOCAL_CRATE).as_str()),
};
let mut name_in_debuginfo = tcx
.sess
.local_crate_source_file()
.unwrap_or_else(|| PathBuf::from(tcx.crate_name(LOCAL_CRATE).as_str()));
// To avoid breaking split DWARF, we need to ensure that each codegen unit
// has a unique `DW_AT_name`. This is because there's a remote chance that

56
compiler/rustc_driver/src/lib.rs
View File

@ -26,7 +26,6 @@ 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;
@ -260,12 +259,8 @@ fn run_compiler(
describe_lints(compiler.session(), &lint_store, registered_lints);
return;
}
let should_stop = print_crate_info(
&***compiler.codegen_backend(),
compiler.session(),
false,
compiler.io(),
);
let should_stop =
print_crate_info(&***compiler.codegen_backend(), compiler.session(), false);
if should_stop == Compilation::Stop {
return;
@ -287,16 +282,9 @@ fn run_compiler(
interface::run_compiler(config, |compiler| {
let sess = compiler.session();
let should_stop =
print_crate_info(&***compiler.codegen_backend(), sess, true, compiler.io())
.and_then(|| {
list_metadata(
sess,
&*compiler.codegen_backend().metadata_loader(),
&compiler.io().input,
)
})
.and_then(|| try_process_rlink(sess, compiler));
let should_stop = print_crate_info(&***compiler.codegen_backend(), sess, true)
.and_then(|| list_metadata(sess, &*compiler.codegen_backend().metadata_loader()))
.and_then(|| try_process_rlink(sess, compiler));
if should_stop == Compilation::Stop {
return sess.compile_status();
@ -310,17 +298,12 @@ fn run_compiler(
if ppm.needs_ast_map() {
let expanded_crate = queries.expansion()?.borrow().0.clone();
queries.global_ctxt()?.enter(|tcx| {
pretty::print_after_hir_lowering(
tcx,
compiler.io(),
&*expanded_crate,
*ppm,
);
pretty::print_after_hir_lowering(tcx, &*expanded_crate, *ppm);
Ok(())
})?;
} else {
let krate = queries.parse()?.steal();
pretty::print_after_parsing(sess, compiler.io(), &krate, *ppm);
pretty::print_after_parsing(sess, &krate, *ppm);
}
trace!("finished pretty-printing");
return early_exit();
@ -370,9 +353,9 @@ fn run_compiler(
save::process_crate(
tcx,
crate_name,
&compiler.io().input,
&sess.io.input,
None,
DumpHandler::new(compiler.io().output_dir.as_deref(), crate_name),
DumpHandler::new(sess.io.output_dir.as_deref(), crate_name),
)
});
}
@ -546,7 +529,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.io().input {
if let Input::File(file) = &sess.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, &[]);
@ -587,13 +570,9 @@ pub fn try_process_rlink(sess: &Session, compiler: &interface::Compiler) -> Comp
}
}
pub fn list_metadata(
sess: &Session,
metadata_loader: &dyn MetadataLoader,
input: &Input,
) -> Compilation {
pub fn list_metadata(sess: &Session, metadata_loader: &dyn MetadataLoader) -> Compilation {
if sess.opts.unstable_opts.ls {
match *input {
match sess.io.input {
Input::File(ref ifile) => {
let path = &(*ifile);
let mut v = Vec::new();
@ -614,7 +593,6 @@ fn print_crate_info(
codegen_backend: &dyn CodegenBackend,
sess: &Session,
parse_attrs: bool,
io: &CompilerIO,
) -> Compilation {
use rustc_session::config::PrintRequest::*;
// NativeStaticLibs and LinkArgs are special - printed during linking
@ -624,7 +602,7 @@ fn print_crate_info(
}
let attrs = if parse_attrs {
let result = parse_crate_attrs(sess, &io.input);
let result = parse_crate_attrs(sess);
match result {
Ok(attrs) => Some(attrs),
Err(mut parse_error) => {
@ -649,8 +627,8 @@ fn print_crate_info(
}
FileNames | CrateName => {
let attrs = attrs.as_ref().unwrap();
let t_outputs = rustc_interface::util::build_output_filenames(io, attrs, sess);
let id = rustc_session::output::find_crate_name(sess, attrs, &io.input);
let t_outputs = rustc_interface::util::build_output_filenames(attrs, sess);
let id = rustc_session::output::find_crate_name(sess, attrs);
if *req == PrintRequest::CrateName {
println!("{id}");
continue;
@ -1086,8 +1064,8 @@ pub fn handle_options(args: &[String]) -> Option<getopts::Matches> {
Some(matches)
}
fn parse_crate_attrs<'a>(sess: &'a Session, input: &Input) -> PResult<'a, ast::AttrVec> {
match input {
fn parse_crate_attrs<'a>(sess: &'a Session) -> PResult<'a, ast::AttrVec> {
match &sess.io.input {
Input::File(ifile) => rustc_parse::parse_crate_attrs_from_file(ifile, &sess.parse_sess),
Input::Str { name, input } => rustc_parse::parse_crate_attrs_from_source_str(
name.clone(),

39
compiler/rustc_driver/src/pretty.rs
View File

@ -6,18 +6,16 @@ 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};
use rustc_session::config::{Input, PpAstTreeMode, PpHirMode, PpMode, PpSourceMode};
use rustc_session::config::{PpAstTreeMode, PpHirMode, PpMode, PpSourceMode};
use rustc_session::Session;
use rustc_span::symbol::Ident;
use rustc_span::FileName;
use std::cell::Cell;
use std::fmt::Write;
use std::path::PathBuf;
pub use self::PpMode::*;
pub use self::PpSourceMode::*;
@ -346,8 +344,8 @@ impl<'tcx> pprust_hir::PpAnn for TypedAnnotation<'tcx> {
}
}
fn get_source(input: &Input, sess: &Session) -> (String, FileName) {
let src_name = input.source_name();
fn get_source(sess: &Session) -> (String, FileName) {
let src_name = sess.io.input.source_name();
let src = String::clone(
sess.source_map()
.get_source_file(&src_name)
@ -359,8 +357,8 @@ fn get_source(input: &Input, sess: &Session) -> (String, FileName) {
(src, src_name)
}
fn write_or_print(out: &str, ofile: &Option<PathBuf>, sess: &Session) {
match ofile {
fn write_or_print(out: &str, sess: &Session) {
match &sess.io.output_file {
None => print!("{out}"),
Some(p) => {
if let Err(e) = std::fs::write(p, out) {
@ -373,8 +371,8 @@ fn write_or_print(out: &str, ofile: &Option<PathBuf>, sess: &Session) {
}
}
pub fn print_after_parsing(sess: &Session, io: &CompilerIO, krate: &ast::Crate, ppm: PpMode) {
let (src, src_name) = get_source(&io.input, sess);
pub fn print_after_parsing(sess: &Session, krate: &ast::Crate, ppm: PpMode) {
let (src, src_name) = get_source(sess);
let out = match ppm {
Source(s) => {
@ -402,21 +400,16 @@ pub fn print_after_parsing(sess: &Session, io: &CompilerIO, krate: &ast::Crate,
_ => unreachable!(),
};
write_or_print(&out, &io.output_file, sess);
write_or_print(&out, sess);
}
pub fn print_after_hir_lowering<'tcx>(
tcx: TyCtxt<'tcx>,
io: &CompilerIO,
krate: &ast::Crate,
ppm: PpMode,
) {
pub fn print_after_hir_lowering<'tcx>(tcx: TyCtxt<'tcx>, krate: &ast::Crate, ppm: PpMode) {
if ppm.needs_analysis() {
abort_on_err(print_with_analysis(tcx, ppm, &io.output_file), tcx.sess);
abort_on_err(print_with_analysis(tcx, ppm), tcx.sess);
return;
}
let (src, src_name) = get_source(&io.input, tcx.sess);
let (src, src_name) = get_source(tcx.sess);
let out = match ppm {
Source(s) => {
@ -468,18 +461,14 @@ pub fn print_after_hir_lowering<'tcx>(
_ => unreachable!(),
};
write_or_print(&out, &io.output_file, tcx.sess);
write_or_print(&out, tcx.sess);
}
// In an ideal world, this would be a public function called by the driver after
// analysis is performed. However, we want to call `phase_3_run_analysis_passes`
// with a different callback than the standard driver, so that isn't easy.
// Instead, we call that function ourselves.
fn print_with_analysis(
tcx: TyCtxt<'_>,
ppm: PpMode,
ofile: &Option<PathBuf>,
) -> Result<(), ErrorGuaranteed> {
fn print_with_analysis(tcx: TyCtxt<'_>, ppm: PpMode) -> Result<(), ErrorGuaranteed> {
tcx.analysis(())?;
let out = match ppm {
Mir => {
@ -512,7 +501,7 @@ fn print_with_analysis(
_ => unreachable!(),
};
write_or_print(&out, ofile, tcx.sess);
write_or_print(&out, tcx.sess);
Ok(())
}

32
compiler/rustc_interface/src/interface.rs
View File

@ -14,10 +14,10 @@ use rustc_middle::ty;
use rustc_parse::maybe_new_parser_from_source_str;
use rustc_query_impl::QueryCtxt;
use rustc_session::config::{self, CheckCfg, ErrorOutputType, Input, OutputFilenames};
use rustc_session::early_error;
use rustc_session::lint;
use rustc_session::parse::{CrateConfig, ParseSess};
use rustc_session::Session;
use rustc_session::{early_error, CompilerIO};
use rustc_span::source_map::{FileLoader, FileName};
use rustc_span::symbol::sym;
use std::path::PathBuf;
@ -35,19 +35,11 @@ pub type Result<T> = result::Result<T, ErrorGuaranteed>;
pub struct Compiler {
pub(crate) sess: Lrc<Session>,
codegen_backend: Lrc<Box<dyn CodegenBackend>>,
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
@ -55,9 +47,6 @@ impl Compiler {
pub fn codegen_backend(&self) -> &Lrc<Box<dyn CodegenBackend>> {
&self.codegen_backend
}
pub fn io(&self) -> &CompilerIO {
&self.io
}
pub fn register_lints(&self) -> &Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>> {
&self.register_lints
}
@ -66,7 +55,7 @@ impl Compiler {
sess: &Session,
attrs: &[ast::Attribute],
) -> OutputFilenames {
util::build_output_filenames(&self.io, attrs, sess)
util::build_output_filenames(attrs, sess)
}
}
@ -273,12 +262,19 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
crate::callbacks::setup_callbacks();
let registry = &config.registry;
let temps_dir = config.opts.unstable_opts.temps_dir.as_deref().map(PathBuf::from);
let (mut sess, codegen_backend) = util::create_session(
config.opts,
config.crate_cfg,
config.crate_check_cfg,
config.file_loader,
config.input.opt_path(),
CompilerIO {
input: config.input,
output_dir: config.output_dir,
output_file: config.output_file,
temps_dir,
},
config.lint_caps,
config.make_codegen_backend,
registry.clone(),
@ -288,17 +284,9 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
parse_sess_created(&mut sess.parse_sess);
}
let temps_dir = sess.opts.unstable_opts.temps_dir.as_deref().map(PathBuf::from);
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,
};

15
compiler/rustc_interface/src/passes.rs
View File

@ -50,8 +50,8 @@ use std::rc::Rc;
use std::sync::LazyLock;
use std::{env, fs, iter};
pub fn parse<'a>(sess: &'a Session, input: &Input) -> PResult<'a, ast::Crate> {
let krate = sess.time("parse_crate", || match input {
pub fn parse<'a>(sess: &'a Session) -> PResult<'a, ast::Crate> {
let krate = sess.time("parse_crate", || match &sess.io.input {
Input::File(file) => parse_crate_from_file(file, &sess.parse_sess),
Input::Str { input, name } => {
parse_crate_from_source_str(name.clone(), input.clone(), &sess.parse_sess)
@ -665,7 +665,6 @@ fn write_out_deps(
pub fn prepare_outputs(
sess: &Session,
compiler: &Compiler,
krate: &ast::Crate,
boxed_resolver: &RefCell<BoxedResolver>,
crate_name: Symbol,
@ -673,13 +672,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.io, &krate.attrs, sess);
let outputs = util::build_output_filenames(&krate.attrs, sess);
let output_paths =
generated_output_paths(sess, &outputs, compiler.io.output_file.is_some(), crate_name);
generated_output_paths(sess, &outputs, sess.io.output_file.is_some(), crate_name);
// Ensure the source file isn't accidentally overwritten during compilation.
if let Some(ref input_path) = compiler.io.input.opt_path() {
if let Some(ref input_path) = sess.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 });
@ -693,7 +692,7 @@ pub fn prepare_outputs(
}
}
if let Some(ref dir) = compiler.io.temps_dir {
if let Some(ref dir) = sess.io.temps_dir {
if fs::create_dir_all(dir).is_err() {
let reported = sess.emit_err(TempsDirError);
return Err(reported);
@ -706,7 +705,7 @@ pub fn prepare_outputs(
&& sess.opts.output_types.len() == 1;
if !only_dep_info {
if let Some(ref dir) = compiler.io.output_dir {
if let Some(ref dir) = sess.io.output_dir {
if fs::create_dir_all(dir).is_err() {
let reported = sess.emit_err(OutDirError);
return Err(reported);

16
compiler/rustc_interface/src/queries.rs
View File

@ -128,10 +128,8 @@ impl<'tcx> Queries<'tcx> {
}
pub fn parse(&self) -> Result<QueryResult<'_, ast::Crate>> {
self.parse.compute(|| {
passes::parse(self.session(), &self.compiler.io.input)
.map_err(|mut parse_error| parse_error.emit())
})
self.parse
.compute(|| passes::parse(self.session()).map_err(|mut parse_error| parse_error.emit()))
}
pub fn register_plugins(&self) -> Result<QueryResult<'_, (ast::Crate, Lrc<LintStore>)>> {
@ -165,7 +163,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.io.input)
find_crate_name(self.session(), &krate.attrs)
})
})
}
@ -214,13 +212,7 @@ impl<'tcx> Queries<'tcx> {
let crate_name = *self.crate_name()?.borrow();
let (krate, resolver, lint_store) = self.expansion()?.steal();
let outputs = passes::prepare_outputs(
self.session(),
self.compiler,
&krate,
&resolver,
crate_name,
)?;
let outputs = passes::prepare_outputs(self.session(), &krate, &resolver, crate_name)?;
let ty::ResolverOutputs {
untracked,

12
compiler/rustc_interface/src/tests.rs
View File

@ -4,6 +4,7 @@ use crate::interface::parse_cfgspecs;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{emitter::HumanReadableErrorType, registry, ColorConfig};
use rustc_session::config::rustc_optgroups;
use rustc_session::config::Input;
use rustc_session::config::TraitSolver;
use rustc_session::config::{build_configuration, build_session_options, to_crate_config};
use rustc_session::config::{
@ -17,9 +18,11 @@ use rustc_session::config::{InstrumentCoverage, Passes};
use rustc_session::lint::Level;
use rustc_session::search_paths::SearchPath;
use rustc_session::utils::{CanonicalizedPath, NativeLib, NativeLibKind};
use rustc_session::CompilerIO;
use rustc_session::{build_session, getopts, Session};
use rustc_span::edition::{Edition, DEFAULT_EDITION};
use rustc_span::symbol::sym;
use rustc_span::FileName;
use rustc_span::SourceFileHashAlgorithm;
use rustc_target::spec::{CodeModel, LinkerFlavorCli, MergeFunctions, PanicStrategy, RelocModel};
use rustc_target::spec::{RelroLevel, SanitizerSet, SplitDebuginfo, StackProtector, TlsModel};
@ -39,7 +42,14 @@ fn build_session_options_and_crate_config(matches: getopts::Matches) -> (Options
fn mk_session(matches: getopts::Matches) -> (Session, CfgSpecs) {
let registry = registry::Registry::new(&[]);
let (sessopts, cfg) = build_session_options_and_crate_config(matches);
let sess = build_session(sessopts, None, None, registry, Default::default(), None, None);
let temps_dir = sessopts.unstable_opts.temps_dir.as_deref().map(PathBuf::from);
let io = CompilerIO {
input: Input::Str { name: FileName::Custom(String::new()), input: String::new() },
output_dir: None,
output_file: None,
temps_dir,
};
let sess = build_session(sessopts, io, None, registry, Default::default(), None, None);
(sess, cfg)
}

25
compiler/rustc_interface/src/util.rs
View File

@ -17,6 +17,7 @@ use rustc_span::edition::Edition;
use rustc_span::lev_distance::find_best_match_for_name;
use rustc_span::source_map::FileLoader;
use rustc_span::symbol::{sym, Symbol};
use session::CompilerIO;
use std::env;
use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
use std::mem;
@ -25,8 +26,6 @@ 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>;
@ -60,7 +59,7 @@ pub fn create_session(
cfg: FxHashSet<(String, Option<String>)>,
check_cfg: CheckCfg,
file_loader: Option<Box<dyn FileLoader + Send + Sync + 'static>>,
input_path: Option<PathBuf>,
io: CompilerIO,
lint_caps: FxHashMap<lint::LintId, lint::Level>,
make_codegen_backend: Option<
Box<dyn FnOnce(&config::Options) -> Box<dyn CodegenBackend> + Send>,
@ -91,7 +90,7 @@ pub fn create_session(
let mut sess = session::build_session(
sopts,
input_path,
io,
bundle,
descriptions,
lint_caps,
@ -488,17 +487,13 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<C
base
}
pub fn build_output_filenames(
io: &CompilerIO,
attrs: &[ast::Attribute],
sess: &Session,
) -> OutputFilenames {
match io.output_file {
pub fn build_output_filenames(attrs: &[ast::Attribute], sess: &Session) -> OutputFilenames {
match sess.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 = io.output_dir.clone().unwrap_or_default();
let dirpath = sess.io.output_dir.clone().unwrap_or_default();
// If a crate name is present, we use it as the link name
let stem = sess
@ -506,13 +501,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(|| io.input.filestem().to_owned());
.unwrap_or_else(|| sess.io.input.filestem().to_owned());
OutputFilenames::new(
dirpath,
stem,
None,
io.temps_dir.clone(),
sess.io.temps_dir.clone(),
sess.opts.cg.extra_filename.clone(),
sess.opts.output_types.clone(),
)
@ -533,7 +528,7 @@ pub fn build_output_filenames(
}
Some(out_file.clone())
};
if io.output_dir != None {
if sess.io.output_dir != None {
sess.warn("ignoring --out-dir flag due to -o flag");
}
@ -541,7 +536,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,
io.temps_dir.clone(),
sess.io.temps_dir.clone(),
sess.opts.cg.extra_filename.clone(),
sess.opts.output_types.clone(),
)

2
compiler/rustc_passes/src/entry.rs
View File

@ -195,7 +195,7 @@ fn no_main_err(tcx: TyCtxt<'_>, visitor: &EntryContext<'_>) {
// There is no main function.
let mut has_filename = true;
let filename = tcx.sess.local_crate_source_file.clone().unwrap_or_else(|| {
let filename = tcx.sess.local_crate_source_file().unwrap_or_else(|| {
has_filename = false;
Default::default()
});

16
compiler/rustc_save_analysis/src/dump_visitor.rs
View File

@ -112,9 +112,7 @@ impl<'tcx> DumpVisitor<'tcx> {
}
pub fn dump_crate_info(&mut self, name: Symbol) {
let source_file = self.tcx.sess.local_crate_source_file.as_ref();
let crate_root = source_file.map(|source_file| {
let source_file = Path::new(source_file);
let crate_root = self.tcx.sess.local_crate_source_file().map(|source_file| {
match source_file.file_name() {
Some(_) => source_file.parent().unwrap().display(),
None => source_file.display(),
@ -157,10 +155,14 @@ impl<'tcx> DumpVisitor<'tcx> {
.enumerate()
.filter(|(i, _)| !remap_arg_indices.contains(i))
.map(|(_, arg)| match input {
Input::File(ref path) if path == Path::new(&arg) => {
let mapped = &self.tcx.sess.local_crate_source_file;
mapped.as_ref().unwrap().to_string_lossy().into()
}
Input::File(ref path) if path == Path::new(&arg) => self
.tcx
.sess
.local_crate_source_file()
.as_ref()
.unwrap()
.to_string_lossy()
.into(),
_ => arg,
});

4
compiler/rustc_session/src/output.rs
View File

@ -45,7 +45,7 @@ fn is_writeable(p: &Path) -> bool {
}
}
pub fn find_crate_name(sess: &Session, attrs: &[ast::Attribute], input: &Input) -> Symbol {
pub fn find_crate_name(sess: &Session, attrs: &[ast::Attribute]) -> Symbol {
let validate = |s: Symbol, span: Option<Span>| {
validate_crate_name(sess, s, span);
s
@ -71,7 +71,7 @@ pub fn find_crate_name(sess: &Session, attrs: &[ast::Attribute], input: &Input)
if let Some((attr, s)) = attr_crate_name {
return validate(s, Some(attr.span));
}
if let Input::File(ref path) = *input {
if let Input::File(ref path) = sess.io.input {
if let Some(s) = path.file_stem().and_then(|s| s.to_str()) {
if s.starts_with('-') {
sess.emit_err(CrateNameInvalid { s });

27
compiler/rustc_session/src/session.rs
View File

@ -1,6 +1,7 @@
use crate::cgu_reuse_tracker::CguReuseTracker;
use crate::code_stats::CodeStats;
pub use crate::code_stats::{DataTypeKind, FieldInfo, SizeKind, VariantInfo};
use crate::config::Input;
use crate::config::{self, CrateType, InstrumentCoverage, OptLevel, OutputType, SwitchWithOptPath};
use crate::errors::{
BranchProtectionRequiresAArch64, CannotEnableCrtStaticLinux, CannotMixAndMatchSanitizers,
@ -137,6 +138,13 @@ pub struct Limits {
pub const_eval_limit: Limit,
}
pub struct CompilerIO {
pub input: Input,
pub output_dir: Option<PathBuf>,
pub output_file: Option<PathBuf>,
pub temps_dir: Option<PathBuf>,
}
/// Represents the data associated with a compilation
/// session for a single crate.
pub struct Session {
@ -147,9 +155,8 @@ pub struct Session {
pub target_tlib_path: Lrc<SearchPath>,
pub parse_sess: ParseSess,
pub sysroot: PathBuf,
/// The name of the root source file of the crate, in the local file system.
/// `None` means that there is no source file.
pub local_crate_source_file: Option<PathBuf>,
/// Input, input file path and output file path to this compilation process.
pub io: CompilerIO,
crate_types: OnceCell<Vec<CrateType>>,
/// The `stable_crate_id` is constructed out of the crate name and all the
@ -228,6 +235,11 @@ impl Session {
self.miri_unleashed_features.lock().push((span, feature_gate));
}
pub fn local_crate_source_file(&self) -> Option<PathBuf> {
let path = self.io.input.opt_path()?;
Some(self.opts.file_path_mapping().map_prefix(path).0)
}
fn check_miri_unleashed_features(&self) {
let unleashed_features = self.miri_unleashed_features.lock();
if !unleashed_features.is_empty() {
@ -1298,7 +1310,7 @@ fn default_emitter(
#[allow(rustc::bad_opt_access)]
pub fn build_session(
sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
io: CompilerIO,
bundle: Option<Lrc<rustc_errors::FluentBundle>>,
registry: rustc_errors::registry::Registry,
driver_lint_caps: FxHashMap<lint::LintId, lint::Level>,
@ -1391,11 +1403,6 @@ pub fn build_session(
Lrc::new(SearchPath::from_sysroot_and_triple(&sysroot, target_triple))
};
let file_path_mapping = sopts.file_path_mapping();
let local_crate_source_file =
local_crate_source_file.map(|path| file_path_mapping.map_prefix(path).0);
let optimization_fuel = Lock::new(OptimizationFuel {
remaining: sopts.unstable_opts.fuel.as_ref().map_or(0, |&(_, i)| i),
out_of_fuel: false,
@ -1427,7 +1434,7 @@ pub fn build_session(
target_tlib_path,
parse_sess,
sysroot,
local_crate_source_file,
io,
crate_types: OnceCell::new(),
stable_crate_id: OnceCell::new(),
features: OnceCell::new(),

2
src/librustdoc/html/render/mod.rs
View File

@ -2921,7 +2921,7 @@ fn render_call_locations(w: &mut Buffer, cx: &mut Context<'_>, item: &clean::Ite
// Look for the example file in the source map if it exists, otherwise return a dummy span
let file_span = (|| {
let source_map = tcx.sess.source_map();
let crate_src = tcx.sess.local_crate_source_file.as_ref()?;
let crate_src = tcx.sess.local_crate_source_file()?;
let abs_crate_src = crate_src.canonicalize().ok()?;
let crate_root = abs_crate_src.parent()?.parent()?;
let rel_path = path.strip_prefix(crate_root).ok()?;

11
src/tools/miri/src/bin/miri.rs
View File

@ -56,12 +56,12 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
fn after_analysis<'tcx>(
&mut self,
compiler: &rustc_interface::interface::Compiler,
_: &rustc_interface::interface::Compiler,
queries: &'tcx rustc_interface::Queries<'tcx>,
) -> Compilation {
compiler.session().abort_if_errors();
queries.global_ctxt().unwrap().enter(|tcx| {
tcx.sess.abort_if_errors();
init_late_loggers(tcx);
if !tcx.sess.crate_types().contains(&CrateType::Executable) {
tcx.sess.fatal("miri only makes sense on bin crates");
@ -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.io().input.filestem().to_string());
config.args.insert(0, tcx.sess.io.input.filestem().to_string());
// Adjust working directory for interpretation.
if let Some(cwd) = env::var_os("MIRI_CWD") {
@ -87,10 +87,9 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
i32::try_from(return_code).expect("Return value was too large!"),
);
}
tcx.sess.abort_if_errors();
});
compiler.session().abort_if_errors();
Compilation::Stop
}
}