Error on projection of dyn noncompat type in old trait solver

[spirali]

View all comments

Trying to fix rust-lang/trait-system-refactor-initiative#269

I am not sure that the check is placed into the right place in the code.

r? lcnr

[lcnr]

View changes since the review

that's annoying :< ideally we'd silence method errors if the self type is not well-formed, tracking that is non-trivial and I don't know how we'd do so myself rn

[lcnr]

lgtm, let's do a crater run, there should be exactly 1 regression from this

@bors try

[rust-bors]

☀️ Try build successful (CI)
Build commit: a611f2a (a611f2a14e38407ec6717a86a01424ee6fc80762, parent: 1fe72d35998dea48aeecaf7fc07783b0b553f24f)

[lcnr]

@craterbot check

[craterbot]

👌 Experiment pr-154992 created and queued.
🤖 Automatically detected try build a611f2a
🔍 You can check out the queue and this experiment's details.

ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

[craterbot]

🚧 Experiment pr-154992 is now running

ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

[craterbot]

🎉 Experiment pr-154992 is completed!
📊 18 regressed and 6 fixed (886019 total)
📊 5676 spurious results on the retry-regressed-list.txt, consider a retry¹ if this is a significant amount.
📰 Open the summary report.

⚠️ If you notice any spurious failure please add them to the denylist!
ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

Footnotes

1. re-run the experiment with crates=https://crater-reports.s3.amazonaws.com/pr-154992/retry-regressed-list.txt ↩

[lcnr]

@craterbot check crates=https://crater-reports.s3.amazonaws.com/pr-154992/retry-regressed-list.txt

[craterbot]

👌 Experiment pr-154992-1 created and queued.
🤖 Automatically detected try build a611f2a
🔍 You can check out the queue and this experiment's details.

ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

[lcnr]

@craterbot p=1

[craterbot]

📝 Configuration of the pr-154992-1 experiment changed.

ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

[craterbot]

🚧 Experiment pr-154992-1 is now running

ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

[craterbot]

🎉 Experiment pr-154992-1 is completed!
📊 13 regressed and 0 fixed (5381 total)
📊 968 spurious results on the retry-regressed-list.txt, consider a retry¹ if this is a significant amount.
📰 Open the summary report.

⚠️ If you notice any spurious failure please add them to the denylist!
ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

Footnotes

1. re-run the experiment with crates=https://crater-reports.s3.amazonaws.com/pr-154992-1/retry-regressed-list.txt ↩

[lcnr]

@craterbot check crates=https://crater-reports.s3.amazonaws.com/pr-154992-1/retry-regressed-list.txt p=1

surprising that we have that many spurious regressions still?

it's caused by build OOMs and unlike the new solver, this PR shouldn't really change max-rss in any way 😅 cc @rust-lang/infra

[craterbot]

👌 Experiment pr-154992-2 created and queued.
🤖 Automatically detected try build a611f2a
🔍 You can check out the queue and this experiment's details.

ℹ️ Crater is a tool to run experiments across parts of the Rust ecosystem. Learn more

[lcnr]

Alright 🤔 @spirali can you look at the crater report and figure out whether they are expected?

[spirali]

Oh, I had some problems with notifications again. I will look at it.

Alright 🤔 @spirali can you look at the crater report and figure out whether they are expected?

[spirali]

It seems that all fails are realated to a single crate: git-url-parse crate; in code:

    fn path_abempty_parser<'url>(
    ) -> impl Parser<
        &'url str,
        Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
            &'url str,
        >>::Output,
        Error = nom::error::Error<&'url str>,
    >{

it fails with error:

info: `cargo` is unavailable for the active toolchain
info: falling back to "/home/ada/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/bin/cargo"
    Checking git-url-parse v0.6.0 (/home/ada/projects/git-url-parse-rs)
error[E0271]: type mismatch resolving `<Context<...> as Parser<...>>::Output == <... as Parser<...>>::Output`
   --> src/types/spec.rs:374:10
    |
374 |       ) -> impl Parser<
    |  __________^
