rust/src/librustc_error_codes/error_codes, branch 1.45.2

Rollup merge of #72880 - GuillaumeGomez:cleanup-e0637, r=Dylan-DPC

2020-06-02T04:07:20+00:00

Clean up E0637 explanation r? @Dylan-DPC

Clean up E0637 explanation

2020-06-01T11:07:29+00:00

Rollup merge of #72818 - GuillaumeGomez:cleanup-e0622, r=Dylan-DPC

2020-06-01T01:14:10+00:00

Clean up E0622 explanation r? @Dylan-DPC

Clean up E0622 explanation

2020-05-31T12:09:15+00:00

Rollup merge of #72540 - davidtwco:issue-67552-mono-collector-comparison, r=varkor

2020-05-30T11:45:10+00:00

mir: adjust conditional in recursion limit check Fixes #67552. This PR adjusts the condition used in the recursion limit check of the monomorphization collector, from `>` to `>=`. In #67552, the test case had infinite indirect recursion, repeating a handful of functions (from the perspective of the monomorphization collector): `rec` -> `identity` -> `Iterator::count` -> `Iterator::fold` -> `Iterator::next` -> `rec`. During this process, `resolve_associated_item` was invoked for `Iterator::fold` (during the construction of an `Instance`), and ICE'd due to substitutions needing inference. However, previous iterations of this recursion would have called this function for `Iterator::fold` - and did! - and succeeded in doing so (trivially checkable from debug logging, `()` is present where `_` is in the substs of the failing execution). The expected outcome of this test case would be a recursion limit error (which is present when the `identity` fn indirection is removed), and the recursion depth of `rec` is increasing (other functions finish collecting their neighbours and thus have their recursion depths reset). When the ICE occurs, the recursion depth of `rec` is 256 (which matches the recursion limit), which suggests perhaps that a different part of the compiler is using a `>=` comparison and returning a different result on this recursion rather than what it returned in every previous recursion, thus stopping the monomorphization collector from reporting an error on the next recursion, where `recursion_depth_of_rec > 256` would have been true. With grep and some educated guesses, we can determine that the recursion limit check at line 818 in `src/librustc_trait_selection/traits/project.rs` is the other check that is using a different comparison. Modifying either comparison to be `>` or `>=` respectively will fix the error, but changing the monomorphization collector produces the nicer error.

Rollup merge of #72731 - GuillaumeGomez:cleanup-e0619, r=Dylan-DPC

2020-05-29T18:21:26+00:00

Add missing empty line in E0619 explanation r? @Dylan-DPC

Add missing empty line in E0619 explanation

2020-05-29T09:06:48+00:00

Rollup merge of #72495 - GuillaumeGomez:cleanup-e0601, r=Dylan-DPC

2020-05-29T06:07:02+00:00

Improve E0601 explanation r? @Dylan-DPC

Rollup merge of #72605 - GuillaumeGomez:cleanup-e0617, r=Dylan-DPC

2020-05-29T00:33:14+00:00

Add working example for E0617 explanation r? @Dylan-DPC

standardize limit comparisons with `Limit` type

2020-05-28T09:33:07+00:00

This commit introduces a `Limit` type which is used to ensure that all comparisons against limits within the compiler are consistent (which can result in ICEs if they aren't). Signed-off-by: David Wood