user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rollup merge of #142799 - petrochenkov:expnop, r=bjorn3

Browse source 
rustc_session: Add a structure for keeping both explicit and default sysroots

Also avoid creating and cloning sysroot unnecessarily.

Implements the suggestion from https://github.com/rust-lang/rust/pull/142089#discussion_r2132204079.
r? ``@bjorn3``
This commit is contained in:
Matthias Krüger 2025-06-24 20:46:04 +02:00 • committed by GitHub
commit 03c2197d6c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 93 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock
View file

@ -3655,7 +3655,6 @@ dependencies = [
"rustc_macros",
"rustc_serialize",
"rustc_span",
"smallvec",
"tracing",
"unic-langid",
]
@ -4446,7 +4445,6 @@ dependencies = [
"rustc_serialize",
"rustc_span",
"rustc_target",
"smallvec",
"termize",
"tracing",
"windows",

12
compiler/rustc_codegen_ssa/src/back/link.rs
View file

@ -865,7 +865,7 @@ fn link_natively(
command: cmd,
escaped_output,
verbose: sess.opts.verbose,
sysroot_dir: sess.sysroot.clone(),
sysroot_dir: sess.opts.sysroot.path().to_owned(),
};
sess.dcx().emit_err(err);
// If MSVC's `link.exe` was expected but the return code
@ -1249,10 +1249,10 @@ fn link_sanitizer_runtime(
if path.exists() {
sess.target_tlib_path.dir.clone()
} else {
let default_sysroot = filesearch::get_or_default_sysroot();
let default_tlib =
filesearch::make_target_lib_path(&default_sysroot, sess.opts.target_triple.tuple());
default_tlib
filesearch::make_target_lib_path(
&sess.opts.sysroot.default,
sess.opts.target_triple.tuple(),
)
}
}
@ -1758,7 +1758,7 @@ fn detect_self_contained_mingw(sess: &Session, linker: &Path) -> bool {
for dir in env::split_paths(&env::var_os("PATH").unwrap_or_default()) {
let full_path = dir.join(&linker_with_extension);
// If linker comes from sysroot assume self-contained mode
if full_path.is_file() && !full_path.starts_with(&sess.sysroot) {
if full_path.is_file() && !full_path.starts_with(sess.opts.sysroot.path()) {
return false;
}
}

2
compiler/rustc_codegen_ssa/src/back/linker.rs
View file

@ -1059,7 +1059,7 @@ impl<'a> Linker for MsvcLinker<'a> {
self.link_arg("/PDBALTPATH:%_PDB%");
// This will cause the Microsoft linker to embed .natvis info into the PDB file
let natvis_dir_path = self.sess.sysroot.join("lib\\rustlib\\etc");
let natvis_dir_path = self.sess.opts.sysroot.path().join("lib\\rustlib\\etc");
if let Ok(natvis_dir) = fs::read_dir(&natvis_dir_path) {
for entry in natvis_dir {
match entry {

10
compiler/rustc_driver_impl/src/lib.rs
View file

@ -53,13 +53,13 @@ use rustc_metadata::locator;
use rustc_middle::ty::TyCtxt;
use rustc_parse::{new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal};
use rustc_session::config::{
CG_OPTIONS, CrateType, ErrorOutputType, Input, OptionDesc, OutFileName, OutputType,
CG_OPTIONS, CrateType, ErrorOutputType, Input, OptionDesc, OutFileName, OutputType, Sysroot,
UnstableOptions, Z_OPTIONS, nightly_options, parse_target_triple,
};
use rustc_session::getopts::{self, Matches};
use rustc_session::lint::{Lint, LintId};
use rustc_session::output::{CRATE_TYPES, collect_crate_types, invalid_output_for_target};
use rustc_session::{EarlyDiagCtxt, Session, config, filesearch};
use rustc_session::{EarlyDiagCtxt, Session, config};
use rustc_span::FileName;
use rustc_span::def_id::LOCAL_CRATE;
use rustc_target::json::ToJson;
@ -662,7 +662,7 @@ fn print_crate_info(
println_info!("{}", targets.join("\n"));
}
HostTuple => println_info!("{}", rustc_session::config::host_tuple()),
Sysroot => println_info!("{}", sess.sysroot.display()),
Sysroot => println_info!("{}", sess.opts.sysroot.path().display()),
TargetLibdir => println_info!("{}", sess.target_tlib_path.dir.display()),
TargetSpecJson => {
println_info!("{}", serde_json::to_string_pretty(&sess.target.to_json()).unwrap());
@ -1114,8 +1114,8 @@ fn get_backend_from_raw_matches(
let debug_flags = matches.opt_strs("Z");
let backend_name = debug_flags.iter().find_map(|x| x.strip_prefix("codegen-backend="));
let target = parse_target_triple(early_dcx, matches);
let sysroot = filesearch::materialize_sysroot(matches.opt_str("sysroot").map(PathBuf::from));
let target = config::build_target_config(early_dcx, &target, &sysroot);
let sysroot = Sysroot::new(matches.opt_str("sysroot").map(PathBuf::from));
let target = config::build_target_config(early_dcx, &target, sysroot.path());
get_codegen_backend(early_dcx, &sysroot, backend_name, &target)
}

1
compiler/rustc_error_messages/Cargo.toml
View file

@ -16,7 +16,6 @@ rustc_data_structures = { path = "../rustc_data_structures" }
rustc_macros = { path = "../rustc_macros" }
rustc_serialize = { path = "../rustc_serialize" }
rustc_span = { path = "../rustc_span" }
smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
tracing = "0.1"
unic-langid = { version = "0.9.0", features = ["macros"] }
# tidy-alphabetical-end

8
compiler/rustc_error_messages/src/lib.rs
View file

@ -8,7 +8,7 @@
use std::borrow::Cow;
use std::error::Error;
use std::path::{Path, PathBuf};
use std::path::Path;
use std::sync::{Arc, LazyLock};
use std::{fmt, fs, io};
@ -21,7 +21,6 @@ use intl_memoizer::concurrent::IntlLangMemoizer;
use rustc_data_structures::sync::{DynSend, IntoDynSyncSend};
use rustc_macros::{Decodable, Encodable};
use rustc_span::Span;
use smallvec::SmallVec;
use tracing::{instrument, trace};
pub use unic_langid::{LanguageIdentifier, langid};
@ -107,7 +106,7 @@ impl From<Vec<FluentError>> for TranslationBundleError {
/// (overriding any conflicting messages).
#[instrument(level = "trace")]
pub fn fluent_bundle(
sysroot_candidates: SmallVec<[PathBuf; 2]>,
sysroot_candidates: &[&Path],
requested_locale: Option<LanguageIdentifier>,
additional_ftl_path: Option<&Path>,
with_directionality_markers: bool,
@ -141,7 +140,8 @@ pub fn fluent_bundle(
// If the user requests the default locale then don't try to load anything.
if let Some(requested_locale) = requested_locale {
let mut found_resources = false;
for mut sysroot in sysroot_candidates {
for sysroot in sysroot_candidates {
let mut sysroot = sysroot.to_path_buf();
sysroot.push("share");
sysroot.push("locale");
sysroot.push(requested_locale.to_string());

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

@ -18,7 +18,6 @@ use rustc_parse::parser::attr::AllowLeadingUnsafe;
use rustc_query_impl::QueryCtxt;
use rustc_query_system::query::print_query_stack;
use rustc_session::config::{self, Cfg, CheckCfg, ExpectedValues, Input, OutFileName};
use rustc_session::filesearch::sysroot_with_fallback;
use rustc_session::parse::ParseSess;
use rustc_session::{CompilerIO, EarlyDiagCtxt, Session, lint};
use rustc_span::source_map::{FileLoader, RealFileLoader, SourceMapInputs};
@ -405,8 +404,11 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
crate::callbacks::setup_callbacks();
let sysroot = config.opts.sysroot.clone();
let target = config::build_target_config(&early_dcx, &config.opts.target_triple, &sysroot);
let target = config::build_target_config(
&early_dcx,
&config.opts.target_triple,
config.opts.sysroot.path(),
);
let file_loader = config.file_loader.unwrap_or_else(|| Box::new(RealFileLoader));
let path_mapping = config.opts.file_path_mapping();
let hash_kind = config.opts.unstable_opts.src_hash_algorithm(&target);
@ -426,7 +428,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
let codegen_backend = match config.make_codegen_backend {
None => util::get_codegen_backend(
&early_dcx,
&sysroot,
&config.opts.sysroot,
config.opts.unstable_opts.codegen_backend.as_deref(),
&target,
),
@ -440,7 +442,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
let temps_dir = config.opts.unstable_opts.temps_dir.as_deref().map(PathBuf::from);
let bundle = match rustc_errors::fluent_bundle(
sysroot_with_fallback(&config.opts.sysroot),
&config.opts.sysroot.all_paths().collect::<Vec<_>>(),
config.opts.unstable_opts.translate_lang.clone(),
config.opts.unstable_opts.translate_additional_ftl.as_deref(),
config.opts.unstable_opts.translate_directionality_markers,
@ -469,7 +471,6 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
locale_resources,
config.lint_caps,
target,
sysroot,
util::rustc_version_str().unwrap_or("unknown"),
config.ice_file,
config.using_internal_features,

9
compiler/rustc_interface/src/tests.rs
View file

@ -41,9 +41,11 @@ where
let matches = optgroups().parse(args).unwrap();
let sessopts = build_session_options(&mut early_dcx, &matches);
let sysroot = sessopts.sysroot.clone();
let target =
rustc_session::config::build_target_config(&early_dcx, &sessopts.target_triple, &sysroot);
let target = rustc_session::config::build_target_config(
&early_dcx,
&sessopts.target_triple,
sessopts.sysroot.path(),
);
let hash_kind = sessopts.unstable_opts.src_hash_algorithm(&target);
let checksum_hash_kind = sessopts.unstable_opts.checksum_hash_algorithm();
let sm_inputs = Some(SourceMapInputs {
@ -72,7 +74,6 @@ where
vec![],
Default::default(),
target,
sysroot,
"",
None,
&USING_INTERNAL_FEATURES,

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

@ -11,7 +11,7 @@ use rustc_data_structures::sync;
use rustc_metadata::{DylibError, load_symbol_from_dylib};
use rustc_middle::ty::CurrentGcx;
use rustc_parse::validate_attr;
use rustc_session::config::{Cfg, OutFileName, OutputFilenames, OutputTypes, host_tuple};
use rustc_session::config::{Cfg, OutFileName, OutputFilenames, OutputTypes, Sysroot, host_tuple};
use rustc_session::lint::{self, BuiltinLintDiag, LintBuffer};
use rustc_session::output::{CRATE_TYPES, categorize_crate_type};
use rustc_session::{EarlyDiagCtxt, Session, filesearch};
@ -305,7 +305,7 @@ fn load_backend_from_dylib(early_dcx: &EarlyDiagCtxt, path: &Path) -> MakeBacken
/// A name of `None` indicates that the default backend should be used.
pub fn get_codegen_backend(
early_dcx: &EarlyDiagCtxt,
sysroot: &Path,
sysroot: &Sysroot,
backend_name: Option<&str>,
target: &Target,
) -> Box<dyn CodegenBackend> {
@ -336,25 +336,24 @@ pub fn get_codegen_backend(
// This is used for rustdoc, but it uses similar machinery to codegen backend
// loading, so we leave the code here. It is potentially useful for other tools
// that want to invoke the rustc binary while linking to rustc as well.
pub fn rustc_path<'a>() -> Option<&'a Path> {
pub fn rustc_path<'a>(sysroot: &Sysroot) -> Option<&'a Path> {
static RUSTC_PATH: OnceLock<Option<PathBuf>> = OnceLock::new();
const BIN_PATH: &str = env!("RUSTC_INSTALL_BINDIR");
RUSTC_PATH.get_or_init(|| get_rustc_path_inner(BIN_PATH)).as_deref()
}
fn get_rustc_path_inner(bin_path: &str) -> Option<PathBuf> {
let candidate = filesearch::get_or_default_sysroot()
.join(bin_path)
.join(if cfg!(target_os = "windows") { "rustc.exe" } else { "rustc" });
candidate.exists().then_some(candidate)
RUSTC_PATH
.get_or_init(|| {
let candidate = sysroot
.default
.join(env!("RUSTC_INSTALL_BINDIR"))
.join(if cfg!(target_os = "windows") { "rustc.exe" } else { "rustc" });
candidate.exists().then_some(candidate)
})
.as_deref()
}
#[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
fn get_codegen_sysroot(
early_dcx: &EarlyDiagCtxt,
sysroot: &Path,
sysroot: &Sysroot,
backend_name: &str,
) -> MakeBackendFn {
// For now we only allow this function to be called once as it'll dlopen a
@ -369,10 +368,9 @@ fn get_codegen_sysroot(
);
let target = host_tuple();
let sysroot_candidates = filesearch::sysroot_with_fallback(&sysroot);
let sysroot = sysroot_candidates
.iter()
let sysroot = sysroot
.all_paths()
.map(|sysroot| {
filesearch::make_target_lib_path(sysroot, target).with_file_name("codegen-backends")
})
@ -381,8 +379,8 @@ fn get_codegen_sysroot(
f.exists()
})
.unwrap_or_else(|| {
let candidates = sysroot_candidates
.iter()
let candidates = sysroot
.all_paths()
.map(|p| p.display().to_string())
.collect::<Vec<_>>()
.join("\n* ");

2
compiler/rustc_metadata/src/locator.rs
View file

@ -321,7 +321,7 @@ impl<'a> CrateLocator<'a> {
CrateLocator {
only_needs_metadata,
sysroot: &sess.sysroot,
sysroot: sess.opts.sysroot.path(),
metadata_loader,
cfg_version: sess.cfg_version,
crate_name,

1
compiler/rustc_session/Cargo.toml
View file

@ -22,7 +22,6 @@ rustc_macros = { path = "../rustc_macros" }
rustc_serialize = { path = "../rustc_serialize" }
rustc_span = { path = "../rustc_span" }
rustc_target = { path = "../rustc_target" }
smallvec = "1.8.1"
termize = "0.1.1"
tracing = "0.1"
# tidy-alphabetical-end

31
compiler/rustc_session/src/config.rs
View file

@ -1296,6 +1296,28 @@ bitflags::bitflags! {
}
}
#[derive(Clone, Debug)]
pub struct Sysroot {
pub explicit: Option<PathBuf>,
pub default: PathBuf,
}
impl Sysroot {
pub fn new(explicit: Option<PathBuf>) -> Sysroot {
Sysroot { explicit, default: filesearch::default_sysroot() }
}
/// Return explicit sysroot if it was passed with `--sysroot`, or default sysroot otherwise.
pub fn path(&self) -> &Path {
self.explicit.as_deref().unwrap_or(&self.default)
}
/// Returns both explicit sysroot if it was passed with `--sysroot` and the default sysroot.
pub fn all_paths(&self) -> impl Iterator<Item = &Path> {
self.explicit.as_deref().into_iter().chain(iter::once(&*self.default))
}
}
pub fn host_tuple() -> &'static str {
// Get the host triple out of the build environment. This ensures that our
// idea of the host triple is the same as for the set of libraries we've
@ -1342,7 +1364,7 @@ impl Default for Options {
describe_lints: false,
output_types: OutputTypes(BTreeMap::new()),
search_paths: vec![],
sysroot: filesearch::materialize_sysroot(None),
sysroot: Sysroot::new(None),
target_triple: TargetTuple::from_tuple(host_tuple()),
test: false,
incremental: None,
@ -2673,7 +2695,6 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
let cg = cg;
let sysroot_opt = matches.opt_str("sysroot").map(|m| PathBuf::from(&m));
let target_triple = parse_target_triple(early_dcx, matches);
let opt_level = parse_opt_level(early_dcx, matches, &cg);
// The `-g` and `-C debuginfo` flags specify the same setting, so we want to be able
@ -2712,10 +2733,10 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
let logical_env = parse_logical_env(early_dcx, matches);
let sysroot = filesearch::materialize_sysroot(sysroot_opt);
let sysroot = Sysroot::new(matches.opt_str("sysroot").map(PathBuf::from));
let real_source_base_dir = |suffix: &str, confirm: &str| {
let mut candidate = sysroot.join(suffix);
let mut candidate = sysroot.path().join(suffix);
if let Ok(metadata) = candidate.symlink_metadata() {
// Replace the symlink bootstrap creates, with its destination.
// We could try to use `fs::canonicalize` instead, but that might
@ -2742,7 +2763,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
let mut search_paths = vec![];
for s in &matches.opt_strs("L") {
search_paths.push(SearchPath::from_cli_opt(
&sysroot,
sysroot.path(),
&target_triple,
early_dcx,
s,

18
compiler/rustc_session/src/filesearch.rs
View file

@ -5,7 +5,6 @@ use std::{env, fs};
use rustc_fs_util::try_canonicalize;
use rustc_target::spec::Target;
use smallvec::{SmallVec, smallvec};
use crate::search_paths::{PathKind, SearchPath};
@ -182,24 +181,9 @@ fn current_dll_path() -> Result<PathBuf, String> {
Err("current_dll_path is not supported on WASI".to_string())
}
pub fn sysroot_with_fallback(sysroot: &Path) -> SmallVec<[PathBuf; 2]> {
let mut candidates = smallvec![sysroot.to_owned()];
let default_sysroot = get_or_default_sysroot();
if default_sysroot != sysroot {
candidates.push(default_sysroot);
}
candidates
}
/// Returns the provided sysroot or calls [`get_or_default_sysroot`] if it's none.
/// Panics if [`get_or_default_sysroot`] returns an error.
pub fn materialize_sysroot(maybe_sysroot: Option<PathBuf>) -> PathBuf {
maybe_sysroot.unwrap_or_else(|| get_or_default_sysroot())
}
/// This function checks if sysroot is found using env::args().next(), and if it
/// is not found, finds sysroot from current rustc_driver dll.
pub fn get_or_default_sysroot() -> PathBuf {
pub(crate) fn default_sysroot() -> PathBuf {
fn default_from_rustc_driver_dll() -> Result<PathBuf, String> {
let dll = current_dll_path()?;

2
compiler/rustc_session/src/options.rs
View file

@ -337,7 +337,7 @@ top_level_options!(
output_types: OutputTypes [TRACKED],
search_paths: Vec<SearchPath> [UNTRACKED],
libs: Vec<NativeLib> [TRACKED],
sysroot: PathBuf [UNTRACKED],
sysroot: Sysroot [UNTRACKED],
target_triple: TargetTuple [TRACKED],

16
compiler/rustc_session/src/session.rs
View file

@ -149,7 +149,6 @@ pub struct Session {
pub opts: config::Options,
pub target_tlib_path: Arc<SearchPath>,
pub psess: ParseSess,
pub sysroot: PathBuf,
/// Input, input file path and output file path to this compilation process.
pub io: CompilerIO,
@ -456,8 +455,10 @@ impl Session {
/// directories are also returned, for example if `--sysroot` is used but tools are missing
/// (#125246): we also add the bin directories to the sysroot where rustc is located.
pub fn get_tools_search_paths(&self, self_contained: bool) -> Vec<PathBuf> {
let search_paths = filesearch::sysroot_with_fallback(&self.sysroot)
.into_iter()
let search_paths = self
.opts
.sysroot
.all_paths()
.map(|sysroot| filesearch::make_target_bin_path(&sysroot, config::host_tuple()));
if self_contained {
@ -1028,7 +1029,6 @@ pub fn build_session(
fluent_resources: Vec<&'static str>,
driver_lint_caps: FxHashMap<lint::LintId, lint::Level>,
target: Target,
sysroot: PathBuf,
cfg_version: &'static str,
ice_file: Option<PathBuf>,
using_internal_features: &'static AtomicBool,
@ -1063,7 +1063,7 @@ pub fn build_session(
}
let host_triple = TargetTuple::from_tuple(config::host_tuple());
let (host, target_warnings) = Target::search(&host_triple, &sysroot)
let (host, target_warnings) = Target::search(&host_triple, sopts.sysroot.path())
.unwrap_or_else(|e| dcx.handle().fatal(format!("Error loading host specification: {e}")));
for warning in target_warnings.warning_messages() {
dcx.handle().warn(warning)
@ -1096,13 +1096,14 @@ pub fn build_session(
let host_triple = config::host_tuple();
let target_triple = sopts.target_triple.tuple();
// FIXME use host sysroot?
let host_tlib_path = Arc::new(SearchPath::from_sysroot_and_triple(&sysroot, host_triple));
let host_tlib_path =
Arc::new(SearchPath::from_sysroot_and_triple(sopts.sysroot.path(), host_triple));
let target_tlib_path = if host_triple == target_triple {
// Use the same `SearchPath` if host and target triple are identical to avoid unnecessary
// rescanning of the target lib path and an unnecessary allocation.
Arc::clone(&host_tlib_path)
} else {
Arc::new(SearchPath::from_sysroot_and_triple(&sysroot, target_triple))
Arc::new(SearchPath::from_sysroot_and_triple(sopts.sysroot.path(), target_triple))
};
let prof = SelfProfilerRef::new(
@ -1134,7 +1135,6 @@ pub fn build_session(
opts: sopts,
target_tlib_path,
psess,
sysroot,
io,
incr_comp_session: RwLock::new(IncrCompSession::NotInitialized),
prof,

14
src/librustdoc/config.rs
View file

@ -9,7 +9,7 @@ use rustc_data_structures::fx::FxIndexMap;
use rustc_errors::DiagCtxtHandle;
use rustc_session::config::{
self, CodegenOptions, CrateType, ErrorOutputType, Externs, Input, JsonUnusedExterns,
OptionsTargetModifiers, UnstableOptions, get_cmd_lint_options, nightly_options,
OptionsTargetModifiers, Sysroot, UnstableOptions, get_cmd_lint_options, nightly_options,
parse_crate_types_from_list, parse_externs, parse_target_triple,
};
use rustc_session::lint::Level;
@ -103,9 +103,7 @@ pub(crate) struct Options {
/// compiling doctests from the crate.
pub(crate) edition: Edition,
/// The path to the sysroot. Used during the compilation process.
pub(crate) sysroot: PathBuf,
/// Has the same value as `sysroot` except is `None` when the user didn't pass `---sysroot`.
pub(crate) maybe_sysroot: Option<PathBuf>,
pub(crate) sysroot: Sysroot,
/// Lint information passed over the command-line.
pub(crate) lint_opts: Vec<(String, Level)>,
/// Whether to ask rustc to describe the lints it knows.
@ -201,7 +199,6 @@ impl fmt::Debug for Options {
.field("target", &self.target)
.field("edition", &self.edition)
.field("sysroot", &self.sysroot)
.field("maybe_sysroot", &self.maybe_sysroot)
.field("lint_opts", &self.lint_opts)
.field("describe_lints", &self.describe_lints)
.field("lint_cap", &self.lint_cap)
@ -725,16 +722,14 @@ impl Options {
}
let target = parse_target_triple(early_dcx, matches);
let maybe_sysroot = matches.opt_str("sysroot").map(PathBuf::from);
let sysroot = rustc_session::filesearch::materialize_sysroot(maybe_sysroot.clone());
let sysroot = Sysroot::new(matches.opt_str("sysroot").map(PathBuf::from));
let libs = matches
.opt_strs("L")
.iter()
.map(|s| {
SearchPath::from_cli_opt(
&sysroot,
sysroot.path(),
&target,
early_dcx,
s,
@ -827,7 +822,6 @@ impl Options {
target,
edition,
sysroot,
maybe_sysroot,
lint_opts,
describe_lints,
lint_cap,

7
src/librustdoc/doctest.rs
View file

@ -514,8 +514,9 @@ fn run_test(
compiler_args.push(format!("@{}", doctest.global_opts.args_file.display()));
if let Some(sysroot) = &rustdoc_options.maybe_sysroot {
compiler_args.push(format!("--sysroot={}", sysroot.display()));
let sysroot = &rustdoc_options.sysroot;
if let Some(explicit_sysroot) = &sysroot.explicit {
compiler_args.push(format!("--sysroot={}", explicit_sysroot.display()));
}
compiler_args.extend_from_slice(&["--edition".to_owned(), doctest.edition.to_string()]);
@ -574,7 +575,7 @@ fn run_test(
let rustc_binary = rustdoc_options
.test_builder
.as_deref()
.unwrap_or_else(|| rustc_interface::util::rustc_path().expect("found rustc"));
.unwrap_or_else(|| rustc_interface::util::rustc_path(sysroot).expect("found rustc"));
let mut compiler = wrapped_rustc_command(&rustdoc_options.test_builder_wrappers, rustc_binary);
compiler.args(&compiler_args);

6
tests/ui-fulldeps/run-compiler-twice.rs
View file

@ -18,7 +18,7 @@ extern crate rustc_span;
use std::path::{Path, PathBuf};
use rustc_interface::{Linker, interface};
use rustc_session::config::{Input, Options, OutFileName, OutputType, OutputTypes};
use rustc_session::config::{Input, Options, OutFileName, OutputType, OutputTypes, Sysroot};
use rustc_span::FileName;
fn main() {
@ -32,7 +32,7 @@ fn main() {
panic!("expected sysroot (and optional linker)");
}
let sysroot = PathBuf::from(&args[1]);
let sysroot = Sysroot::new(Some(PathBuf::from(&args[1])));
let linker = args.get(2).map(PathBuf::from);
// compiletest sets the current dir to `output_base_dir` when running.
@ -43,7 +43,7 @@ fn main() {
compile(src.to_string(), tmpdir.join("out"), sysroot.clone(), linker.as_deref());
}
fn compile(code: String, output: PathBuf, sysroot: PathBuf, linker: Option<&Path>) {
fn compile(code: String, output: PathBuf, sysroot: Sysroot, linker: Option<&Path>) {
let mut opts = Options::default();
opts.output_types = OutputTypes::new(&[(OutputType::Exe, None)]);
opts.sysroot = sysroot;