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