375 | |         &'url str,
376 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
377 | |             &'url str,
378 | |         >>::Output,
379 | |         Error = nom::error::Error<&'url str>,
380 | |     >{
    | |_____^ expected associated type, found `&str`
    |
    = note: expected associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output`
                     found reference `&'url str`
    = help: consider constraining the associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output` to `&'url str` or calling a method that returns `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
    = note: the full name for the type has been written to '/home/ada/projects/git-url-parse-rs/target/debug/deps/git_url_parse-15b0a6ff9f5232d5.long-type-8233111347681804376.txt'
    = note: consider using `--verbose` to print the full type name to the console

error[E0271]: type mismatch resolving `<Context<...> as Parser<...>>::Output == <... as Parser<...>>::Output`
   --> src/types/spec.rs:398:10
    |
398 |       ) -> impl Parser<
    |  __________^
399 | |         &'url str,
400 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
401 | |             &'url str,
402 | |         >>::Output,
403 | |         Error = nom::error::Error<&'url str>,
404 | |     >{
    | |_____^ expected associated type, found `&str`
    |
    = note: expected associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output`
                     found reference `&'url str`
    = help: consider constraining the associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output` to `&'url str` or calling a method that returns `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
    = note: the full name for the type has been written to '/home/ada/projects/git-url-parse-rs/target/debug/deps/git_url_parse-15b0a6ff9f5232d5.long-type-5159688081705980566.txt'
    = note: consider using `--verbose` to print the full type name to the console

error[E0271]: type mismatch resolving `<Context<...> as Parser<...>>::Output == <... as Parser<...>>::Output`
   --> src/types/spec.rs:422:10
    |
422 |       ) -> impl Parser<
    |  __________^
