rust/tests/ui/reachable/expr_unary.stderr

error[E0614]: type `!` cannot be dereferenced
  --> $DIR/expr_unary.rs:8:16
   |
LL |     let x: ! = * { return; };
   |                ^^^^^^^^^^^^^

error: unreachable expression
  --> $DIR/expr_unary.rs:8:16
   |
LL |     let x: ! = * { return; };
   |                ^^^^------^^^
   |                |   |
   |                |   any code following this expression is unreachable
   |                unreachable expression
   |
note: the lint level is defined here
  --> $DIR/expr_unary.rs:5:9
   |
LL | #![deny(unreachable_code)]
   |         ^^^^^^^^^^^^^^^^

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0614`.
Replace ! with * in ui test of unary expr reachability 2021-11-21 19:30:17 -08:00			error[E0614]: type `!` cannot be dereferenced
Revert "Remove `#![feature(never_type)]` from tests." This reverts commit 8f6197f39f7d468dfc5b2bd41dae4769992a2f83. 2019-12-11 09:51:28 -05:00			`--> $DIR/expr_unary.rs:8:16`
Make coerce_never lint an error Remove the coerce_never lint and make the behaviour an error. 2018-02-01 15:23:04 +08:00			`\|`
Replace ! with * in ui test of unary expr reachability 2021-11-21 19:30:17 -08:00			`LL \| let x: ! = * { return; };`
			`\| ^^^^^^^^^^^^^`
Make coerce_never lint an error Remove the coerce_never lint and make the behaviour an error. 2018-02-01 15:23:04 +08:00
rustc: Rearchitect lints to be emitted more eagerly In preparation for incremental compilation this commit refactors the lint handling infrastructure in the compiler to be more "eager" and overall more incremental-friendly. Many passes of the compiler can emit lints at various points but before this commit all lints were buffered in a table to be emitted at the very end of compilation. This commit changes these lints to be emitted immediately during compilation using pre-calculated lint level-related data structures. Linting today is split into two phases, one set of "early" lints run on the `syntax::ast` and a "late" set of lints run on the HIR. This commit moves the "early" lints to running as late as possible in compilation, just before HIR lowering. This notably means that we're catching resolve-related lints just before HIR lowering. The early linting remains a pass very similar to how it was before, maintaining context of the current lint level as it walks the tree. Post-HIR, however, linting is structured as a method on the `TyCtxt` which transitively executes a query to calculate lint levels. Each request to lint on a `TyCtxt` will query the entire crate's 'lint level data structure' and then go from there about whether the lint should be emitted or not. The query depends on the entire HIR crate but should be very quick to calculate (just a quick walk of the HIR) and the red-green system should notice that the lint level data structure rarely changes, and should hopefully preserve incrementality. Overall this resulted in a pretty big change to the test suite now that lints are emitted much earlier in compilation (on-demand vs only at the end). This in turn necessitated the addition of many `#![allow(warnings)]` directives throughout the compile-fail test suite and a number of updates to the UI test suite. 2017-07-26 21:51:09 -07:00			`error: unreachable expression`
Revert "Remove `#![feature(never_type)]` from tests." This reverts commit 8f6197f39f7d468dfc5b2bd41dae4769992a2f83. 2019-12-11 09:51:28 -05:00			`--> $DIR/expr_unary.rs:8:16`
rustc: Rearchitect lints to be emitted more eagerly In preparation for incremental compilation this commit refactors the lint handling infrastructure in the compiler to be more "eager" and overall more incremental-friendly. Many passes of the compiler can emit lints at various points but before this commit all lints were buffered in a table to be emitted at the very end of compilation. This commit changes these lints to be emitted immediately during compilation using pre-calculated lint level-related data structures. Linting today is split into two phases, one set of "early" lints run on the `syntax::ast` and a "late" set of lints run on the HIR. This commit moves the "early" lints to running as late as possible in compilation, just before HIR lowering. This notably means that we're catching resolve-related lints just before HIR lowering. The early linting remains a pass very similar to how it was before, maintaining context of the current lint level as it walks the tree. Post-HIR, however, linting is structured as a method on the `TyCtxt` which transitively executes a query to calculate lint levels. Each request to lint on a `TyCtxt` will query the entire crate's 'lint level data structure' and then go from there about whether the lint should be emitted or not. The query depends on the entire HIR crate but should be very quick to calculate (just a quick walk of the HIR) and the red-green system should notice that the lint level data structure rarely changes, and should hopefully preserve incrementality. Overall this resulted in a pretty big change to the test suite now that lints are emitted much earlier in compilation (on-demand vs only at the end). This in turn necessitated the addition of many `#![allow(warnings)]` directives throughout the compile-fail test suite and a number of updates to the UI test suite. 2017-07-26 21:51:09 -07:00			`\|`
Replace ! with * in ui test of unary expr reachability 2021-11-21 19:30:17 -08:00			`LL \| let x: ! = * { return; };`
Do not trigger unreachable lint in async body and Use span labels 2019-09-21 12:33:02 -07:00			`\| ^^^^------^^^`
			`\| \| \|`
			`\| \| any code following this expression is unreachable`
			`\| unreachable expression`
