Remove src/tools/rust-demangler

Cargo.lock

@@ -3479,14 +3479,6 @@ dependencies = [
  "wasmparser",
 ]
 
-[[package]]
-name = "rust-demangler"
-version = "0.0.1"
-dependencies = [
- "regex",
- "rustc-demangle",
-]
-
 [[package]]
 name = "rustbook"
 version = "0.1.0"

Cargo.toml

@@ -23,7 +23,6 @@ members = [
   "src/tools/remote-test-client",
   "src/tools/remote-test-server",
   "src/tools/rust-installer",
-  "src/tools/rust-demangler",
   "src/tools/rustdoc",
   "src/tools/rls",
   "src/tools/rustfmt",

config.example.toml

@@ -321,8 +321,7 @@
 #
 # If `extended = false`, the only one of these built by default is rustdoc.
 #
-# If `extended = true`, they're all included, with the exception of
+# If `extended = true`, they are all included.
-# rust-demangler which additionally requires `profiler = true` to be set.
 #
 # If any enabled tool fails to build, the installation fails.
 #tools = [
@@ -334,7 +333,6 @@
 #    "rust-analyzer-proc-macro-srv",
 #    "analysis",
 #    "src",
-#    "rust-demangler",  # if profiler = true
 #]
 
 # Verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose, 3 == print environment variables on each rustc invocation

src/bootstrap/src/core/build_steps/clippy.rs

@@ -322,7 +322,6 @@ fn run(self, builder: &Builder<'_>) -> Self::Output {
     RemoteTestServer, "src/tools/remote-test-server", "remote-test-server";
     Rls, "src/tools/rls", "rls";
     RustAnalyzer, "src/tools/rust-analyzer", "rust-analyzer";
-    RustDemangler, "src/tools/rust-demangler", "rust-demangler";
     Rustdoc, "src/tools/rustdoc", "clippy";
     Rustfmt, "src/tools/rustfmt", "rustfmt";
     RustInstaller, "src/tools/rust-installer", "rust-installer";

src/bootstrap/src/core/build_steps/dist.rs

@@ -1459,62 +1459,6 @@ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
     }
 }
 