423 | |         &'url str,
424 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
425 | |             &'url str,
426 | |         >>::Output,
427 | |         Error = nom::error::Error<&'url str>,
428 | |     >{
    | |_____^ expected associated type, found `&str`
    |
    = note: expected associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output`
                     found reference `&'url str`
    = help: consider constraining the associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output` to `&'url str` or calling a method that returns `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = &'url str> + 'static) as Parser<&'url str>>::Output`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
    = note: the full name for the type has been written to '/home/ada/projects/git-url-parse-rs/target/debug/deps/git_url_parse-15b0a6ff9f5232d5.long-type-15696984571572880886.txt'
    = note: consider using `--verbose` to print the full type name to the console

error[E0271]: type mismatch resolving `<Context<...> as Parser<...>>::Output == <... as Parser<...>>::Output`
   --> src/types/spec.rs:444:43
    |
444 |       fn short_git_scheme_parser<'url>() -> impl Parser<
    |  ___________________________________________^
445 | |         &'url str,
446 | |         Output = <dyn Parser<
447 | |             &'url str,
...   |
451 | |         Error = nom::error::Error<&'url str>,
452 | |     > {
    | |_____^ expected associated type, found `Option<&str>`
...
458 | /         context(
459 | |             "short git scheme parse",
460 | |             opt(terminated(
461 | |                 tag::<&str, &str, nom::error::Error<&str>>("git"),
462 | |                 tag::<&str, &str, nom::error::Error<&str>>(":"),
463 | |             )),
464 | |         )
    | |_________- return type was inferred to be `Context<impl Parser<&str, Output = Option<...>, Error = ...>>` here
    |
    = note: expected associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = Option<&'url str>> + 'static) as Parser<&'url str>>::Output`
                          found enum `Option<&'url str>`
    = help: consider constraining the associated type `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = Option<&'url str>> + 'static) as Parser<&'url str>>::Output` to `Option<&'url str>` or calling a method that returns `<(dyn Parser<&'url str, Error = nom::error::Error<&'url str>, Output = Option<&'url str>> + 'static) as Parser<&'url str>>::Output`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
    = note: the full name for the type has been written to '/home/ada/projects/git-url-parse-rs/target/debug/deps/git_url_parse-15b0a6ff9f5232d5.long-type-14154493317055821403.txt'
    = note: consider using `--verbose` to print the full type name to the console

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:78:74
    |
 78 |             if let Ok((input, scheme)) = Self::short_git_scheme_parser().parse(input) {
    |                                                                          ^^^^^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0599]: the method `map` exists for associated type `<dyn Parser<&str, Error = ..., Output = ...> as Parser<...>>::Output`, but its trait bounds were not satisfied
  --> src/types/spec.rs:79:42
   |
79 |                 return Ok((input, scheme.map(|s| s.to_string())));
   |                                          ^^^ method cannot be called due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `<<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output as FnOnce<(_,)>>::Output = Result<(_, _), nom::Err<_>>`
           which is required by `<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Parser<_>`
           `<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: FnMut<(_,)>`
           which is required by `<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Parser<_>`
           `<&<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output as FnOnce<(_,)>>::Output = Result<(_, _), nom::Err<_>>`
           which is required by `&<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Parser<_>`
           `&<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: FnMut<(_,)>`
           which is required by `&<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Parser<_>`
           `<&mut <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output as FnOnce<(_,)>>::Output = Result<(_, _), nom::Err<_>>`
           which is required by `&mut <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Parser<_>`
           `&mut <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: FnMut<(_,)>`
           which is required by `&mut <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Parser<_>`
           `<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Iterator`
           which is required by `&mut <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = Option<&str>> + 'static) as Parser<&str>>::Output: Iterator`
   = note: the full name for the type has been written to '/home/ada/projects/git-url-parse-rs/target/debug/deps/git_url_parse-15b0a6ff9f5232d5.long-type-14690613962513128976.txt'
   = note: consider using `--verbose` to print the full type name to the console

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:143:13
    |
143 |             verify(
    |             ^^^^^^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0631]: type mismatch in closure arguments
   --> src/types/spec.rs:143:13
    |
143 | /             verify(
144 | |                 alt((
145 | |                     //preceded(tag("//"), Self::path_abempty_parser()),
146 | |                     Self::path_abempty_parser(),
...   |
150 | |                 |s: &str| !s.is_empty(),
    | |                 --------- found signature defined here
151 | |             ),
    | |_____________^ expected due to this
    |
    = note: expected closure signature `for<'a> fn(&'a <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = &str> + 'static) as Parser<&str>>::Output) -> _`
               found closure signature `fn(&str) -> _`
note: required by a bound in `verify`
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/combinator/mod.rs:501:6
    |
495 | pub fn verify<I: Clone, O2, E: ParseError<I>, F, G>(
    |        ------ required by a bound in this function
...
501 |   G: Fn(&O2) -> bool,
    |      ^^^^^^^^^^^^^^^ required by this bound in `verify`

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:143:13
    |
143 | /             verify(
144 | |                 alt((
145 | |                     //preceded(tag("//"), Self::path_abempty_parser()),
146 | |                     Self::path_abempty_parser(),
...   |
150 | |                 |s: &str| !s.is_empty(),
151 | |             ),
    | |_____________^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0631]: type mismatch in closure arguments
   --> src/types/spec.rs:141:29
    |
141 |         let (input, path) = context(
    |                             ^^^^^^^ expected due to this
...
150 |                 |s: &str| !s.is_empty(),
    |                 --------- found signature defined here
    |
    = note: expected closure signature `for<'a> fn(&'a <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = &str> + 'static) as Parser<&str>>::Output) -> _`
               found closure signature `fn(&str) -> _`
note: required by a bound in `verify`
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/combinator/mod.rs:501:6
    |
495 | pub fn verify<I: Clone, O2, E: ParseError<I>, F, G>(
    |        ------ required by a bound in this function
...
501 |   G: Fn(&O2) -> bool,
    |      ^^^^^^^^^^^^^^^ required by this bound in `verify`

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:141:29
    |
141 |         let (input, path) = context(
    |                             ^^^^^^^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0631]: type mismatch in closure arguments
   --> src/types/spec.rs:141:29
    |
141 |           let (input, path) = context(
    |  _____________________________^
142 | |             "Top of path parsers",
143 | |             verify(
144 | |                 alt((
...   |
150 | |                 |s: &str| !s.is_empty(),
    | |                 --------- found signature defined here
151 | |             ),
152 | |         )
    | |_________^ expected due to this
    |
    = note: expected closure signature `for<'a> fn(&'a <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = &str> + 'static) as Parser<&str>>::Output) -> _`
               found closure signature `fn(&str) -> _`
note: required by a bound in `verify`
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/combinator/mod.rs:501:6
    |
495 | pub fn verify<I: Clone, O2, E: ParseError<I>, F, G>(
    |        ------ required by a bound in this function
...
501 |   G: Fn(&O2) -> bool,
    |      ^^^^^^^^^^^^^^^ required by this bound in `verify`

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:141:29
    |
141 |           let (input, path) = context(
    |  _____________________________^
142 | |             "Top of path parsers",
143 | |             verify(
144 | |                 alt((
...   |
151 | |             ),
152 | |         )
    | |_________^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0631]: type mismatch in closure arguments
   --> src/types/spec.rs:141:29
    |
141 |           let (input, path) = context(
    |  _____________________________^
142 | |             "Top of path parsers",
143 | |             verify(
144 | |                 alt((
...   |
150 | |                 |s: &str| !s.is_empty(),
    | |                 --------- found signature defined here
...   |
153 | |         .parse(input)?;
    | |_____________________^ expected due to this
    |
    = note: expected closure signature `for<'a> fn(&'a <(dyn Parser<&str, Error = nom::error::Error<&str>, Output = &str> + 'static) as Parser<&str>>::Output) -> _`
               found closure signature `fn(&str) -> _`
note: required by a bound in `verify`
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/combinator/mod.rs:501:6
    |
495 | pub fn verify<I: Clone, O2, E: ParseError<I>, F, G>(
    |        ------ required by a bound in this function
...
501 |   G: Fn(&O2) -> bool,
    |      ^^^^^^^^^^^^^^^ required by this bound in `verify`

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:141:29
    |
141 |           let (input, path) = context(
    |  _____________________________^
142 | |             "Top of path parsers",
143 | |             verify(
144 | |                 alt((
...   |
153 | |         .parse(input)?;
    | |_____________________^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:141:29
    |
141 |           let (input, path) = context(
    |  _____________________________^
142 | |             "Top of path parsers",
143 | |             verify(
144 | |                 alt((
...   |
153 | |         .parse(input)?;
    | |______________________^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0599]: `<dyn Parser<&str, Error = ..., Output = ...> as Parser<...>>::Output` doesn't implement `std::fmt::Display`
   --> src/types/spec.rs:157:24
    |
157 |             path: path.to_string(),
    |                        ^^^^^^^^^ method cannot be called due to unsatisfied trait bounds
    |
    = note: the following trait bounds were not satisfied:
            `<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = &str> + 'static) as Parser<&str>>::Output: std::fmt::Display`
            which is required by `<(dyn Parser<&str, Error = nom::error::Error<&str>, Output = &str> + 'static) as Parser<&str>>::Output: ToString`
    = note: the full name for the type has been written to '/home/ada/projects/git-url-parse-rs/target/debug/deps/git_url_parse-15b0a6ff9f5232d5.long-type-9985031168499164621.txt'
    = note: consider using `--verbose` to print the full type name to the console

Some errors have detailed explanations: E0038, E0271, E0599, E0631.
For more information about an error, try `rustc --explain E0038`.
error: could not compile `git-url-parse` (lib) due to 17 previous errors

It seems that error message is correct as the Parser (that comes from nom) is not dyn-compatible.

[lcnr]

yeah, valid regression, these error messages are horrible though 😅

I think getting errors at every callsite is hard to avoid rn. I don't quite get why we get type mismatch errors here though. I would hope that failing to normalize would instead just result in stuff being tainted or sth, silencing/avoidng the type mismatch

do you have an idea what's going on there/are you able to minimize that?

[spirali]

I have implemented a new version. It suppresses downstream errors by returning a Progress with a tainted type. As I understand, the previous version had a problem that leads to find no candidates and eventually returns NoProgress from project() that triggers unrelated errors.

git-url-parse-rs now returns the following error messages that just straightforwardly indicates that Parser is not dyn compatible.

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:374:10
    |
374 |       ) -> impl Parser<
    |  __________^
375 | |         &'url str,
376 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
377 | |             &'url str,
378 | |         >>::Output,
379 | |         Error = nom::error::Error<&'url str>,
380 | |     >{
    | |_____^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:398:10
    |
398 |       ) -> impl Parser<
    |  __________^
399 | |         &'url str,
400 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
401 | |             &'url str,
402 | |         >>::Output,
403 | |         Error = nom::error::Error<&'url str>,
404 | |     >{
    | |_____^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:422:10
    |
422 |       ) -> impl Parser<
    |  __________^
423 | |         &'url str,
424 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
425 | |             &'url str,
426 | |         >>::Output,
427 | |         Error = nom::error::Error<&'url str>,
428 | |     >{
    | |_____^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:444:43
    |
444 |       fn short_git_scheme_parser<'url>() -> impl Parser<
    |  ___________________________________________^
445 | |         &'url str,
446 | |         Output = <dyn Parser<
447 | |             &'url str,
...   |
451 | |         Error = nom::error::Error<&'url str>,
452 | |     > {
    | |_____^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:78:74
    |
 78 |             if let Ok((input, scheme)) = Self::short_git_scheme_parser().parse(input) {
    |                                                                          ^^^^^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

error[E0038]: the trait `Parser` is not dyn compatible
   --> src/types/spec.rs:143:13
    |
143 | /             verify(
144 | |                 alt((
145 | |                     //preceded(tag("//"), Self::path_abempty_parser()),
146 | |                     Self::path_abempty_parser(),
...   |
150 | |                 |s: &str| !s.is_empty(),
151 | |             ),
    | |_____________^ `Parser` is not dyn compatible
    |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
   --> /home/ada/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs:425:6
    |
425 |   fn process<OM: OutputMode>(
    |      ^^^^^^^ the trait is not dyn compatible because method `process` has generic type parameters

For more information about this error, try `rustc --explain E0038`.
error: could not compile `git-url-parse` (lib) due to 6 previous errors

[lcnr]

is there something preventing us from putting this into assemble_candidates_from_object_ty?

View changes since the review

[spirali]

AFAIK there is no easy way to produce an error term from assemble_candidates_from_object_ty. I wanted to avoid adding a new variant into ProjectionCandidateSet and then patching surrounding code.

But if you prefer it, I can add a new variant to ProjectionCandidateSet.

[lcnr]

hmm, could you manually call mark_error with https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/traits/enum.SelectionError.html#variant.TraitDynIncompatible instead of eagerly reporting an error there?

I think that should do what we want 🤔

[spirali]

Calling mark_error (without eager reporting) will produce the following worse error message on git-url-parse-rs:

error[E0283]: type annotations needed
   --> src/types/spec.rs:374:10
    |
374 |       ) -> impl Parser<
    |  __________^
375 | |         &'url str,
376 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
377 | |             &'url str,
378 | |         >>::Output,
379 | |         Error = nom::error::Error<&'url str>,
380 | |     >{
    | |_____^ cannot infer type
...
387 | /         context(
388 | |             "Path parser (abempty)",
389 | |             recognize(many1(pair(
390 | |                 tag("/"),
391 | |                 take_while(|c: char| pchar_uri_chars(c)),
392 | |             ))),
393 | |         )
    | |_________- return type was inferred to be `nom::error::Context<impl Parser<_, Output = _, Error = _>>` here
    |
    = note: multiple `impl`s satisfying `_: nom::error::ParseError<&'url str>` found in the `nom` crate:
            - impl<I> nom::error::ParseError<I> for ();
            - impl<I> nom::error::ParseError<I> for (I, nom::error::ErrorKind);
            - impl<I> nom::error::ParseError<I> for nom::error::Error<I>;

error[E0283]: type annotations needed
   --> src/types/spec.rs:398:10
    |
398 |       ) -> impl Parser<
    |  __________^
399 | |         &'url str,
400 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
401 | |             &'url str,
402 | |         >>::Output,
403 | |         Error = nom::error::Error<&'url str>,
404 | |     >{
    | |_____^ cannot infer type
...
410 | /         context(
411 | |             "Path parser (ssh)",
412 | |             recognize((
413 | |                 tag(":"),
...   |
416 | |             )),
417 | |         )
    | |_________- return type was inferred to be `nom::error::Context<impl Parser<_, Output = _, Error = _>>` here
    |
    = note: multiple `impl`s satisfying `_: nom::error::ParseError<&'url str>` found in the `nom` crate:
            - impl<I> nom::error::ParseError<I> for ();
            - impl<I> nom::error::ParseError<I> for (I, nom::error::ErrorKind);
            - impl<I> nom::error::ParseError<I> for nom::error::Error<I>;

error[E0283]: type annotations needed
   --> src/types/spec.rs:422:10
    |
422 |       ) -> impl Parser<
    |  __________^
423 | |         &'url str,
424 | |         Output = <dyn Parser<&'url str, Output = &'url str, Error = nom::error::Error<&'url str>> as Parser<
425 | |             &'url str,
426 | |         >>::Output,
427 | |         Error = nom::error::Error<&'url str>,
428 | |     >{
    | |_____^ cannot infer type
...
434 | /         context(
435 | |             "Path parser (rootless)",
436 | |             recognize(pair(
437 | |                 take_while(|c: char| pchar_uri_chars(c)),
438 | |                 many0(pair(tag("/"), take_while(|c: char| pchar_uri_chars(c)))),
439 | |             )),
440 | |         )
    | |_________- return type was inferred to be `nom::error::Context<impl Parser<_, Output = _, Error = _>>` here
    |
    = note: multiple `impl`s satisfying `_: nom::error::ParseError<&'url str>` found in the `nom` crate:
            - impl<I> nom::error::ParseError<I> for ();
            - impl<I> nom::error::ParseError<I> for (I, nom::error::ErrorKind);
            - impl<I> nom::error::ParseError<I> for nom::error::Error<I>;

error[E0283]: type annotations needed
   --> src/types/spec.rs:444:43
    |
444 |       fn short_git_scheme_parser<'url>() -> impl Parser<
    |  ___________________________________________^
445 | |         &'url str,
446 | |         Output = <dyn Parser<
447 | |             &'url str,
...   |
451 | |         Error = nom::error::Error<&'url str>,
452 | |     > {
    | |_____^ cannot infer type
...
458 | /         context(
459 | |             "short git scheme parse",
460 | |             opt(terminated(
461 | |                 tag::<&str, &str, nom::error::Error<&str>>("git"),
462 | |                 tag::<&str, &str, nom::error::Error<&str>>(":"),
463 | |             )),
464 | |         )
    | |_________- return type was inferred to be `Context<impl Parser<&str, Output = Option<...>, Error = ...>>` here
    |
    = note: multiple `impl`s satisfying `_: nom::error::ParseError<&'url str>` found in the `nom` crate:
            - impl<I> nom::error::ParseError<I> for ();
            - impl<I> nom::error::ParseError<I> for (I, nom::error::ErrorKind);
            - impl<I> nom::error::ParseError<I> for nom::error::Error<I>;
    = note: the full name for the type has been written to '/home/ada/projects/git-url-parse-rs/target/markerror-test/debug/deps/git_url_parse-361fe5f41c7460ea.long-type-1968890314864789529.txt'
    = note: consider using `--verbose` to print the full type name to the console

error[E0282]: type annotations needed
  --> src/types/spec.rs:79:35
   |
79 |                 return Ok((input, scheme.map(|s| s.to_string())));
   |                                   ^^^^^^ cannot infer type

error[E0282]: type annotations needed for `(&str, _)`
   --> src/types/spec.rs:141:13
    |
141 |         let (input, path) = context(
    |             ^^^^^^^^^^^^^
...
157 |             path: path.to_string(),
    |                   ---- type must be known at this point
    |
help: consider giving this pattern a type, where the placeholders `_` are specified
    |
141 |         let (input, path): (&_, Output) = context(
    |                          ++++++++++++++

[lcnr]

Very cool 😊 would you be open to write an types FCP proposal for this change? I'd gladly help out so reach out if you're unsure about what exactly to write/how to explain parts of it

[rustbot]

Some changes occurred in src/tools/cargo

cc @weihanglo

[rustbot]

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

[rustbot]

⚠️ Warning ⚠️

• Some commits in this PR modify submodules.

  If this was not intentional, see I changed a submodule on accident in the rustc dev guide.

[spirali]

FCP

Summary

Projecting an associated type through dyn Trait self type where Trait is
not dyn compatible is now an error.

The old solver did not check dyn compatibility when normalizing such a
projection, so <dyn Trait as Trait>::Assoc was normalized via the object
candidate even for traits that can never have a trait object.

This is an instance of #100041: normalizing a
projection does not require its self type to be well-formed. dyn Trait is
only WF if Trait is dyn compatible, so nothing else on the path to
normalization catches the ill-formed self type.

The new solver always checks dyn compatibility when using an object candidate,
so making this an error now preempts a future breakage when switching to the
next solver.

Example

trait Trait {
    type Output;
    fn process<T>(&mut self, input: T) -> T; // not dyn compatible
}

struct MyImpl;

impl Trait for MyImpl {
    type Output = &'static str;
    fn process<T>(&mut self, input: T) -> T { input }
}

fn make() -> impl Trait<Output = <dyn Trait<Output = &'static str> as Trait>::Output> {
    MyImpl
}

fn main() {}

Before this PR this compiles. After it:

error[E0038]: the trait `Trait` is not dyn compatible
  --> src/main.rs:15:14
   |
LL | fn make() -> impl Trait<Output = <dyn Trait<Output = &'static str> as Trait>::Output> {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Trait` is not dyn compatible
   |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
  --> src/main.rs:5:8
   |
LL | trait Trait {
   |       ----- this trait is not dyn compatible...
LL |     type Output;
LL |     fn process<T>(&mut self, input: T) -> T;
   |        ^^^^^^^ ...because method `process` has generic type parameters
   = help: consider moving `process` to another trait

Crater report

Crater found a single affected crate, git-url-parse-rs
(report: https://crater-reports.s3.amazonaws.com/pr-154992-3/index.html),
where the usage is invalid. A PR with fix already exists: tjtelan/git-url-parse-rs#84.

[lcnr]

@rfcbot fcp merge types

[rust-rfcbot]

@lcnr has proposed to merge this. The next step is review by the rest of the tagged team members:

• @BoxyUwU
• @jackh726
• @lcnr
• @oli-obk
• @spastorino

No concerns currently listed.

Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!

See this document for info about what commands tagged team members can give me.