mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
128,602 Commits 2 Branches 0 Tags
Commit Graph

818 Commits

Author SHA1 Message Date
Bastian Kauschke
45d92b43e3 merge need_type_info_err(_const) 2020-09-23 09:24:58 +02:00
Andreas Jonson
6586c37bec Move MiniSet to data_structures 
remove the need for T to be copy from MiniSet as was done for MiniMap
 2020-09-23 08:09:16 +02:00
bors
f6d59207ad Auto merge of #76850 - ecstatic-morse:const-checking-refactor, r=oli-obk 
Remove `qualify_min_const_fn`

~~Blocked on #76807 (the first six commits).~~

With this PR, all checks in `qualify_min_const_fn` are replicated in `check_consts`, and the former is no longer invoked. My goal was to have as few changes to test output as possible, since making sweeping changes to the code *while* doing big batches of diagnostics updates turned out to be a headache. To this end, there's a few `HACK`s in `check_consts` to achieve parity with `qualify_min_const_fn`.

The new system that replaces `is_min_const_fn` is referred to as "const-stability"  My end goal for the const-stability rules is this:
* Const-stability is only applicable to functions defined in `staged_api` crates.
* All functions not marked `rustc_const_unstable` are considered "const-stable".
    - NB. This is currently not implemented. `#[unstable]` functions are also const-unstable. This causes problems when searching for feature gates.
    - All "const-unstable" functions have an associated feature gate
* const-stable functions can only call other const-stable functions
     - `allow_internal_unstable` can be used to circumvent this.
* All const-stable functions are subject to some additional checks (the ones that were unique to `qualify_min_const_fn`)

The plan is to remove each `HACK` individually in subsequent PRs. That way, changes to error message output can be reviewed in isolation.
 2020-09-23 05:40:35 +00:00
Jacob Hughes
3f1b4b39e3 Fix compilation & test failures 2020-09-22 22:54:52 -04:00
Avi Dessauer
2793da3f39 Update src/librustc_passes/stability.rs 
Co-authored-by: varkor <github@varkor.com>
 2020-09-22 21:55:38 -04:00
Avi Dessauer
25dba40cbe Update src/librustc_middle/middle/stability.rs 
Co-authored-by: varkor <github@varkor.com>
 2020-09-22 21:55:35 -04:00
Avi Dessauer
9eb595705e Update src/librustc_typeck/astconv.rs 
Co-authored-by: varkor <github@varkor.com>
 2020-09-22 21:55:32 -04:00
Avi Dessauer
41eec9065a Update src/librustc_passes/stability.rs 
Co-authored-by: varkor <github@varkor.com>
 2020-09-22 21:55:29 -04:00
Avi Dessauer
19e90843a4 Add documentation 2020-09-22 21:55:23 -04:00
Avi Dessauer
3947591ee8 Remove now unneeded check_stability argument 2020-09-22 21:54:16 -04:00
Avi Dessauer
a7a2086053 Stability annotations on generic trait parameters 2020-09-22 21:53:48 -04:00
LingMan
d76b80768c
Merge two almost identical match arms 2020-09-23 01:09:24 +02:00
bors
6d3acf5129 Auto merge of #76928 - lcnr:opaque-types-cache, r=tmandry 
cache types during normalization

partially fixes #75992

reduces the following test from 14 to 3 seconds locally.

