nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-01 06:51:58 +00:00
Code Issues Packages Projects Releases Wiki Activity
5bc7687351
rust/tests/ui/span/coerce-suggestions.stderr

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

76 lines
2.0 KiB
Plaintext
Raw Normal View History

improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
error[E0308]: mismatched types
Remove licenses
2018-12-25 15:56:47 +00:00
--> $DIR/coerce-suggestions.rs:7:20
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
|
Update UI tests
2018-02-23 00:42:32 +00:00
LL | let x: usize = String::new();
Modify primary span label for E0308 The previous output was unintuitive to users.
2023-01-03 02:00:33 +00:00
| ----- ^^^^^^^^^^^^^ expected `usize`, found `String`
Point at type in `let` assignment on type errors
2019-11-19 05:00:24 +00:00
| |
| expected due to this
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
error[E0308]: mismatched types
Remove licenses
2018-12-25 15:56:47 +00:00
--> $DIR/coerce-suggestions.rs:9:19
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
|
Update UI tests
2018-02-23 00:42:32 +00:00
LL | let x: &str = String::new();
Tweak borrow suggestion
2023-04-18 19:44:27 +00:00
| ---- ^^^^^^^^^^^^^ expected `&str`, found `String`
| |
Point at type in `let` assignment on type errors
2019-11-19 05:00:24 +00:00
| expected due to this
Tweak borrow suggestion
2023-04-18 19:44:27 +00:00
|
help: consider borrowing here
|
LL | let x: &str = &String::new();
| +
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
error[E0308]: mismatched types
Remove licenses
2018-12-25 15:56:47 +00:00
--> $DIR/coerce-suggestions.rs:12:10
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
|
Update UI tests
2018-02-23 00:42:32 +00:00
LL | test(&y);
Implementation for 65853 This attempts to bring better error messages to invalid method calls, by applying some heuristics to identify common mistakes. The algorithm is inspired by Levenshtein distance and longest common sub-sequence. In essence, we treat the types of the function, and the types of the arguments you provided as two "words" and compute the edits to get from one to the other. We then modify that algorithm to detect 4 cases: - A function input is missing - An extra argument was provided - The type of an argument is straight up invalid - Two arguments have been swapped - A subset of the arguments have been shuffled (We detect the last two as separate cases so that we can detect two swaps, instead of 4 parameters permuted.) It helps to understand this argument by paying special attention to terminology: "inputs" refers to the inputs being *expected* by the function, and "arguments" refers to what has been provided at the call site. The basic sketch of the algorithm is as follows: - Construct a boolean grid, with a row for each argument, and a column for each input. The cell [i, j] is true if the i'th argument could satisfy the j'th input. - If we find an argument that could satisfy no inputs, provided for an input that can't be satisfied by any other argument, we consider this an "invalid type". - Extra arguments are those that can't satisfy any input, provided for an input that *could* be satisfied by another argument. - Missing inputs are inputs that can't be satisfied by any argument, where the provided argument could satisfy another input - Swapped / Permuted arguments are identified with a cycle detection algorithm. As each issue is found, we remove the relevant inputs / arguments and check for more issues. If we find no issues, we match up any "valid" arguments, and start again. Note that there's a lot of extra complexity: - We try to stay efficient on the happy path, only computing the diagonal until we find a problem, and then filling in the rest of the matrix. - Closure arguments are wrapped in a tuple and need to be unwrapped - We need to resolve closure types after the rest, to allow the most specific type constraints - We need to handle imported C functions that might be variadic in their inputs. I tried to document a lot of this in comments in the code and keep the naming clear.
2022-01-22 04:50:54 +00:00
| ---- ^^ types differ in mutability
| |
| arguments to this function are incorrect
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
|
pretty: trim paths of unique symbols If a symbol name can only be imported from one place for a type, and as long as it was not glob-imported anywhere in the current crate, we can trim its printed path and print only the name. This has wide implications on error messages with types, for example, shortening `std::vec::Vec` to just `Vec`, as long as there is no other `Vec` importable anywhere. This adds a new '-Z trim-diagnostic-paths=false' option to control this feature. On the good path, with no diagnosis printed, we should try to avoid issuing this query, so we need to prevent trimmed_def_paths query on several cases. This change also relies on a previous commit that differentiates between `Debug` and `Display` on various rustc types, where the latter is trimmed and presented to the user and the former is not.
2020-09-02 07:40:56 +00:00
= note: expected mutable reference `&mut String`
found reference `&String`
Implementation for 65853 This attempts to bring better error messages to invalid method calls, by applying some heuristics to identify common mistakes. The algorithm is inspired by Levenshtein distance and longest common sub-sequence. In essence, we treat the types of the function, and the types of the arguments you provided as two "words" and compute the edits to get from one to the other. We then modify that algorithm to detect 4 cases: - A function input is missing - An extra argument was provided - The type of an argument is straight up invalid - Two arguments have been swapped - A subset of the arguments have been shuffled (We detect the last two as separate cases so that we can detect two swaps, instead of 4 parameters permuted.) It helps to understand this argument by paying special attention to terminology: "inputs" refers to the inputs being *expected* by the function, and "arguments" refers to what has been provided at the call site. The basic sketch of the algorithm is as follows: - Construct a boolean grid, with a row for each argument, and a column for each input. The cell [i, j] is true if the i'th argument could satisfy the j'th input. - If we find an argument that could satisfy no inputs, provided for an input that can't be satisfied by any other argument, we consider this an "invalid type". - Extra arguments are those that can't satisfy any input, provided for an input that *could* be satisfied by another argument. - Missing inputs are inputs that can't be satisfied by any argument, where the provided argument could satisfy another input - Swapped / Permuted arguments are identified with a cycle detection algorithm. As each issue is found, we remove the relevant inputs / arguments and check for more issues. If we find no issues, we match up any "valid" arguments, and start again. Note that there's a lot of extra complexity: - We try to stay efficient on the happy path, only computing the diagonal until we find a problem, and then filling in the rest of the matrix. - Closure arguments are wrapped in a tuple and need to be unwrapped - We need to resolve closure types after the rest, to allow the most specific type constraints - We need to handle imported C functions that might be variadic in their inputs. I tried to document a lot of this in comments in the code and keep the naming clear.
2022-01-22 04:50:54 +00:00
note: function defined here
--> $DIR/coerce-suggestions.rs:1:4
|
LL | fn test(_x: &mut String) {}
| ^^^^ ---------------
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
error[E0308]: mismatched types
Remove licenses
2018-12-25 15:56:47 +00:00
--> $DIR/coerce-suggestions.rs:14:11
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
|
Update UI tests
2018-02-23 00:42:32 +00:00
LL | test2(&y);
Implementation for 65853 This attempts to bring better error messages to invalid method calls, by applying some heuristics to identify common mistakes. The algorithm is inspired by Levenshtein distance and longest common sub-sequence. In essence, we treat the types of the function, and the types of the arguments you provided as two "words" and compute the edits to get from one to the other. We then modify that algorithm to detect 4 cases: - A function input is missing - An extra argument was provided - The type of an argument is straight up invalid - Two arguments have been swapped - A subset of the arguments have been shuffled (We detect the last two as separate cases so that we can detect two swaps, instead of 4 parameters permuted.) It helps to understand this argument by paying special attention to terminology: "inputs" refers to the inputs being *expected* by the function, and "arguments" refers to what has been provided at the call site. The basic sketch of the algorithm is as follows: - Construct a boolean grid, with a row for each argument, and a column for each input. The cell [i, j] is true if the i'th argument could satisfy the j'th input. - If we find an argument that could satisfy no inputs, provided for an input that can't be satisfied by any other argument, we consider this an "invalid type". - Extra arguments are those that can't satisfy any input, provided for an input that *could* be satisfied by another argument. - Missing inputs are inputs that can't be satisfied by any argument, where the provided argument could satisfy another input - Swapped / Permuted arguments are identified with a cycle detection algorithm. As each issue is found, we remove the relevant inputs / arguments and check for more issues. If we find no issues, we match up any "valid" arguments, and start again. Note that there's a lot of extra complexity: - We try to stay efficient on the happy path, only computing the diagonal until we find a problem, and then filling in the rest of the matrix. - Closure arguments are wrapped in a tuple and need to be unwrapped - We need to resolve closure types after the rest, to allow the most specific type constraints - We need to handle imported C functions that might be variadic in their inputs. I tried to document a lot of this in comments in the code and keep the naming clear.
2022-01-22 04:50:54 +00:00
| ----- ^^ types differ in mutability
| |
| arguments to this function are incorrect
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
|
Specific labels when referring to "expected" and "found" types
2019-11-13 22:16:56 +00:00
= note: expected mutable reference `&mut i32`
pretty: trim paths of unique symbols If a symbol name can only be imported from one place for a type, and as long as it was not glob-imported anywhere in the current crate, we can trim its printed path and print only the name. This has wide implications on error messages with types, for example, shortening `std::vec::Vec` to just `Vec`, as long as there is no other `Vec` importable anywhere. This adds a new '-Z trim-diagnostic-paths=false' option to control this feature. On the good path, with no diagnosis printed, we should try to avoid issuing this query, so we need to prevent trimmed_def_paths query on several cases. This change also relies on a previous commit that differentiates between `Debug` and `Display` on various rustc types, where the latter is trimmed and presented to the user and the former is not.
2020-09-02 07:40:56 +00:00
found reference `&String`
Implementation for 65853 This attempts to bring better error messages to invalid method calls, by applying some heuristics to identify common mistakes. The algorithm is inspired by Levenshtein distance and longest common sub-sequence. In essence, we treat the types of the function, and the types of the arguments you provided as two "words" and compute the edits to get from one to the other. We then modify that algorithm to detect 4 cases: - A function input is missing - An extra argument was provided - The type of an argument is straight up invalid - Two arguments have been swapped - A subset of the arguments have been shuffled (We detect the last two as separate cases so that we can detect two swaps, instead of 4 parameters permuted.) It helps to understand this argument by paying special attention to terminology: "inputs" refers to the inputs being *expected* by the function, and "arguments" refers to what has been provided at the call site. The basic sketch of the algorithm is as follows: - Construct a boolean grid, with a row for each argument, and a column for each input. The cell [i, j] is true if the i'th argument could satisfy the j'th input. - If we find an argument that could satisfy no inputs, provided for an input that can't be satisfied by any other argument, we consider this an "invalid type". - Extra arguments are those that can't satisfy any input, provided for an input that *could* be satisfied by another argument. - Missing inputs are inputs that can't be satisfied by any argument, where the provided argument could satisfy another input - Swapped / Permuted arguments are identified with a cycle detection algorithm. As each issue is found, we remove the relevant inputs / arguments and check for more issues. If we find no issues, we match up any "valid" arguments, and start again. Note that there's a lot of extra complexity: - We try to stay efficient on the happy path, only computing the diagonal until we find a problem, and then filling in the rest of the matrix. - Closure arguments are wrapped in a tuple and need to be unwrapped - We need to resolve closure types after the rest, to allow the most specific type constraints - We need to handle imported C functions that might be variadic in their inputs. I tried to document a lot of this in comments in the code and keep the naming clear.
2022-01-22 04:50:54 +00:00
note: function defined here
--> $DIR/coerce-suggestions.rs:3:4
|
LL | fn test2(_x: &mut i32) {}
| ^^^^^ ------------
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
error[E0308]: mismatched types
Remove licenses
2018-12-25 15:56:47 +00:00
--> $DIR/coerce-suggestions.rs:17:9
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
|
Remove box syntax from most places in src/test outside of the issues dir
2021-08-25 00:39:40 +00:00
LL | f = Box::new(f);
Deduplicate box deref and regular deref suggestions
2022-01-12 04:57:40 +00:00
| ^^^^^^^^^^^ cyclic type of infinite size
|
help: consider unboxing the value
|
LL | f = *Box::new(f);
| +
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
Use callsite's span for macro calls on suggestion When suggesting an appropriate mutability for a macro call, use the call span instead of the expanded macro's span.
2017-06-01 06:48:19 +00:00
error[E0308]: mismatched types
Remove licenses
2018-12-25 15:56:47 +00:00
--> $DIR/coerce-suggestions.rs:21:9
Use callsite's span for macro calls on suggestion When suggesting an appropriate mutability for a macro call, use the call span instead of the expanded macro's span.
2017-06-01 06:48:19 +00:00
|
Update UI tests
2018-02-23 00:42:32 +00:00
LL | s = format!("foo");
Modify primary span label for E0308 The previous output was unintuitive to users.
2023-01-03 02:00:33 +00:00
| ^^^^^^^^^^^^^^ expected `&mut String`, found `String`
Use callsite's span for macro calls on suggestion When suggesting an appropriate mutability for a macro call, use the call span instead of the expanded macro's span.
2017-06-01 06:48:19 +00:00
|
Show macro name in 'this error originates in macro' message When there are multiple macros in use, it can be difficult to tell which one was responsible for producing an error.
2021-02-13 19:52:25 +00:00
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
Use callsite's span for macro calls on suggestion When suggesting an appropriate mutability for a macro call, use the call span instead of the expanded macro's span.
2017-06-01 06:48:19 +00:00
Revert "Change error count messages" This reverts commit 5558c64f33446225739c1153b43d2e309bb4f50e.
2017-07-02 10:49:30 +00:00
error: aborting due to 6 previous errors
improve suggestions output and add ui test
2016-11-01 15:00:24 +00:00
update tests
2018-03-03 14:59:40 +00:00
For more information about this error, try `rustc --explain E0308`.
Reference in New Issue Copy Permalink