Compile is too slow

[araraloren]

I tried this code (issue code repo (c1421faeeb9b8a2775d3ce460ee56e42064ea709)):

let unit = neu::ascii_alphabetic()
    .or(neu::ascii_alphanumeric())
    .or('_');
let ident = unit.repeat_one_more();
let ty = neu::ascii_alphabetic()
    .or('_')
    .repeat_one()
    .then(ident)
    .pat();
// compile about 25s+
let layer1 = ty
    .then(ty.quote("<", ">"))
    .map(|(w, ty)| Ok(Ty::Layer1(w, ty)));
let layer2 = ty
    .then(ty.then(ty.quote("<", ">")).quote("<", ">"))
    .map(|(w1, (w2, ty))| Ok(Ty::Layer2(w1, w2, ty)));
let layer0 = ty.map(|ty| Ok(Ty::Layer0(ty)));
let field = ident.sep_once(":", layer2.or(layer1.or(layer0)));
// let layer1 = ty
//     .then(ty.quote("<", ">"))
//     .map(|(w, ty)| Ok(Ty::Layer1(w, ty)));
// let layer0 = ty.map(|ty| Ok(Ty::Layer0(ty)));
// let field = ident.sep_once(":", layer1.or(layer0));
// comment 55 ~ 62 and uncomment current block, compile about 2s+
let public = field
    .padded("pub")
    .map(|(name, ty_name)| Ok(Field::public(name, ty_name)));
let private = field.map(|(name, ty_name)| Ok(Field::private(name, ty_name)));
let parser = public.or(private).sep(",");

let data = "abc: Option<i32>";
let b_policy = re_policy(neu::whitespace().repeat_full());

dbg!(PolicyCtx::new(CharsCtx::new(data), b_policy).ctor(&parser)?);

I expected to see this happen: compile in several seconds.

Instead, this happened: compile in 27s+.

   Compiling api-gen v0.1.0 (E:\Rust\issue-example)
warning: field `public` is never read
  --> src\main.rs:23:5
   |
   |            ----- field in this struct
...
23 |     public: bool,
   |     ^^^^^^
   |
   = note: `Field` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
   = note: `#[warn(dead_code)]` on by default

warning: `api-gen` (bin "api-gen") generated 1 warning
    Finished dev [unoptimized + debuginfo] target(s) in 27.29s

neure is a crate write for parsing string or binary data,

Meta

rustc --version --verbose:

rustc 1.77.0-nightly (3cdd004e5 2023-12-29)
binary: rustc
commit-hash: 3cdd004e55c869faa2b7b25efd3becf50346e7d6
commit-date: 2023-12-29
host: x86_64-pc-windows-msvc
release: 1.77.0-nightly
LLVM version: 17.0.6

[Noratrieb]

Thank you for the report. I was able to reproduce this on my computer with the latest nightly. The output of -Ztime-passes is pretty clear, all time is spent in typeck:
time: 57.059; rss: 77MB -> 1244MB (+1167MB) type_check_crate
I will try to minimize your code a bit.

[Noratrieb]

running perf record on nightly revels the following function to be the majority of the tine <rustc_infer::infer::error_reporting::TypeErrCtxt as rustc_trait_selection::traits::error_reporting::type_err_ctxt_ext::InferCtxtPrivExt>::error_implies
which suggests that this is caused by expontentialness in some error reporting path

using this code

use neure::{
    ctx::{re_policy, PolicyCtx},
    prelude::*,
};

#[derive(Debug, Clone)]
pub enum Ty<'a> {
    Layer0(&'a str),

    Layer1(&'a str, &'a str),

    Layer2(&'a str, &'a str, &'a str),
}

#[derive(Debug, Clone)]
pub struct Field<'a> {
    #[allow(unused)]
    ident: &'a str,

    #[allow(unused)]
    ty_name: Ty<'a>,

    public: bool,
}

impl<'a> Field<'a> {
    pub fn private(ident: &'a str, ty_name: Ty<'a>) -> Self {
        Self {
            ident,
            ty_name,
            public: false,
        }
    }

    pub fn public(name: &'a str, ty_name: Ty<'a>) -> Self {
        Self {
            ident: name,
            ty_name,
            public: true,
        }
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let unit = neu::ascii_alphabetic()
        .or(neu::ascii_alphanumeric())
        .or('_');
    let ident = unit.repeat_one_more();
    let ty = neu::ascii_alphabetic()
        .or('_')
        .repeat_one()
        .then(ident)
        .pat();
    // compile about 25s+
    let layer1 = ty
        .then(ty.quote("<", ">"))
        .map(|(w, ty)| Ok(Ty::Layer1(w, ty)));
    let layer2 = ty
        .then(ty.then(ty.quote("<", ">")).quote("<", ">"))
        .map(|(w1, (w2, ty))| Ok(Ty::Layer2(w1, w2, ty)));
    let layer0 = ty.map(|ty| Ok(Ty::Layer0(ty)));
    let field = ident.sep_once(":", layer2.or(layer1.or(layer0)));

    let public = field
        .padded("pub")
        .map(|(name, ty_name)| Ok(Field::public(name, ty_name)));
    let private = field.map(|(name, ty_name)| Ok(Field::private(name, ty_name)));
    let parser = public.or(private).sep(",");

    Ok(())
}

[Noratrieb]

I tried using perf record on a local build with debuginfo and it just pointed at the usual hot code paths in the trait solver. This code doing a lot of trait solving makes sense, and if it was just that, then there isn't much that can be fixed as-is. The library should offer ways to reduce type sizes behind boxing (like chumsky.

Compilation also succeeded in this attempt (using the git repo you posted as-is) so this seems kinda inevitable.

[araraloren]

I tried using perf record on a local build with debuginfo and it just pointed at the usual hot code paths in the trait solver. This code doing a lot of trait solving makes sense, and if it was just that, then there isn't much that can be fixed as-is. The library should offer ways to reduce type sizes behind boxing (like chumsky.

Compilation also succeeded in this attempt (using the git repo you posted as-is) so this seems kinda inevitable.

Okay, I see, thanks for the explain.