cc `@Mark-Simulacrum` would it make sense to add that test to `perf`?
```rust
#![recursion_limit="2048"]
#![type_length_limit="112457564"]

pub async fn h0(v: &String, x: &u64) { println!("{} {}", v, x) }
pub async fn h1(v: &String, x: &u64) { h0(v, x).await }
pub async fn h2(v: &String, x: &u64) { h1(v, x).await }
pub async fn h3(v: &String, x: &u64) { h2(v, x).await }
pub async fn h4(v: &String, x: &u64) { h3(v, x).await }
pub async fn h5(v: &String, x: &u64) { h4(v, x).await }
pub async fn h6(v: &String, x: &u64) { h5(v, x).await }
pub async fn h7(v: &String, x: &u64) { h6(v, x).await }
pub async fn h8(v: &String, x: &u64) { h7(v, x).await }
pub async fn h9(v: &String, x: &u64) { h8(v, x).await }

pub async fn h10(v: &String, x: &u64) { h9(v, x).await }
pub async fn h11(v: &String, x: &u64) { h10(v, x).await }
pub async fn h12(v: &String, x: &u64) { h11(v, x).await }
pub async fn h13(v: &String, x: &u64) { h12(v, x).await }
pub async fn h14(v: &String, x: &u64) { h13(v, x).await }
pub async fn h15(v: &String, x: &u64) { h14(v, x).await }
pub async fn h16(v: &String, x: &u64) { h15(v, x).await }
pub async fn h17(v: &String, x: &u64) { h16(v, x).await }
pub async fn h18(v: &String, x: &u64) { h17(v, x).await }
pub async fn h19(v: &String, x: &u64) { h18(v, x).await }

macro_rules! async_recursive {
    (29, $inner:expr) => { async { async_recursive!(28, $inner) }.await };
    (28, $inner:expr) => { async { async_recursive!(27, $inner) }.await };
    (27, $inner:expr) => { async { async_recursive!(26, $inner) }.await };
    (26, $inner:expr) => { async { async_recursive!(25, $inner) }.await };
    (25, $inner:expr) => { async { async_recursive!(24, $inner) }.await };
    (24, $inner:expr) => { async { async_recursive!(23, $inner) }.await };
    (23, $inner:expr) => { async { async_recursive!(22, $inner) }.await };
    (22, $inner:expr) => { async { async_recursive!(21, $inner) }.await };
    (21, $inner:expr) => { async { async_recursive!(20, $inner) }.await };
    (20, $inner:expr) => { async { async_recursive!(19, $inner) }.await };

    (19, $inner:expr) => { async { async_recursive!(18, $inner) }.await };
    (18, $inner:expr) => { async { async_recursive!(17, $inner) }.await };
    (17, $inner:expr) => { async { async_recursive!(16, $inner) }.await };
    (16, $inner:expr) => { async { async_recursive!(15, $inner) }.await };
    (15, $inner:expr) => { async { async_recursive!(14, $inner) }.await };
    (14, $inner:expr) => { async { async_recursive!(13, $inner) }.await };
    (13, $inner:expr) => { async { async_recursive!(12, $inner) }.await };
    (12, $inner:expr) => { async { async_recursive!(11, $inner) }.await };
    (11, $inner:expr) => { async { async_recursive!(10, $inner) }.await };
    (10, $inner:expr) => { async { async_recursive!(9, $inner) }.await };

    (9, $inner:expr) => { async { async_recursive!(8, $inner) }.await };
    (8, $inner:expr) => { async { async_recursive!(7, $inner) }.await };
    (7, $inner:expr) => { async { async_recursive!(6, $inner) }.await };
    (6, $inner:expr) => { async { async_recursive!(5, $inner) }.await };
    (5, $inner:expr) => { async { async_recursive!(4, $inner) }.await };
    (4, $inner:expr) => { async { async_recursive!(3, $inner) }.await };
    (3, $inner:expr) => { async { async_recursive!(2, $inner) }.await };
    (2, $inner:expr) => { async { async_recursive!(1, $inner) }.await };
    (1, $inner:expr) => { async { async_recursive!(0, $inner) }.await };
    (0, $inner:expr) => { async { h19(&String::from("owo"), &0).await; $inner }.await };
}

async fn f() {
    async_recursive!(14, println!("hello"));
}

fn main() {
    let _ = f();
}
```
r? `@eddyb` requires a perf run.
 2020-09-22 22:52:07 +00:00
LingMan
c07890543d
Don't use an if guard to check equality with a constant 
Match on it directly instead
 2020-09-23 00:29:56 +02:00
