rust/tests/ui/inference/issue-72690.stderr

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:7:5
   |
LL |     String::from("x".as_ref());
   |     ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:7:22
   |
LL |     String::from("x".as_ref());
   |                      ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     String::from(<str as AsRef<T>>::as_ref("x"));
   |                  ++++++++++++++++++++++++++   ~

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:12:9
   |
LL |     |x| String::from("x".as_ref());
   |         ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:12:26
   |
LL |     |x| String::from("x".as_ref());
   |                          ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     |x| String::from(<str as AsRef<T>>::as_ref("x"));
   |                      ++++++++++++++++++++++++++   ~

error[E0283]: type annotations needed for `&_`
  --> $DIR/issue-72690.rs:17:9
   |
LL |     let _ = "x".as_ref();
   |         ^       ------ type must be known at this point
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: consider giving this pattern a type, where the type for type parameter `T` is specified
   |
LL |     let _: &T = "x".as_ref();
   |          ++++

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:21:5
   |
LL |     String::from("x".as_ref());
   |     ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:21:22
   |
LL |     String::from("x".as_ref());
   |                      ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     String::from(<str as AsRef<T>>::as_ref("x"));
   |                  ++++++++++++++++++++++++++   ~

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:28:5
   |
LL |     String::from("x".as_ref());
   |     ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:28:22
   |
LL |     String::from("x".as_ref());
   |                      ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     String::from(<str as AsRef<T>>::as_ref("x"));
   |                  ++++++++++++++++++++++++++   ~

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:37:5
   |
LL |     String::from("x".as_ref());
   |     ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:37:22
   |
LL |     String::from("x".as_ref());
   |                      ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     String::from(<str as AsRef<T>>::as_ref("x"));
   |                  ++++++++++++++++++++++++++   ~

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:46:5
   |
LL |     String::from("x".as_ref());
   |     ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:46:22
   |
LL |     String::from("x".as_ref());
   |                      ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     String::from(<str as AsRef<T>>::as_ref("x"));
   |                  ++++++++++++++++++++++++++   ~

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:53:5
   |
LL |     String::from("x".as_ref());
   |     ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:53:22
   |
LL |     String::from("x".as_ref());
   |                      ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     String::from(<str as AsRef<T>>::as_ref("x"));
   |                  ++++++++++++++++++++++++++   ~

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:62:5
   |
LL |     String::from("x".as_ref());
   |     ^^^^^^ cannot infer type for reference `&_`
   |
   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
           - impl From<&String> for String;
           - impl From<&str> for String;

error[E0283]: type annotations needed
  --> $DIR/issue-72690.rs:62:22
   |
LL |     String::from("x".as_ref());
   |                      ^^^^^^
   |
   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
           - impl AsRef<OsStr> for str;
           - impl AsRef<Path> for str;
           - impl AsRef<[u8]> for str;
           - impl AsRef<str> for str;
help: try using a fully qualified path to specify the expected types
   |
LL |     String::from(<str as AsRef<T>>::as_ref("x"));
   |                  ++++++++++++++++++++++++++   ~

error: aborting due to 17 previous errors

For more information about this error, try `rustc --explain E0283`.
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`error[E0283]: type annotations needed`
			`--> $DIR/issue-72690.rs:7:5`
			`\|`
			`LL \| String::from("x".as_ref());`
More accurately point at arguments 2023-08-26 19:25:46 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
Tweak output of `to_pretty_impl_header` involving only anon lifetimes Do not print `impl<> Foo for &Bar`. 2023-08-28 17:17:11 +00:00			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`error[E0283]: type annotations needed`
			`--> $DIR/issue-72690.rs:7:22`
			`\|`
			`LL \| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
Reorder fullfillment errors to keep more interesting ones first In `report_fullfillment_errors` push back `T: Sized`, `T: WellFormed` and coercion errors to the end of the list. The pre-existing deduplication logic eliminates redundant errors better that way, keeping the resulting output with fewer errors than before, while also having more detail. 2023-08-14 13:09:53 +00:00			`error[E0283]: type annotations needed`
			`--> $DIR/issue-72690.rs:12:9`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| \|x\| String::from("x".as_ref());`
Reorder fullfillment errors to keep more interesting ones first In `report_fullfillment_errors` push back `T: Sized`, `T: WellFormed` and coercion errors to the end of the list. The pre-existing deduplication logic eliminates redundant errors better that way, keeping the resulting output with fewer errors than before, while also having more detail. 2023-08-14 13:09:53 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\|`
Reorder fullfillment errors to keep more interesting ones first In `report_fullfillment_errors` push back `T: Sized`, `T: WellFormed` and coercion errors to the end of the list. The pre-existing deduplication logic eliminates redundant errors better that way, keeping the resulting output with fewer errors than before, while also having more detail. 2023-08-14 13:09:53 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`error[E0283]: type annotations needed`
			`--> $DIR/issue-72690.rs:12:26`
			`\|`
			`LL \| \|x\| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| \|x\| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