rustc: Rearchitect lints to be emitted more eagerly In preparation for incremental compilation this commit refactors the lint handling infrastructure in the compiler to be more "eager" and overall more incremental-friendly. Many passes of the compiler can emit lints at various points but before this commit all lints were buffered in a table to be emitted at the very end of compilation. This commit changes these lints to be emitted immediately during compilation using pre-calculated lint level-related data structures. Linting today is split into two phases, one set of "early" lints run on the `syntax::ast` and a "late" set of lints run on the HIR. This commit moves the "early" lints to running as late as possible in compilation, just before HIR lowering. This notably means that we're catching resolve-related lints just before HIR lowering. The early linting remains a pass very similar to how it was before, maintaining context of the current lint level as it walks the tree. Post-HIR, however, linting is structured as a method on the `TyCtxt` which transitively executes a query to calculate lint levels. Each request to lint on a `TyCtxt` will query the entire crate's 'lint level data structure' and then go from there about whether the lint should be emitted or not. The query depends on the entire HIR crate but should be very quick to calculate (just a quick walk of the HIR) and the red-green system should notice that the lint level data structure rarely changes, and should hopefully preserve incrementality. Overall this resulted in a pretty big change to the test suite now that lints are emitted much earlier in compilation (on-demand vs only at the end). This in turn necessitated the addition of many `#![allow(warnings)]` directives throughout the compile-fail test suite and a number of updates to the UI test suite. 2017-07-26 21:51:09 -07:00			`\|`
Normalise notes with the/is 2020-01-22 23:57:38 +00:00			`note: the lint level is defined here`
Revert "Remove `#![feature(never_type)]` from tests." This reverts commit 8f6197f39f7d468dfc5b2bd41dae4769992a2f83. 2019-12-11 09:51:28 -05:00			`--> $DIR/expr_unary.rs:5:9`
rustc: Rearchitect lints to be emitted more eagerly In preparation for incremental compilation this commit refactors the lint handling infrastructure in the compiler to be more "eager" and overall more incremental-friendly. Many passes of the compiler can emit lints at various points but before this commit all lints were buffered in a table to be emitted at the very end of compilation. This commit changes these lints to be emitted immediately during compilation using pre-calculated lint level-related data structures. Linting today is split into two phases, one set of "early" lints run on the `syntax::ast` and a "late" set of lints run on the HIR. This commit moves the "early" lints to running as late as possible in compilation, just before HIR lowering. This notably means that we're catching resolve-related lints just before HIR lowering. The early linting remains a pass very similar to how it was before, maintaining context of the current lint level as it walks the tree. Post-HIR, however, linting is structured as a method on the `TyCtxt` which transitively executes a query to calculate lint levels. Each request to lint on a `TyCtxt` will query the entire crate's 'lint level data structure' and then go from there about whether the lint should be emitted or not. The query depends on the entire HIR crate but should be very quick to calculate (just a quick walk of the HIR) and the red-green system should notice that the lint level data structure rarely changes, and should hopefully preserve incrementality. Overall this resulted in a pretty big change to the test suite now that lints are emitted much earlier in compilation (on-demand vs only at the end). This in turn necessitated the addition of many `#![allow(warnings)]` directives throughout the compile-fail test suite and a number of updates to the UI test suite. 2017-07-26 21:51:09 -07:00			`\|`
Update UI tests 2018-02-23 03:42:32 +03:00			`LL \| #![deny(unreachable_code)]`
rustc: Rearchitect lints to be emitted more eagerly In preparation for incremental compilation this commit refactors the lint handling infrastructure in the compiler to be more "eager" and overall more incremental-friendly. Many passes of the compiler can emit lints at various points but before this commit all lints were buffered in a table to be emitted at the very end of compilation. This commit changes these lints to be emitted immediately during compilation using pre-calculated lint level-related data structures. Linting today is split into two phases, one set of "early" lints run on the `syntax::ast` and a "late" set of lints run on the HIR. This commit moves the "early" lints to running as late as possible in compilation, just before HIR lowering. This notably means that we're catching resolve-related lints just before HIR lowering. The early linting remains a pass very similar to how it was before, maintaining context of the current lint level as it walks the tree. Post-HIR, however, linting is structured as a method on the `TyCtxt` which transitively executes a query to calculate lint levels. Each request to lint on a `TyCtxt` will query the entire crate's 'lint level data structure' and then go from there about whether the lint should be emitted or not. The query depends on the entire HIR crate but should be very quick to calculate (just a quick walk of the HIR) and the red-green system should notice that the lint level data structure rarely changes, and should hopefully preserve incrementality. Overall this resulted in a pretty big change to the test suite now that lints are emitted much earlier in compilation (on-demand vs only at the end). This in turn necessitated the addition of many `#![allow(warnings)]` directives throughout the compile-fail test suite and a number of updates to the UI test suite. 2017-07-26 21:51:09 -07:00			`\| ^^^^^^^^^^^^^^^^`

Make coerce_never lint an error Remove the coerce_never lint and make the behaviour an error. 2018-02-01 15:23:04 +08:00			`error: aborting due to 2 previous errors`
cherry-pick over the tests I wrote for the reachability code For the most part, the current code performs similarly, although it differs in some particulars. I'll be nice to have these tests for judging future changes, as well. 2017-03-21 09:41:41 -04:00
Replace ! with * in ui test of unary expr reachability 2021-11-21 19:30:17 -08:00			For more information about this error, try `rustc --explain E0614`.