use smallvec::SmallVec;
use std::env;
use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
-use std::io;
use std::lazy::SyncOnceCell;
use std::mem;
use std::ops::DerefMut;
use std::panic;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
use std::thread;
use tracing::info;
/// Like a `thread::Builder::spawn` followed by a `join()`, but avoids the need
/// for `'static` bounds.
#[cfg(not(parallel_compiler))]
-pub fn scoped_thread<F: FnOnce() -> R + Send, R: Send>(cfg: thread::Builder, f: F) -> R {
+fn scoped_thread<F: FnOnce() -> R + Send, R: Send>(cfg: thread::Builder, f: F) -> R {
// SAFETY: join() is called immediately, so any closure captures are still
// alive.
match unsafe { cfg.spawn_unchecked(f) }.unwrap().join() {
}
#[cfg(not(parallel_compiler))]
-pub fn setup_callbacks_and_run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
+pub fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
edition: Edition,
_threads: usize,
- stderr: &Option<Arc<Mutex<Vec<u8>>>>,
f: F,
) -> R {
let mut cfg = thread::Builder::new().name("rustc".to_string());
cfg = cfg.stack_size(size);
}
- crate::callbacks::setup_callbacks();
-
- let main_handler = move || {
- rustc_span::create_session_globals_then(edition, || {
- io::set_output_capture(stderr.clone());
- f()
- })
- };
+ let main_handler = move || rustc_span::create_session_globals_then(edition, f);
scoped_thread(cfg, main_handler)
}
}
#[cfg(parallel_compiler)]
-pub fn setup_callbacks_and_run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
+pub fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
edition: Edition,
threads: usize,
- stderr: &Option<Arc<Mutex<Vec<u8>>>>,
f: F,
) -> R {
- crate::callbacks::setup_callbacks();
-
let mut config = rayon::ThreadPoolBuilder::new()
.thread_name(|_| "rustc".to_string())
.acquire_thread_handler(jobserver::acquire_thread)
// the thread local rustc uses. `session_globals` is captured and set
// on the new threads.
let main_handler = move |thread: rayon::ThreadBuilder| {
- rustc_span::set_session_globals_then(session_globals, || {
- io::set_output_capture(stderr.clone());
- thread.run()
- })
+ rustc_span::set_session_globals_then(session_globals, || thread.run())
};
config.build_scoped(main_handler, with_pool).unwrap()
#[cfg(windows)]
fn current_dll_path() -> Option<PathBuf> {
use std::ffi::OsString;
+ use std::io;
use std::os::windows::prelude::*;
use std::ptr;
}
}
-
pub fn get_codegen_sysroot(maybe_sysroot: &Option<PathBuf>, backend_name: &str) -> MakeBackendFn {
+fn get_codegen_sysroot(maybe_sysroot: &Option<PathBuf>, backend_name: &str) -> MakeBackendFn {
// For now we only allow this function to be called once as it'll dlopen a
// few things, which seems to work best if we only do that once. In
// general this assertion never trips due to the once guard in `get_codegen_backend`,
}
fn should_ignore_fn(ret_ty: &ast::FnRetTy) -> bool {
- if let ast::FnRetTy::Ty(ref ty) = ret_ty {
- fn involves_impl_trait(ty: &ast::Ty) -> bool {
- match ty.kind {
- ast::TyKind::ImplTrait(..) => true,
- ast::TyKind::Slice(ref subty)
- | ast::TyKind::Array(ref subty, _)
- | ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. })
- | ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. })
- | ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
- ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
- ast::TyKind::Path(_, ref path) => {
- path.segments.iter().any(|seg| match seg.args.as_deref() {
- None => false,
- Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
- data.args.iter().any(|arg| match arg {
- ast::AngleBracketedArg::Arg(arg) => match arg {
- ast::GenericArg::Type(ty) => involves_impl_trait(ty),
- ast::GenericArg::Lifetime(_)
- | ast::GenericArg::Const(_) => false,
- },
- ast::AngleBracketedArg::Constraint(c) => match c.kind {
- ast::AssocConstraintKind::Bound { .. } => true,
- ast::AssocConstraintKind::Equality { ref term } => {
- match term {
- Term::Ty(ty) => involves_impl_trait(ty),
- // FIXME(...): This should check if the constant
- // involves a trait impl, but for now ignore.
- Term::Const(_) => false,
- }
+ let ast::FnRetTy::Ty(ref ty) = ret_ty else {
+ return false;
+ };
+ fn involves_impl_trait(ty: &ast::Ty) -> bool {
+ match ty.kind {
+ ast::TyKind::ImplTrait(..) => true,
+ ast::TyKind::Slice(ref subty)
+ | ast::TyKind::Array(ref subty, _)
+ | ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. })
+ | ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. })
+ | ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
+ ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
+ ast::TyKind::Path(_, ref path) => {
+ path.segments.iter().any(|seg| match seg.args.as_deref() {
+ None => false,
+ Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
+ data.args.iter().any(|arg| match arg {
+ ast::AngleBracketedArg::Arg(arg) => match arg {
+ ast::GenericArg::Type(ty) => involves_impl_trait(ty),
+ ast::GenericArg::Lifetime(_) | ast::GenericArg::Const(_) => {
+ false
+ }
+ },
+ ast::AngleBracketedArg::Constraint(c) => match c.kind {
+ ast::AssocConstraintKind::Bound { .. } => true,
+ ast::AssocConstraintKind::Equality { ref term } => {
+ match term {
+ Term::Ty(ty) => involves_impl_trait(ty),
+ // FIXME(...): This should check if the constant
+ // involves a trait impl, but for now ignore.
+ Term::Const(_) => false,
}
- },
- })
- }
- Some(&ast::GenericArgs::Parenthesized(ref data)) => {
- any_involves_impl_trait(data.inputs.iter())
- || ReplaceBodyWithLoop::should_ignore_fn(&data.output)
- }
- })
- }
- _ => false,
+ }
+ },
+ })
+ }
+ Some(&ast::GenericArgs::Parenthesized(ref data)) => {
+ any_involves_impl_trait(data.inputs.iter())
+ || ReplaceBodyWithLoop::should_ignore_fn(&data.output)
+ }
+ })
}
+ _ => false,
}
+ }
- fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
- it.any(|subty| involves_impl_trait(subty))
- }
-
- involves_impl_trait(ty)
- } else {
- false
+ fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
+ it.any(|subty| involves_impl_trait(subty))
}
+
+ involves_impl_trait(ty)
}
fn is_sig_const(sig: &ast::FnSig) -> bool {
projects / rust.git / blobdiff