-#[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
-pub struct RustDemangler {
-    pub compiler: Compiler,
-    pub target: TargetSelection,
-}
-
-impl Step for RustDemangler {
-    type Output = Option<GeneratedTarball>;
-    const DEFAULT: bool = true;
-    const ONLY_HOSTS: bool = true;
-
-    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        // While other tools use `should_build_extended_tool` to decide whether to be run by
-        // default or not, `rust-demangler` must be build when *either* it's enabled as a tool like
-        // the other ones or if `profiler = true`. Because we don't know the target at this stage
-        // we run the step by default when only `extended = true`, and decide whether to actually
-        // run it or not later.
-        let default = run.builder.config.extended;
-        run.alias("rust-demangler").default_condition(default)
-    }
-
-    fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(RustDemangler {
-            compiler: run.builder.compiler_for(
-                run.builder.top_stage,
-                run.builder.config.build,
-                run.target,
-            ),
-            target: run.target,
-        });
-    }
-
-    fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
-        let compiler = self.compiler;
-        let target = self.target;
-
-        // Only build this extended tool if explicitly included in `tools`, or if `profiler = true`
-        let condition = should_build_extended_tool(builder, "rust-demangler")
-            || builder.config.profiler_enabled(target);
-        if builder.config.extended && !condition {
-            return None;
-        }
-
-        let rust_demangler =
-            builder.ensure(tool::RustDemangler { compiler, target, extra_features: Vec::new() });
-
-        // Prepare the image directory
-        let mut tarball = Tarball::new(builder, "rust-demangler", &target.triple);
-        tarball.set_overlay(OverlayKind::RustDemangler);
-        tarball.is_preview(true);
-        tarball.add_file(rust_demangler, "bin", 0o755);
-        tarball.add_legal_and_readme_to("share/doc/rust-demangler");
-        Some(tarball.generate())
-    }
-}
-
 #[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
 pub struct Extended {
     stage: u32,
@@ -1572,7 +1516,6 @@ macro_rules! add_component {
 
         add_component!("rust-docs" => Docs { host: target });
         add_component!("rust-json-docs" => JsonDocs { host: target });
-        add_component!("rust-demangler"=> RustDemangler { compiler, target });
         add_component!("cargo" => Cargo { compiler, target });
         add_component!("rustfmt" => Rustfmt { compiler, target });
         add_component!("rls" => Rls { compiler, target });
@@ -1636,7 +1579,7 @@ fn filter(contents: &str, marker: &str) -> String {
 
         let xform = |p: &Path| {
             let mut contents = t!(fs::read_to_string(p));
-            for tool in &["rust-demangler", "miri", "rust-docs"] {
+            for tool in &["miri", "rust-docs"] {
                 if !built_tools.contains(tool) {
                     contents = filter(&contents, tool);
                 }
@@ -1677,7 +1620,7 @@ fn filter(contents: &str, marker: &str) -> String {
             prepare("rust-analysis");
             prepare("clippy");
             prepare("rust-analyzer");
-            for tool in &["rust-docs", "rust-demangler", "miri", "rustc-codegen-cranelift"] {
+            for tool in &["rust-docs", "miri", "rustc-codegen-cranelift"] {
                 if built_tools.contains(tool) {
                     prepare(tool);
                 }
@@ -1717,8 +1660,6 @@ fn filter(contents: &str, marker: &str) -> String {
                     "rust-analyzer-preview".to_string()
                 } else if name == "clippy" {
                     "clippy-preview".to_string()
-                } else if name == "rust-demangler" {
-                    "rust-demangler-preview".to_string()
                 } else if name == "miri" {
                     "miri-preview".to_string()
                 } else if name == "rustc-codegen-cranelift" {
@@ -1738,7 +1679,7 @@ fn filter(contents: &str, marker: &str) -> String {
             prepare("cargo");
             prepare("rust-analysis");
             prepare("rust-std");
-            for tool in &["clippy", "rust-analyzer", "rust-docs", "rust-demangler", "miri"] {
+            for tool in &["clippy", "rust-analyzer", "rust-docs", "miri"] {
                 if built_tools.contains(tool) {
                     prepare(tool);
                 }
@@ -1862,25 +1803,6 @@ fn filter(contents: &str, marker: &str) -> String {
                         .arg(etc.join("msi/remove-duplicates.xsl")),
                 );
             }
-            if built_tools.contains("rust-demangler") {
-                builder.run(
-                    Command::new(&heat)
-                        .current_dir(&exe)
-                        .arg("dir")
-                        .arg("rust-demangler")
-                        .args(heat_flags)
-                        .arg("-cg")
-                        .arg("RustDemanglerGroup")
-                        .arg("-dr")
-                        .arg("RustDemangler")
-                        .arg("-var")
-                        .arg("var.RustDemanglerDir")
-                        .arg("-out")
-                        .arg(exe.join("RustDemanglerGroup.wxs"))
-                        .arg("-t")
-                        .arg(etc.join("msi/remove-duplicates.xsl")),
-                );
-            }
             if built_tools.contains("miri") {
                 builder.run(
                     Command::new(&heat)
@@ -1958,9 +1880,6 @@ fn filter(contents: &str, marker: &str) -> String {
                 if built_tools.contains("rust-docs") {
                     cmd.arg("-dDocsDir=rust-docs");
                 }
-                if built_tools.contains("rust-demangler") {
-                    cmd.arg("-dRustDemanglerDir=rust-demangler");
-                }
                 if built_tools.contains("rust-analyzer") {
                     cmd.arg("-dRustAnalyzerDir=rust-analyzer");
                 }
@@ -1987,9 +1906,6 @@ fn filter(contents: &str, marker: &str) -> String {
             if built_tools.contains("miri") {
                 candle("MiriGroup.wxs".as_ref());
             }
-            if built_tools.contains("rust-demangler") {
-                candle("RustDemanglerGroup.wxs".as_ref());
-            }
             if built_tools.contains("rust-analyzer") {
                 candle("RustAnalyzerGroup.wxs".as_ref());
             }
@@ -2031,9 +1947,6 @@ fn filter(contents: &str, marker: &str) -> String {
             if built_tools.contains("rust-analyzer") {
                 cmd.arg("RustAnalyzerGroup.wixobj");
             }
-            if built_tools.contains("rust-demangler") {
-                cmd.arg("RustDemanglerGroup.wixobj");
-            }
             if built_tools.contains("rust-docs") {
                 cmd.arg("DocsGroup.wixobj");
             }

src/bootstrap/src/core/build_steps/install.rs

@@ -265,22 +265,6 @@ fn run($sel, $builder: &Builder<'_>) {
             );
         }
     };
-    RustDemangler, alias = "rust-demangler", Self::should_build(_config), only_hosts: true, {
-        // NOTE: Even though `should_build` may return true for `extended` default tools,
-        // dist::RustDemangler may still return None, unless the target-dependent `profiler` config
-        // is also true, or the `tools` array explicitly includes "rust-demangler".
-        if let Some(tarball) = builder.ensure(dist::RustDemangler {
-            compiler: self.compiler,
-            target: self.target
-        }) {
-            install_sh(builder, "rust-demangler", self.compiler.stage, Some(self.target), &tarball);
-        } else {
-            builder.info(
-                &format!("skipping Install RustDemangler stage{} ({})",
-                         self.compiler.stage, self.target),
-            );
-        }
-    };
     Rustc, path = "compiler/rustc", true, only_hosts: true, {
         let tarball = builder.ensure(dist::Rustc {
             compiler: builder.compiler(builder.top_stage, self.target),

src/bootstrap/src/core/build_steps/test.rs

@@ -432,65 +432,6 @@ fn run(self, builder: &Builder<'_>) {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RustDemangler {
-    stage: u32,
-    host: TargetSelection,
-}
-
-impl Step for RustDemangler {
-    type Output = ();
-    const ONLY_HOSTS: bool = true;
-
-    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.path("src/tools/rust-demangler")
-    }
-
-    fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(RustDemangler { stage: run.builder.top_stage, host: run.target });
-    }
-
-    /// Runs `cargo test` for rust-demangler.
-    fn run(self, builder: &Builder<'_>) {
-        let stage = self.stage;
-        let host = self.host;
-        let compiler = builder.compiler(stage, host);
-
-        let rust_demangler = builder.ensure(tool::RustDemangler {
-            compiler,
-            target: self.host,
-            extra_features: Vec::new(),
-        });
-        let mut cargo = tool::prepare_tool_cargo(
-            builder,
-            compiler,
-            Mode::ToolRustc,
-            host,
-            "test",
-            "src/tools/rust-demangler",
-            SourceType::InTree,
-            &[],
-        );
-
-        let dir = testdir(builder, compiler.host);
-        t!(fs::create_dir_all(dir));
-
-        cargo.env("RUST_DEMANGLER_DRIVER_PATH", rust_demangler);
-        cargo.add_rustc_lib_path(builder);
-
-        run_cargo_test(
-            cargo,
-            &[],
-            &[],
-            "rust-demangler",
-            "rust-demangler",
-            compiler,
-            host,
-            builder,
-        );
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Miri {
     target: TargetSelection,

src/bootstrap/src/core/build_steps/tool.rs

@@ -964,7 +964,6 @@ fn run(mut $sel, $builder: &Builder<'_>) -> PathBuf {
     // But `builder.cargo` doesn't know how to handle ToolBootstrap in stages other than 0,
     // and this is close enough for now.
     Rls, "src/tools/rls", "rls", stable=true, tool_std=true;
-    RustDemangler, "src/tools/rust-demangler", "rust-demangler", stable=false, tool_std=true;
     Rustfmt, "src/tools/rustfmt", "rustfmt", stable=true, add_bins_to_sysroot = ["rustfmt", "cargo-fmt"];
 );
 

src/bootstrap/src/core/builder.rs

@@ -736,7 +736,6 @@ macro_rules! describe {
                 tool::Rls,
                 tool::RustAnalyzer,
                 tool::RustAnalyzerProcMacroSrv,
-                tool::RustDemangler,
                 tool::Rustdoc,
                 tool::Clippy,
                 tool::CargoClippy,
@@ -774,7 +773,6 @@ macro_rules! describe {
                 clippy::RemoteTestServer,
                 clippy::Rls,
                 clippy::RustAnalyzer,
-                clippy::RustDemangler,
                 clippy::Rustdoc,
                 clippy::Rustfmt,
                 clippy::RustInstaller,
@@ -842,7 +840,6 @@ macro_rules! describe {
                 test::Miri,
                 test::CargoMiri,
                 test::Clippy,
-                test::RustDemangler,
                 test::CompiletestTest,
                 test::CrateRunMakeSupport,
                 test::RustdocJSStd,
@@ -903,7 +900,6 @@ macro_rules! describe {
                 dist::Rls,
                 dist::RustAnalyzer,
                 dist::Rustfmt,
-                dist::RustDemangler,
                 dist::Clippy,
                 dist::Miri,
                 dist::LlvmTools,
@@ -930,7 +926,6 @@ macro_rules! describe {
                 install::Cargo,
                 install::RustAnalyzer,
                 install::Rustfmt,
-                install::RustDemangler,
                 install::Clippy,
                 install::Miri,
                 install::LlvmTools,

src/bootstrap/src/utils/tarball.rs

@@ -23,7 +23,6 @@ pub(crate) enum OverlayKind {
     Clippy,
     Miri,
     Rustfmt,
-    RustDemangler,
     Rls,
     RustAnalyzer,
     RustcCodegenCranelift,
@@ -58,9 +57,6 @@ fn legal_and_readme(&self) -> &[&str] {
                 "src/tools/rustfmt/LICENSE-APACHE",
                 "src/tools/rustfmt/LICENSE-MIT",
             ],
-            OverlayKind::RustDemangler => {
-                &["src/tools/rust-demangler/README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-            }
             OverlayKind::Rls => &["src/tools/rls/README.md", "LICENSE-APACHE", "LICENSE-MIT"],
             OverlayKind::RustAnalyzer => &[
                 "src/tools/rust-analyzer/README.md",
@@ -85,7 +81,6 @@ fn version(&self, builder: &Builder<'_>) -> String {
         match self {
             OverlayKind::Rust => builder.rust_version(),
             OverlayKind::Llvm => builder.rust_version(),
-            OverlayKind::RustDemangler => builder.release_num("rust-demangler"),
             OverlayKind::Cargo => {
                 builder.cargo_info.version(builder, &builder.release_num("cargo"))
             }

src/doc/rustc/src/instrument-coverage.md

@@ -49,12 +49,6 @@ One option for a Rust demangler is [`rustfilt`], which can be installed with:
 cargo install rustfilt
 ```
 
-Another option, if you are building from the Rust compiler source distribution, is to use the `rust-demangler` tool included in the Rust source distribution, which can be built with:
-
-```shell
-$ ./x.py build rust-demangler
-```
-
 [`rustfilt`]: https://crates.io/crates/rustfilt
 
 ## Compiling with coverage enabled
@@ -164,7 +158,7 @@ $ llvm-cov show -Xdemangler=rustfilt target/debug/examples/formatjson5 \
 
 Some of the more notable options in this example include:
 
--   `--Xdemangler=rustfilt` - the command name or path used to demangle Rust symbols (`rustfilt` in the example, but this could also be a path to the `rust-demangler` tool)
+-   `--Xdemangler=rustfilt` - the command name or path used to demangle Rust symbols (`rustfilt` in the example)
 -   `target/debug/examples/formatjson5` - the instrumented binary (from which to extract the coverage map)
 -   `--instr-profile=<path-to-file>.profdata` - the location of the `.profdata` file created by `llvm-profdata merge` (from the `.profraw` file generated by the instrumented binary)
 -   `--name=<exact-function-name>` - to show coverage for a specific function (or, consider using another filter option, such as `--name-regex=<pattern>`)

src/tools/rust-demangler/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "rust-demangler"
-version = "0.0.1"
-edition = "2021"
-
-[dependencies]
-regex = "1.0"
-rustc-demangle = "0.1.17"
-
-[lib]
-name = "rust_demangler"
-doctest = false
-
-[[bin]]
-name = "rust-demangler"
-test = false

src/tools/rust-demangler/README.md

@@ -1,36 +0,0 @@
-# rust-demangler
-
-_Demangles rustc mangled names._
-
-`rust-demangler` supports the requirements of the [`llvm-cov show -Xdemangler`
-option](https://llvm.org/docs/CommandGuide/llvm-cov.html#cmdoption-llvm-cov-show-xdemangler),
-to perform Rust-specific symbol demangling:
-
-> _The demangler is expected to read a newline-separated list of symbols from
-> stdin and write a newline-separated list of the same length to stdout._
-
-To use `rust-demangler` with `llvm-cov` for example:
-
-```shell
-$ TARGET="${PWD}/build/x86_64-unknown-linux-gnu"
-$ "${TARGET}"/llvm/bin/llvm-cov show \
-  --Xdemangler=path/to/rust-demangler \
-  --instr-profile=main.profdata ./main --show-line-counts-or-regions
-```
-
-`rust-demangler` is a Rust "extended tool", used in Rust compiler tests, and
-optionally included in Rust distributions that enable coverage profiling. Symbol
-demangling is implemented using the
-[rustc-demangle](https://crates.io/crates/rustc-demangle) crate.
-
-_(Note, for Rust developers, the third-party tool
-[`rustfilt`](https://crates.io/crates/rustfilt) also supports `llvm-cov` symbol
-demangling. `rustfilt` is a more generalized tool that searches any body of
-text, using pattern matching, to find and demangle Rust symbols.)_
-
-## License
-
-Rust-demangler is distributed under the terms of both the MIT license and the
-Apache License (Version 2.0).
-
-See [LICENSE-APACHE](/LICENSE-APACHE) and [LICENSE-MIT](/LICENSE-MIT) for details.

src/tools/rust-demangler/src/lib.rs

@@ -1,21 +0,0 @@
-use regex::Regex;
-use rustc_demangle::demangle;
-use std::str::Lines;
-
-const REPLACE_COLONS: &str = "::";
-
-pub fn create_disambiguator_re() -> Regex {
-    Regex::new(r"\[[a-f0-9]{5,16}\]::").unwrap()
-}
-
-pub fn demangle_lines(lines: Lines<'_>, strip_crate_disambiguators: Option<Regex>) -> Vec<String> {
-    let mut demangled_lines = Vec::new();
-    for mangled in lines {
-        let mut demangled = demangle(mangled).to_string();
-        if let Some(re) = &strip_crate_disambiguators {
-            demangled = re.replace_all(&demangled, REPLACE_COLONS).to_string();
-        }
-        demangled_lines.push(demangled);
-    }
-    demangled_lines
-}

src/tools/rust-demangler/src/main.rs

@@ -1,97 +0,0 @@
-//! Demangles rustc mangled names.
-//!
-//! Note regarding crate disambiguators:
-//!
-//! Some demangled symbol paths can include "crate disambiguator" suffixes, represented as a large
-//! hexadecimal value enclosed in square braces, and appended to the name of the crate. a suffix to the
-//! original crate name. For example, the `core` crate, here, includes a disambiguator:
-//!
-//! ```rust
-//!     <generics::Firework<f64> as core[a7a74cee373f048]::ops::drop::Drop>::drop
-//! ```
-//!
-//! These disambiguators are known to vary depending on environmental circumstances. As a result,
-//! tests that compare results including demangled names can fail across development environments,
-//! particularly with cross-platform testing. Also, the resulting crate paths are not syntactically
-//! valid, and don't match the original source symbol paths, which can impact development tools.
-//!
-//! For these reasons, by default, `rust-demangler` uses a heuristic to remove crate disambiguators
-//! from their original demangled representation before printing them to standard output. If crate
-//! disambiguators are required, add the `-d` (or `--disambiguators`) flag, and the disambiguators
-//! will not be removed.
-//!
-//! Also note that the disambiguators are stripped by a Regex pattern that is tolerant to some
-//! variation in the number of hexadecimal digits. The disambiguators come from a hash value, which
-//! typically generates a 16-digit hex representation on a 64-bit architecture; however, leading
-//! zeros are not included, which can shorten the hex digit length, and a different hash algorithm
-//! that might also be dependent on the architecture, might shorten the length even further. A
-//! minimum length of 5 digits is assumed, which should be more than sufficient to support hex
-//! representations that generate only 8-digits of precision with an extremely rare (but not
-//! impossible) result with up to 3 leading zeros.
-//!
-//! Using a minimum number of digits less than 5 risks the possibility of stripping demangled name
-//! components with a similar pattern. For example, some closures instantiated multiple times
-//! include their own disambiguators, demangled as non-hashed zero-based indexes in square brackets.
-//! These disambiguators seem to have more analytical value (for instance, in coverage analysis), so
-//! they are not removed.
-
-use rust_demangler::*;
-use std::io::{self, Read, Write};
-
-fn main() -> io::Result<()> {
-    // FIXME(richkadel): In Issue #77615 discussed updating the `rustc-demangle` library, to provide
-    // an option to generate demangled names without including crate disambiguators. If that
-    // happens, update this tool to use that option (if the `-d` flag is not set) instead stripping
-    // them via the Regex heuristic. The update the doc comments and help.
-
-    // Strip hashed hexadecimal crate disambiguators. Leading zeros are not enforced, and can be
-    // different across different platform/architecture types, so while 16 hex digits are common,
-    // they can also be shorter.
-    //
-    // Also note that a demangled symbol path may include the `[<digits>]` pattern, with zero-based
-    // indexes (such as for closures, and possibly for types defined in anonymous scopes). Preferably
-    // these should not be stripped.
-    //
-    // The minimum length of 5 digits supports the possibility that some target architecture (maybe
-    // a 32-bit or smaller architecture) could generate a hash value with a maximum of 8 digits,
-    // and more than three leading zeros should be extremely unlikely. Conversely, it should be
-    // sufficient to assume the zero-based indexes for closures and anonymous scopes will never
-    // exceed the value 9999.
-    let mut strip_crate_disambiguators = Some(create_disambiguator_re());
-
-    let mut args = std::env::args();
-    let progname = args.next().unwrap();
-    for arg in args {
-        if arg == "--disambiguators" || arg == "-d" {
-            strip_crate_disambiguators = None;
-        } else {
-            eprintln!();
-            eprintln!("Usage: {} [-d|--disambiguators]", progname);
-            eprintln!();
-            eprintln!(
-                "This tool converts a list of Rust mangled symbols (one per line) into a\n\
-                corresponding list of demangled symbols."
-            );
-            eprintln!();
-            eprintln!(
-                "With -d (--disambiguators), Rust symbols mangled with the v0 symbol mangler may\n\
-                include crate disambiguators (a hexadecimal hash value, typically up to 16 digits\n\
-                long, enclosed in square brackets)."
-            );
-            eprintln!();
-            eprintln!(
-                "By default, crate disambiguators are removed, using a heuristics-based regular\n\
-                expression. (See the `rust-demangler` doc comments for more information.)"
-            );
-            eprintln!();
-            std::process::exit(1)
-        }
-    }
-
-    let mut buffer = String::new();
-    io::stdin().read_to_string(&mut buffer)?;
-    let mut demangled_lines = demangle_lines(buffer.lines(), strip_crate_disambiguators);
-    demangled_lines.push("".to_string()); // ensure a trailing newline
-    io::stdout().write_all(demangled_lines.join("\n").as_bytes())?;
-    Ok(())
-}

src/tools/rust-demangler/tests/lib.rs

@@ -1,84 +0,0 @@
-use rust_demangler::*;
-
-const MANGLED_INPUT: &str = r"
-_RNvC6_123foo3bar
-_RNqCs4fqI2P2rA04_11utf8_identsu30____7hkackfecea1cbdathfdh9hlq6y
-_RNCNCNgCs6DXkGYLi8lr_2cc5spawn00B5_
-_RNCINkXs25_NgCsbmNqQUJIY6D_4core5sliceINyB9_4IterhENuNgNoBb_4iter8iterator8Iterator9rpositionNCNgNpB9_6memchr7memrchrs_0E0Bb_
-_RINbNbCskIICzLVDPPb_5alloc5alloc8box_freeDINbNiB4_5boxed5FnBoxuEp6OutputuEL_ECs1iopQbuBiw2_3std
-INtC8arrayvec8ArrayVechKj7b_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_8UnsignedKhb_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_6SignedKs98_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_6SignedKanb_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_4BoolKb0_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_4BoolKb1_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKc76_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKca_E
-_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKc2202_E
-_RNvNvMCs4fqI2P2rA04_13const_genericINtB4_3FooKpE3foo3FOO
-_RC3foo.llvm.9D1C9369
-_RC3foo.llvm.9D1C9369@@16
-_RNvC9backtrace3foo.llvm.A5310EB9
-_RNvNtNtNtNtCs92dm3009vxr_4rand4rngs7adapter9reseeding4fork23FORK_HANDLER_REGISTERED.0.0
-";
-
-const DEMANGLED_OUTPUT: &str = r"
-123foo[0]::bar
-utf8_idents[317d481089b8c8fe]::საჭმელად_გემრიელი_სადილი
-cc[4d6468d6c9fd4bb3]::spawn::{closure#0}::{closure#0}
-<core[846817f741e54dfd]::slice::Iter<u8> as core[846817f741e54dfd]::iter::iterator::Iterator>::rposition::<core[846817f741e54dfd]::slice::memchr::memrchr::{closure#1}>::{closure#0}
-alloc[f15a878b47eb696b]::alloc::box_free::<dyn alloc[f15a878b47eb696b]::boxed::FnBox<(), Output = ()>>
-INtC8arrayvec8ArrayVechKj7b_E
-<const_generic[317d481089b8c8fe]::Unsigned<11u8>>
-<const_generic[317d481089b8c8fe]::Signed<152i16>>
-<const_generic[317d481089b8c8fe]::Signed<-11i8>>
-<const_generic[317d481089b8c8fe]::Bool<false>>
-<const_generic[317d481089b8c8fe]::Bool<true>>
-<const_generic[317d481089b8c8fe]::Char<'v'>>
-<const_generic[317d481089b8c8fe]::Char<'\n'>>
-<const_generic[317d481089b8c8fe]::Char<'∂'>>
-<const_generic[317d481089b8c8fe]::Foo<_>>::foo::FOO
-foo[0]
-foo[0]
-backtrace[0]::foo
-rand[693ea8e72247470f]::rngs::adapter::reseeding::fork::FORK_HANDLER_REGISTERED.0.0
-";
-
-const DEMANGLED_OUTPUT_NO_CRATE_DISAMBIGUATORS: &str = r"
-123foo[0]::bar
-utf8_idents::საჭმელად_გემრიელი_სადილი
-cc::spawn::{closure#0}::{closure#0}
-<core::slice::Iter<u8> as core::iter::iterator::Iterator>::rposition::<core::slice::memchr::memrchr::{closure#1}>::{closure#0}
-alloc::alloc::box_free::<dyn alloc::boxed::FnBox<(), Output = ()>>
-INtC8arrayvec8ArrayVechKj7b_E
-<const_generic::Unsigned<11u8>>
-<const_generic::Signed<152i16>>
-<const_generic::Signed<-11i8>>
-<const_generic::Bool<false>>
-<const_generic::Bool<true>>
-<const_generic::Char<'v'>>
-<const_generic::Char<'\n'>>
-<const_generic::Char<'∂'>>
-<const_generic::Foo<_>>::foo::FOO
-foo[0]
-foo[0]
-backtrace[0]::foo
-rand::rngs::adapter::reseeding::fork::FORK_HANDLER_REGISTERED.0.0
-";
-
-#[test]
-fn test_demangle_lines() {
-    let demangled_lines = demangle_lines(MANGLED_INPUT.lines(), None);
-    for (expected, actual) in DEMANGLED_OUTPUT.lines().zip(demangled_lines) {
-        assert_eq!(expected, actual);
-    }
-}
-
-#[test]
-fn test_demangle_lines_no_crate_disambiguators() {
-    let demangled_lines = demangle_lines(MANGLED_INPUT.lines(), Some(create_disambiguator_re()));
-    for (expected, actual) in DEMANGLED_OUTPUT_NO_CRATE_DISAMBIGUATORS.lines().zip(demangled_lines)
-    {
-        assert_eq!(expected, actual);
-    }
-}