src/librustc_interface/util.rs

   1 use log::info;
   2 use rustc::lint;
   3 use rustc::session::config::{ErrorOutputType, Input, OutputFilenames};
   4 use rustc::session::CrateDisambiguator;
   5 use rustc::session::{self, config, early_error, filesearch, DiagnosticOutput, Session};
   6 use rustc::ty;
   7 use rustc_codegen_utils::codegen_backend::CodegenBackend;
   8 use rustc_data_structures::fingerprint::Fingerprint;
   9 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  10 #[cfg(parallel_compiler)]
  11 use rustc_data_structures::jobserver;
  12 use rustc_data_structures::stable_hasher::StableHasher;
  13 use rustc_data_structures::sync::{Lock, Lrc};
  14 use rustc_errors::registry::Registry;
  15 use rustc_metadata::dynamic_lib::DynamicLibrary;
  16 use rustc_resolve::{self, Resolver};
  17 use smallvec::SmallVec;
  18 use std::env;
  19 use std::io::{self, Write};
  20 use std::mem;
  21 use std::ops::DerefMut;
  22 use std::path::{Path, PathBuf};
  23 use std::sync::{Arc, Mutex, Once};
  24 #[cfg(not(parallel_compiler))]
  25 use std::{panic, thread};
  26 use syntax::ast::{AttrVec, BlockCheckMode};
  27 use syntax::mut_visit::{visit_clobber, MutVisitor, *};
  28 use syntax::ptr::P;
  29 use syntax::source_map::{FileLoader, RealFileLoader, SourceMap};
  30 use syntax::symbol::{sym, Symbol};
  31 use syntax::util::lev_distance::find_best_match_for_name;
  32 use syntax::{self, ast, attr};
  33 use syntax_pos::edition::Edition;
  34
  35 /// Adds `target_feature = "..."` cfgs for a variety of platform
  36 /// specific features (SSE, NEON etc.).
  37 ///
  38 /// This is performed by checking whether a whitelisted set of
  39 /// features is available on the target machine, by querying LLVM.
  40 pub fn add_configuration(
  41     cfg: &mut ast::CrateConfig,
  42     sess: &Session,
  43     codegen_backend: &dyn CodegenBackend,
  44 ) {
  45     let tf = sym::target_feature;
  46
  47     cfg.extend(codegen_backend.target_features(sess).into_iter().map(|feat| (tf, Some(feat))));
  48
  49     if sess.crt_static_feature() {
  50         cfg.insert((tf, Some(Symbol::intern("crt-static"))));
  51     }
  52 }
  53
  54 pub fn create_session(
  55     sopts: config::Options,
  56     cfg: FxHashSet<(String, Option<String>)>,
  57     diagnostic_output: DiagnosticOutput,
  58     file_loader: Option<Box<dyn FileLoader + Send + Sync + 'static>>,
  59     input_path: Option<PathBuf>,
  60     lint_caps: FxHashMap<lint::LintId, lint::Level>,
  61     descriptions: Registry,
  62 ) -> (Lrc<Session>, Lrc<Box<dyn CodegenBackend>>, Lrc<SourceMap>) {
  63     let loader = file_loader.unwrap_or(box RealFileLoader);
  64     let source_map = Lrc::new(SourceMap::with_file_loader(loader, sopts.file_path_mapping()));
  65     let mut sess = session::build_session_with_source_map(
  66         sopts,
  67         input_path,
  68         descriptions,
  69         source_map.clone(),
  70         diagnostic_output,
  71         lint_caps,
  72     );
  73
  74     sess.prof.register_queries(|profiler| {
  75         rustc::ty::query::QueryName::register_with_profiler(&profiler);
  76     });
  77
  78     let codegen_backend = get_codegen_backend(&sess);
  79
  80     let mut cfg = config::build_configuration(&sess, config::to_crate_config(cfg));
  81     add_configuration(&mut cfg, &sess, &*codegen_backend);
  82     sess.parse_sess.config = cfg;
  83
  84     (Lrc::new(sess), Lrc::new(codegen_backend), source_map)
  85 }
  86
  87 // Temporarily have stack size set to 32MB to deal with various crates with long method
  88 // chains or deep syntax trees, except when on Haiku.
  89 // FIXME(oli-obk): get https://github.com/rust-lang/rust/pull/55617 the finish line
  90 #[cfg(not(target_os = "haiku"))]
  91 const STACK_SIZE: usize = 32 * 1024 * 1024;
  92
  93 #[cfg(target_os = "haiku")]
  94 const STACK_SIZE: usize = 16 * 1024 * 1024;
  95
  96 fn get_stack_size() -> Option<usize> {
  97     // FIXME: Hacks on hacks. If the env is trying to override the stack size
  98     // then *don't* set it explicitly.
  99     env::var_os("RUST_MIN_STACK").is_none().then_some(STACK_SIZE)
 100 }
 101
 102 struct Sink(Arc<Mutex<Vec<u8>>>);
 103 impl Write for Sink {
 104     fn write(&mut self, data: &[u8]) -> io::Result<usize> {
 105         Write::write(&mut *self.0.lock().unwrap(), data)
 106     }
 107     fn flush(&mut self) -> io::Result<()> {
 108         Ok(())
 109     }
 110 }
 111
 112 #[cfg(not(parallel_compiler))]
 113 pub fn scoped_thread<F: FnOnce() -> R + Send, R: Send>(cfg: thread::Builder, f: F) -> R {
 114     struct Ptr(*mut ());
 115     unsafe impl Send for Ptr {}
 116     unsafe impl Sync for Ptr {}
 117
 118     let mut f = Some(f);
 119     let run = Ptr(&mut f as *mut _ as *mut ());
 120     let mut result = None;
 121     let result_ptr = Ptr(&mut result as *mut _ as *mut ());
 122
 123     let thread = cfg.spawn(move || {
 124         let run = unsafe { (*(run.0 as *mut Option<F>)).take().unwrap() };
 125         let result = unsafe { &mut *(result_ptr.0 as *mut Option<R>) };
 126         *result = Some(run());
 127     });
 128
 129     match thread.unwrap().join() {
 130         Ok(()) => result.unwrap(),
 131         Err(p) => panic::resume_unwind(p),
 132     }
 133 }
 134
 135 #[cfg(not(parallel_compiler))]
 136 pub fn spawn_thread_pool<F: FnOnce() -> R + Send, R: Send>(
 137     edition: Edition,
 138     _threads: usize,
 139     stderr: &Option<Arc<Mutex<Vec<u8>>>>,
 140     f: F,
 141 ) -> R {
 142     let mut cfg = thread::Builder::new().name("rustc".to_string());
 143
 144     if let Some(size) = get_stack_size() {
 145         cfg = cfg.stack_size(size);
 146     }
 147
 148     scoped_thread(cfg, || {
 149         syntax::with_globals(edition, || {
 150             ty::tls::GCX_PTR.set(&Lock::new(0), || {
 151                 if let Some(stderr) = stderr {
 152                     io::set_panic(Some(box Sink(stderr.clone())));
 153                 }
 154                 ty::tls::with_thread_locals(|| f())
 155             })
 156         })
 157     })
 158 }
 159
 160 #[cfg(parallel_compiler)]
 161 pub fn spawn_thread_pool<F: FnOnce() -> R + Send, R: Send>(
 162     edition: Edition,
 163     threads: usize,
 164     stderr: &Option<Arc<Mutex<Vec<u8>>>>,
 165     f: F,
 166 ) -> R {
 167     use rayon::{ThreadBuilder, ThreadPool, ThreadPoolBuilder};
 168
 169     let gcx_ptr = &Lock::new(0);
 170
 171     let mut config = ThreadPoolBuilder::new()
 172         .thread_name(|_| "rustc".to_string())
 173         .acquire_thread_handler(jobserver::acquire_thread)
 174         .release_thread_handler(jobserver::release_thread)
 175         .num_threads(threads)
 176         .deadlock_handler(|| unsafe { ty::query::handle_deadlock() });
 177
 178     if let Some(size) = get_stack_size() {
 179         config = config.stack_size(size);
 180     }
 181
 182     let with_pool = move |pool: &ThreadPool| pool.install(move || f());
 183
 184     syntax::with_globals(edition, || {
 185         syntax::GLOBALS.with(|syntax_globals| {
 186             syntax_pos::GLOBALS.with(|syntax_pos_globals| {
 187                 // The main handler runs for each Rayon worker thread and sets up
 188                 // the thread local rustc uses. syntax_globals and syntax_pos_globals are
 189                 // captured and set on the new threads. ty::tls::with_thread_locals sets up
 190                 // thread local callbacks from libsyntax
 191                 let main_handler = move |thread: ThreadBuilder| {
 192                     syntax::GLOBALS.set(syntax_globals, || {
 193                         syntax_pos::GLOBALS.set(syntax_pos_globals, || {
 194                             if let Some(stderr) = stderr {
 195                                 io::set_panic(Some(box Sink(stderr.clone())));
 196                             }
 197                             ty::tls::with_thread_locals(|| {
 198                                 ty::tls::GCX_PTR.set(gcx_ptr, || thread.run())
 199                             })
 200                         })
 201                     })
 202                 };
 203
 204                 config.build_scoped(main_handler, with_pool).unwrap()
 205             })
 206         })
 207     })
 208 }
 209
 210 fn load_backend_from_dylib(path: &Path) -> fn() -> Box<dyn CodegenBackend> {
 211     let lib = DynamicLibrary::open(Some(path)).unwrap_or_else(|err| {
 212         let err = format!("couldn't load codegen backend {:?}: {:?}", path, err);
 213         early_error(ErrorOutputType::default(), &err);
 214     });
 215     unsafe {
 216         match lib.symbol("__rustc_codegen_backend") {
 217             Ok(f) => {
 218                 mem::forget(lib);
 219                 mem::transmute::<*mut u8, _>(f)
 220             }
 221             Err(e) => {
 222                 let err = format!(
 223                     "couldn't load codegen backend as it \
 224                                    doesn't export the `__rustc_codegen_backend` \
 225                                    symbol: {:?}",
 226                     e
 227                 );
 228                 early_error(ErrorOutputType::default(), &err);
 229             }
 230         }
 231     }
 232 }
 233
 234 pub fn get_codegen_backend(sess: &Session) -> Box<dyn CodegenBackend> {
 235     static INIT: Once = Once::new();
 236
 237     static mut LOAD: fn() -> Box<dyn CodegenBackend> = || unreachable!();
 238
 239     INIT.call_once(|| {
 240         let codegen_name = sess
 241             .opts
 242             .debugging_opts
 243             .codegen_backend
 244             .as_ref()
 245             .unwrap_or(&sess.target.target.options.codegen_backend);
 246         let backend = match &codegen_name[..] {
 247             filename if filename.contains(".") => load_backend_from_dylib(filename.as_ref()),
 248             codegen_name => get_builtin_codegen_backend(codegen_name),
 249         };
 250
 251         unsafe {
 252             LOAD = backend;
 253         }
 254     });
 255     let backend = unsafe { LOAD() };
 256     backend.init(sess);
 257     backend
 258 }
 259
 260 // This is used for rustdoc, but it uses similar machinery to codegen backend
 261 // loading, so we leave the code here. It is potentially useful for other tools
 262 // that want to invoke the rustc binary while linking to rustc as well.
 263 pub fn rustc_path<'a>() -> Option<&'a Path> {
 264     static RUSTC_PATH: once_cell::sync::OnceCell<Option<PathBuf>> =
 265         once_cell::sync::OnceCell::new();
 266
 267     const BIN_PATH: &str = env!("RUSTC_INSTALL_BINDIR");
 268
 269     RUSTC_PATH.get_or_init(|| get_rustc_path_inner(BIN_PATH)).as_ref().map(|v| &**v)
 270 }
 271
 272 fn get_rustc_path_inner(bin_path: &str) -> Option<PathBuf> {
 273     sysroot_candidates()
 274         .iter()
 275         .filter_map(|sysroot| {
 276             let candidate = sysroot.join(bin_path).join(if cfg!(target_os = "windows") {
 277                 "rustc.exe"
 278             } else {
 279                 "rustc"
 280             });
 281             candidate.exists().then_some(candidate)
 282         })
 283         .next()
 284 }
 285
 286 fn sysroot_candidates() -> Vec<PathBuf> {
 287     let target = session::config::host_triple();
 288     let mut sysroot_candidates = vec![filesearch::get_or_default_sysroot()];
 289     let path = current_dll_path().and_then(|s| s.canonicalize().ok());
 290     if let Some(dll) = path {
 291         // use `parent` twice to chop off the file name and then also the
 292         // directory containing the dll which should be either `lib` or `bin`.
 293         if let Some(path) = dll.parent().and_then(|p| p.parent()) {
 294             // The original `path` pointed at the `rustc_driver` crate's dll.
 295             // Now that dll should only be in one of two locations. The first is
 296             // in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
 297             // other is the target's libdir, for example
 298             // `$sysroot/lib/rustlib/$target/lib/*.dll`.
 299             //
 300             // We don't know which, so let's assume that if our `path` above
 301             // ends in `$target` we *could* be in the target libdir, and always
 302             // assume that we may be in the main libdir.
 303             sysroot_candidates.push(path.to_owned());
 304
 305             if path.ends_with(target) {
 306                 sysroot_candidates.extend(
 307                     path.parent() // chop off `$target`
 308                         .and_then(|p| p.parent()) // chop off `rustlib`
 309                         .and_then(|p| p.parent()) // chop off `lib`
 310                         .map(|s| s.to_owned()),
 311                 );
 312             }
 313         }
 314     }
 315
 316     return sysroot_candidates;
 317
 318     #[cfg(unix)]
 319     fn current_dll_path() -> Option<PathBuf> {
 320         use std::ffi::{CStr, OsStr};
 321         use std::os::unix::prelude::*;
 322
 323         unsafe {
 324             let addr = current_dll_path as usize as *mut _;
 325             let mut info = mem::zeroed();
 326             if libc::dladdr(addr, &mut info) == 0 {
 327                 info!("dladdr failed");
 328                 return None;
 329             }
 330             if info.dli_fname.is_null() {
 331                 info!("dladdr returned null pointer");
 332                 return None;
 333             }
 334             let bytes = CStr::from_ptr(info.dli_fname).to_bytes();
 335             let os = OsStr::from_bytes(bytes);
 336             Some(PathBuf::from(os))
 337         }
 338     }
 339
 340     #[cfg(windows)]
 341     fn current_dll_path() -> Option<PathBuf> {
 342         use std::ffi::OsString;
 343         use std::os::windows::prelude::*;
 344
 345         extern "system" {
 346             fn GetModuleHandleExW(dwFlags: u32, lpModuleName: usize, phModule: *mut usize) -> i32;
 347             fn GetModuleFileNameW(hModule: usize, lpFilename: *mut u16, nSize: u32) -> u32;
 348         }
 349
 350         const GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS: u32 = 0x00000004;
 351
 352         unsafe {
 353             let mut module = 0;
 354             let r = GetModuleHandleExW(
 355                 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
 356                 current_dll_path as usize,
 357                 &mut module,
 358             );
 359             if r == 0 {
 360                 info!("GetModuleHandleExW failed: {}", io::Error::last_os_error());
 361                 return None;
 362             }
 363             let mut space = Vec::with_capacity(1024);
 364             let r = GetModuleFileNameW(module, space.as_mut_ptr(), space.capacity() as u32);
 365             if r == 0 {
 366                 info!("GetModuleFileNameW failed: {}", io::Error::last_os_error());
 367                 return None;
 368             }
 369             let r = r as usize;
 370             if r >= space.capacity() {
 371                 info!("our buffer was too small? {}", io::Error::last_os_error());
 372                 return None;
 373             }
 374             space.set_len(r);
 375             let os = OsString::from_wide(&space);
 376             Some(PathBuf::from(os))
 377         }
 378     }
 379 }
 380
 381 pub fn get_builtin_codegen_backend(backend_name: &str) -> fn() -> Box<dyn CodegenBackend> {
 382     #[cfg(feature = "llvm")]
 383     {
 384         if backend_name == "llvm" {
 385             return rustc_codegen_llvm::LlvmCodegenBackend::new;
 386         }
 387     }
 388
 389     let err = format!("unsupported builtin codegen backend `{}`", backend_name);
 390     early_error(ErrorOutputType::default(), &err);
 391 }
 392
 393 pub(crate) fn compute_crate_disambiguator(session: &Session) -> CrateDisambiguator {
 394     use std::hash::Hasher;
 395
 396     // The crate_disambiguator is a 128 bit hash. The disambiguator is fed
 397     // into various other hashes quite a bit (symbol hashes, incr. comp. hashes,
 398     // debuginfo type IDs, etc), so we don't want it to be too wide. 128 bits
 399     // should still be safe enough to avoid collisions in practice.
 400     let mut hasher = StableHasher::new();
 401
 402     let mut metadata = session.opts.cg.metadata.clone();
 403     // We don't want the crate_disambiguator to dependent on the order
 404     // -C metadata arguments, so sort them:
 405     metadata.sort();
 406     // Every distinct -C metadata value is only incorporated once:
 407     metadata.dedup();
 408
 409     hasher.write(b"metadata");
 410     for s in &metadata {
 411         // Also incorporate the length of a metadata string, so that we generate
 412         // different values for `-Cmetadata=ab -Cmetadata=c` and
 413         // `-Cmetadata=a -Cmetadata=bc`
 414         hasher.write_usize(s.len());
 415         hasher.write(s.as_bytes());
 416     }
 417
 418     // Also incorporate crate type, so that we don't get symbol conflicts when
 419     // linking against a library of the same name, if this is an executable.
 420     let is_exe = session.crate_types.borrow().contains(&config::CrateType::Executable);
 421     hasher.write(if is_exe { b"exe" } else { b"lib" });
 422
 423     CrateDisambiguator::from(hasher.finish::<Fingerprint>())
 424 }
 425
 426 pub(crate) fn check_attr_crate_type(attrs: &[ast::Attribute], lint_buffer: &mut lint::LintBuffer) {
 427     // Unconditionally collect crate types from attributes to make them used
 428     for a in attrs.iter() {
 429         if a.check_name(sym::crate_type) {
 430             if let Some(n) = a.value_str() {
 431                 if let Some(_) = categorize_crate_type(n) {
 432                     return;
 433                 }
 434
 435                 if let ast::MetaItemKind::NameValue(spanned) = a.meta().unwrap().kind {
 436                     let span = spanned.span;
 437                     let lev_candidate = find_best_match_for_name(
 438                         CRATE_TYPES.iter().map(|(k, _)| k),
 439                         &n.as_str(),
 440                         None,
 441                     );
 442                     if let Some(candidate) = lev_candidate {
 443                         lint_buffer.buffer_lint_with_diagnostic(
 444                             lint::builtin::UNKNOWN_CRATE_TYPES,
 445                             ast::CRATE_NODE_ID,
 446                             span,
 447                             "invalid `crate_type` value",
 448                             lint::builtin::BuiltinLintDiagnostics::UnknownCrateTypes(
 449                                 span,
 450                                 "did you mean".to_string(),
 451                                 format!("\"{}\"", candidate),
 452                             ),
 453                         );
 454                     } else {
 455                         lint_buffer.buffer_lint(
 456                             lint::builtin::UNKNOWN_CRATE_TYPES,
 457                             ast::CRATE_NODE_ID,
 458                             span,
 459                             "invalid `crate_type` value",
 460                         );
 461                     }
 462                 }
 463             }
 464         }
 465     }
 466 }
 467
 468 const CRATE_TYPES: &[(Symbol, config::CrateType)] = &[
 469     (sym::rlib, config::CrateType::Rlib),
 470     (sym::dylib, config::CrateType::Dylib),
 471     (sym::cdylib, config::CrateType::Cdylib),
 472     (sym::lib, config::default_lib_output()),
 473     (sym::staticlib, config::CrateType::Staticlib),
 474     (sym::proc_dash_macro, config::CrateType::ProcMacro),
 475     (sym::bin, config::CrateType::Executable),
 476 ];
 477
 478 fn categorize_crate_type(s: Symbol) -> Option<config::CrateType> {
 479     Some(CRATE_TYPES.iter().find(|(key, _)| *key == s)?.1)
 480 }
 481
 482 pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<config::CrateType> {
 483     // Unconditionally collect crate types from attributes to make them used
 484     let attr_types: Vec<config::CrateType> = attrs
 485         .iter()
 486         .filter_map(|a| {
 487             if a.check_name(sym::crate_type) {
 488                 match a.value_str() {
 489                     Some(s) => categorize_crate_type(s),
 490                     _ => None,
 491                 }
 492             } else {
 493                 None
 494             }
 495         })
 496         .collect();
 497
 498     // If we're generating a test executable, then ignore all other output
 499     // styles at all other locations
 500     if session.opts.test {
 501         return vec![config::CrateType::Executable];
 502     }
 503
 504     // Only check command line flags if present. If no types are specified by
 505     // command line, then reuse the empty `base` Vec to hold the types that
 506     // will be found in crate attributes.
 507     let mut base = session.opts.crate_types.clone();
 508     if base.is_empty() {
 509         base.extend(attr_types);
 510         if base.is_empty() {
 511             base.push(::rustc_codegen_utils::link::default_output_for_target(session));
 512         } else {
 513             base.sort();
 514             base.dedup();
 515         }
 516     }
 517
 518     base.retain(|crate_type| {
 519         let res = !::rustc_codegen_utils::link::invalid_output_for_target(session, *crate_type);
 520
 521         if !res {
 522             session.warn(&format!(
 523                 "dropping unsupported crate type `{}` for target `{}`",
 524                 *crate_type, session.opts.target_triple
 525             ));
 526         }
 527
 528         res
 529     });
 530
 531     base
 532 }
 533
 534 pub fn build_output_filenames(
 535     input: &Input,
 536     odir: &Option<PathBuf>,
 537     ofile: &Option<PathBuf>,
 538     attrs: &[ast::Attribute],
 539     sess: &Session,
 540 ) -> OutputFilenames {
 541     match *ofile {
 542         None => {
 543             // "-" as input file will cause the parser to read from stdin so we
 544             // have to make up a name
 545             // We want to toss everything after the final '.'
 546             let dirpath = (*odir).as_ref().cloned().unwrap_or_default();
 547
 548             // If a crate name is present, we use it as the link name
 549             let stem = sess
 550                 .opts
 551                 .crate_name
 552                 .clone()
 553                 .or_else(|| attr::find_crate_name(attrs).map(|n| n.to_string()))
 554                 .unwrap_or_else(|| input.filestem().to_owned());
 555
 556             OutputFilenames {
 557                 out_directory: dirpath,
 558                 out_filestem: stem,
 559                 single_output_file: None,
 560                 extra: sess.opts.cg.extra_filename.clone(),
 561                 outputs: sess.opts.output_types.clone(),
 562             }
 563         }
 564
 565         Some(ref out_file) => {
 566             let unnamed_output_types =
 567                 sess.opts.output_types.values().filter(|a| a.is_none()).count();
 568             let ofile = if unnamed_output_types > 1 {
 569                 sess.warn(
 570                     "due to multiple output types requested, the explicitly specified \
 571                      output file name will be adapted for each output type",
 572                 );
 573                 None
 574             } else {
 575                 if !sess.opts.cg.extra_filename.is_empty() {
 576                     sess.warn("ignoring -C extra-filename flag due to -o flag");
 577                 }
 578                 Some(out_file.clone())
 579             };
 580             if *odir != None {
 581                 sess.warn("ignoring --out-dir flag due to -o flag");
 582             }
 583
 584             OutputFilenames {
 585                 out_directory: out_file.parent().unwrap_or_else(|| Path::new("")).to_path_buf(),
 586                 out_filestem: out_file
 587                     .file_stem()
 588                     .unwrap_or_default()
 589                     .to_str()
 590                     .unwrap()
 591                     .to_string(),
 592                 single_output_file: ofile,
 593                 extra: sess.opts.cg.extra_filename.clone(),
 594                 outputs: sess.opts.output_types.clone(),
 595             }
 596         }
 597     }
 598 }
 599
 600 // Note: Also used by librustdoc, see PR #43348. Consider moving this struct elsewhere.
 601 //
 602 // FIXME: Currently the `everybody_loops` transformation is not applied to:
 603 //  * `const fn`, due to issue #43636 that `loop` is not supported for const evaluation. We are
 604 //    waiting for miri to fix that.
 605 //  * `impl Trait`, due to issue #43869 that functions returning impl Trait cannot be diverging.
 606 //    Solving this may require `!` to implement every trait, which relies on the an even more
 607 //    ambitious form of the closed RFC #1637. See also [#34511].
 608 //
 609 // [#34511]: https://github.com/rust-lang/rust/issues/34511#issuecomment-322340401
 610 pub struct ReplaceBodyWithLoop<'a, 'b> {
 611     within_static_or_const: bool,
 612     nested_blocks: Option<Vec<ast::Block>>,
 613     resolver: &'a mut Resolver<'b>,
 614 }
 615
 616 impl<'a, 'b> ReplaceBodyWithLoop<'a, 'b> {
 617     pub fn new(resolver: &'a mut Resolver<'b>) -> ReplaceBodyWithLoop<'a, 'b> {
 618         ReplaceBodyWithLoop { within_static_or_const: false, nested_blocks: None, resolver }
 619     }
 620
 621     fn run<R, F: FnOnce(&mut Self) -> R>(&mut self, is_const: bool, action: F) -> R {
 622         let old_const = mem::replace(&mut self.within_static_or_const, is_const);
 623         let old_blocks = self.nested_blocks.take();
 624         let ret = action(self);
 625         self.within_static_or_const = old_const;
 626         self.nested_blocks = old_blocks;
 627         ret
 628     }
 629
 630     fn should_ignore_fn(ret_ty: &ast::FunctionRetTy) -> bool {
 631         if let ast::FunctionRetTy::Ty(ref ty) = ret_ty {
 632             fn involves_impl_trait(ty: &ast::Ty) -> bool {
 633                 match ty.kind {
 634                     ast::TyKind::ImplTrait(..) => true,
 635                     ast::TyKind::Slice(ref subty)
 636                     | ast::TyKind::Array(ref subty, _)
 637                     | ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. })
 638                     | ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. })
 639                     | ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
 640                     ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
 641                     ast::TyKind::Path(_, ref path) => path.segments.iter().any(|seg| {
 642                         match seg.args.as_ref().map(|generic_arg| &**generic_arg) {
 643                             None => false,
 644                             Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
 645                                 let types = data.args.iter().filter_map(|arg| match arg {
 646                                     ast::GenericArg::Type(ty) => Some(ty),
 647                                     _ => None,
 648                                 });
 649                                 any_involves_impl_trait(types.into_iter())
 650                                     || data.constraints.iter().any(|c| match c.kind {
 651                                         ast::AssocTyConstraintKind::Bound { .. } => true,
 652                                         ast::AssocTyConstraintKind::Equality { ref ty } => {
 653                                             involves_impl_trait(ty)
 654                                         }
 655                                     })
 656                             }
 657                             Some(&ast::GenericArgs::Parenthesized(ref data)) => {
 658                                 any_involves_impl_trait(data.inputs.iter())
 659                                     || ReplaceBodyWithLoop::should_ignore_fn(&data.output)
 660                             }
 661                         }
 662                     }),
 663                     _ => false,
 664                 }
 665             }
 666
 667             fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
 668                 it.any(|subty| involves_impl_trait(subty))
 669             }
 670
 671             involves_impl_trait(ty)
 672         } else {
 673             false
 674         }
 675     }
 676
 677     fn is_sig_const(sig: &ast::FnSig) -> bool {
 678         sig.header.constness.node == ast::Constness::Const
 679             || ReplaceBodyWithLoop::should_ignore_fn(&sig.decl.output)
 680     }
 681 }
 682
 683 impl<'a> MutVisitor for ReplaceBodyWithLoop<'a, '_> {
 684     fn visit_item_kind(&mut self, i: &mut ast::ItemKind) {
 685         let is_const = match i {
 686             ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true,
 687             ast::ItemKind::Fn(ref sig, _, _) => Self::is_sig_const(sig),
 688             _ => false,
 689         };
 690         self.run(is_const, |s| noop_visit_item_kind(i, s))
 691     }
 692
 693     fn flat_map_trait_item(&mut self, i: ast::AssocItem) -> SmallVec<[ast::AssocItem; 1]> {
 694         let is_const = match i.kind {
 695             ast::AssocItemKind::Const(..) => true,
 696             ast::AssocItemKind::Fn(ref sig, _) => Self::is_sig_const(sig),
 697             _ => false,
 698         };
 699         self.run(is_const, |s| noop_flat_map_assoc_item(i, s))
 700     }
 701
 702     fn flat_map_impl_item(&mut self, i: ast::AssocItem) -> SmallVec<[ast::AssocItem; 1]> {
 703         self.flat_map_trait_item(i)
 704     }
 705
 706     fn visit_anon_const(&mut self, c: &mut ast::AnonConst) {
 707         self.run(true, |s| noop_visit_anon_const(c, s))
 708     }
 709
 710     fn visit_block(&mut self, b: &mut P<ast::Block>) {
 711         fn stmt_to_block(
 712             rules: ast::BlockCheckMode,
 713             s: Option<ast::Stmt>,
 714             resolver: &mut Resolver<'_>,
 715         ) -> ast::Block {
 716             ast::Block {
 717                 stmts: s.into_iter().collect(),
 718                 rules,
 719                 id: resolver.next_node_id(),
 720                 span: syntax_pos::DUMMY_SP,
 721             }
 722         }
 723
 724         fn block_to_stmt(b: ast::Block, resolver: &mut Resolver<'_>) -> ast::Stmt {
 725             let expr = P(ast::Expr {
 726                 id: resolver.next_node_id(),
 727                 kind: ast::ExprKind::Block(P(b), None),
 728                 span: syntax_pos::DUMMY_SP,
 729                 attrs: AttrVec::new(),
 730             });
 731
 732             ast::Stmt {
 733                 id: resolver.next_node_id(),
 734                 kind: ast::StmtKind::Expr(expr),
 735                 span: syntax_pos::DUMMY_SP,
 736             }
 737         }
 738
 739         let empty_block = stmt_to_block(BlockCheckMode::Default, None, self.resolver);
 740         let loop_expr = P(ast::Expr {
 741             kind: ast::ExprKind::Loop(P(empty_block), None),
 742             id: self.resolver.next_node_id(),
 743             span: syntax_pos::DUMMY_SP,
 744             attrs: AttrVec::new(),
 745         });
 746
 747         let loop_stmt = ast::Stmt {
 748             id: self.resolver.next_node_id(),
 749             span: syntax_pos::DUMMY_SP,
 750             kind: ast::StmtKind::Expr(loop_expr),
 751         };
 752
 753         if self.within_static_or_const {
 754             noop_visit_block(b, self)
 755         } else {
 756             visit_clobber(b.deref_mut(), |b| {
 757                 let mut stmts = vec![];
 758                 for s in b.stmts {
 759                     let old_blocks = self.nested_blocks.replace(vec![]);
 760
 761                     stmts.extend(self.flat_map_stmt(s).into_iter().filter(|s| s.is_item()));
 762
 763                     // we put a Some in there earlier with that replace(), so this is valid
 764                     let new_blocks = self.nested_blocks.take().unwrap();
 765                     self.nested_blocks = old_blocks;
 766                     stmts.extend(new_blocks.into_iter().map(|b| block_to_stmt(b, self.resolver)));
 767                 }
 768
 769                 let mut new_block = ast::Block { stmts, ..b };
 770
 771                 if let Some(old_blocks) = self.nested_blocks.as_mut() {
 772                     //push our fresh block onto the cache and yield an empty block with `loop {}`
 773                     if !new_block.stmts.is_empty() {
 774                         old_blocks.push(new_block);
 775                     }
 776
 777                     stmt_to_block(b.rules, Some(loop_stmt), &mut self.resolver)
 778                 } else {
 779                     //push `loop {}` onto the end of our fresh block and yield that
 780                     new_block.stmts.push(loop_stmt);
 781
 782                     new_block
 783                 }
 784             })
 785         }
 786     }
 787
 788     // in general the pretty printer processes unexpanded code, so
 789     // we override the default `visit_mac` method which panics.
 790     fn visit_mac(&mut self, mac: &mut ast::Mac) {
 791         noop_visit_mac(mac, self)
 792     }
 793 }