Simon Vandel Sillesen
b6f51d6d6a cleanup cfg after optimization 2020-09-22 23:09:07 +02:00
Simon Vandel Sillesen
f472303a93 The optimization should also apply for DropAndReplace 2020-09-22 23:09:07 +02:00
Simon Vandel Sillesen
d3338dcf4d Get LocalDefId from source instead of passing in 2020-09-22 23:09:07 +02:00
Simon Vandel Sillesen
b4bdaa14f2 Suggestion from review 
Co-authored-by: Andreas Jonson <andjo403@users.noreply.github.com>
 2020-09-22 23:09:07 +02:00
Simon Vandel Sillesen
290dca1781 MIR pass to remove unneeded drops on types not needing drop 
This is heavily dependent on MIR inlining running to actually see the drop statement
 2020-09-22 23:09:07 +02:00
Bastian Kauschke
438d229b25 dead_code: look at trait impls even if they don't contain items 2020-09-22 22:13:58 +02:00
Jonas Schievink
4b6a4821b7 Fix dest prop miscompilation around references 2020-09-22 20:19:00 +02:00
Dylan MacKenzie
186d148b4c Use correct feature gate for unsizing casts 2020-09-22 10:22:50 -07:00
Dylan MacKenzie
6044836284 Add #![feature(const_fn_transmute)] to rustc_ast 2020-09-22 10:22:21 -07:00
Dylan MacKenzie
08e3822d9a Replace missing comment 2020-09-22 10:05:58 -07:00
Dylan MacKenzie
d60e204e0a Use the same name everywhere for is_const_stable_const_fn 2020-09-22 10:05:58 -07:00
Dylan MacKenzie
3569bb6323 Update const-checker to replicate qualify_min_const_fn 2020-09-22 10:05:58 -07:00
Dylan MacKenzie
5ee5429e00 Add structured errors for qualify_min_const_fn checks 2020-09-22 10:05:58 -07:00
Dylan MacKenzie
bfc10a89c3 Allow errors to abort const checking when emitted 
This is a hack for parity with `qualify_min_const_fn`, which only
emitted a single error.
 2020-09-22 10:05:58 -07:00
Dylan MacKenzie
7fb9587a3c Return true if check_const emits an error 2020-09-22 10:05:58 -07:00
Dylan MacKenzie
a173c5c1b3 Add const-stability helpers 2020-09-22 10:05:58 -07:00
Dylan MacKenzie
3dd28c78c3 Useful derives on ops::Status 2020-09-22 10:05:58 -07:00
bors
c113030f6b Auto merge of #76906 - Nicholas-Baron:shorten_typeck_check, r=oli-obk 
Split rustc_typeck::check into separate files

Contributing to #60302.
 2020-09-22 08:11:07 +00:00
Ralf Jung
731113b8ee Miri: more informative deallocation error messages 2020-09-22 09:05:12 +02:00
Ishi Tatsuyuki
01a771a7d8 Add debug assertions against slow path reference results 2020-09-22 14:40:44 +09:00
ecstatic-morse
0863f9a965
Rollup merge of #77032 - lcnr:visit-all-the-item-likes, r=davidtwco 
lint missing docs for extern items

fixes #76991
 2020-09-21 20:41:01 -07:00
ecstatic-morse
359615b852
Rollup merge of #77022 - Juici:master, r=lcnr 
Reduce boilerplate for BytePos and CharPos

Reduces boilerplate code for BytePos and CharPos by using a macro to implement shared traits.
 2020-09-21 20:40:59 -07:00
ecstatic-morse
50d4aebc7a
Rollup merge of #76914 - lcnr:path-no-more, r=ecstatic-morse 
extend `Ty` and `TyCtxt` lints to self types

blocked on #76891

r? @ecstatic-morse cc @Aaron1011
 2020-09-21 20:40:57 -07:00
ecstatic-morse
dcf4d1f2be
Rollup merge of #76888 - matthiaskrgr:clippy_single_match_2, r=Dylan-DPC 
use if let instead of single match arm expressions

use if let instead of single match arm expressions to compact code and reduce nesting (clippy::single_match)
 2020-09-21 20:40:55 -07:00