Use `fn` ptr signature instead of `{closure@..}` in infer error When suggesting a type on inference error, do not use `{closure@..}`. Instead, replace with an appropriate `fn` ptr. On the error message, use `short_ty_string` and write long types to disk. ``` error[E0284]: type annotations needed for `Select<{closure@lib.rs:2782:13}, _, Expression<'_>, _>` --> crates/lang/src/parser.rs:41:13 \| 41 \| let lit = select! { \| ^^^ 42 \| Token::Int(i) = e => Expression::new(Expr::Lit(ast::Lit::Int(i.parse().unwrap())), e.span()), \| ---- type must be known at this point \| = note: the full type name has been written to '/home/gh-estebank/iowo/target/debug/deps/lang-e2d6e25819442273.long-type-4587393693885174369.txt' = note: cannot satisfy `<_ as chumsky::input::Input<'_>>::Span == SimpleSpan` help: consider giving `lit` an explicit type, where the type for type parameter `I` is specified \| 41 \| let lit: Select<for<'a, 'b> fn(tokens::Token<'_>, &'a mut MapExtra<'_, 'b, _, _>) -> Option<Expression<'_>>, _, Expression<'_>, _> = select! { \| +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ``` instead of ``` error[E0284]: type annotations needed for `Select<{closure@/home/gh-estebank/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-1.0.0-alpha.6/src/lib.rs:2782:13: 2782:28}, _, Expression<'_>, _>` --> crates/lang/src/parser.rs:41:13 \| 41 \| let lit = select! { \| ^^^ 42 \| Token::Int(i) = e => Expression::new(Expr::Lit(ast::Lit::Int(i.parse().unwrap())), e.span()), \| ---- type must be known at this point \| = note: cannot satisfy `<_ as chumsky::input::Input<'_>>::Span == SimpleSpan` help: consider giving `lit` an explicit type, where the type for type parameter `I` is specified \| 41 \| let lit: Select<{closure@/home/gh-estebank/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-1.0.0-alpha.6/src/lib.rs:2782:13: 2782:28}, _, Expression<'_>, _> = select! { \| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ``` Fix #123630. 2024-04-10 00:11:52 +00:00			error[E0283]: type annotations needed for `&_`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`--> $DIR/issue-72690.rs:17:9`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| let _ = "x".as_ref();`
Show source of ambiguity in a few more places 2022-06-25 16:28:27 +00:00			`\| ^ ------ type must be known at this point`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			help: consider giving this pattern a type, where the type for type parameter `T` is specified
			`\|`
			`LL \| let _: &T = "x".as_ref();`
			`\| ++++`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:21:5`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
More accurately point at arguments 2023-08-26 19:25:46 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
Tweak output of `to_pretty_impl_header` involving only anon lifetimes Do not print `impl<> Foo for &Bar`. 2023-08-28 17:17:11 +00:00			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:21:22`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:28:5`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
More accurately point at arguments 2023-08-26 19:25:46 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
Tweak output of `to_pretty_impl_header` involving only anon lifetimes Do not print `impl<> Foo for &Bar`. 2023-08-28 17:17:11 +00:00			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:28:22`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:37:5`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
More accurately point at arguments 2023-08-26 19:25:46 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
Tweak output of `to_pretty_impl_header` involving only anon lifetimes Do not print `impl<> Foo for &Bar`. 2023-08-28 17:17:11 +00:00			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
don't assume trait ambiguity happens in `Self` 2020-10-19 16:42:57 +00:00			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:37:22`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:46:5`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
More accurately point at arguments 2023-08-26 19:25:46 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
Tweak output of `to_pretty_impl_header` involving only anon lifetimes Do not print `impl<> Foo for &Bar`. 2023-08-28 17:17:11 +00:00			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
don't assume trait ambiguity happens in `Self` 2020-10-19 16:42:57 +00:00			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:46:22`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:53:5`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
More accurately point at arguments 2023-08-26 19:25:46 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
Tweak output of `to_pretty_impl_header` involving only anon lifetimes Do not print `impl<> Foo for &Bar`. 2023-08-28 17:17:11 +00:00			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
don't assume trait ambiguity happens in `Self` 2020-10-19 16:42:57 +00:00			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:53:22`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:62:5`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
More accurately point at arguments 2023-08-26 19:25:46 +00:00			\| ^^^^^^ cannot infer type for reference `&_`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00			`\|`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			= note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
Tweak output of `to_pretty_impl_header` involving only anon lifetimes Do not print `impl<> Foo for &Bar`. 2023-08-28 17:17:11 +00:00			`- impl From<&String> for String;`
			`- impl From<&str> for String;`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`error[E0283]: type annotations needed`
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`--> $DIR/issue-72690.rs:62:22`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			`LL \| String::from("x".as_ref());`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`\| ^^^^^^`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00			`\|`
			= note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
			`- impl AsRef<OsStr> for str;`
			`- impl AsRef<Path> for str;`
			`- impl AsRef<[u8]> for str;`
			`- impl AsRef<str> for str;`
add new `emit_inference_failure_err` 2022-02-14 12:25:26 +00:00			`help: try using a fully qualified path to specify the expected types`
			`\|`
			`LL \| String::from(<str as AsRef<T>>::as_ref("x"));`
			`\| ++++++++++++++++++++++++++ ~`
Point at overlapping impls when type annotations are needed 2021-10-01 13:05:17 +00:00
skip pointing out ambuguous impls in alloc/std crates too 2022-01-29 23:34:06 +00:00			`error: aborting due to 17 previous errors`
Make `need_type_info_err` more conservative 2020-06-05 11:27:43 +00:00
Reorder fullfillment errors to keep more interesting ones first In `report_fullfillment_errors` push back `T: Sized`, `T: WellFormed` and coercion errors to the end of the list. The pre-existing deduplication logic eliminates redundant errors better that way, keeping the resulting output with fewer errors than before, while also having more detail. 2023-08-14 13:09:53 +00:00			For more information about this error, try `rustc --explain E0283`.