ecstatic-morse
60b99015e9
Rollup merge of #76807 - ecstatic-morse:const-checking-staged-api, r=oli-obk 
Use const-checking to forbid use of unstable features in const-stable functions

First step towards #76618.

Currently this code isn't ever hit because `qualify_min_const_fn` runs first and catches pretty much everything. One exception is `const_precise_live_drops`, which does not use the newly added code since it runs as part of a separate pass.

Also contains some unrelated refactoring, which is split into separate commits.

r? @oli-obk
 2020-09-21 20:40:53 -07:00
ecstatic-morse
30f1bab7e6
Rollup merge of #76581 - lcnr:bound-too-generic, r=eddyb 
do not ICE on bound variables, return `TooGeneric` instead

fixes #73260, fixes #74634, fixes #76595

r? @nikomatsakis
 2020-09-21 20:40:47 -07:00
ecstatic-morse
ef6c3a7bca
Rollup merge of #76489 - GuillaumeGomez:add-explanation-e0756, r=jyn514 
Add explanation for E0756

r? @pickfire
 2020-09-21 20:40:46 -07:00
ecstatic-morse
dc42aa8cd4
Rollup merge of #76131 - Aaron1011:fix/pretty-print-zip, r=lcnr 
Don't use `zip` to compare iterators during pretty-print hack

If the right-hand iterator has exactly one more element than the
left-hand iterator, then both iterators will be fully consumed, but
the extra element will never be compared.

Split out from https://github.com/rust-lang/rust/pull/76130
 2020-09-21 20:40:39 -07:00
bors
45198456be Auto merge of #76913 - vandenheuvel:performance_debug, r=lcnr 
Fixing the performance regression of #76244

Issue https://github.com/rust-lang/rust/issues/74865 suggested that removing the `def_id` field from `ParamEnv` would improve performance. PR https://github.com/rust-lang/rust/pull/76244 implemented this change.

Generally, [results](https://perf.rust-lang.org/compare.html?start=80fc9b0ecb29050d45b17c64af004200afd3cfc2&end=5ef250dd2ad618ee339f165e9b711a1b4746887d) were as expected: an instruction count decrease of about a percent. The instruction count for the unicode crates increased by about 3%, which `@nnethercote` speculated to be caused by a quirk of inlining or codegen. As the results were generally positive, and for chalk integration, this was also a step in the right direction, the PR was r+'d regardless.

However, [wall-time performance results](https://perf.rust-lang.org/compare.html?start=a055c5a1bd95e029e9b31891db63b6dc8258b472&end=7402a394471a6738a40fea7d4f1891666e5a80c5&stat=task-clock) show a much larger performance degradation: 25%, as [mentioned](https://github.com/rust-lang/rust/pull/76244#issuecomment-694459840) by `@Mark-Simulacrum.`

This PR, for now, reverts #76244 and attempts to find out, which change caused the regression.
 2020-09-22 00:22:24 +00:00
Bastian Kauschke
d452744100 lint missing docs for extern items 2020-09-22 00:02:46 +02:00
Bastian Kauschke
2f893e458a review 2020-09-21 23:25:52 +02:00
Simon Vandel Sillesen
2bb3844820 Add optimization to avoid load of address 2020-09-21 22:08:27 +02:00
Aaron Hill
f5d71a9b3c
Don't use zip to compare iterators during pretty-print hack 
If the right-hand iterator has exactly one more element than the
left-hand iterator, then both iterators will be fully consumed, but
the extra element will never be compared.
 2020-09-21 15:11:59 -04:00
Aaron Hill
e734733a9e
Record tcx.def_span instead of item.span in crate metadata 
This was missed in PR #75465. As a result, a few places have been using
the full body span of functions, instead of just the header span.
 2020-09-21 15:10:16 -04:00
Guillaume Gomez
63195ecb45 Add explanation for E0756 2020-09-21 21:04:56 +02:00
Mara Bos
9e3f94dabc Don't unwrap but report a fatal error for TargetDataLayout::parse. 2020-09-21 20:43:44 +02:00