Auto merge of #62072 - eddyb:generator-memory-index, r=tmandry
rustc: correctly transform memory_index mappings for generators.
Fixes #61793, closes #62011 (previous attempt at fixing #61793).
During #60187, I made the mistake of suggesting that the (re-)computation of `memory_index` in `ty::layout`, after generator-specific logic split/recombined fields, be done off of the `offsets` of those fields (which needed to be computed anyway), as opposed to the `memory_index`.
`memory_index` maps each field to its in-memory order index, which ranges over the same `0..n` values as the fields themselves, making it a bijective mapping, and more specifically a permutation (indeed, it's the permutation resulting from field reordering optimizations).
Each field has an unique "memory index", meaning a sort based on them, even an unstable one, will not put them in the wrong order. But offsets don't have that property, because of ZSTs (which do not increase the offset), so sorting based on the offset of fields alone can (and did) result in wrong orders.
Instead of going back to sorting based on (slices/subsets of) `memory_index`, or special-casing ZSTs to make sorting based on offsets produce the right results (presumably), as #62011 does, I opted to drop sorting altogether and focus on `O(n)` operations involving *permutations*:
* a permutation is easily inverted (see the `invert_mapping` `fn`)
* an `inverse_memory_index` was already employed in other parts of the `ty::layout` code (that is, a mapping from memory order to field indices)
* inverting twice produces the original permutation, so you can invert, modify, and invert again, if it's easier to modify the inverse mapping than the direct one
* you can modify/remove elements in a permutation, as long as the result remains dense (i.e. using every integer in `0..len`, without gaps)
* for splitting a `0..n` permutation into disjoint `0..x` and `x..n` ranges, you can pick the elements based on a `i < x` / `i >= x` predicate, and for the latter, also subtract `x` to compact the range to `0..n-x`
* in the general case, for taking an arbitrary subset of the permutation, you need a renumbering from that subset to a dense `0..subset.len()` - but notably, this is still `O(n)`!
* you can merge permutations, as long as the result remains disjoint (i.e. each element is unique)
* for concatenating two `0..n` and `0..m` permutations, you can renumber the elements in the latter to `n..n+m`
* some of these operations can be combined, and an inverse mapping (be it a permutation or not) can still be used instead of a forward one by changing the "domain" of the loop performing the operation
I wish I had a nicer / more mathematical description of the recombinations involved, but my focus was to fix the bug (in a way which preserves information more directly than sorting would), so I may have missed potential changes in the surrounding generator layout code, that would make this all more straight-forward.
r? @tmandry
diff --git a/Cargo.lock b/Cargo.lock
index cf44893..eaec52a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -149,19 +149,6 @@
]
[[package]]
-name = "bit-set"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bit-vec 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "bit-vec"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
name = "bitflags"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -312,7 +299,6 @@
"opener 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
"pretty_env_logger 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "proptest 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-workspace-hack 1.0.0",
"rustfix 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
"same-file 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -329,7 +315,6 @@
"unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
"url_serde 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
@@ -1156,11 +1141,6 @@
[[package]]
name = "hashbrown"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "hashbrown"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
@@ -1399,11 +1379,6 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
-name = "leb128"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
name = "libc"
version = "0.2.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1881,14 +1856,6 @@
]
[[package]]
-name = "ordered-float"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
name = "ordermap"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1957,24 +1924,6 @@
]
[[package]]
-name = "partial_ref"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "partial_ref_derive 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "partial_ref_derive"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.35 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
name = "percent-encoding"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2137,25 +2086,6 @@
]
[[package]]
-name = "proptest"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bit-set 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "rusty-fork 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
name = "pulldown-cmark"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3254,6 +3184,7 @@
"minifier 0.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
"pulldown-cmark 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-rayon 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
@@ -3325,17 +3256,6 @@
]
[[package]]
-name = "rusty-fork"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "wait-timeout 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
name = "ryu"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3800,9 +3720,11 @@
name = "tidy"
version = "0.1.0"
dependencies = [
+ "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
+ "walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
@@ -4178,76 +4100,6 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
-name = "varisat"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "leb128 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "ordered-float 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "partial_ref 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-checker 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-dimacs 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-formula 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-internal-macros 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-internal-proof 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "vec_mut_scan 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "varisat-checker"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "hashbrown 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-dimacs 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-formula 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-internal-proof 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "varisat-dimacs"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-formula 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "varisat-formula"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "varisat-internal-macros"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "varisat-internal-proof"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "varisat-formula 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
name = "vcpkg"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -4258,11 +4110,6 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
-name = "vec_mut_scan"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
name = "vergen"
version = "3.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -4291,14 +4138,6 @@
]
[[package]]
-name = "wait-timeout"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.54 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
name = "walkdir"
version = "2.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -4400,8 +4239,6 @@
"checksum autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "0e49efa51329a5fd37e7c79db4621af617cd4e3e5bc224939808d076077077bf"
"checksum backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)" = "2d631cd7af21b7ff796293f1990104e3cdb606852863bac32f000c193aa35dfb"
"checksum backtrace-sys 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)" = "6ea90dd7b012b3d1a2cb6bec16670a0db2c95d4e931e84f4047e0460c1b34c8d"
-"checksum bit-set 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6f1efcc46c18245a69c38fcc5cc650f16d3a59d034f3106e9ed63748f695730a"
-"checksum bit-vec 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4440d5cb623bb7390ae27fec0bb6c61111969860f8e3ae198bfa0663645e67cf"
"checksum bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4efd02e230a02e18f92fc2735f44597385ed02ad8f831e7c1c1156ee5e1ab3a5"
"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
"checksum blake2-rfc 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)" = "5d6d530bdd2d52966a6d03b7a964add7ae1a288d25214066fd4b600f0f796400"
@@ -4491,7 +4328,6 @@
"checksum globset 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ef4feaabe24a0a658fd9cf4a9acf6ed284f045c77df0f49020ba3245cfb7b454"
"checksum handlebars 0.32.4 (registry+https://github.com/rust-lang/crates.io-index)" = "d89ec99d1594f285d4590fc32bac5f75cdab383f1123d504d27862c644a807dd"
"checksum handlebars 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d82e5750d8027a97b9640e3fefa66bbaf852a35228e1c90790efd13c4b09c166"
-"checksum hashbrown 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "29fba9abe4742d586dfd0c06ae4f7e73a1c2d86b856933509b269d82cdf06e18"
"checksum hashbrown 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9529213c67695ca2d146e6f263b7b72df8fa973368beadf767e8ed80c03f2f36"
"checksum heck 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ea04fa3ead4e05e51a7c806fc07271fdbde4e246a6c6d1efd52e72230b771b82"
"checksum hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "805026a5d0141ffc30abb3be3173848ad46a1b1664fe632428479619a3644d77"
@@ -4519,7 +4355,6 @@
"checksum lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
-"checksum leb128 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
"checksum libc 0.2.54 (registry+https://github.com/rust-lang/crates.io-index)" = "c6785aa7dd976f5fbf3b71cfd9cd49d7f783c1ff565a858d71031c6c313aa5c6"
"checksum libgit2-sys 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "941a41e23f77323b8c9d2ee118aec9ee39dfc176078c18b4757d3bad049d9ff7"
"checksum libnghttp2-sys 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d75d7966bda4730b722d1eab8e668df445368a24394bae9fc1e8dc0ab3dbe4f4"
@@ -4565,15 +4400,12 @@
"checksum openssl-probe 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
"checksum openssl-src 111.1.0+1.1.1a (registry+https://github.com/rust-lang/crates.io-index)" = "26bb632127731bf4ac49bf86a5dde12d2ca0918c2234fc39d79d4da2ccbc6da7"
"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
-"checksum ordered-float 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "18869315e81473c951eb56ad5558bbc56978562d3ecfb87abb7a1e944cea4518"
"checksum ordermap 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "a86ed3f5f244b372d6b1a00b72ef7f8876d0bc6a78a4c9985c53614041512063"
"checksum ordslice 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "dd20eec3dbe4376829cb7d80ae6ac45e0a766831dca50202ff2d40db46a8a024"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum packed_simd 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "25d36de864f7218ec5633572a800109bbe5a1cc8d9d95a967f3daf93ea7e6ddc"
"checksum parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab41b4aed082705d1056416ae4468b6ea99d52599ecf3169b00088d43113e337"
"checksum parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94c8c7923936b28d546dfd14d4472eaf34c99b14e1c973a32b3e6d4eb04298c9"
-"checksum partial_ref 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b2b85fa89a02abf59d36821c373b5ed38c8e075505f1a08618b000fce81229bc"
-"checksum partial_ref_derive 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "759319b785d033e4279ec98fb2d1fb767a1af5b6a8996086c07168169cff079b"
"checksum percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"
"checksum pest 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0fce5d8b5cc33983fc74f78ad552b5522ab41442c4ca91606e4236eb4b5ceefc"
"checksum pest 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "54f0c72a98d8ab3c99560bfd16df8059cc10e1f9a8e83e6e3b97718dd766e9c3"
@@ -4592,7 +4424,6 @@
"checksum pretty_assertions 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3a029430f0d744bc3d15dd474d591bed2402b645d024583082b9f63bb936dac6"
"checksum pretty_env_logger 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "df8b3f4e0475def7d9c2e5de8e5a1306949849761e107b360d03e98eafaffd61"
"checksum proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)" = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"
-"checksum proptest 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)" = "24f5844db2f839e97e3021980975f6ebf8691d9b9b2ca67ed3feb38dc3edb52c"
"checksum pulldown-cmark 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d6fdf85cda6cadfae5428a54661d431330b312bc767ddbc57adbedc24da66e32"
"checksum pulldown-cmark 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "051e60ace841b3bfecd402fe5051c06cb3bec4a6e6fdd060a37aa8eb829a1db3"
"checksum punycode 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6ddd112cca70a4d30883b2d21568a1d376ff8be4758649f64f973c6845128ad3"
@@ -4645,7 +4476,6 @@
"checksum rustc_tools_util 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b725dadae9fabc488df69a287f5a99c5eaf5d10853842a8a3dfac52476f544ee"
"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
"checksum rustfix 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af7c21531a91512a4a51b490be6ba1c8eff34fdda0dc5bf87dc28d86748aac56"
-"checksum rusty-fork 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9591f190d2852720b679c21f66ad929f9f1d7bb09d1193c26167586029d8489c"
"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum same-file 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8f20c4be53a8a1ff4c1f1b2bd14570d2f634628709752f0702ecdd2b3f9a5267"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
@@ -4728,20 +4558,12 @@
"checksum utf-8 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f1262dfab4c30d5cb7c07026be00ee343a6cf5027fdc0104a9160f354e5db75c"
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"checksum utf8parse 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8772a4ccbb4e89959023bc5b7cb8623a795caa7092d99f3aa9501b9484d4557d"
-"checksum varisat 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a2640f5949bcd945ffdb030f5f336d0a5da8fe8ddab8e8230e2e030ea0623cfa"
-"checksum varisat-checker 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a44da8d5e25b089d66fb3d14ae87994e2f7ba7f86ff396b7c490083d8a9a0a7b"
-"checksum varisat-dimacs 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f992cf40560ad73983369414fcc5a42fb9c9e39ae7ff215c75725f9c6785f0b9"
-"checksum varisat-formula 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "78d44ab5c6de769e855c77add5b0efa73ed3320b06485f04c8d3fad9b2eb9997"
-"checksum varisat-internal-macros 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0e76c43d9badf53d22b0edd25667d65b7b67167e2cce249c9d1e3ca0f02dc81c"
-"checksum varisat-internal-proof 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5a7553f03a4a8581410fb1813add70ce54e481d0e3eb1ca2cc1754faf46ff9ad"
"checksum vcpkg 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "def296d3eb3b12371b2c7d0e83bfe1403e4db2d7a0bba324a12b21c4ee13143d"
"checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
-"checksum vec_mut_scan 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b4d5668931075a8dfe6eb3e9e585d06f0ab4d9b377663e94d135ef51933ff9f6"
"checksum vergen 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "6aba5e34f93dc7051dfad05b98a18e9156f27e7b431fe1d2398cb6061c0a1dba"
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"checksum vte 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4f42f536e22f7fcbb407639765c8fd78707a33109301f834a594758bedd6e8cf"
-"checksum wait-timeout 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "b9f3bf741a801531993db6478b95682117471f76916f5e690dd8d45395b09349"
"checksum walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9d9d7ed3431229a144296213105a390676cc49c9b6a72bd19f3176c98e129fa1"
"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
diff --git a/src/bootstrap/cc_detect.rs b/src/bootstrap/cc_detect.rs
index dfc243b..400375c 100644
--- a/src/bootstrap/cc_detect.rs
+++ b/src/bootstrap/cc_detect.rs
@@ -95,30 +95,40 @@
};
build.cc.insert(target, compiler);
+ let cflags = build.cflags(target, GitRepo::Rustc);
+
+ // If we use llvm-libunwind, we will need a C++ compiler as well for all targets
+ // We'll need one anyways if the target triple is also a host triple
+ let mut cfg = cc::Build::new();
+ cfg.cargo_metadata(false).opt_level(2).warnings(false).debug(false).cpp(true)
+ .target(&target).host(&build.build);
+
+ let cxx_configured = if let Some(cxx) = config.and_then(|c| c.cxx.as_ref()) {
+ cfg.compiler(cxx);
+ true
+ } else if build.hosts.contains(&target) || build.build == target {
+ set_compiler(&mut cfg, Language::CPlusPlus, target, config, build);
+ true
+ } else {
+ false
+ };
+
+ if cxx_configured {
+ let compiler = cfg.get_compiler();
+ build.cxx.insert(target, compiler);
+ }
+
build.verbose(&format!("CC_{} = {:?}", &target, build.cc(target)));
- build.verbose(&format!("CFLAGS_{} = {:?}", &target, build.cflags(target, GitRepo::Rustc)));
+ build.verbose(&format!("CFLAGS_{} = {:?}", &target, cflags));
+ if let Ok(cxx) = build.cxx(target) {
+ build.verbose(&format!("CXX_{} = {:?}", &target, cxx));
+ build.verbose(&format!("CXXFLAGS_{} = {:?}", &target, cflags));
+ }
if let Some(ar) = ar {
build.verbose(&format!("AR_{} = {:?}", &target, ar));
build.ar.insert(target, ar);
}
}
-
- // For all host triples we need to find a C++ compiler as well
- let hosts = build.hosts.iter().cloned().chain(iter::once(build.build)).collect::<HashSet<_>>();
- for host in hosts.into_iter() {
- let mut cfg = cc::Build::new();
- cfg.cargo_metadata(false).opt_level(2).warnings(false).debug(false).cpp(true)
- .target(&host).host(&build.build);
- let config = build.config.target_config.get(&host);
- if let Some(cxx) = config.and_then(|c| c.cxx.as_ref()) {
- cfg.compiler(cxx);
- } else {
- set_compiler(&mut cfg, Language::CPlusPlus, host, config, build);
- }
- let compiler = cfg.get_compiler();
- build.verbose(&format!("CXX_{} = {:?}", host, compiler.path()));
- build.cxx.insert(host, compiler);
- }
}
fn set_compiler(cfg: &mut cc::Build,
diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs
index 74caaae..2f9bd06 100644
--- a/src/bootstrap/test.rs
+++ b/src/bootstrap/test.rs
@@ -709,8 +709,8 @@
if !builder.config.vendor {
cmd.arg("--no-vendor");
}
- if !builder.config.verbose_tests {
- cmd.arg("--quiet");
+ if builder.is_verbose() {
+ cmd.arg("--verbose");
}
let _folder = builder.fold_output(|| "tidy");
diff --git a/src/doc/rustc/src/linker-plugin-lto.md b/src/doc/rustc/src/linker-plugin-lto.md
index 73a2efc..2ae726c 100644
--- a/src/doc/rustc/src/linker-plugin-lto.md
+++ b/src/doc/rustc/src/linker-plugin-lto.md
@@ -100,9 +100,10 @@
The following table shows known good combinations of toolchain versions.
-| | Clang 7 | Clang 8 |
+| | Clang 7 | Clang 8 |
|-----------|-----------|-----------|
| Rust 1.34 | ✗ | ✓ |
-| Rust 1.35 | ✗ | ✓(?) |
+| Rust 1.35 | ✗ | ✓ |
+| Rust 1.36 | ✗ | ✓ |
Note that the compatibility policy for this feature might change in the future.
diff --git a/src/doc/unstable-book/src/language-features/arbitrary-enum-discriminant.md b/src/doc/unstable-book/src/language-features/arbitrary-enum-discriminant.md
new file mode 100644
index 0000000..e0bb782
--- /dev/null
+++ b/src/doc/unstable-book/src/language-features/arbitrary-enum-discriminant.md
@@ -0,0 +1,37 @@
+# `arbitrary_enum_discriminant`
+
+The tracking issue for this feature is: [#60553]
+
+[#60553]: https://github.com/rust-lang/rust/issues/60553
+
+------------------------
+
+The `arbitrary_enum_discriminant` feature permits tuple-like and
+struct-like enum variants with `#[repr(<int-type>)]` to have explicit discriminants.
+
+## Examples
+
+```rust
+#![feature(arbitrary_enum_discriminant)]
+
+#[allow(dead_code)]
+#[repr(u8)]
+enum Enum {
+ Unit = 3,
+ Tuple(u16) = 2,
+ Struct {
+ a: u8,
+ b: u16,
+ } = 1,
+}
+
+impl Enum {
+ fn tag(&self) -> u8 {
+ unsafe { *(self as *const Self as *const u8) }
+ }
+}
+
+assert_eq!(3, Enum::Unit.tag());
+assert_eq!(2, Enum::Tuple(5).tag());
+assert_eq!(1, Enum::Struct{a: 7, b: 11}.tag());
+```
diff --git a/src/liballoc/slice.rs b/src/liballoc/slice.rs
index aeb7f90..f7b0a5e 100644
--- a/src/liballoc/slice.rs
+++ b/src/liballoc/slice.rs
@@ -581,7 +581,9 @@
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_deprecated(since = "1.3.0", reason = "renamed to join")]
- fn connect(&self, sep: &T) -> Self::Output;
+ fn connect(&self, sep: &T) -> Self::Output {
+ self.join(sep)
+ }
}
#[unstable(feature = "slice_concat_ext",
@@ -615,10 +617,6 @@
}
result
}
-
- fn connect(&self, sep: &T) -> Vec<T> {
- self.join(sep)
- }
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/liballoc/str.rs b/src/liballoc/str.rs
index 0c7d2b8..4010455 100644
--- a/src/liballoc/str.rs
+++ b/src/liballoc/str.rs
@@ -86,10 +86,6 @@
String::from_utf8_unchecked( join_generic_copy(self, sep.as_bytes()) )
}
}
-
- fn connect(&self, sep: &str) -> String {
- self.join(sep)
- }
}
macro_rules! spezialize_for_lengths {
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 2f6d745..17ea584 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -2070,19 +2070,19 @@
() => ();
( $($name:ident,)+ ) => (
#[stable(feature = "rust1", since = "1.0.0")]
- impl<$($name:Debug),*> Debug for ($($name,)*) where last_type!($($name,)+): ?Sized {
+ impl<$($name:Debug),+> Debug for ($($name,)+) where last_type!($($name,)+): ?Sized {
#[allow(non_snake_case, unused_assignments)]
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
let mut builder = f.debug_tuple("");
- let ($(ref $name,)*) = *self;
+ let ($(ref $name,)+) = *self;
$(
builder.field(&$name);
- )*
+ )+
builder.finish()
}
}
- peel! { $($name,)* }
+ peel! { $($name,)+ }
)
}
diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
index 98150fd..38e3864 100644
--- a/src/libcore/hash/mod.rs
+++ b/src/libcore/hash/mod.rs
@@ -617,11 +617,11 @@
( $($name:ident)+) => (
#[stable(feature = "rust1", since = "1.0.0")]
- impl<$($name: Hash),*> Hash for ($($name,)*) where last_type!($($name,)+): ?Sized {
+ impl<$($name: Hash),+> Hash for ($($name,)+) where last_type!($($name,)+): ?Sized {
#[allow(non_snake_case)]
fn hash<S: Hasher>(&self, state: &mut S) {
- let ($(ref $name,)*) = *self;
- $($name.hash(state);)*
+ let ($(ref $name,)+) = *self;
+ $($name.hash(state);)+
}
}
);
diff --git a/src/libcore/iter/traits/accum.rs b/src/libcore/iter/traits/accum.rs
index 4eac5cb..adfb639 100644
--- a/src/libcore/iter/traits/accum.rs
+++ b/src/libcore/iter/traits/accum.rs
@@ -72,10 +72,10 @@
($($a:ty)*) => (
integer_sum_product!(@impls 0, 1,
#[stable(feature = "iter_arith_traits", since = "1.12.0")],
- $($a)+);
+ $($a)*);
integer_sum_product!(@impls Wrapping(0), Wrapping(1),
#[stable(feature = "wrapping_iter_arith", since = "1.14.0")],
- $(Wrapping<$a>)+);
+ $(Wrapping<$a>)*);
);
}
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 1bfb852..04c5032 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -69,7 +69,6 @@
#![feature(allow_internal_unstable)]
#![feature(arbitrary_self_types)]
#![feature(asm)]
-#![feature(associated_type_defaults)]
#![feature(bound_cloned)]
#![feature(cfg_target_has_atomic)]
#![feature(concat_idents)]
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index 8b44025..589061b 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -15,7 +15,7 @@
$crate::panic!($msg)
);
($fmt:expr, $($arg:tt)+) => ({
- $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*),
+ $crate::panicking::panic_fmt(format_args!($fmt, $($arg)+),
&(file!(), line!(), __rust_unstable_column!()))
});
}
@@ -558,7 +558,7 @@
#[stable(feature = "rust1", since = "1.0.0")]
macro_rules! unimplemented {
() => (panic!("not yet implemented"));
- ($($arg:tt)+) => (panic!("not yet implemented: {}", format_args!($($arg)*)));
+ ($($arg:tt)+) => (panic!("not yet implemented: {}", format_args!($($arg)+)));
}
/// Indicates unfinished code.
@@ -617,7 +617,7 @@
#[unstable(feature = "todo_macro", issue = "59277")]
macro_rules! todo {
() => (panic!("not yet implemented"));
- ($($arg:tt)+) => (panic!("not yet implemented: {}", format_args!($($arg)*)));
+ ($($arg:tt)+) => (panic!("not yet implemented: {}", format_args!($($arg)+)));
}
/// Creates an array of [`MaybeUninit`].
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 74f685a..3f4ff7c 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -103,7 +103,7 @@
/// `Unsize` is implemented for:
///
/// - `[T; N]` is `Unsize<[T]>`
-/// - `T` is `Unsize<Trait>` when `T: Trait`
+/// - `T` is `Unsize<dyn Trait>` when `T: Trait`
/// - `Foo<..., T, ...>` is `Unsize<Foo<..., U, ...>>` if:
/// - `T: Unsize<U>`
/// - Foo is a struct
diff --git a/src/libcore/ops/arith.rs b/src/libcore/ops/arith.rs
index 8139305..3c009d6 100644
--- a/src/libcore/ops/arith.rs
+++ b/src/libcore/ops/arith.rs
@@ -508,7 +508,7 @@
pub trait Rem<Rhs=Self> {
/// The resulting type after applying the `%` operator.
#[stable(feature = "rust1", since = "1.0.0")]
- type Output = Self;
+ type Output;
/// Performs the `%` operation.
#[must_use]
diff --git a/src/libcore/ptr/mod.rs b/src/libcore/ptr/mod.rs
index ba88fde..fccb00d7 100644
--- a/src/libcore/ptr/mod.rs
+++ b/src/libcore/ptr/mod.rs
@@ -2725,12 +2725,12 @@
macro_rules! fnptr_impls_args {
($($Arg: ident),+) => {
- fnptr_impls_safety_abi! { extern "Rust" fn($($Arg),*) -> Ret, $($Arg),* }
- fnptr_impls_safety_abi! { extern "C" fn($($Arg),*) -> Ret, $($Arg),* }
- fnptr_impls_safety_abi! { extern "C" fn($($Arg),* , ...) -> Ret, $($Arg),* }
- fnptr_impls_safety_abi! { unsafe extern "Rust" fn($($Arg),*) -> Ret, $($Arg),* }
- fnptr_impls_safety_abi! { unsafe extern "C" fn($($Arg),*) -> Ret, $($Arg),* }
- fnptr_impls_safety_abi! { unsafe extern "C" fn($($Arg),* , ...) -> Ret, $($Arg),* }
+ fnptr_impls_safety_abi! { extern "Rust" fn($($Arg),+) -> Ret, $($Arg),+ }
+ fnptr_impls_safety_abi! { extern "C" fn($($Arg),+) -> Ret, $($Arg),+ }
+ fnptr_impls_safety_abi! { extern "C" fn($($Arg),+ , ...) -> Ret, $($Arg),+ }
+ fnptr_impls_safety_abi! { unsafe extern "Rust" fn($($Arg),+) -> Ret, $($Arg),+ }
+ fnptr_impls_safety_abi! { unsafe extern "C" fn($($Arg),+) -> Ret, $($Arg),+ }
+ fnptr_impls_safety_abi! { unsafe extern "C" fn($($Arg),+ , ...) -> Ret, $($Arg),+ }
};
() => {
// No variadic functions with 0 parameters
diff --git a/src/libproc_macro/bridge/rpc.rs b/src/libproc_macro/bridge/rpc.rs
index 5018be7..5c2f9ec 100644
--- a/src/libproc_macro/bridge/rpc.rs
+++ b/src/libproc_macro/bridge/rpc.rs
@@ -59,7 +59,7 @@
}
};
(enum $name:ident $(<$($T:ident),+>)? { $($variant:ident $(($field:ident))*),* $(,)? }) => {
- impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)* {
+ impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
fn encode(self, w: &mut Writer, s: &mut S) {
// HACK(eddyb): `Tag` enum duplicated between the
// two impls as there's no other place to stash it.
@@ -79,8 +79,8 @@
}
}
- impl<S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)*> DecodeMut<'a, '_, S>
- for $name $(<$($T),+>)*
+ impl<S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)?> DecodeMut<'a, '_, S>
+ for $name $(<$($T),+>)?
{
fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
// HACK(eddyb): `Tag` enum duplicated between the
diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
index 1777d76..9c05f18 100644
--- a/src/librustc/hir/intravisit.rs
+++ b/src/librustc/hir/intravisit.rs
@@ -1056,7 +1056,7 @@
}
ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(right_expression);
- visitor.visit_expr(left_expression)
+ visitor.visit_expr(left_expression);
}
ExprKind::Field(ref subexpression, ident) => {
visitor.visit_expr(subexpression);
diff --git a/src/librustc/hir/itemlikevisit.rs b/src/librustc/hir/itemlikevisit.rs
index bfc9e8f..35b1812 100644
--- a/src/librustc/hir/itemlikevisit.rs
+++ b/src/librustc/hir/itemlikevisit.rs
@@ -51,7 +51,7 @@
fn visit_impl_item(&mut self, impl_item: &'hir ImplItem);
}
-pub struct DeepVisitor<'v, V: 'v> {
+pub struct DeepVisitor<'v, V> {
visitor: &'v mut V,
}
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index c87ab68..1b8e299 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -148,11 +148,11 @@
pub trait Resolver {
/// Resolve a path generated by the lowerer when expanding `for`, `if let`, etc.
- fn resolve_hir_path(
+ fn resolve_ast_path(
&mut self,
path: &ast::Path,
is_value: bool,
- ) -> hir::Path;
+ ) -> Res<NodeId>;
/// Obtain resolution for a `NodeId` with a single resolution.
fn get_partial_res(&mut self, id: NodeId) -> Option<PartialRes>;
@@ -167,7 +167,7 @@
/// This should only return `None` during testing.
fn definitions(&mut self) -> &mut Definitions;
- /// Given suffix `["b", "c", "d"]`, creates a HIR path for `[::crate_root]::b::c::d` and
+ /// Given suffix `["b", "c", "d"]`, creates an AST path for `[::crate_root]::b::c::d` and
/// resolves it based on `is_value`.
fn resolve_str_path(
&mut self,
@@ -175,7 +175,7 @@
crate_root: Option<Symbol>,
components: &[Symbol],
is_value: bool,
- ) -> hir::Path;
+ ) -> (ast::Path, Res<NodeId>);
}
/// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree,
@@ -1382,7 +1382,7 @@
attrs: self.lower_attrs(&arm.attrs),
pats: arm.pats.iter().map(|x| self.lower_pat(x)).collect(),
guard: match arm.guard {
- Some(Guard::If(ref x)) => Some(hir::Guard::If(P(self.lower_expr(x)))),
+ Some(ref x) => Some(hir::Guard::If(P(self.lower_expr(x)))),
_ => None,
},
body: P(self.lower_expr(&arm.body)),
@@ -4344,53 +4344,147 @@
let ohs = P(self.lower_expr(ohs));
hir::ExprKind::AddrOf(m, ohs)
}
- // More complicated than you might expect because the else branch
- // might be `if let`.
- ExprKind::If(ref cond, ref then, ref else_opt) => {
- // `true => then`:
- let then_pat = self.pat_bool(e.span, true);
- let then_blk = self.lower_block(then, false);
- let then_expr = self.expr_block(then_blk, ThinVec::new());
- let then_arm = self.arm(hir_vec![then_pat], P(then_expr));
+ ExprKind::Let(ref pats, ref scrutinee) => {
+ // If we got here, the `let` expression is not allowed.
+ self.sess
+ .struct_span_err(e.span, "`let` expressions are not supported here")
+ .note("only supported directly in conditions of `if`- and `while`-expressions")
+ .note("as well as when nested within `&&` and parenthesis in those conditions")
+ .emit();
+ // For better recovery, we emit:
+ // ```
+ // match scrutinee { pats => true, _ => false }
+ // ```
+ // While this doesn't fully match the user's intent, it has key advantages:
+ // 1. We can avoid using `abort_if_errors`.
+ // 2. We can typeck both `pats` and `scrutinee`.
+ // 3. `pats` is allowed to be refutable.
+ // 4. The return type of the block is `bool` which seems like what the user wanted.
+ let scrutinee = self.lower_expr(scrutinee);
+ let then_arm = {
+ let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
+ let expr = self.expr_bool(e.span, true);
+ self.arm(pats, P(expr))
+ };
+ let else_arm = {
+ let pats = hir_vec![self.pat_wild(e.span)];
+ let expr = self.expr_bool(e.span, false);
+ self.arm(pats, P(expr))
+ };
+ hir::ExprKind::Match(
+ P(scrutinee),
+ vec![then_arm, else_arm].into(),
+ hir::MatchSource::Normal,
+ )
+ }
+ // FIXME(#53667): handle lowering of && and parens.
+ ExprKind::If(ref cond, ref then, ref else_opt) => {
// `_ => else_block` where `else_block` is `{}` if there's `None`:
let else_pat = self.pat_wild(e.span);
- let else_expr = match else_opt {
- None => self.expr_block_empty(e.span),
- Some(els) => match els.node {
- ExprKind::IfLet(..) => {
- // Wrap the `if let` expr in a block.
- let els = self.lower_expr(els);
- let blk = self.block_all(els.span, hir_vec![], Some(P(els)));
- self.expr_block(P(blk), ThinVec::new())
- }
- _ => self.lower_expr(els),
- }
+ let (else_expr, contains_else_clause) = match else_opt {
+ None => (self.expr_block_empty(e.span), false),
+ Some(els) => (self.lower_expr(els), true),
};
let else_arm = self.arm(hir_vec![else_pat], P(else_expr));
- // Lower condition:
- let span_block = self.mark_span_with_reason(IfTemporary, cond.span, None);
- let cond = self.lower_expr(cond);
- // Wrap in a construct equivalent to `{ let _t = $cond; _t }` to preserve drop
- // semantics since `if cond { ... }` don't let temporaries live outside of `cond`.
- let cond = self.expr_drop_temps(span_block, P(cond), ThinVec::new());
+ // Handle then + scrutinee:
+ let then_blk = self.lower_block(then, false);
+ let then_expr = self.expr_block(then_blk, ThinVec::new());
+ let (then_pats, scrutinee, desugar) = match cond.node {
+ // `<pat> => <then>`
+ ExprKind::Let(ref pats, ref scrutinee) => {
+ let scrutinee = self.lower_expr(scrutinee);
+ let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
+ let desugar = hir::MatchSource::IfLetDesugar { contains_else_clause };
+ (pats, scrutinee, desugar)
+ }
+ // `true => then`:
+ _ => {
+ // Lower condition:
+ let cond = self.lower_expr(cond);
+ // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
+ // to preserve drop semantics since `if cond { ... }`
+ // don't let temporaries live outside of `cond`.
+ let span_block = self.mark_span_with_reason(IfTemporary, cond.span, None);
+ // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
+ // to preserve drop semantics since `if cond { ... }` does not
+ // let temporaries live outside of `cond`.
+ let cond = self.expr_drop_temps(span_block, P(cond), ThinVec::new());
- hir::ExprKind::Match(
- P(cond),
- vec![then_arm, else_arm].into(),
- hir::MatchSource::IfDesugar {
- contains_else_clause: else_opt.is_some()
- },
- )
+ let desugar = hir::MatchSource::IfDesugar { contains_else_clause };
+ let pats = hir_vec![self.pat_bool(e.span, true)];
+ (pats, cond, desugar)
+ }
+ };
+ let then_arm = self.arm(then_pats, P(then_expr));
+
+ hir::ExprKind::Match(P(scrutinee), vec![then_arm, else_arm].into(), desugar)
}
- ExprKind::While(ref cond, ref body, opt_label) => self.with_loop_scope(e.id, |this| {
- hir::ExprKind::While(
- this.with_loop_condition_scope(|this| P(this.lower_expr(cond))),
- this.lower_block(body, false),
- this.lower_label(opt_label),
- )
- }),
+ // FIXME(#53667): handle lowering of && and parens.
+ ExprKind::While(ref cond, ref body, opt_label) => {
+ // Desugar `ExprWhileLet`
+ // from: `[opt_ident]: while let <pat> = <sub_expr> <body>`
+ if let ExprKind::Let(ref pats, ref sub_expr) = cond.node {
+ // to:
+ //
+ // [opt_ident]: loop {
+ // match <sub_expr> {
+ // <pat> => <body>,
+ // _ => break
+ // }
+ // }
+
+ // Note that the block AND the condition are evaluated in the loop scope.
+ // This is done to allow `break` from inside the condition of the loop.
+ let (body, break_expr, sub_expr) = self.with_loop_scope(e.id, |this| {
+ (
+ this.lower_block(body, false),
+ this.expr_break(e.span, ThinVec::new()),
+ this.with_loop_condition_scope(|this| P(this.lower_expr(sub_expr))),
+ )
+ });
+
+ // `<pat> => <body>`
+ let pat_arm = {
+ let body_expr = P(self.expr_block(body, ThinVec::new()));
+ let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
+ self.arm(pats, body_expr)
+ };
+
+ // `_ => break`
+ let break_arm = {
+ let pat_under = self.pat_wild(e.span);
+ self.arm(hir_vec![pat_under], break_expr)
+ };
+
+ // `match <sub_expr> { ... }`
+ let arms = hir_vec![pat_arm, break_arm];
+ let match_expr = self.expr(
+ sub_expr.span,
+ hir::ExprKind::Match(sub_expr, arms, hir::MatchSource::WhileLetDesugar),
+ ThinVec::new(),
+ );
+
+ // `[opt_ident]: loop { ... }`
+ let loop_block = P(self.block_expr(P(match_expr)));
+ let loop_expr = hir::ExprKind::Loop(
+ loop_block,
+ self.lower_label(opt_label),
+ hir::LoopSource::WhileLet,
+ );
+ // Add attributes to the outer returned expr node.
+ loop_expr
+ } else {
+ self.with_loop_scope(e.id, |this| {
+ hir::ExprKind::While(
+ this.with_loop_condition_scope(|this| P(this.lower_expr(cond))),
+ this.lower_block(body, false),
+ this.lower_label(opt_label),
+ )
+ })
+ }
+ }
ExprKind::Loop(ref body, opt_label) => self.with_loop_scope(e.id, |this| {
hir::ExprKind::Loop(
this.lower_block(body, false),
@@ -4703,105 +4797,6 @@
ExprKind::Err => hir::ExprKind::Err,
- // Desugar `ExprIfLet`
- // from: `if let <pat> = <sub_expr> <body> [<else_opt>]`
- ExprKind::IfLet(ref pats, ref sub_expr, ref body, ref else_opt) => {
- // to:
- //
- // match <sub_expr> {
- // <pat> => <body>,
- // _ => [<else_opt> | ()]
- // }
-
- let mut arms = vec![];
-
- // `<pat> => <body>`
- {
- let body = self.lower_block(body, false);
- let body_expr = P(self.expr_block(body, ThinVec::new()));
- let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
- arms.push(self.arm(pats, body_expr));
- }
-
- // _ => [<else_opt>|{}]
- {
- let wildcard_arm: Option<&Expr> = else_opt.as_ref().map(|p| &**p);
- let wildcard_pattern = self.pat_wild(e.span);
- let body = if let Some(else_expr) = wildcard_arm {
- self.lower_expr(else_expr)
- } else {
- self.expr_block_empty(e.span)
- };
- arms.push(self.arm(hir_vec![wildcard_pattern], P(body)));
- }
-
- let contains_else_clause = else_opt.is_some();
-
- let sub_expr = P(self.lower_expr(sub_expr));
-
- hir::ExprKind::Match(
- sub_expr,
- arms.into(),
- hir::MatchSource::IfLetDesugar {
- contains_else_clause,
- },
- )
- }
-
- // Desugar `ExprWhileLet`
- // from: `[opt_ident]: while let <pat> = <sub_expr> <body>`
- ExprKind::WhileLet(ref pats, ref sub_expr, ref body, opt_label) => {
- // to:
- //
- // [opt_ident]: loop {
- // match <sub_expr> {
- // <pat> => <body>,
- // _ => break
- // }
- // }
-
- // Note that the block AND the condition are evaluated in the loop scope.
- // This is done to allow `break` from inside the condition of the loop.
- let (body, break_expr, sub_expr) = self.with_loop_scope(e.id, |this| {
- (
- this.lower_block(body, false),
- this.expr_break(e.span, ThinVec::new()),
- this.with_loop_condition_scope(|this| P(this.lower_expr(sub_expr))),
- )
- });
-
- // `<pat> => <body>`
- let pat_arm = {
- let body_expr = P(self.expr_block(body, ThinVec::new()));
- let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
- self.arm(pats, body_expr)
- };
-
- // `_ => break`
- let break_arm = {
- let pat_under = self.pat_wild(e.span);
- self.arm(hir_vec![pat_under], break_expr)
- };
-
- // `match <sub_expr> { ... }`
- let arms = hir_vec![pat_arm, break_arm];
- let match_expr = self.expr(
- sub_expr.span,
- hir::ExprKind::Match(sub_expr, arms, hir::MatchSource::WhileLetDesugar),
- ThinVec::new(),
- );
-
- // `[opt_ident]: loop { ... }`
- let loop_block = P(self.block_expr(P(match_expr)));
- let loop_expr = hir::ExprKind::Loop(
- loop_block,
- self.lower_label(opt_label),
- hir::LoopSource::WhileLet,
- );
- // Add attributes to the outer returned expr node.
- loop_expr
- }
-
// Desugar `ExprForLoop`
// from: `[opt_ident]: for <pat> in <head> <body>`
ExprKind::ForLoop(ref pat, ref head, ref body, opt_label) => {
@@ -5463,10 +5458,15 @@
)
}
+ /// Constructs a `true` or `false` literal expression.
+ fn expr_bool(&mut self, span: Span, val: bool) -> hir::Expr {
+ let lit = Spanned { span, node: LitKind::Bool(val) };
+ self.expr(span, hir::ExprKind::Lit(lit), ThinVec::new())
+ }
+
/// Constructs a `true` or `false` literal pattern.
fn pat_bool(&mut self, span: Span, val: bool) -> P<hir::Pat> {
- let lit = Spanned { span, node: LitKind::Bool(val) };
- let expr = self.expr(span, hir::ExprKind::Lit(lit), ThinVec::new());
+ let expr = self.expr_bool(span, val);
self.pat(span, hir::PatKind::Lit(P(expr)))
}
@@ -5546,16 +5546,26 @@
params: Option<P<hir::GenericArgs>>,
is_value: bool,
) -> hir::Path {
- let mut path = self.resolver
+ let (path, res) = self.resolver
.resolve_str_path(span, self.crate_root, components, is_value);
- path.segments.last_mut().unwrap().args = params;
- for seg in path.segments.iter_mut() {
- if seg.hir_id.is_some() {
- seg.hir_id = Some(self.next_id());
+ let mut segments: Vec<_> = path.segments.iter().map(|segment| {
+ let res = self.expect_full_res(segment.id);
+ hir::PathSegment {
+ ident: segment.ident,
+ hir_id: Some(self.lower_node_id(segment.id)),
+ res: Some(self.lower_res(res)),
+ infer_args: true,
+ args: None,
}
+ }).collect();
+ segments.last_mut().unwrap().args = params;
+
+ hir::Path {
+ span,
+ res: res.map_id(|_| panic!("unexpected node_id")),
+ segments: segments.into(),
}
- path
}
fn ty_path(&mut self, mut hir_id: hir::HirId, span: Span, qpath: hir::QPath) -> hir::Ty {
diff --git a/src/librustc/hir/map/blocks.rs b/src/librustc/hir/map/blocks.rs
index f50037a..351f581 100644
--- a/src/librustc/hir/map/blocks.rs
+++ b/src/librustc/hir/map/blocks.rs
@@ -15,7 +15,7 @@
use crate::hir::map;
use crate::hir::{Expr, FnDecl, Node};
use crate::hir::intravisit::FnKind;
-use syntax::ast::{Attribute, Ident, NodeId};
+use syntax::ast::{Attribute, Ident};
use syntax_pos::Span;
/// An FnLikeNode is a Node that is like a fn, in that it has a decl
@@ -83,7 +83,7 @@
}
/// Attempts to construct a Code from presumed FnLike or Expr node input.
- pub fn from_node(map: &map::Map<'a>, id: NodeId) -> Option<Code<'a>> {
+ pub fn from_node(map: &map::Map<'a>, id: ast::HirId) -> Option<Code<'a>> {
match map.get(id) {
map::Node::Block(_) => {
// Use the parent, hopefully an expression node.
diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs
index 6a561f0..b4bda36 100644
--- a/src/librustc/hir/map/definitions.rs
+++ b/src/librustc/hir/map/definitions.rs
@@ -397,11 +397,6 @@
self.node_to_hir_id[node_id]
}
- #[inline]
- pub fn def_index_to_node_id(&self, def_index: DefIndex) -> ast::NodeId {
- self.as_local_node_id(DefId::local(def_index)).unwrap()
- }
-
/// Retrieves the span of the given `DefId` if `DefId` is in the local crate, the span exists
/// and it's not `DUMMY_SP`.
#[inline]
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
index 87da327..3d591c9 100644
--- a/src/librustc/hir/map/mod.rs
+++ b/src/librustc/hir/map/mod.rs
@@ -291,8 +291,8 @@
self.definitions.def_index_to_hir_id(def_id.to_def_id().index)
}
- fn def_kind(&self, node_id: NodeId) -> Option<DefKind> {
- let node = if let Some(node) = self.find(node_id) {
+ fn def_kind(&self, hir_id: HirId) -> Option<DefKind> {
+ let node = if let Some(node) = self.find(hir_id) {
node
} else {
return None
@@ -347,7 +347,7 @@
if variant_data.ctor_hir_id().is_none() {
return None;
}
- let ctor_of = match self.find(self.get_parent_node(node_id)) {
+ let ctor_of = match self.find(self.get_parent_node(hir_id)) {
Some(Node::Item(..)) => def::CtorOf::Struct,
Some(Node::Variant(..)) => def::CtorOf::Variant,
_ => unreachable!(),
@@ -424,7 +424,7 @@
/// which this is the body of, i.e., a `fn`, `const` or `static`
/// item (possibly associated), a closure, or a `hir::AnonConst`.
pub fn body_owner(&self, BodyId { hir_id }: BodyId) -> HirId {
- let parent = self.get_parent_node_by_hir_id(hir_id);
+ let parent = self.get_parent_node(hir_id);
assert!(self.lookup(parent).map_or(false, |e| e.is_body_owner(hir_id)));
parent
}
@@ -458,7 +458,7 @@
}
pub fn body_owner_kind(&self, id: HirId) -> BodyOwnerKind {
- match self.get_by_hir_id(id) {
+ match self.get(id) {
Node::Item(&Item { node: ItemKind::Const(..), .. }) |
Node::TraitItem(&TraitItem { node: TraitItemKind::Const(..), .. }) |
Node::ImplItem(&ImplItem { node: ImplItemKind::Const(..), .. }) |
@@ -482,16 +482,16 @@
}
pub fn ty_param_owner(&self, id: HirId) -> HirId {
- match self.get_by_hir_id(id) {
+ match self.get(id) {
Node::Item(&Item { node: ItemKind::Trait(..), .. }) |
Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => id,
- Node::GenericParam(_) => self.get_parent_node_by_hir_id(id),
+ Node::GenericParam(_) => self.get_parent_node(id),
_ => bug!("ty_param_owner: {} not a type parameter", self.node_to_string(id))
}
}
pub fn ty_param_name(&self, id: HirId) -> Name {
- match self.get_by_hir_id(id) {
+ match self.get(id) {
Node::Item(&Item { node: ItemKind::Trait(..), .. }) |
Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => kw::SelfUpper,
Node::GenericParam(param) => param.name.ident().name,
@@ -561,20 +561,14 @@
}
/// Retrieves the `Node` corresponding to `id`, panicking if it cannot be found.
- pub fn get(&self, id: NodeId) -> Node<'hir> {
- let hir_id = self.node_to_hir_id(id);
- self.get_by_hir_id(hir_id)
- }
-
- // FIXME(@ljedrz): replace the `NodeId` variant.
- pub fn get_by_hir_id(&self, id: HirId) -> Node<'hir> {
+ pub fn get(&self, id: HirId) -> Node<'hir> {
// read recorded by `find`
- self.find_by_hir_id(id).unwrap_or_else(||
+ self.find(id).unwrap_or_else(||
bug!("couldn't find hir id {} in the HIR map", id))
}
pub fn get_if_local(&self, id: DefId) -> Option<Node<'hir>> {
- self.as_local_node_id(id).map(|id| self.get(id)) // read recorded by `get`
+ self.as_local_hir_id(id).map(|id| self.get(id)) // read recorded by `get`
}
pub fn get_generics(&self, id: DefId) -> Option<&'hir Generics> {
@@ -601,13 +595,7 @@
}
/// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found.
- pub fn find(&self, id: NodeId) -> Option<Node<'hir>> {
- let hir_id = self.node_to_hir_id(id);
- self.find_by_hir_id(hir_id)
- }
-
- // FIXME(@ljedrz): replace the `NodeId` variant.
- pub fn find_by_hir_id(&self, hir_id: HirId) -> Option<Node<'hir>> {
+ pub fn find(&self, hir_id: HirId) -> Option<Node<'hir>> {
let result = self.find_entry(hir_id).and_then(|entry| {
if let Node::Crate = entry.node {
None
@@ -621,24 +609,17 @@
result
}
- /// Similar to `get_parent`; returns the parent node-ID, or just `hir_id` if there
- /// is no parent. Note that the parent may be `CRATE_NODE_ID`, which is not itself
+ /// Similar to `get_parent`; returns the parent HIR Id, or just `hir_id` if there
+ /// is no parent. Note that the parent may be `CRATE_HIR_ID`, which is not itself
/// present in the map, so passing the return value of `get_parent_node` to
/// `get` may in fact panic.
- /// This function returns the immediate parent in the AST, whereas `get_parent`
+ /// This function returns the immediate parent in the HIR, whereas `get_parent`
/// returns the enclosing item. Note that this might not be the actual parent
- /// node in the AST -- some kinds of nodes are not in the map and these will
+ /// node in the HIR -- some kinds of nodes are not in the map and these will
/// never appear as the parent node. Thus, you can always walk the parent nodes
- /// from a node to the root of the AST (unless you get back the same ID here,
+ /// from a node to the root of the HIR (unless you get back the same ID here,
/// which can happen if the ID is not in the map itself or is just weird).
- pub fn get_parent_node(&self, id: NodeId) -> NodeId {
- let hir_id = self.node_to_hir_id(id);
- let parent_hir_id = self.get_parent_node_by_hir_id(hir_id);
- self.hir_to_node_id(parent_hir_id)
- }
-
- // FIXME(@ljedrz): replace the `NodeId` variant.
- pub fn get_parent_node_by_hir_id(&self, hir_id: HirId) -> HirId {
+ pub fn get_parent_node(&self, hir_id: HirId) -> HirId {
if self.dep_graph.is_fully_enabled() {
let hir_id_owner = hir_id.owner;
let def_path_hash = self.definitions.def_path_hash(hir_id_owner);
@@ -652,7 +633,7 @@
/// Check if the node is an argument. An argument is a local variable whose
/// immediate parent is an item or a closure.
- pub fn is_argument(&self, id: NodeId) -> bool {
+ pub fn is_argument(&self, id: HirId) -> bool {
match self.find(id) {
Some(Node::Binding(_)) => (),
_ => return false,
@@ -693,7 +674,7 @@
{
let mut id = start_id;
loop {
- let parent_id = self.get_parent_node_by_hir_id(id);
+ let parent_id = self.get_parent_node(id);
if parent_id == CRATE_HIR_ID {
return Ok(CRATE_HIR_ID);
}
@@ -846,7 +827,7 @@
if scope == CRATE_HIR_ID {
return Some(CRATE_HIR_ID);
}
- match self.get_by_hir_id(scope) {
+ match self.get(scope) {
Node::Item(i) => {
match i.node {
ItemKind::Existential(ExistTy { impl_trait_fn: None, .. }) => {}
@@ -878,28 +859,28 @@
}
pub fn expect_item(&self, id: HirId) -> &'hir Item {
- match self.find_by_hir_id(id) { // read recorded by `find`
+ match self.find(id) { // read recorded by `find`
Some(Node::Item(item)) => item,
_ => bug!("expected item, found {}", self.node_to_string(id))
}
}
pub fn expect_impl_item(&self, id: HirId) -> &'hir ImplItem {
- match self.find_by_hir_id(id) {
+ match self.find(id) {
Some(Node::ImplItem(item)) => item,
_ => bug!("expected impl item, found {}", self.node_to_string(id))
}
}
pub fn expect_trait_item(&self, id: HirId) -> &'hir TraitItem {
- match self.find_by_hir_id(id) {
+ match self.find(id) {
Some(Node::TraitItem(item)) => item,
_ => bug!("expected trait item, found {}", self.node_to_string(id))
}
}
pub fn expect_variant_data(&self, id: HirId) -> &'hir VariantData {
- match self.find_by_hir_id(id) {
+ match self.find(id) {
Some(Node::Item(i)) => {
match i.node {
ItemKind::Struct(ref struct_def, _) |
@@ -914,41 +895,28 @@
}
pub fn expect_variant(&self, id: HirId) -> &'hir Variant {
- match self.find_by_hir_id(id) {
+ match self.find(id) {
Some(Node::Variant(variant)) => variant,
_ => bug!("expected variant, found {}", self.node_to_string(id)),
}
}
pub fn expect_foreign_item(&self, id: HirId) -> &'hir ForeignItem {
- match self.find_by_hir_id(id) {
+ match self.find(id) {
Some(Node::ForeignItem(item)) => item,
_ => bug!("expected foreign item, found {}", self.node_to_string(id))
}
}
- pub fn expect_expr(&self, id: NodeId) -> &'hir Expr {
- let hir_id = self.node_to_hir_id(id);
- self.expect_expr_by_hir_id(hir_id)
- }
-
- // FIXME(@ljedrz): replace the `NodeId` variant.
- pub fn expect_expr_by_hir_id(&self, id: HirId) -> &'hir Expr {
- match self.find_by_hir_id(id) { // read recorded by find
+ pub fn expect_expr(&self, id: HirId) -> &'hir Expr {
+ match self.find(id) { // read recorded by find
Some(Node::Expr(expr)) => expr,
_ => bug!("expected expr, found {}", self.node_to_string(id))
}
}
- /// Returns the name associated with the given `NodeId`'s AST.
- pub fn name(&self, id: NodeId) -> Name {
- let hir_id = self.node_to_hir_id(id);
- self.name_by_hir_id(hir_id)
- }
-
- // FIXME(@ljedrz): replace the `NodeId` variant.
- pub fn name_by_hir_id(&self, id: HirId) -> Name {
- match self.get_by_hir_id(id) {
+ pub fn name(&self, id: HirId) -> Name {
+ match self.get(id) {
Node::Item(i) => i.ident.name,
Node::ForeignItem(fi) => fi.ident.name,
Node::ImplItem(ii) => ii.ident.name,
@@ -958,7 +926,7 @@
Node::Lifetime(lt) => lt.name.ident().name,
Node::GenericParam(param) => param.name.ident().name,
Node::Binding(&Pat { node: PatKind::Binding(_, _, l, _), .. }) => l.name,
- Node::Ctor(..) => self.name_by_hir_id(self.get_parent_item(id)),
+ Node::Ctor(..) => self.name(self.get_parent_item(id)),
_ => bug!("no name for {}", self.node_to_string(id))
}
}
@@ -1047,8 +1015,8 @@
Some(Node::Pat(pat)) => pat.span,
Some(Node::Arm(arm)) => arm.span,
Some(Node::Block(block)) => block.span,
- Some(Node::Ctor(..)) => match self.find_by_hir_id(
- self.get_parent_node_by_hir_id(hir_id))
+ Some(Node::Ctor(..)) => match self.find(
+ self.get_parent_node(hir_id))
{
Some(Node::Item(item)) => item.span,
Some(Node::Variant(variant)) => variant.span,
@@ -1080,7 +1048,7 @@
}
pub fn hir_to_pretty_string(&self, id: HirId) -> String {
- print::to_string(self, |s| s.print_node(self.get_by_hir_id(id)))
+ print::to_string(self, |s| s.print_node(self.get(id)))
}
}
@@ -1119,7 +1087,7 @@
// chain, then returns `None`.
fn find_first_mod_parent<'a>(map: &'a Map<'_>, mut id: HirId) -> Option<(HirId, Name)> {
loop {
- if let Node::Item(item) = map.find_by_hir_id(id)? {
+ if let Node::Item(item) = map.find(id)? {
if item_is_mod(&item) {
return Some((id, item.ident.name))
}
@@ -1292,7 +1260,7 @@
})
};
- match map.find_by_hir_id(id) {
+ match map.find(id) {
Some(Node::Item(item)) => {
let item_str = match item.node {
ItemKind::ExternCrate(..) => "extern crate",
@@ -1407,8 +1375,8 @@
pub fn provide(providers: &mut Providers<'_>) {
providers.def_kind = |tcx, def_id| {
- if let Some(node_id) = tcx.hir().as_local_node_id(def_id) {
- tcx.hir().def_kind(node_id)
+ if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
+ tcx.hir().def_kind(hir_id)
} else {
bug!("calling local def_kind query provider for upstream DefId: {:?}",
def_id
diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
index 9b144b1..0ddc921 100644
--- a/src/librustc/ich/impls_ty.rs
+++ b/src/librustc/ich/impls_ty.rs
@@ -175,13 +175,18 @@
hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>,
) {
- self.bytes.hash_stable(hcx, hasher);
- for reloc in self.relocations.iter() {
+ let mir::interpret::Allocation {
+ bytes, relocations, undef_mask, align, mutability,
+ extra: _,
+ } = self;
+ bytes.hash_stable(hcx, hasher);
+ relocations.len().hash_stable(hcx, hasher);
+ for reloc in relocations.iter() {
reloc.hash_stable(hcx, hasher);
}
- self.undef_mask.hash_stable(hcx, hasher);
- self.align.hash_stable(hcx, hasher);
- self.mutability.hash_stable(hcx, hasher);
+ undef_mask.hash_stable(hcx, hasher);
+ align.hash_stable(hcx, hasher);
+ mutability.hash_stable(hcx, hasher);
}
}
diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs
index 321c068..6522516 100644
--- a/src/librustc/infer/error_reporting/mod.rs
+++ b/src/librustc/infer/error_reporting/mod.rs
@@ -86,7 +86,7 @@
)
};
let span = scope.span(self, region_scope_tree);
- let tag = match self.hir().find_by_hir_id(scope.hir_id(region_scope_tree)) {
+ let tag = match self.hir().find(scope.hir_id(region_scope_tree)) {
Some(Node::Block(_)) => "block",
Some(Node::Expr(expr)) => match expr.node {
hir::ExprKind::Call(..) => "call",
@@ -182,7 +182,7 @@
let scope = region.free_region_binding_scope(self);
let node = self.hir().as_local_hir_id(scope).unwrap_or(hir::DUMMY_HIR_ID);
- let tag = match self.hir().find_by_hir_id(node) {
+ let tag = match self.hir().find(node) {
Some(Node::Block(_)) | Some(Node::Expr(_)) => "body",
Some(Node::Item(it)) => Self::item_scope_tag(&it),
Some(Node::TraitItem(it)) => Self::trait_item_scope_tag(&it),
@@ -617,7 +617,7 @@
}
hir::MatchSource::TryDesugar => {
if let Some(ty::error::ExpectedFound { expected, .. }) = exp_found {
- let discrim_expr = self.tcx.hir().expect_expr_by_hir_id(discrim_hir_id);
+ let discrim_expr = self.tcx.hir().expect_expr(discrim_hir_id);
let discrim_ty = if let hir::ExprKind::Call(_, args) = &discrim_expr.node {
let arg_expr = args.first().expect("try desugaring call w/out arg");
self.in_progress_tables.and_then(|tables| {
@@ -1335,7 +1335,7 @@
// We do this to avoid suggesting code that ends up as `T: 'a'b`,
// instead we suggest `T: 'a + 'b` in that case.
let mut has_bounds = false;
- if let Node::GenericParam(ref param) = hir.get_by_hir_id(id) {
+ if let Node::GenericParam(ref param) = hir.get(id) {
has_bounds = !param.bounds.is_empty();
}
let sp = hir.span(id);
@@ -1583,7 +1583,7 @@
format!(" for lifetime parameter `{}` in coherence check", name)
}
infer::UpvarRegion(ref upvar_id, _) => {
- let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id);
+ let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
format!(" for capture of `{}` by closure", var_name)
}
infer::NLL(..) => bug!("NLL variable found in lexical phase"),
diff --git a/src/librustc/infer/error_reporting/need_type_info.rs b/src/librustc/infer/error_reporting/need_type_info.rs
index fe151bd..4426b5c 100644
--- a/src/librustc/infer/error_reporting/need_type_info.rs
+++ b/src/librustc/infer/error_reporting/need_type_info.rs
@@ -133,7 +133,7 @@
};
if let Some(body_id) = body_id {
- let expr = self.tcx.hir().expect_expr_by_hir_id(body_id.hir_id);
+ let expr = self.tcx.hir().expect_expr(body_id.hir_id);
local_visitor.visit_expr(expr);
}
diff --git a/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs b/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs
index 78d1d569..283af94 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs
@@ -29,7 +29,7 @@
if let Some(anon_reg) = self.tcx().is_suitable_region(region) {
let def_id = anon_reg.def_id;
if let Some(hir_id) = self.tcx().hir().as_local_hir_id(def_id) {
- let fndecl = match self.tcx().hir().get_by_hir_id(hir_id) {
+ let fndecl = match self.tcx().hir().get(hir_id) {
Node::Item(&hir::Item {
node: hir::ItemKind::Fn(ref fndecl, ..),
..
diff --git a/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs b/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs
index 6ed2b67..f5a4dac 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs
@@ -52,7 +52,7 @@
if let Node::Expr(Expr {
node: Closure(_, _, _, closure_span, None),
..
- }) = hir.get_by_hir_id(hir_id) {
+ }) = hir.get(hir_id) {
let sup_sp = sup_origin.span();
let origin_sp = origin.span();
let mut err = self.tcx().sess.struct_span_err(
diff --git a/src/librustc/infer/error_reporting/note.rs b/src/librustc/infer/error_reporting/note.rs
index cc7c13c..caed428 100644
--- a/src/librustc/infer/error_reporting/note.rs
+++ b/src/librustc/infer/error_reporting/note.rs
@@ -31,7 +31,7 @@
"...so that reference does not outlive borrowed content");
}
infer::ReborrowUpvar(span, ref upvar_id) => {
- let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id);
+ let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
err.span_note(span,
&format!("...so that closure can access `{}`", var_name));
}
@@ -163,7 +163,7 @@
err
}
infer::ReborrowUpvar(span, ref upvar_id) => {
- let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id);
+ let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
let mut err = struct_span_err!(self.tcx.sess,
span,
E0313,
diff --git a/src/librustc/infer/freshen.rs b/src/librustc/infer/freshen.rs
index 7f4a817..400a538 100644
--- a/src/librustc/infer/freshen.rs
+++ b/src/librustc/infer/freshen.rs
@@ -260,7 +260,7 @@
ConstValue::Param(_) |
ConstValue::Scalar(_) |
ConstValue::Slice { .. } |
- ConstValue::ByRef(..) |
+ ConstValue::ByRef { .. } |
ConstValue::Unevaluated(..) => {}
}
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
index fc46fe3..9a5c726 100644
--- a/src/librustc/infer/mod.rs
+++ b/src/librustc/infer/mod.rs
@@ -171,6 +171,7 @@
/// Track how many errors were reported when this infcx is created.
/// If the number of errors increases, that's also a sign (line
/// `tained_by_errors`) to avoid reporting certain kinds of errors.
+ // FIXME(matthewjasper) Merge into `tainted_by_errors_flag`
err_count_on_creation: usize,
/// This flag is true while there is an active snapshot.
@@ -265,7 +266,7 @@
DerefPointer(Span),
/// Closure bound must not outlive captured variables
- ClosureCapture(Span, ast::NodeId),
+ ClosureCapture(Span, hir::HirId),
/// Index into slice must be within its lifetime
IndexSlice(Span),
diff --git a/src/librustc/infer/nll_relate/mod.rs b/src/librustc/infer/nll_relate/mod.rs
index 2148996..a1a93eb 100644
--- a/src/librustc/infer/nll_relate/mod.rs
+++ b/src/librustc/infer/nll_relate/mod.rs
@@ -800,7 +800,7 @@
/// [blog post]: https://is.gd/0hKvIr
struct TypeGeneralizer<'me, 'tcx, D>
where
- D: TypeRelatingDelegate<'tcx> + 'me,
+ D: TypeRelatingDelegate<'tcx>,
{
infcx: &'me InferCtxt<'me, 'tcx>,
diff --git a/src/librustc/infer/opaque_types/mod.rs b/src/librustc/infer/opaque_types/mod.rs
index 60554a3..6b6dbd4 100644
--- a/src/librustc/infer/opaque_types/mod.rs
+++ b/src/librustc/infer/opaque_types/mod.rs
@@ -777,7 +777,7 @@
.local_def_id_from_hir_id(opaque_parent_hir_id)
};
let (in_definition_scope, origin) =
- match tcx.hir().find_by_hir_id(opaque_hir_id)
+ match tcx.hir().find(opaque_hir_id)
{
Some(Node::Item(item)) => match item.node {
// Anonymous `impl Trait`
@@ -945,8 +945,8 @@
let mut hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
trace!(
"may_define_existential_type(def={:?}, opaque_node={:?})",
- tcx.hir().get_by_hir_id(hir_id),
- tcx.hir().get_by_hir_id(opaque_hir_id)
+ tcx.hir().get(hir_id),
+ tcx.hir().get(opaque_hir_id)
);
// Named existential types can be defined by any siblings or children of siblings.
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index e2f2799..257d515 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -31,7 +31,6 @@
#![deny(rust_2018_idioms)]
#![deny(internal)]
#![deny(unused_lifetimes)]
-#![allow(explicit_outlives_requirements)]
#![feature(arbitrary_self_types)]
#![feature(box_patterns)]
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
index 9e2038f..e02ee89 100644
--- a/src/librustc/middle/dead.rs
+++ b/src/librustc/middle/dead.rs
@@ -27,7 +27,7 @@
// function, then we should explore its block to check for codes that
// may need to be marked as live.
fn should_explore<'tcx>(tcx: TyCtxt<'tcx>, hir_id: hir::HirId) -> bool {
- match tcx.hir().find_by_hir_id(hir_id) {
+ match tcx.hir().find(hir_id) {
Some(Node::Item(..)) |
Some(Node::ImplItem(..)) |
Some(Node::ForeignItem(..)) |
@@ -145,7 +145,7 @@
// tuple struct constructor function
let id = self.struct_constructors.get(&id).cloned().unwrap_or(id);
- if let Some(node) = self.tcx.hir().find_by_hir_id(id) {
+ if let Some(node) = self.tcx.hir().find(id) {
self.live_symbols.insert(id);
self.visit_node(node);
}
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index bf054d6..7b69fe3 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -110,7 +110,7 @@
use std::io::prelude::*;
use std::io;
use std::rc::Rc;
-use syntax::ast::{self, NodeId};
+use syntax::ast;
use syntax::ptr::P;
use syntax::symbol::{kw, sym};
use syntax_pos::Span;
@@ -369,7 +369,7 @@
// Don't run unused pass for #[derive()]
if let FnKind::Method(..) = fk {
let parent = ir.tcx.hir().get_parent_item(id);
- if let Some(Node::Item(i)) = ir.tcx.hir().find_by_hir_id(parent) {
+ if let Some(Node::Item(i)) = ir.tcx.hir().find(parent) {
if i.attrs.iter().any(|a| a.check_name(sym::automatically_derived)) {
return;
}
@@ -1327,12 +1327,11 @@
}
}
- fn access_var(&mut self, hir_id: HirId, nid: NodeId, succ: LiveNode, acc: u32, span: Span)
+ fn access_var(&mut self, hir_id: HirId, var_hid: HirId, succ: LiveNode, acc: u32, span: Span)
-> LiveNode {
let ln = self.live_node(hir_id, span);
if acc != 0 {
self.init_from_succ(ln, succ);
- let var_hid = self.ir.tcx.hir().node_to_hir_id(nid);
let var = self.variable(var_hid, span);
self.acc(ln, var, acc);
}
@@ -1345,8 +1344,7 @@
Res::Local(hid) => {
let upvars = self.ir.tcx.upvars(self.ir.body_owner);
if !upvars.map_or(false, |upvars| upvars.contains_key(&hid)) {
- let nid = self.ir.tcx.hir().hir_to_node_id(hid);
- self.access_var(hir_id, nid, succ, acc, path.span)
+ self.access_var(hir_id, hid, succ, acc, path.span)
} else {
succ
}
@@ -1630,7 +1628,7 @@
);
if self.ir.variable_is_shorthand(var) {
- if let Node::Binding(pat) = self.ir.tcx.hir().get_by_hir_id(hir_id) {
+ if let Node::Binding(pat) = self.ir.tcx.hir().get(hir_id) {
// Handle `ref` and `ref mut`.
let spans = spans.iter()
.map(|_span| (pat.span, format!("{}: _", name)))
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index c0f56a3..e7253a7 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -344,7 +344,7 @@
tables: &ty::TypeckTables<'_>,
id: hir::HirId,
) -> MutabilityCategory {
- let ret = match tcx.hir().get_by_hir_id(id) {
+ let ret = match tcx.hir().get(id) {
Node::Binding(p) => match p.node {
PatKind::Binding(..) => {
let bm = *tables.pat_binding_modes()
@@ -1526,7 +1526,7 @@
"non-place".into()
}
Categorization::Local(vid) => {
- if tcx.hir().is_argument(tcx.hir().hir_to_node_id(vid)) {
+ if tcx.hir().is_argument(vid) {
"argument"
} else {
"local variable"
diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs
index 593c5e73..d607c35 100644
--- a/src/librustc/middle/reachable.rs
+++ b/src/librustc/middle/reachable.rs
@@ -53,7 +53,7 @@
return true
}
if let Some(impl_hir_id) = tcx.hir().as_local_hir_id(impl_src) {
- match tcx.hir().find_by_hir_id(impl_hir_id) {
+ match tcx.hir().find(impl_hir_id) {
Some(Node::Item(item)) =>
item_might_be_inlined(tcx, &item, codegen_fn_attrs),
Some(..) | None =>
@@ -147,7 +147,7 @@
None => { return false; }
};
- match self.tcx.hir().find_by_hir_id(hir_id) {
+ match self.tcx.hir().find(hir_id) {
Some(Node::Item(item)) => {
match item.node {
hir::ItemKind::Fn(..) =>
@@ -205,7 +205,7 @@
continue
}
- if let Some(ref item) = self.tcx.hir().find_by_hir_id(search_item) {
+ if let Some(ref item) = self.tcx.hir().find(search_item) {
self.propagate_node(item, search_item);
}
}
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 93cb6ab..114684b 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -190,7 +190,7 @@
}
let span = tcx.hir().span(hir_id);
if let ScopeData::Remainder(first_statement_index) = self.data {
- if let Node::Block(ref blk) = tcx.hir().get_by_hir_id(hir_id) {
+ if let Node::Block(ref blk) = tcx.hir().get(hir_id) {
// Want span for scope starting after the
// indexed statement and ending at end of
// `blk`; reuse span of `blk` and shift `lo`
@@ -371,7 +371,12 @@
// The number of expressions and patterns visited in the current body
expr_and_pat_count: usize,
-
+ // When this is `true`, we record the `Scopes` we encounter
+ // when processing a Yield expression. This allows us to fix
+ // up their indices.
+ pessimistic_yield: bool,
+ // Stores scopes when pessimistic_yield is true.
+ fixup_scopes: Vec<Scope>,
// Generated scope tree:
scope_tree: ScopeTree,
@@ -947,12 +952,107 @@
}
}
+ let prev_pessimistic = visitor.pessimistic_yield;
+
+ // Ordinarily, we can rely on the visit order of HIR intravisit
+ // to correspond to the actual execution order of statements.
+ // However, there's a weird corner case with compund assignment
+ // operators (e.g. `a += b`). The evaluation order depends on whether
+ // or not the operator is overloaded (e.g. whether or not a trait
+ // like AddAssign is implemented).
+
+ // For primitive types (which, despite having a trait impl, don't actually
+ // end up calling it), the evluation order is right-to-left. For example,
+ // the following code snippet:
+ //
+ // let y = &mut 0;
+ // *{println!("LHS!"); y} += {println!("RHS!"); 1};
+ //
+ // will print:
+ //
+ // RHS!
+ // LHS!
+ //
+ // However, if the operator is used on a non-primitive type,
+ // the evaluation order will be left-to-right, since the operator
+ // actually get desugared to a method call. For example, this
+ // nearly identical code snippet:
+ //
+ // let y = &mut String::new();
+ // *{println!("LHS String"); y} += {println!("RHS String"); "hi"};
+ //
+ // will print:
+ // LHS String
+ // RHS String
+ //
+ // To determine the actual execution order, we need to perform
+ // trait resolution. Unfortunately, we need to be able to compute
+ // yield_in_scope before type checking is even done, as it gets
+ // used by AST borrowcheck.
+ //
+ // Fortunately, we don't need to know the actual execution order.
+ // It suffices to know the 'worst case' order with respect to yields.
+ // Specifically, we need to know the highest 'expr_and_pat_count'
+ // that we could assign to the yield expression. To do this,
+ // we pick the greater of the two values from the left-hand
+ // and right-hand expressions. This makes us overly conservative
+ // about what types could possibly live across yield points,
+ // but we will never fail to detect that a type does actually
+ // live across a yield point. The latter part is critical -
+ // we're already overly conservative about what types will live
+ // across yield points, as the generated MIR will determine
+ // when things are actually live. However, for typecheck to work
+ // properly, we can't miss any types.
+
+
match expr.node {
// Manually recurse over closures, because they are the only
// case of nested bodies that share the parent environment.
hir::ExprKind::Closure(.., body, _, _) => {
let body = visitor.tcx.hir().body(body);
visitor.visit_body(body);
+ },
+ hir::ExprKind::AssignOp(_, ref left_expr, ref right_expr) => {
+ debug!("resolve_expr - enabling pessimistic_yield, was previously {}",
+ prev_pessimistic);
+
+ let start_point = visitor.fixup_scopes.len();
+ visitor.pessimistic_yield = true;
+
+ // If the actual execution order turns out to be right-to-left,
+ // then we're fine. However, if the actual execution order is left-to-right,
+ // then we'll assign too low a count to any `yield` expressions
+ // we encounter in 'right_expression' - they should really occur after all of the
+ // expressions in 'left_expression'.
+ visitor.visit_expr(&right_expr);
+ visitor.pessimistic_yield = prev_pessimistic;
+
+ debug!("resolve_expr - restoring pessimistic_yield to {}", prev_pessimistic);
+ visitor.visit_expr(&left_expr);
+ debug!("resolve_expr - fixing up counts to {}", visitor.expr_and_pat_count);
+
+ // Remove and process any scopes pushed by the visitor
+ let target_scopes = visitor.fixup_scopes.drain(start_point..);
+
+ for scope in target_scopes {
+ let mut yield_data = visitor.scope_tree.yield_in_scope.get_mut(&scope).unwrap();
+ let count = yield_data.expr_and_pat_count;
+ let span = yield_data.span;
+
+ // expr_and_pat_count never decreases. Since we recorded counts in yield_in_scope
+ // before walking the left-hand side, it should be impossible for the recorded
+ // count to be greater than the left-hand side count.
+ if count > visitor.expr_and_pat_count {
+ bug!("Encountered greater count {} at span {:?} - expected no greater than {}",
+ count, span, visitor.expr_and_pat_count);
+ }
+ let new_count = visitor.expr_and_pat_count;
+ debug!("resolve_expr - increasing count for scope {:?} from {} to {} at span {:?}",
+ scope, count, new_count, span);
+
+ yield_data.expr_and_pat_count = new_count;
+ }
+
}
_ => intravisit::walk_expr(visitor, expr)
@@ -972,6 +1072,10 @@
source: *source,
};
visitor.scope_tree.yield_in_scope.insert(scope, data);
+ if visitor.pessimistic_yield {
+ debug!("resolve_expr in pessimistic_yield - marking scope {:?} for fixup", scope);
+ visitor.fixup_scopes.push(scope);
+ }
// Keep traversing up while we can.
match visitor.scope_tree.parent_map.get(&scope) {
@@ -1360,6 +1464,8 @@
var_parent: None,
},
terminating_scopes: Default::default(),
+ pessimistic_yield: false,
+ fixup_scopes: vec![],
};
let body = tcx.hir().body(body_id);
@@ -1368,7 +1474,7 @@
// If the item is an associated const or a method,
// record its impl/trait parent, as it can also have
// lifetime parameters free in this body.
- match tcx.hir().get_by_hir_id(id) {
+ match tcx.hir().get(id) {
Node::ImplItem(_) |
Node::TraitItem(_) => {
visitor.scope_tree.root_parent = Some(tcx.hir().get_parent_item(id));
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
index f68e18c..412346b 100644
--- a/src/librustc/middle/resolve_lifetime.rs
+++ b/src/librustc/middle/resolve_lifetime.rs
@@ -662,7 +662,7 @@
if let Some(Region::LateBound(_, def_id, _)) = def {
if let Some(hir_id) = self.tcx.hir().as_local_hir_id(def_id) {
// Ensure that the parent of the def is an item, not HRTB
- let parent_id = self.tcx.hir().get_parent_node_by_hir_id(hir_id);
+ let parent_id = self.tcx.hir().get_parent_node(hir_id);
let parent_impl_id = hir::ImplItemId { hir_id: parent_id };
let parent_trait_id = hir::TraitItemId { hir_id: parent_id };
let krate = self.tcx.hir().forest.krate();
@@ -1488,8 +1488,8 @@
}
}
};
- if let Node::Lifetime(hir_lifetime) = self.tcx.hir().get_by_hir_id(lifetime.hir_id) {
- if let Some(parent) = self.tcx.hir().find_by_hir_id(
+ if let Node::Lifetime(hir_lifetime) = self.tcx.hir().get(lifetime.hir_id) {
+ if let Some(parent) = self.tcx.hir().find(
self.tcx.hir().get_parent_item(hir_lifetime.hir_id))
{
match parent {
@@ -1569,7 +1569,7 @@
Some(LifetimeUseSet::One(lifetime)) => {
let hir_id = self.tcx.hir().as_local_hir_id(def_id).unwrap();
debug!("hir id first={:?}", hir_id);
- if let Some((id, span, name)) = match self.tcx.hir().get_by_hir_id(hir_id) {
+ if let Some((id, span, name)) = match self.tcx.hir().get(hir_id) {
Node::Lifetime(hir_lifetime) => Some((
hir_lifetime.hir_id,
hir_lifetime.span,
@@ -1620,7 +1620,7 @@
}
None => {
let hir_id = self.tcx.hir().as_local_hir_id(def_id).unwrap();
- if let Some((id, span, name)) = match self.tcx.hir().get_by_hir_id(hir_id) {
+ if let Some((id, span, name)) = match self.tcx.hir().get(hir_id) {
Node::Lifetime(hir_lifetime) => Some((
hir_lifetime.hir_id,
hir_lifetime.span,
@@ -1823,7 +1823,7 @@
// Do not free early-bound regions, only late-bound ones.
} else if let Some(body_id) = outermost_body {
let fn_id = self.tcx.hir().body_owner(body_id);
- match self.tcx.hir().get_by_hir_id(fn_id) {
+ match self.tcx.hir().get(fn_id) {
Node::Item(&hir::Item {
node: hir::ItemKind::Fn(..),
..
@@ -2051,8 +2051,8 @@
// and whether there's a `self` argument (treated specially).
let mut assoc_item_kind = None;
let mut impl_self = None;
- let parent = self.tcx.hir().get_parent_node_by_hir_id(output.hir_id);
- let body = match self.tcx.hir().get_by_hir_id(parent) {
+ let parent = self.tcx.hir().get_parent_node(output.hir_id);
+ let body = match self.tcx.hir().get(parent) {
// `fn` definitions and methods.
Node::Item(&hir::Item {
node: hir::ItemKind::Fn(.., body),
diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
index 5a1e521..38df406 100644
--- a/src/librustc/middle/stability.rs
+++ b/src/librustc/middle/stability.rs
@@ -580,7 +580,7 @@
let mut diag = self.struct_span_lint_hir(lint, id, span, &msg);
if let Some(suggestion) = suggestion {
- if let hir::Node::Expr(_) = self.hir().get_by_hir_id(id) {
+ if let hir::Node::Expr(_) = self.hir().get(id) {
diag.span_suggestion(
span,
"replace the use of the deprecated item",
diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs
index b6cd24c..4fb88da 100644
--- a/src/librustc/middle/weak_lang_items.rs
+++ b/src/librustc/middle/weak_lang_items.rs
@@ -147,7 +147,7 @@
let lang_items = self.lang_items();
let did = Some(item_def_id);
- $(lang_items.$name() == did)||+
+ $(lang_items.$name() == did)||*
}
}
diff --git a/src/librustc/mir/interpret/allocation.rs b/src/librustc/mir/interpret/allocation.rs
index d7caf95..c8bf250 100644
--- a/src/librustc/mir/interpret/allocation.rs
+++ b/src/librustc/mir/interpret/allocation.rs
@@ -6,44 +6,13 @@
use crate::ty::layout::{Size, Align};
use syntax::ast::Mutability;
-use std::{iter, fmt::{self, Display}};
+use std::iter;
use crate::mir;
-use std::ops::{Deref, DerefMut};
+use std::ops::{Range, Deref, DerefMut};
use rustc_data_structures::sorted_map::SortedMap;
-use rustc_macros::HashStable;
use rustc_target::abi::HasDataLayout;
use std::borrow::Cow;
-/// Used by `check_bounds` to indicate whether the pointer needs to be just inbounds
-/// or also inbounds of a *live* allocation.
-#[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub enum InboundsCheck {
- Live,
- MaybeDead,
-}
-
-/// Used by `check_in_alloc` to indicate context of check
-#[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub enum CheckInAllocMsg {
- MemoryAccessTest,
- NullPointerTest,
- PointerArithmeticTest,
- InboundsTest,
-}
-
-impl Display for CheckInAllocMsg {
- /// When this is printed as an error the context looks like this
- /// "{test name} failed: pointer must be in-bounds at offset..."
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "{}", match *self {
- CheckInAllocMsg::MemoryAccessTest => "Memory access",
- CheckInAllocMsg::NullPointerTest => "Null pointer test",
- CheckInAllocMsg::PointerArithmeticTest => "Pointer arithmetic",
- CheckInAllocMsg::InboundsTest => "Inbounds test",
- })
- }
-}
-
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
pub struct Allocation<Tag=(),Extra=()> {
/// The actual bytes of the allocation.
@@ -146,37 +115,30 @@
impl<'tcx> ::serialize::UseSpecializedDecodable for &'tcx Allocation {}
-/// Alignment and bounds checks
-impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
- /// Checks if the pointer is "in-bounds". Notice that a pointer pointing at the end
- /// of an allocation (i.e., at the first *inaccessible* location) *is* considered
- /// in-bounds! This follows C's/LLVM's rules.
- /// If you want to check bounds before doing a memory access, better use `check_bounds`.
- fn check_bounds_ptr(
- &self,
- ptr: Pointer<Tag>,
- msg: CheckInAllocMsg,
- ) -> InterpResult<'tcx> {
- let allocation_size = self.bytes.len() as u64;
- ptr.check_in_alloc(Size::from_bytes(allocation_size), msg)
- }
-
- /// Checks if the memory range beginning at `ptr` and of size `Size` is "in-bounds".
- #[inline(always)]
- pub fn check_bounds(
- &self,
- cx: &impl HasDataLayout,
- ptr: Pointer<Tag>,
- size: Size,
- msg: CheckInAllocMsg,
- ) -> InterpResult<'tcx> {
- // if ptr.offset is in bounds, then so is ptr (because offset checks for overflow)
- self.check_bounds_ptr(ptr.offset(size, cx)?, msg)
- }
-}
-
/// Byte accessors
impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
+ /// Just a small local helper function to avoid a bit of code repetition.
+ /// Returns the range of this allocation that was meant.
+ #[inline]
+ fn check_bounds(
+ &self,
+ offset: Size,
+ size: Size
+ ) -> Range<usize> {
+ let end = offset + size; // this does overflow checking
+ assert_eq!(
+ end.bytes() as usize as u64, end.bytes(),
+ "cannot handle this access on this host architecture"
+ );
+ let end = end.bytes() as usize;
+ assert!(
+ end <= self.bytes.len(),
+ "Out-of-bounds access at offset {}, size {} in allocation of size {}",
+ offset.bytes(), size.bytes(), self.bytes.len()
+ );
+ (offset.bytes() as usize)..end
+ }
+
/// The last argument controls whether we error out when there are undefined
/// or pointer bytes. You should never call this, call `get_bytes` or
/// `get_bytes_with_undef_and_ptr` instead,
@@ -184,16 +146,17 @@
/// This function also guarantees that the resulting pointer will remain stable
/// even when new allocations are pushed to the `HashMap`. `copy_repeatedly` relies
/// on that.
+ ///
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
fn get_bytes_internal(
&self,
cx: &impl HasDataLayout,
ptr: Pointer<Tag>,
size: Size,
check_defined_and_ptr: bool,
- msg: CheckInAllocMsg,
) -> InterpResult<'tcx, &[u8]>
{
- self.check_bounds(cx, ptr, size, msg)?;
+ let range = self.check_bounds(ptr.offset, size);
if check_defined_and_ptr {
self.check_defined(ptr, size)?;
@@ -205,12 +168,13 @@
AllocationExtra::memory_read(self, ptr, size)?;
- assert_eq!(ptr.offset.bytes() as usize as u64, ptr.offset.bytes());
- assert_eq!(size.bytes() as usize as u64, size.bytes());
- let offset = ptr.offset.bytes() as usize;
- Ok(&self.bytes[offset..offset + size.bytes() as usize])
+ Ok(&self.bytes[range])
}
+ /// Check that these bytes are initialized and not pointer bytes, and then return them
+ /// as a slice.
+ ///
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
#[inline]
pub fn get_bytes(
&self,
@@ -219,11 +183,13 @@
size: Size,
) -> InterpResult<'tcx, &[u8]>
{
- self.get_bytes_internal(cx, ptr, size, true, CheckInAllocMsg::MemoryAccessTest)
+ self.get_bytes_internal(cx, ptr, size, true)
}
/// It is the caller's responsibility to handle undefined and pointer bytes.
/// However, this still checks that there are no relocations on the *edges*.
+ ///
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
#[inline]
pub fn get_bytes_with_undef_and_ptr(
&self,
@@ -232,11 +198,13 @@
size: Size,
) -> InterpResult<'tcx, &[u8]>
{
- self.get_bytes_internal(cx, ptr, size, false, CheckInAllocMsg::MemoryAccessTest)
+ self.get_bytes_internal(cx, ptr, size, false)
}
/// Just calling this already marks everything as defined and removes relocations,
/// so be sure to actually put data there!
+ ///
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
pub fn get_bytes_mut(
&mut self,
cx: &impl HasDataLayout,
@@ -244,18 +212,14 @@
size: Size,
) -> InterpResult<'tcx, &mut [u8]>
{
- assert_ne!(size.bytes(), 0, "0-sized accesses should never even get a `Pointer`");
- self.check_bounds(cx, ptr, size, CheckInAllocMsg::MemoryAccessTest)?;
+ let range = self.check_bounds(ptr.offset, size);
- self.mark_definedness(ptr, size, true)?;
+ self.mark_definedness(ptr, size, true);
self.clear_relocations(cx, ptr, size)?;
AllocationExtra::memory_written(self, ptr, size)?;
- assert_eq!(ptr.offset.bytes() as usize as u64, ptr.offset.bytes());
- assert_eq!(size.bytes() as usize as u64, size.bytes());
- let offset = ptr.offset.bytes() as usize;
- Ok(&mut self.bytes[offset..offset + size.bytes() as usize])
+ Ok(&mut self.bytes[range])
}
}
@@ -276,9 +240,10 @@
let size_with_null = Size::from_bytes((size + 1) as u64);
// Go through `get_bytes` for checks and AllocationExtra hooks.
// We read the null, so we include it in the request, but we want it removed
- // from the result!
+ // from the result, so we do subslicing.
Ok(&self.get_bytes(cx, ptr, size_with_null)?[..size])
}
+ // This includes the case where `offset` is out-of-bounds to begin with.
None => err!(UnterminatedCString(ptr.erase_tag())),
}
}
@@ -306,7 +271,7 @@
/// Writes `src` to the memory starting at `ptr.offset`.
///
- /// Will do bounds checks on the allocation.
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
pub fn write_bytes(
&mut self,
cx: &impl HasDataLayout,
@@ -320,6 +285,8 @@
}
/// Sets `count` bytes starting at `ptr.offset` with `val`. Basically `memset`.
+ ///
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
pub fn write_repeat(
&mut self,
cx: &impl HasDataLayout,
@@ -342,7 +309,7 @@
/// * in oder to obtain a `Pointer` we need to check for ZSTness anyway due to integer pointers
/// being valid for ZSTs
///
- /// Note: This function does not do *any* alignment checks, you need to do these before calling
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
pub fn read_scalar(
&self,
cx: &impl HasDataLayout,
@@ -378,7 +345,9 @@
Ok(ScalarMaybeUndef::Scalar(Scalar::from_uint(bits, size)))
}
- /// Note: This function does not do *any* alignment checks, you need to do these before calling
+ /// Read a pointer-sized scalar.
+ ///
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
pub fn read_ptr_sized(
&self,
cx: &impl HasDataLayout,
@@ -395,7 +364,7 @@
/// * in oder to obtain a `Pointer` we need to check for ZSTness anyway due to integer pointers
/// being valid for ZSTs
///
- /// Note: This function does not do *any* alignment checks, you need to do these before calling
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
pub fn write_scalar(
&mut self,
cx: &impl HasDataLayout,
@@ -406,7 +375,10 @@
{
let val = match val {
ScalarMaybeUndef::Scalar(scalar) => scalar,
- ScalarMaybeUndef::Undef => return self.mark_definedness(ptr, type_size, false),
+ ScalarMaybeUndef::Undef => {
+ self.mark_definedness(ptr, type_size, false);
+ return Ok(());
+ },
};
let bytes = match val.to_bits_or_ptr(type_size, cx) {
@@ -432,7 +404,9 @@
Ok(())
}
- /// Note: This function does not do *any* alignment checks, you need to do these before calling
+ /// Write a pointer-sized scalar.
+ ///
+ /// It is the caller's responsibility to check bounds and alignment beforehand.
pub fn write_ptr_sized(
&mut self,
cx: &impl HasDataLayout,
@@ -550,16 +524,15 @@
ptr: Pointer<Tag>,
size: Size,
new_state: bool,
- ) -> InterpResult<'tcx> {
+ ) {
if size.bytes() == 0 {
- return Ok(());
+ return;
}
self.undef_mask.set_range(
ptr.offset,
ptr.offset + size,
new_state,
);
- Ok(())
}
}
diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs
index a36c788..1b29425 100644
--- a/src/librustc/mir/interpret/mod.rs
+++ b/src/librustc/mir/interpret/mod.rs
@@ -17,12 +17,9 @@
pub use self::value::{Scalar, ScalarMaybeUndef, RawConst, ConstValue};
-pub use self::allocation::{
- InboundsCheck, Allocation, AllocationExtra,
- Relocations, UndefMask, CheckInAllocMsg,
-};
+pub use self::allocation::{Allocation, AllocationExtra, Relocations, UndefMask};
-pub use self::pointer::{Pointer, PointerArithmetic};
+pub use self::pointer::{Pointer, PointerArithmetic, CheckInAllocMsg};
use std::fmt;
use crate::mir;
diff --git a/src/librustc/mir/interpret/pointer.rs b/src/librustc/mir/interpret/pointer.rs
index 26002a4..a17bc1f 100644
--- a/src/librustc/mir/interpret/pointer.rs
+++ b/src/librustc/mir/interpret/pointer.rs
@@ -1,13 +1,35 @@
-use std::fmt;
+use std::fmt::{self, Display};
use crate::mir;
use crate::ty::layout::{self, HasDataLayout, Size};
use rustc_macros::HashStable;
use super::{
- AllocId, InterpResult, CheckInAllocMsg
+ AllocId, InterpResult,
};
+/// Used by `check_in_alloc` to indicate context of check
+#[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)]
+pub enum CheckInAllocMsg {
+ MemoryAccessTest,
+ NullPointerTest,
+ PointerArithmeticTest,
+ InboundsTest,
+}
+
+impl Display for CheckInAllocMsg {
+ /// When this is printed as an error the context looks like this
+ /// "{test name} failed: pointer must be in-bounds at offset..."
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}", match *self {
+ CheckInAllocMsg::MemoryAccessTest => "Memory access",
+ CheckInAllocMsg::NullPointerTest => "Null pointer test",
+ CheckInAllocMsg::PointerArithmeticTest => "Pointer arithmetic",
+ CheckInAllocMsg::InboundsTest => "Inbounds test",
+ })
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
// Pointer arithmetic
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs
index 40e8111..388c549 100644
--- a/src/librustc/mir/interpret/value.rs
+++ b/src/librustc/mir/interpret/value.rs
@@ -43,14 +43,21 @@
end: usize,
},
- /// An allocation together with a pointer into the allocation.
- /// Invariant: the pointer's `AllocId` resolves to the allocation.
- /// The alignment exists to allow `const_field` to have `ByRef` access to nonprimitive fields
- /// of `repr(packed)` structs. The alignment may be lower than the type of this constant.
- /// This permits reads with lower alignment than what the type would normally require.
- /// FIXME(RalfJ,oli-obk): The alignment checks are part of miri, but const eval doesn't really
- /// need them. Disabling them may be too hard though.
- ByRef(Pointer, Align, &'tcx Allocation),
+ /// A value not represented/representable by `Scalar` or `Slice`
+ ByRef {
+ /// The alignment exists to allow `const_field` to have `ByRef` access to nonprimitive
+ /// fields of `repr(packed)` structs. The alignment may be lower than the type of this
+ /// constant. This permits reads with lower alignment than what the type would normally
+ /// require.
+ /// FIXME(RalfJ,oli-obk): The alignment checks are part of miri, but const eval doesn't
+ /// really need them. Disabling them may be too hard though.
+ align: Align,
+ /// Offset into `alloc`
+ offset: Size,
+ /// The backing memory of the value, may contain more memory than needed for just the value
+ /// in order to share `Allocation`s between values
+ alloc: &'tcx Allocation,
+ },
/// Used in the HIR by using `Unevaluated` everywhere and later normalizing to one of the other
/// variants when the code is monomorphic enough for that.
@@ -67,7 +74,7 @@
ConstValue::Param(_) |
ConstValue::Infer(_) |
ConstValue::Placeholder(_) |
- ConstValue::ByRef(..) |
+ ConstValue::ByRef{ .. } |
ConstValue::Unevaluated(..) |
ConstValue::Slice { .. } => None,
ConstValue::Scalar(val) => Some(val),
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index 6e09cc0..9b1808c 100644
--- a/src/librustc/mir/mod.rs
+++ b/src/librustc/mir/mod.rs
@@ -2096,6 +2096,18 @@
}
}
+impl From<Local> for Place<'_> {
+ fn from(local: Local) -> Self {
+ Place::Base(local.into())
+ }
+}
+
+impl From<Local> for PlaceBase<'_> {
+ fn from(local: Local) -> Self {
+ PlaceBase::Local(local)
+ }
+}
+
/// A linked list of projections running up the stack; begins with the
/// innermost projection and extends to the outermost (e.g., `a.b.c`
/// would have the place `b` with a "next" pointer to `b.c`).
@@ -2573,7 +2585,7 @@
if let Some(upvars) = tcx.upvars(def_id) {
for (&var_id, place) in upvars.keys().zip(places) {
- let var_name = tcx.hir().name_by_hir_id(var_id);
+ let var_name = tcx.hir().name(var_id);
struct_fmt.field(&var_name.as_str(), place);
}
}
@@ -2592,7 +2604,7 @@
if let Some(upvars) = tcx.upvars(def_id) {
for (&var_id, place) in upvars.keys().zip(places) {
- let var_name = tcx.hir().name_by_hir_id(var_id);
+ let var_name = tcx.hir().name(var_id);
struct_fmt.field(&var_name.as_str(), place);
}
}
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
index fc09248..895f9c6 100644
--- a/src/librustc/session/config.rs
+++ b/src/librustc/session/config.rs
@@ -330,14 +330,6 @@
bug!("Duplicate key in CLI DepTrackingHash: {}", stringify!($opt_name))
}
});
- ($opt_name:ident,
- $opt_expr:expr,
- $sub_hashes:expr,
- [UNTRACKED_WITH_WARNING $warn_val:expr, $warn_text:expr, $error_format:expr]) => ({
- if *$opt_expr == $warn_val {
- early_warn($error_format, $warn_text)
- }
- });
}
macro_rules! top_level_options {
@@ -383,10 +375,6 @@
// [UNTRACKED]
// Incremental compilation is not influenced by this option.
//
-// [UNTRACKED_WITH_WARNING(val, warning)]
-// The option is incompatible with incremental compilation in some way. If it
-// has the value `val`, the string `warning` is emitted as a warning.
-//
// If you add a new option to this struct or one of the sub-structs like
// CodegenOptions, think about how it influences incremental compilation. If in
// doubt, specify [TRACKED], which is always "correct" but might lead to
@@ -1163,9 +1151,7 @@
"a list of extra LLVM passes to run (space separated)"),
llvm_args: Vec<String> = (Vec::new(), parse_list, [TRACKED],
"a list of arguments to pass to llvm (space separated)"),
- save_temps: bool = (false, parse_bool, [UNTRACKED_WITH_WARNING(true,
- "`-C save-temps` might not produce all requested temporary products \
- when incremental compilation is enabled.")],
+ save_temps: bool = (false, parse_bool, [UNTRACKED],
"save all temporary output files during compilation"),
rpath: bool = (false, parse_bool, [UNTRACKED],
"set rpath values in libs/exes"),
@@ -1241,9 +1227,7 @@
"measure time of each rustc pass"),
time: bool = (false, parse_bool, [UNTRACKED],
"measure time of rustc processes"),
- time_llvm_passes: bool = (false, parse_bool, [UNTRACKED_WITH_WARNING(true,
- "The output of `-Z time-llvm-passes` will only reflect timings of \
- re-codegened modules when used with incremental compilation" )],
+ time_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
"measure time of each LLVM pass"),
input_stats: bool = (false, parse_bool, [UNTRACKED],
"gather statistics about the input"),
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index d04b9ac..bb4ef2d 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -320,8 +320,13 @@
self.diagnostic().abort_if_errors();
}
pub fn compile_status(&self) -> Result<(), ErrorReported> {
- compile_result_from_err_count(self.err_count())
+ if self.has_errors() {
+ Err(ErrorReported)
+ } else {
+ Ok(())
+ }
}
+ // FIXME(matthewjasper) Remove this method, it should never be needed.
pub fn track_errors<F, T>(&self, f: F) -> Result<T, ErrorReported>
where
F: FnOnce() -> T,
@@ -1388,11 +1393,3 @@
}
pub type CompileResult = Result<(), ErrorReported>;
-
-pub fn compile_result_from_err_count(err_count: usize) -> CompileResult {
- if err_count == 0 {
- Ok(())
- } else {
- Err(ErrorReported)
- }
-}
diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
index 2555833..f54575f 100644
--- a/src/librustc/traits/error_reporting.rs
+++ b/src/librustc/traits/error_reporting.rs
@@ -937,8 +937,8 @@
code: &ObligationCauseCode<'tcx>,
err: &mut DiagnosticBuilder<'tcx>,
) {
- if let &ObligationCauseCode::VariableType(node_id) = code {
- let parent_node = self.tcx.hir().get_parent_node(node_id);
+ if let &ObligationCauseCode::VariableType(hir_id) = code {
+ let parent_node = self.tcx.hir().get_parent_node(hir_id);
if let Some(Node::Local(ref local)) = self.tcx.hir().find(parent_node) {
if let Some(ref expr) = local.init {
if let hir::ExprKind::Index(_, _) = expr.node {
@@ -1013,8 +1013,8 @@
trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
) {
let hir = self.tcx.hir();
- let parent_node = hir.get_parent_node_by_hir_id(obligation.cause.body_id);
- let node = hir.find_by_hir_id(parent_node);
+ let parent_node = hir.get_parent_node(obligation.cause.body_id);
+ let node = hir.find(parent_node);
if let Some(hir::Node::Item(hir::Item {
node: hir::ItemKind::Fn(decl, _, _, body_id),
..
diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs
index f5c91a7..8d17df1 100644
--- a/src/librustc/traits/mod.rs
+++ b/src/librustc/traits/mod.rs
@@ -188,7 +188,7 @@
/// S { ... } must be Sized
StructInitializerSized,
/// Type of each variable must be Sized
- VariableType(ast::NodeId),
+ VariableType(hir::HirId),
/// Argument type must be Sized
SizedArgumentType,
/// Return type must be Sized
diff --git a/src/librustc/ty/constness.rs b/src/librustc/ty/constness.rs
index 65b8322..e4022bb 100644
--- a/src/librustc/ty/constness.rs
+++ b/src/librustc/ty/constness.rs
@@ -67,13 +67,13 @@
}
-pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {
+pub fn provide(providers: &mut Providers<'_>) {
/// only checks whether the function has a `const` modifier
- fn is_const_fn_raw<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
+ fn is_const_fn_raw(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
let hir_id = tcx.hir().as_local_hir_id(def_id)
.expect("Non-local call to local provider is_const_fn");
- let node = tcx.hir().get_by_hir_id(hir_id);
+ let node = tcx.hir().get(hir_id);
if let Some(fn_like) = FnLikeNode::from_node(node) {
fn_like.constness() == hir::Constness::Const
} else if let hir::Node::Ctor(_) = node {
@@ -83,7 +83,7 @@
}
}
- fn is_promotable_const_fn<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
+ fn is_promotable_const_fn(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
tcx.is_const_fn(def_id) && match tcx.lookup_stability(def_id) {
Some(stab) => {
if cfg!(debug_assertions) && stab.promotable {
@@ -101,7 +101,7 @@
}
}
- fn const_fn_is_allowed_fn_ptr<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
+ fn const_fn_is_allowed_fn_ptr(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
tcx.is_const_fn(def_id) &&
tcx.lookup_stability(def_id)
.map(|stab| stab.allow_const_fn_ptr).unwrap_or(false)
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index b84ebd8..4710d61 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -231,7 +231,7 @@
pub err: &'tcx Const<'tcx>,
}
-pub struct LocalTableInContext<'a, V: 'a> {
+pub struct LocalTableInContext<'a, V> {
local_id_root: Option<DefId>,
data: &'a ItemLocalMap<V>
}
@@ -294,7 +294,7 @@
}
}
-pub struct LocalTableInContextMut<'a, V: 'a> {
+pub struct LocalTableInContextMut<'a, V> {
local_id_root: Option<DefId>,
data: &'a mut ItemLocalMap<V>
}
@@ -1589,7 +1589,7 @@
let hir_id = self.hir()
.as_local_hir_id(suitable_region_binding_scope)
.unwrap();
- let is_impl_item = match self.hir().find_by_hir_id(hir_id) {
+ let is_impl_item = match self.hir().find(hir_id) {
Some(Node::Item(..)) | Some(Node::TraitItem(..)) => false,
Some(Node::ImplItem(..)) => {
self.is_bound_region_in_impl_item(suitable_region_binding_scope)
@@ -1610,7 +1610,7 @@
) -> Option<Ty<'tcx>> {
// HACK: `type_of_def_id()` will fail on these (#55796), so return None
let hir_id = self.hir().as_local_hir_id(scope_def_id).unwrap();
- match self.hir().get_by_hir_id(hir_id) {
+ match self.hir().get(hir_id) {
Node::Item(item) => {
match item.node {
ItemKind::Fn(..) => { /* type_of_def_id() will work */ }
@@ -2171,7 +2171,7 @@
/// An entry in an interner.
-struct Interned<'tcx, T: 'tcx+?Sized>(&'tcx T);
+struct Interned<'tcx, T: ?Sized>(&'tcx T);
impl<'tcx, T: 'tcx+?Sized> Clone for Interned<'tcx, T> {
fn clone(&self) -> Self {
@@ -2223,7 +2223,7 @@
}
impl<'tcx> Borrow<[CanonicalVarInfo]> for Interned<'tcx, List<CanonicalVarInfo>> {
- fn borrow<'a>(&'a self) -> &'a [CanonicalVarInfo] {
+ fn borrow(&self) -> &[CanonicalVarInfo] {
&self.0[..]
}
}
@@ -2236,13 +2236,13 @@
impl<'tcx> Borrow<[ProjectionKind]>
for Interned<'tcx, List<ProjectionKind>> {
- fn borrow<'a>(&'a self) -> &'a [ProjectionKind] {
+ fn borrow(&self) -> &[ProjectionKind] {
&self.0[..]
}
}
impl<'tcx> Borrow<RegionKind> for Interned<'tcx, RegionKind> {
- fn borrow<'a>(&'a self) -> &'a RegionKind {
+ fn borrow(&self) -> &RegionKind {
&self.0
}
}
@@ -2880,7 +2880,7 @@
if lint::maybe_lint_level_root(self, id) {
return id;
}
- let next = self.hir().get_parent_node_by_hir_id(id);
+ let next = self.hir().get_parent_node(id);
if next == id {
bug!("lint traversal reached the root of the crate");
}
@@ -2898,7 +2898,7 @@
if let Some(pair) = sets.level_and_source(lint, id, self.sess) {
return pair
}
- let next = self.hir().get_parent_node_by_hir_id(id);
+ let next = self.hir().get_parent_node(id);
if next == id {
bug!("lint traversal reached the root of the crate");
}
diff --git a/src/librustc/ty/fast_reject.rs b/src/librustc/ty/fast_reject.rs
index 7aab1ae..ee0d33d 100644
--- a/src/librustc/ty/fast_reject.rs
+++ b/src/librustc/ty/fast_reject.rs
@@ -55,8 +55,8 @@
/// then we can't say much about whether two types would unify. Put another way,
/// `can_simplify_params` should be true if type parameters appear free in `ty` and `false` if they
/// are to be considered bound.
-pub fn simplify_type<'tcx>(
- tcx: TyCtxt<'tcx>,
+pub fn simplify_type(
+ tcx: TyCtxt<'_>,
ty: Ty<'_>,
can_simplify_params: bool,
) -> Option<SimplifiedType> {
diff --git a/src/librustc/ty/inhabitedness/def_id_forest.rs b/src/librustc/ty/inhabitedness/def_id_forest.rs
index b22bd21..af8dedf 100644
--- a/src/librustc/ty/inhabitedness/def_id_forest.rs
+++ b/src/librustc/ty/inhabitedness/def_id_forest.rs
@@ -1,6 +1,6 @@
use std::mem;
use smallvec::SmallVec;
-use syntax::ast::CRATE_NODE_ID;
+use rustc::hir::CRATE_HIR_ID;
use crate::ty::context::TyCtxt;
use crate::ty::{DefId, DefIdTree};
@@ -33,7 +33,7 @@
/// crate.
#[inline]
pub fn full(tcx: TyCtxt<'tcx>) -> DefIdForest {
- let crate_id = tcx.hir().local_def_id(CRATE_NODE_ID);
+ let crate_id = tcx.hir().local_def_id_from_hir_id(CRATE_HIR_ID);
DefIdForest::from_id(crate_id)
}
diff --git a/src/librustc/ty/inhabitedness/mod.rs b/src/librustc/ty/inhabitedness/mod.rs
index 5ce7508..0d96e5e 100644
--- a/src/librustc/ty/inhabitedness/mod.rs
+++ b/src/librustc/ty/inhabitedness/mod.rs
@@ -97,7 +97,7 @@
self.ty_inhabitedness_forest(ty).contains(self, module)
}
- pub fn is_ty_uninhabited_from_all_modules(self, ty: Ty<'tcx>) -> bool {
+ pub fn is_ty_uninhabited_from_any_module(self, ty: Ty<'tcx>) -> bool {
!self.ty_inhabitedness_forest(ty).is_empty()
}
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 3614103..ad98807 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -213,7 +213,7 @@
}
}
- pub fn signature<'tcx>(&self, tcx: TyCtxt<'tcx>) -> String {
+ pub fn signature(&self, tcx: TyCtxt<'_>) -> String {
match self.kind {
ty::AssocKind::Method => {
// We skip the binder here because the binder would deanonymize all
@@ -2311,7 +2311,7 @@
/// Returns an iterator over all fields contained
/// by this ADT.
#[inline]
- pub fn all_fields<'s>(&'s self) -> impl Iterator<Item = &'s FieldDef> + Clone {
+ pub fn all_fields(&self) -> impl Iterator<Item=&FieldDef> + Clone {
self.variants.iter().flat_map(|v| v.fields.iter())
}
@@ -2777,20 +2777,6 @@
});
}
- pub fn expr_span(self, id: NodeId) -> Span {
- match self.hir().find(id) {
- Some(Node::Expr(e)) => {
- e.span
- }
- Some(f) => {
- bug!("node-ID {} is not an expr: {:?}", id, f);
- }
- None => {
- bug!("node-ID {} is not present in the node map", id);
- }
- }
- }
-
pub fn provided_trait_methods(self, id: DefId) -> Vec<AssocItem> {
self.associated_items(id)
.filter(|item| item.kind == AssocKind::Method && item.defaultness.has_value())
@@ -2805,7 +2791,7 @@
pub fn opt_associated_item(self, def_id: DefId) -> Option<AssocItem> {
let is_associated_item = if let Some(hir_id) = self.hir().as_local_hir_id(def_id) {
- match self.hir().get_by_hir_id(hir_id) {
+ match self.hir().get(hir_id) {
Node::TraitItem(_) | Node::ImplItem(_) => true,
_ => false,
}
@@ -3125,7 +3111,7 @@
}
}
-fn associated_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> AssocItem {
+fn associated_item(tcx: TyCtxt<'_>, def_id: DefId) -> AssocItem {
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
let parent_id = tcx.hir().get_parent_item(id);
let parent_def_id = tcx.hir().local_def_id_from_hir_id(parent_id);
@@ -3170,7 +3156,7 @@
/// such.
/// - a Error, if a type contained itself. The representability
/// check should catch this case.
-fn adt_sized_constraint<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> AdtSizedConstraint<'tcx> {
+fn adt_sized_constraint(tcx: TyCtxt<'_>, def_id: DefId) -> AdtSizedConstraint<'_> {
let def = tcx.adt_def(def_id);
let result = tcx.mk_type_list(def.variants.iter().flat_map(|v| {
@@ -3184,7 +3170,7 @@
AdtSizedConstraint(result)
}
-fn associated_item_def_ids<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx [DefId] {
+fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: DefId) -> &[DefId] {
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
let item = tcx.hir().expect_item(id);
match item.node {
@@ -3207,14 +3193,14 @@
}
}
-fn def_span<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Span {
+fn def_span(tcx: TyCtxt<'_>, def_id: DefId) -> Span {
tcx.hir().span_if_local(def_id).unwrap()
}
/// If the given `DefId` describes an item belonging to a trait,
/// returns the `DefId` of the trait that the trait item belongs to;
/// otherwise, returns `None`.
-fn trait_of_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option<DefId> {
+fn trait_of_item(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
tcx.opt_associated_item(def_id)
.and_then(|associated_item| {
match associated_item.container {
@@ -3227,7 +3213,7 @@
/// Yields the parent function's `DefId` if `def_id` is an `impl Trait` definition.
pub fn is_impl_trait_defn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
- if let Node::Item(item) = tcx.hir().get_by_hir_id(hir_id) {
+ if let Node::Item(item) = tcx.hir().get(hir_id) {
if let hir::ItemKind::Existential(ref exist_ty) = item.node {
return exist_ty.impl_trait_fn;
}
@@ -3237,7 +3223,7 @@
}
/// See `ParamEnv` struct definition for details.
-fn param_env<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> ParamEnv<'tcx> {
+fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ParamEnv<'_> {
// The param_env of an impl Trait type is its defining function's param_env
if let Some(parent) = is_impl_trait_defn(tcx, def_id) {
return param_env(tcx, parent);
@@ -3272,17 +3258,17 @@
traits::normalize_param_env_or_error(tcx, def_id, unnormalized_env, cause)
}
-fn crate_disambiguator<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> CrateDisambiguator {
+fn crate_disambiguator(tcx: TyCtxt<'_>, crate_num: CrateNum) -> CrateDisambiguator {
assert_eq!(crate_num, LOCAL_CRATE);
tcx.sess.local_crate_disambiguator()
}
-fn original_crate_name<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> Symbol {
+fn original_crate_name(tcx: TyCtxt<'_>, crate_num: CrateNum) -> Symbol {
assert_eq!(crate_num, LOCAL_CRATE);
tcx.crate_name.clone()
}
-fn crate_hash<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> Svh {
+fn crate_hash(tcx: TyCtxt<'_>, crate_num: CrateNum) -> Svh {
assert_eq!(crate_num, LOCAL_CRATE);
tcx.hir().crate_hash
}
@@ -3302,7 +3288,7 @@
/// If `def_id` is an issue 33140 hack impl, returns its self type; otherwise, returns `None`.
///
/// See [`ImplOverlapKind::Issue33140`] for more details.
-fn issue33140_self_ty<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option<Ty<'tcx>> {
+fn issue33140_self_ty(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Ty<'_>> {
debug!("issue33140_self_ty({:?})", def_id);
let trait_ref = tcx.impl_trait_ref(def_id).unwrap_or_else(|| {
diff --git a/src/librustc/ty/print/obsolete.rs b/src/librustc/ty/print/obsolete.rs
index 16fb334..c12402a 100644
--- a/src/librustc/ty/print/obsolete.rs
+++ b/src/librustc/ty/print/obsolete.rs
@@ -186,7 +186,7 @@
// as well as the unprintable types of constants (see `push_type_name` for more details).
pub fn push_const_name(&self, c: &Const<'tcx>, output: &mut String, debug: bool) {
match c.val {
- ConstValue::Scalar(..) | ConstValue::Slice { .. } | ConstValue::ByRef(..) => {
+ ConstValue::Scalar(..) | ConstValue::Slice { .. } | ConstValue::ByRef { .. } => {
// FIXME(const_generics): we could probably do a better job here.
write!(output, "{:?}", c).unwrap()
}
diff --git a/src/librustc/ty/print/pretty.rs b/src/librustc/ty/print/pretty.rs
index d143cc3..cb0ac0f 100644
--- a/src/librustc/ty/print/pretty.rs
+++ b/src/librustc/ty/print/pretty.rs
@@ -600,7 +600,7 @@
p!(
write("{}{}:",
sep,
- self.tcx().hir().name_by_hir_id(var_id)),
+ self.tcx().hir().name(var_id)),
print(upvar_ty));
sep = ", ";
}
@@ -643,7 +643,7 @@
p!(
write("{}{}:",
sep,
- self.tcx().hir().name_by_hir_id(var_id)),
+ self.tcx().hir().name(var_id)),
print(upvar_ty));
sep = ", ";
}
diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs
index 0f158d2..7d5f984 100644
--- a/src/librustc/ty/query/plumbing.rs
+++ b/src/librustc/ty/query/plumbing.rs
@@ -89,7 +89,7 @@
/// A type representing the responsibility to execute the job in the `job` field.
/// This will poison the relevant query if dropped.
-pub(super) struct JobOwner<'a, 'tcx, Q: QueryDescription<'tcx> + 'a> {
+pub(super) struct JobOwner<'a, 'tcx, Q: QueryDescription<'tcx>> {
cache: &'a Lock<QueryCache<'tcx, Q>>,
key: Q::Key,
job: Lrc<QueryJob<'tcx>>,
@@ -230,7 +230,7 @@
}
/// The result of `try_get_lock`
-pub(super) enum TryGetJob<'a, 'tcx, D: QueryDescription<'tcx> + 'a> {
+pub(super) enum TryGetJob<'a, 'tcx, D: QueryDescription<'tcx>> {
/// The query is not yet started. Contains a guard to the cache eventually used to start it.
NotYetStarted(JobOwner<'a, 'tcx, D>),
diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs
index 98fd5d1..46adb7e 100644
--- a/src/librustc/ty/relate.rs
+++ b/src/librustc/ty/relate.rs
@@ -594,7 +594,7 @@
ty: a.ty,
}))
}
- (ConstValue::ByRef(..), _) => {
+ (ConstValue::ByRef { .. }, _) => {
bug!(
"non-Scalar ConstValue encountered in super_relate_consts {:?} {:?}",
a,
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
index 4cd0fd3..3d81705 100644
--- a/src/librustc/ty/structural_impls.rs
+++ b/src/librustc/ty/structural_impls.rs
@@ -62,7 +62,7 @@
impl fmt::Debug for ty::UpvarId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = ty::tls::with(|tcx| {
- tcx.hir().name_by_hir_id(self.var_path.hir_id)
+ tcx.hir().name(self.var_path.hir_id)
});
write!(f, "UpvarId({:?};`{}`;{:?})",
self.var_path.hir_id,
@@ -1335,7 +1335,8 @@
impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {
fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
match *self {
- ConstValue::ByRef(ptr, align, alloc) => ConstValue::ByRef(ptr, align, alloc),
+ ConstValue::ByRef { offset, align, alloc } =>
+ ConstValue::ByRef { offset, align, alloc },
ConstValue::Infer(ic) => ConstValue::Infer(ic.fold_with(folder)),
ConstValue::Param(p) => ConstValue::Param(p.fold_with(folder)),
ConstValue::Placeholder(p) => ConstValue::Placeholder(p),
@@ -1348,7 +1349,7 @@
fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
match *self {
- ConstValue::ByRef(..) => false,
+ ConstValue::ByRef { .. } => false,
ConstValue::Infer(ic) => ic.visit_with(visitor),
ConstValue::Param(p) => p.visit_with(visitor),
ConstValue::Placeholder(_) => false,
diff --git a/src/librustc/ty/trait_def.rs b/src/librustc/ty/trait_def.rs
index c40d4d5..a7ade87 100644
--- a/src/librustc/ty/trait_def.rs
+++ b/src/librustc/ty/trait_def.rs
@@ -150,10 +150,10 @@
}
// Query provider for `trait_impls_of`.
-pub(super) fn trait_impls_of_provider<'tcx>(
- tcx: TyCtxt<'tcx>,
+pub(super) fn trait_impls_of_provider(
+ tcx: TyCtxt<'_>,
trait_id: DefId,
-) -> &'tcx TraitImpls {
+) -> &TraitImpls {
let mut impls = TraitImpls::default();
{
diff --git a/src/librustc/ty/walk.rs b/src/librustc/ty/walk.rs
index 234407a..c74511c 100644
--- a/src/librustc/ty/walk.rs
+++ b/src/librustc/ty/walk.rs
@@ -56,7 +56,7 @@
}
}
-pub fn walk_shallow<'tcx>(ty: Ty<'tcx>) -> smallvec::IntoIter<TypeWalkerArray<'tcx>> {
+pub fn walk_shallow(ty: Ty<'_>) -> smallvec::IntoIter<TypeWalkerArray<'_>> {
let mut stack = SmallVec::new();
push_subtypes(&mut stack, ty);
stack.into_iter()
diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs
index ace4442..714b7c2 100644
--- a/src/librustc_borrowck/borrowck/check_loans.rs
+++ b/src/librustc_borrowck/borrowck/check_loans.rs
@@ -191,7 +191,7 @@
let def_id = bccx.tcx.hir().body_owner_def_id(body.id());
let hir_id = bccx.tcx.hir().as_local_hir_id(def_id).unwrap();
- let movable_generator = !match bccx.tcx.hir().get_by_hir_id(hir_id) {
+ let movable_generator = !match bccx.tcx.hir().get(hir_id) {
Node::Expr(&hir::Expr {
node: hir::ExprKind::Closure(.., Some(hir::GeneratorMovability::Static)),
..
diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs
index 05c0a22..658e430 100644
--- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs
+++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs
@@ -47,9 +47,9 @@
/// with a reference to the let
fn get_pattern_source<'tcx>(tcx: TyCtxt<'tcx>, pat: &Pat) -> PatternSource<'tcx> {
- let parent = tcx.hir().get_parent_node_by_hir_id(pat.hir_id);
+ let parent = tcx.hir().get_parent_node(pat.hir_id);
- match tcx.hir().get_by_hir_id(parent) {
+ match tcx.hir().get(parent) {
Node::Expr(ref e) => {
// the enclosing expression must be a `match` or something else
assert!(match e.node {
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
index 025d5ad..3c7f19f 100644
--- a/src/librustc_borrowck/borrowck/mod.rs
+++ b/src/librustc_borrowck/borrowck/mod.rs
@@ -80,7 +80,7 @@
let owner_id = tcx.hir().as_local_hir_id(owner_def_id).unwrap();
- match tcx.hir().get_by_hir_id(owner_id) {
+ match tcx.hir().get(owner_id) {
Node::Ctor(..) => {
// We get invoked with anything that has MIR, but some of
// those things (notably the synthesized constructors from
@@ -390,7 +390,7 @@
fn closure_to_block(closure_id: LocalDefId, tcx: TyCtxt<'_>) -> HirId {
let closure_id = tcx.hir().local_def_id_to_hir_id(closure_id);
- match tcx.hir().get_by_hir_id(closure_id) {
+ match tcx.hir().get(closure_id) {
Node::Expr(expr) => match expr.node {
hir::ExprKind::Closure(.., body_id, _, _) => {
body_id.hir_id
@@ -702,7 +702,7 @@
move_data::MovePat => (self.tcx.hir().span(hir_id), ""),
move_data::Captured =>
- (match self.tcx.hir().expect_expr_by_hir_id(hir_id).node {
+ (match self.tcx.hir().expect_expr(hir_id).node {
hir::ExprKind::Closure(.., fn_decl_span, _) => fn_decl_span,
ref r => bug!("Captured({:?}) maps to non-closure: {:?}",
the_move.id, r),
@@ -896,7 +896,7 @@
// to implement two traits for "one operator" is not very intuitive for
// many programmers.
if err.cmt.note == mc::NoteIndex {
- let node = self.tcx.hir().get_by_hir_id(err.cmt.hir_id);
+ let node = self.tcx.hir().get(err.cmt.hir_id);
// This pattern probably always matches.
if let Node::Expr(
@@ -1022,7 +1022,7 @@
if let ty::ReScope(scope) = *super_scope {
let hir_id = scope.hir_id(&self.region_scope_tree);
- match self.tcx.hir().find_by_hir_id(hir_id) {
+ match self.tcx.hir().find(hir_id) {
Some(Node::Stmt(_)) => {
if *sub_scope != ty::ReStatic {
db.note("consider using a `let` binding to increase its lifetime");
@@ -1172,7 +1172,7 @@
}
fn local_binding_mode(&self, hir_id: hir::HirId) -> ty::BindingMode {
- let pat = match self.tcx.hir().get_by_hir_id(hir_id) {
+ let pat = match self.tcx.hir().get(hir_id) {
Node::Binding(pat) => pat,
node => bug!("bad node for local: {:?}", node)
};
@@ -1189,8 +1189,8 @@
}
fn local_ty(&self, hir_id: hir::HirId) -> (Option<&hir::Ty>, bool) {
- let parent = self.tcx.hir().get_parent_node_by_hir_id(hir_id);
- let parent_node = self.tcx.hir().get_by_hir_id(parent);
+ let parent = self.tcx.hir().get_parent_node(hir_id);
+ let parent_node = self.tcx.hir().get(parent);
// The parent node is like a fn
if let Some(fn_like) = FnLikeNode::from_node(parent_node) {
@@ -1255,7 +1255,7 @@
None => return
};
- if let Node::Field(ref field) = self.tcx.hir().get_by_hir_id(hir_id) {
+ if let Node::Field(ref field) = self.tcx.hir().get(hir_id) {
if let Some(msg) = self.suggest_mut_for_immutable(&field.ty, false) {
db.span_label(field.ty.span, msg);
}
@@ -1287,7 +1287,7 @@
},
)) = ty.map(|t| &t.node)
{
- let borrow_expr_id = self.tcx.hir().get_parent_node_by_hir_id(borrowed_hir_id);
+ let borrow_expr_id = self.tcx.hir().get_parent_node(borrowed_hir_id);
db.span_suggestion(
self.tcx.hir().span(borrow_expr_id),
"consider removing the `&mut`, as it is an \
@@ -1394,10 +1394,10 @@
out: &mut String) {
match loan_path.kind {
LpUpvar(ty::UpvarId { var_path: ty::UpvarPath { hir_id: id }, closure_expr_id: _ }) => {
- out.push_str(&self.tcx.hir().name_by_hir_id(id).as_str());
+ out.push_str(&self.tcx.hir().name(id).as_str());
}
LpVar(id) => {
- out.push_str(&self.tcx.hir().name_by_hir_id(id).as_str());
+ out.push_str(&self.tcx.hir().name(id).as_str());
}
LpDowncast(ref lp_base, variant_def_id) => {
diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs
index e06b4d8..0709368 100644
--- a/src/librustc_codegen_llvm/builder.rs
+++ b/src/librustc_codegen_llvm/builder.rs
@@ -110,7 +110,7 @@
unsafe {
llvm::$llvm_capi(self.llbuilder, $($arg,)* UNNAMED)
}
- })*
+ })+
}
}
diff --git a/src/librustc_codegen_llvm/consts.rs b/src/librustc_codegen_llvm/consts.rs
index 4bf91bb..e02d14a 100644
--- a/src/librustc_codegen_llvm/consts.rs
+++ b/src/librustc_codegen_llvm/consts.rs
@@ -71,7 +71,9 @@
let static_ = cx.tcx.const_eval(param_env.and(cid))?;
let alloc = match static_.val {
- ConstValue::ByRef(ptr, align, alloc) if ptr.offset.bytes() == 0 && align == alloc.align => {
+ ConstValue::ByRef {
+ offset, align, alloc,
+ } if offset.bytes() == 0 && align == alloc.align => {
alloc
},
_ => bug!("static const eval returned {:#?}", static_),
@@ -208,7 +210,7 @@
let g = if let Some(id) = self.tcx.hir().as_local_hir_id(def_id) {
let llty = self.layout_of(ty).llvm_type(self);
- let (g, attrs) = match self.tcx.hir().get_by_hir_id(id) {
+ let (g, attrs) = match self.tcx.hir().get(id) {
Node::Item(&hir::Item {
ref attrs, span, node: hir::ItemKind::Static(..), ..
}) => {
diff --git a/src/librustc_codegen_llvm/lib.rs b/src/librustc_codegen_llvm/lib.rs
index 1eb6e9a..7283aa9 100644
--- a/src/librustc_codegen_llvm/lib.rs
+++ b/src/librustc_codegen_llvm/lib.rs
@@ -24,7 +24,6 @@
#![deny(rust_2018_idioms)]
#![deny(internal)]
#![deny(unused_lifetimes)]
-#![allow(explicit_outlives_requirements)]
use back::write::{create_target_machine, create_informational_target_machine};
use syntax_pos::symbol::Symbol;
diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs
index aeff73c7..b9ee82f 100644
--- a/src/librustc_codegen_ssa/back/symbol_export.rs
+++ b/src/librustc_codegen_ssa/back/symbol_export.rs
@@ -82,7 +82,7 @@
//
// As a result, if this id is an FFI item (foreign item) then we only
// let it through if it's included statically.
- match tcx.hir().get_by_hir_id(hir_id) {
+ match tcx.hir().get(hir_id) {
Node::ForeignItem(..) => {
let def_id = tcx.hir().local_def_id_from_hir_id(hir_id);
if tcx.is_statically_included_foreign_item(def_id) {
diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs
index 71393e2..b76f098 100644
--- a/src/librustc_codegen_ssa/lib.rs
+++ b/src/librustc_codegen_ssa/lib.rs
@@ -15,7 +15,6 @@
#![deny(rust_2018_idioms)]
#![deny(internal)]
#![deny(unused_lifetimes)]
-#![allow(explicit_outlives_requirements)]
#![recursion_limit="256"]
diff --git a/src/librustc_codegen_ssa/mir/operand.rs b/src/librustc_codegen_ssa/mir/operand.rs
index c1626d3..4a6752f 100644
--- a/src/librustc_codegen_ssa/mir/operand.rs
+++ b/src/librustc_codegen_ssa/mir/operand.rs
@@ -109,8 +109,8 @@
let b_llval = bx.const_usize((end - start) as u64);
OperandValue::Pair(a_llval, b_llval)
},
- ConstValue::ByRef(ptr, align, alloc) => {
- return bx.load_operand(bx.from_const_alloc(layout, align, alloc, ptr.offset));
+ ConstValue::ByRef { offset, align, alloc } => {
+ return bx.load_operand(bx.from_const_alloc(layout, align, alloc, offset));
},
};
diff --git a/src/librustc_codegen_ssa/mir/place.rs b/src/librustc_codegen_ssa/mir/place.rs
index 72aedb4..be5d7b0 100644
--- a/src/librustc_codegen_ssa/mir/place.rs
+++ b/src/librustc_codegen_ssa/mir/place.rs
@@ -424,8 +424,8 @@
let layout = cx.layout_of(self.monomorphize(&ty));
match bx.tcx().const_eval(param_env.and(cid)) {
Ok(val) => match val.val {
- mir::interpret::ConstValue::ByRef(ptr, align, alloc) => {
- bx.cx().from_const_alloc(layout, align, alloc, ptr.offset)
+ mir::interpret::ConstValue::ByRef { offset, align, alloc } => {
+ bx.cx().from_const_alloc(layout, align, alloc, offset)
}
_ => bug!("promoteds should have an allocation: {:?}", val),
},
@@ -470,7 +470,7 @@
}
mir::ProjectionElem::Index(index) => {
let index = &mir::Operand::Copy(
- mir::Place::Base(mir::PlaceBase::Local(index))
+ mir::Place::from(index)
);
let index = self.codegen_operand(bx, index);
let llindex = index.immediate();
diff --git a/src/librustc_codegen_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs
index ba74f79..7ccd024 100644
--- a/src/librustc_codegen_utils/symbol_names.rs
+++ b/src/librustc_codegen_utils/symbol_names.rs
@@ -135,7 +135,7 @@
// FIXME(eddyb) Precompute a custom symbol name based on attributes.
let is_foreign = if let Some(id) = hir_id {
- match tcx.hir().get_by_hir_id(id) {
+ match tcx.hir().get(id) {
Node::ForeignItem(_) => true,
_ => false,
}
diff --git a/src/librustc_data_structures/bit_set.rs b/src/librustc_data_structures/bit_set.rs
index 7a11ca0..5d8388d 100644
--- a/src/librustc_data_structures/bit_set.rs
+++ b/src/librustc_data_structures/bit_set.rs
@@ -5,6 +5,10 @@
use std::marker::PhantomData;
use std::mem;
use std::slice;
+#[cfg(test)]
+extern crate test;
+#[cfg(test)]
+use test::Bencher;
pub type Word = u64;
pub const WORD_BYTES: usize = mem::size_of::<Word>();
@@ -177,6 +181,45 @@
// Note: we currently don't bother trying to make a Sparse set.
HybridBitSet::Dense(self.to_owned())
}
+
+ /// Set `self = self | other`. In contrast to `union` returns `true` if the set contains at
+ /// least one bit that is not in `other` (i.e. `other` is not a superset of `self`).
+ ///
+ /// This is an optimization for union of a hybrid bitset.
+ fn reverse_union_sparse(&mut self, sparse: &SparseBitSet<T>) -> bool {
+ assert!(sparse.domain_size == self.domain_size);
+ self.clear_excess_bits();
+
+ let mut not_already = false;
+ // Index of the current word not yet merged.
+ let mut current_index = 0;
+ // Mask of bits that came from the sparse set in the current word.
+ let mut new_bit_mask = 0;
+ for (word_index, mask) in sparse.iter().map(|x| word_index_and_mask(*x)) {
+ // Next bit is in a word not inspected yet.
+ if word_index > current_index {
+ self.words[current_index] |= new_bit_mask;
+ // Were there any bits in the old word that did not occur in the sparse set?
+ not_already |= (self.words[current_index] ^ new_bit_mask) != 0;
+ // Check all words we skipped for any set bit.
+ not_already |= self.words[current_index+1..word_index].iter().any(|&x| x != 0);
+ // Update next word.
+ current_index = word_index;
+ // Reset bit mask, no bits have been merged yet.
+ new_bit_mask = 0;
+ }
+ // Add bit and mark it as coming from the sparse set.
+ // self.words[word_index] |= mask;
+ new_bit_mask |= mask;
+ }
+ self.words[current_index] |= new_bit_mask;
+ // Any bits in the last inspected word that were not in the sparse set?
+ not_already |= (self.words[current_index] ^ new_bit_mask) != 0;
+ // Any bits in the tail? Note `clear_excess_bits` before.
+ not_already |= self.words[current_index+1..].iter().any(|&x| x != 0);
+
+ not_already
+ }
}
/// This is implemented by all the bitsets so that BitSet::union() can be
@@ -273,11 +316,6 @@
}
}
-pub trait BitSetOperator {
- /// Combine one bitset into another.
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool;
-}
-
#[inline]
fn bitwise<Op>(out_vec: &mut [Word], in_vec: &[Word], op: Op) -> bool
where Op: Fn(Word, Word) -> Word
@@ -514,10 +552,22 @@
changed
}
HybridBitSet::Dense(other_dense) => {
- // `self` is sparse and `other` is dense. Densify
- // `self` and then do the bitwise union.
- let mut new_dense = self_sparse.to_dense();
- let changed = new_dense.union(other_dense);
+ // `self` is sparse and `other` is dense. To
+ // merge them, we have two available strategies:
+ // * Densify `self` then merge other
+ // * Clone other then integrate bits from `self`
+ // The second strategy requires dedicated method
+ // since the usual `union` returns the wrong
+ // result. In the dedicated case the computation
+ // is slightly faster if the bits of the sparse
+ // bitset map to only few words of the dense
+ // representation, i.e. indices are near each
+ // other.
+ //
+ // Benchmarking seems to suggest that the second
+ // option is worth it.
+ let mut new_dense = other_dense.clone();
+ let changed = new_dense.reverse_union_sparse(self_sparse);
*self = HybridBitSet::Dense(new_dense);
changed
}
@@ -1214,3 +1264,87 @@
}
assert!(iter.next().is_none());
}
+
+/// Merge dense hybrid set into empty sparse hybrid set.
+#[bench]
+fn union_hybrid_sparse_empty_to_dense(b: &mut Bencher) {
+ let mut pre_dense: HybridBitSet<usize> = HybridBitSet::new_empty(256);
+ for i in 0..10 {
+ assert!(pre_dense.insert(i));
+ }
+ let pre_sparse: HybridBitSet<usize> = HybridBitSet::new_empty(256);
+ b.iter(|| {
+ let dense = pre_dense.clone();
+ let mut sparse = pre_sparse.clone();
+ sparse.union(&dense);
+ })
+}
+
+/// Merge dense hybrid set into full hybrid set with same indices.
+#[bench]
+fn union_hybrid_sparse_full_to_dense(b: &mut Bencher) {
+ let mut pre_dense: HybridBitSet<usize> = HybridBitSet::new_empty(256);
+ for i in 0..10 {
+ assert!(pre_dense.insert(i));
+ }
+ let mut pre_sparse: HybridBitSet<usize> = HybridBitSet::new_empty(256);
+ for i in 0..SPARSE_MAX {
+ assert!(pre_sparse.insert(i));
+ }
+ b.iter(|| {
+ let dense = pre_dense.clone();
+ let mut sparse = pre_sparse.clone();
+ sparse.union(&dense);
+ })
+}
+
+/// Merge dense hybrid set into full hybrid set with indices over the whole domain.
+#[bench]
+fn union_hybrid_sparse_domain_to_dense(b: &mut Bencher) {
+ let mut pre_dense: HybridBitSet<usize> = HybridBitSet::new_empty(SPARSE_MAX*64);
+ for i in 0..10 {
+ assert!(pre_dense.insert(i));
+ }
+ let mut pre_sparse: HybridBitSet<usize> = HybridBitSet::new_empty(SPARSE_MAX*64);
+ for i in 0..SPARSE_MAX {
+ assert!(pre_sparse.insert(i*64));
+ }
+ b.iter(|| {
+ let dense = pre_dense.clone();
+ let mut sparse = pre_sparse.clone();
+ sparse.union(&dense);
+ })
+}
+
+/// Merge dense hybrid set into empty hybrid set where the domain is very small.
+#[bench]
+fn union_hybrid_sparse_empty_small_domain(b: &mut Bencher) {
+ let mut pre_dense: HybridBitSet<usize> = HybridBitSet::new_empty(SPARSE_MAX);
+ for i in 0..SPARSE_MAX {
+ assert!(pre_dense.insert(i));
+ }
+ let pre_sparse: HybridBitSet<usize> = HybridBitSet::new_empty(SPARSE_MAX);
+ b.iter(|| {
+ let dense = pre_dense.clone();
+ let mut sparse = pre_sparse.clone();
+ sparse.union(&dense);
+ })
+}
+
+/// Merge dense hybrid set into full hybrid set where the domain is very small.
+#[bench]
+fn union_hybrid_sparse_full_small_domain(b: &mut Bencher) {
+ let mut pre_dense: HybridBitSet<usize> = HybridBitSet::new_empty(SPARSE_MAX);
+ for i in 0..SPARSE_MAX {
+ assert!(pre_dense.insert(i));
+ }
+ let mut pre_sparse: HybridBitSet<usize> = HybridBitSet::new_empty(SPARSE_MAX);
+ for i in 0..SPARSE_MAX {
+ assert!(pre_sparse.insert(i));
+ }
+ b.iter(|| {
+ let dense = pre_dense.clone();
+ let mut sparse = pre_sparse.clone();
+ sparse.union(&dense);
+ })
+}
diff --git a/src/librustc_data_structures/indexed_vec.rs b/src/librustc_data_structures/indexed_vec.rs
index c7f6e54..635edbb 100644
--- a/src/librustc_data_structures/indexed_vec.rs
+++ b/src/librustc_data_structures/indexed_vec.rs
@@ -423,7 +423,7 @@
(@derives [$($derives:ident,)*]
@attrs [$(#[$attrs:meta])*]
@type [$type:ident]
- @max [$_max:expr]
+ @max [$max:expr]
@vis [$v:vis]
@debug_format [$debug_format:tt]
$(#[doc = $doc:expr])*
diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs
index eb89b5c..d92f3aa 100644
--- a/src/librustc_driver/pretty.rs
+++ b/src/librustc_driver/pretty.rs
@@ -253,10 +253,9 @@
fn pp_ann<'a>(&'a self) -> &'a dyn pprust_hir::PpAnn;
/// Computes an user-readable representation of a path, if possible.
- fn node_path(&self, id: ast::NodeId) -> Option<String> {
+ fn node_path(&self, id: hir::HirId) -> Option<String> {
self.hir_map().and_then(|map| {
- let hir_id = map.node_to_hir_id(id);
- map.def_path_from_hir_id(hir_id)
+ map.def_path_from_hir_id(id)
}).map(|path| {
path.data
.into_iter()
@@ -471,8 +470,8 @@
self
}
- fn node_path(&self, id: ast::NodeId) -> Option<String> {
- Some(self.tcx.def_path_str(self.tcx.hir().local_def_id(id)))
+ fn node_path(&self, id: hir::HirId) -> Option<String> {
+ Some(self.tcx.def_path_str(self.tcx.hir().local_def_id_from_hir_id(id)))
}
}
@@ -627,11 +626,11 @@
// Find the function this expression is from.
let mut hir_id = expr.hir_id;
loop {
- let node = tcx.hir().get_by_hir_id(hir_id);
+ let node = tcx.hir().get(hir_id);
if let Some(n) = hir::map::blocks::FnLikeNode::from_node(node) {
break n.body();
}
- let parent = tcx.hir().get_parent_node_by_hir_id(hir_id);
+ let parent = tcx.hir().get_parent_node(hir_id);
assert_ne!(hir_id, parent);
hir_id = parent;
}
@@ -830,10 +829,11 @@
box out,
annotation.pp_ann());
for node_id in uii.all_matching_node_ids(hir_map) {
- let node = hir_map.get(node_id);
+ let hir_id = tcx.hir().node_to_hir_id(node_id);
+ let node = hir_map.get(hir_id);
pp_state.print_node(node)?;
pp_state.s.space()?;
- let path = annotation.node_path(node_id)
+ let path = annotation.node_path(hir_id)
.expect("-Z unpretty missing node paths");
pp_state.synth_comment(path)?;
pp_state.s.hardbreak()?;
@@ -847,7 +847,8 @@
s.call_with_pp_support_hir(tcx, move |_annotation, _krate| {
debug!("pretty printing source code {:?}", s);
for node_id in uii.all_matching_node_ids(tcx.hir()) {
- let node = tcx.hir().get(node_id);
+ let hir_id = tcx.hir().node_to_hir_id(node_id);
+ let node = tcx.hir().get(hir_id);
write!(out, "{:#?}", node)?;
}
Ok(())
@@ -905,11 +906,12 @@
let nodeid =
nodeid.expect("`pretty flowgraph=..` needs NodeId (int) or unique path \
suffix (b::c::d)");
- let node = tcx.hir().find(nodeid).unwrap_or_else(|| {
+ let hir_id = tcx.hir().node_to_hir_id(nodeid);
+ let node = tcx.hir().find(hir_id).unwrap_or_else(|| {
tcx.sess.fatal(&format!("--pretty flowgraph couldn't find id: {}", nodeid))
});
- match blocks::Code::from_node(&tcx.hir(), nodeid) {
+ match blocks::Code::from_node(&tcx.hir(), hir_id) {
Some(code) => {
let variants = gather_flowgraph_variants(tcx.sess);
diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs
index 05cee6d..70bd25a 100644
--- a/src/librustc_errors/lib.rs
+++ b/src/librustc_errors/lib.rs
@@ -307,7 +307,12 @@
pub struct Handler {
pub flags: HandlerFlags,
+ /// The number of errors that have been emitted, including duplicates.
+ ///
+ /// This is not necessarily the count that's reported to the user once
+ /// compilation ends.
err_count: AtomicUsize,
+ deduplicated_err_count: AtomicUsize,
emitter: Lock<Box<dyn Emitter + sync::Send>>,
continue_after_error: AtomicBool,
delayed_span_bugs: Lock<Vec<Diagnostic>>,
@@ -352,7 +357,7 @@
impl Drop for Handler {
fn drop(&mut self) {
- if self.err_count() == 0 {
+ if !self.has_errors() {
let mut bugs = self.delayed_span_bugs.borrow_mut();
let has_bugs = !bugs.is_empty();
for bug in bugs.drain(..) {
@@ -407,6 +412,7 @@
Handler {
flags,
err_count: AtomicUsize::new(0),
+ deduplicated_err_count: AtomicUsize::new(0),
emitter: Lock::new(e),
continue_after_error: AtomicBool::new(true),
delayed_span_bugs: Lock::new(Vec::new()),
@@ -428,6 +434,7 @@
pub fn reset_err_count(&self) {
// actually frees the underlying memory (which `clear` would not do)
*self.emitted_diagnostics.borrow_mut() = Default::default();
+ self.deduplicated_err_count.store(0, SeqCst);
self.err_count.store(0, SeqCst);
}
@@ -660,10 +667,10 @@
}
pub fn print_error_count(&self, registry: &Registry) {
- let s = match self.err_count() {
+ let s = match self.deduplicated_err_count.load(SeqCst) {
0 => return,
1 => "aborting due to previous error".to_string(),
- _ => format!("aborting due to {} previous errors", self.err_count())
+ count => format!("aborting due to {} previous errors", count)
};
if self.treat_err_as_bug() {
return;
@@ -705,10 +712,9 @@
}
pub fn abort_if_errors(&self) {
- if self.err_count() == 0 {
- return;
+ if self.has_errors() {
+ FatalError.raise();
}
- FatalError.raise();
}
pub fn emit(&self, msp: &MultiSpan, msg: &str, lvl: Level) {
if lvl == Warning && !self.flags.can_emit_warnings {
@@ -770,9 +776,12 @@
if self.emitted_diagnostics.borrow_mut().insert(diagnostic_hash) {
self.emitter.borrow_mut().emit_diagnostic(db);
if db.is_error() {
- self.bump_err_count();
+ self.deduplicated_err_count.fetch_add(1, SeqCst);
}
}
+ if db.is_error() {
+ self.bump_err_count();
+ }
}
pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str) {
diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs
index e2e4a4e..5296ed0 100644
--- a/src/librustc_incremental/persist/dirty_clean.rs
+++ b/src/librustc_incremental/persist/dirty_clean.rs
@@ -322,7 +322,7 @@
/// Return all DepNode labels that should be asserted for this item.
/// index=0 is the "name" used for error messages
fn auto_labels(&mut self, item_id: hir::HirId, attr: &Attribute) -> (&'static str, Labels) {
- let node = self.tcx.hir().get_by_hir_id(item_id);
+ let node = self.tcx.hir().get(item_id);
let (name, labels) = match node {
HirNode::Item(item) => {
match item.node {
diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
index 69cb696..c1b6e34 100644
--- a/src/librustc_interface/passes.rs
+++ b/src/librustc_interface/passes.rs
@@ -959,7 +959,7 @@
// lot of annoying errors in the compile-fail tests (basically,
// lint warnings and so on -- kindck used to do this abort, but
// kindck is gone now). -nmatsakis
- if sess.err_count() > 0 {
+ if sess.has_errors() {
return Err(ErrorReported);
}
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
index 1a4b12b..12719c3b 100644
--- a/src/librustc_lint/builtin.rs
+++ b/src/librustc_lint/builtin.rs
@@ -405,7 +405,7 @@
// reported for missing docs.
let real_trait = trait_ref.path.res.def_id();
if let Some(hir_id) = cx.tcx.hir().as_local_hir_id(real_trait) {
- match cx.tcx.hir().find_by_hir_id(hir_id) {
+ match cx.tcx.hir().find(hir_id) {
Some(Node::Item(item)) => {
if let hir::VisibilityKind::Inherited = item.vis.node {
for impl_item_ref in impl_item_refs {
diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs
index 5f052f6..d0258ca 100644
--- a/src/librustc_lint/types.rs
+++ b/src/librustc_lint/types.rs
@@ -219,7 +219,7 @@
return Some(format!("{:?}", $itypes))
})*
None
- },)*
+ },)+
_ => None
}
}
@@ -275,8 +275,8 @@
return;
}
- let par_id = cx.tcx.hir().get_parent_node_by_hir_id(e.hir_id);
- if let Node::Expr(par_e) = cx.tcx.hir().get_by_hir_id(par_id) {
+ let par_id = cx.tcx.hir().get_parent_node(e.hir_id);
+ if let Node::Expr(par_e) = cx.tcx.hir().get(par_id) {
if let hir::ExprKind::Struct(..) = par_e.node {
if is_range_literal(cx.sess(), par_e)
&& lint_overflowing_range_endpoint(cx, lit, v, max, e, par_e, t)
@@ -314,8 +314,8 @@
_ => bug!(),
};
if lit_val < min || lit_val > max {
- let parent_id = cx.tcx.hir().get_parent_node_by_hir_id(e.hir_id);
- if let Node::Expr(par_e) = cx.tcx.hir().get_by_hir_id(parent_id) {
+ let parent_id = cx.tcx.hir().get_parent_node(e.hir_id);
+ if let Node::Expr(par_e) = cx.tcx.hir().get(parent_id) {
match par_e.node {
hir::ExprKind::Cast(..) => {
if let ty::Char = cx.tables.expr_ty(par_e).sty {
diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs
index f84ce2f..b5c5fc0 100644
--- a/src/librustc_lint/unused.rs
+++ b/src/librustc_lint/unused.rs
@@ -324,20 +324,28 @@
value: &ast::Expr,
msg: &str,
followed_by_block: bool) {
- if let ast::ExprKind::Paren(ref inner) = value.node {
- let necessary = followed_by_block && match inner.node {
- ast::ExprKind::Ret(_) | ast::ExprKind::Break(..) => true,
- _ => parser::contains_exterior_struct_lit(&inner),
- };
- if !necessary {
- let expr_text = if let Ok(snippet) = cx.sess().source_map()
- .span_to_snippet(value.span) {
- snippet
- } else {
- pprust::expr_to_string(value)
- };
- Self::remove_outer_parens(cx, value.span, &expr_text, msg);
+ match value.node {
+ ast::ExprKind::Paren(ref inner) => {
+ let necessary = followed_by_block && match inner.node {
+ ast::ExprKind::Ret(_) | ast::ExprKind::Break(..) => true,
+ _ => parser::contains_exterior_struct_lit(&inner),
+ };
+ if !necessary {
+ let expr_text = if let Ok(snippet) = cx.sess().source_map()
+ .span_to_snippet(value.span) {
+ snippet
+ } else {
+ pprust::expr_to_string(value)
+ };
+ Self::remove_outer_parens(cx, value.span, &expr_text, msg);
+ }
}
+ ast::ExprKind::Let(_, ref expr) => {
+ // FIXME(#60336): Properly handle `let true = (false && true)`
+ // actually needing the parenthesis.
+ self.check_unused_parens_expr(cx, expr, "`let` head expression", followed_by_block);
+ }
+ _ => {}
}
}
@@ -399,8 +407,6 @@
let (value, msg, followed_by_block) = match e.node {
If(ref cond, ..) => (cond, "`if` condition", true),
While(ref cond, ..) => (cond, "`while` condition", true),
- IfLet(_, ref cond, ..) => (cond, "`if let` head expression", true),
- WhileLet(_, ref cond, ..) => (cond, "`while let` head expression", true),
ForLoop(_, ref cond, ..) => (cond, "`for` head expression", true),
Match(ref head, _) => (head, "`match` head expression", true),
Ret(Some(ref value)) => (value, "`return` value", false),
diff --git a/src/librustc_mir/borrow_check/conflict_errors.rs b/src/librustc_mir/borrow_check/conflict_errors.rs
index dfaad95..f23cffe 100644
--- a/src/librustc_mir/borrow_check/conflict_errors.rs
+++ b/src/librustc_mir/borrow_check/conflict_errors.rs
@@ -853,7 +853,7 @@
format!(
"...but `{}` will be dropped here, when the function `{}` returns",
name,
- self.infcx.tcx.hir().name_by_hir_id(fn_hir_id),
+ self.infcx.tcx.hir().name(fn_hir_id),
),
);
diff --git a/src/librustc_mir/borrow_check/error_reporting.rs b/src/librustc_mir/borrow_check/error_reporting.rs
index 7eb2963..10c9a43 100644
--- a/src/librustc_mir/borrow_check/error_reporting.rs
+++ b/src/librustc_mir/borrow_check/error_reporting.rs
@@ -349,7 +349,7 @@
let (&var_id, _) = self.infcx.tcx.upvars(def_id).unwrap()
.get_index(field.index()).unwrap();
- self.infcx.tcx.hir().name_by_hir_id(var_id).to_string()
+ self.infcx.tcx.hir().name(var_id).to_string()
}
_ => {
// Might need a revision when the fields in trait RFC is implemented
@@ -627,7 +627,7 @@
def_id, is_generator, places
);
if let Some((args_span, var_span)) = self.closure_span(
- *def_id, &Place::Base(PlaceBase::Local(target)), places
+ *def_id, &Place::from(target), places
) {
return ClosureUse {
is_generator,
@@ -659,7 +659,7 @@
def_id, target_place, places
);
let hir_id = self.infcx.tcx.hir().as_local_hir_id(def_id)?;
- let expr = &self.infcx.tcx.hir().expect_expr_by_hir_id(hir_id).node;
+ let expr = &self.infcx.tcx.hir().expect_expr(hir_id).node;
debug!("closure_span: hir_id={:?} expr={:?}", hir_id, expr);
if let hir::ExprKind::Closure(
.., args_span, _
diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs
index ca8c4c5..4872440 100644
--- a/src/librustc_mir/borrow_check/mod.rs
+++ b/src/librustc_mir/borrow_check/mod.rs
@@ -124,14 +124,13 @@
.flat_map(|v| v.values())
.map(|upvar_id| {
let var_hir_id = upvar_id.var_path.hir_id;
- let var_node_id = tcx.hir().hir_to_node_id(var_hir_id);
let capture = tables.upvar_capture(*upvar_id);
let by_ref = match capture {
ty::UpvarCapture::ByValue => false,
ty::UpvarCapture::ByRef(..) => true,
};
let mut upvar = Upvar {
- name: tcx.hir().name(var_node_id),
+ name: tcx.hir().name(var_hir_id),
var_hir_id,
by_ref,
mutability: Mutability::Not,
@@ -231,7 +230,7 @@
|bd, i| DebugFormatted::new(&bd.move_data().inits[i]),
));
- let movable_generator = match tcx.hir().get_by_hir_id(id) {
+ let movable_generator = match tcx.hir().get(id) {
Node::Expr(&hir::Expr {
node: hir::ExprKind::Closure(.., Some(hir::GeneratorMovability::Static)),
..
@@ -621,7 +620,7 @@
StatementKind::StorageDead(local) => {
self.access_place(
location,
- (&Place::Base(PlaceBase::Local(local)), span),
+ (&Place::from(local), span),
(Shallow(None), Write(WriteKind::StorageDeadOrDrop)),
LocalMutationIsAllowed::Yes,
flow_state,
diff --git a/src/librustc_mir/borrow_check/mutability_errors.rs b/src/librustc_mir/borrow_check/mutability_errors.rs
index fc11cd8..92c2e4e 100644
--- a/src/librustc_mir/borrow_check/mutability_errors.rs
+++ b/src/librustc_mir/borrow_check/mutability_errors.rs
@@ -304,7 +304,7 @@
err.span_label(span, format!("cannot {ACT}", ACT = act));
let upvar_hir_id = self.upvars[upvar_index.index()].var_hir_id;
- if let Some(Node::Binding(pat)) = self.infcx.tcx.hir().find_by_hir_id(upvar_hir_id)
+ if let Some(Node::Binding(pat)) = self.infcx.tcx.hir().find(upvar_hir_id)
{
if let hir::PatKind::Binding(
hir::BindingAnnotation::Unannotated,
@@ -633,7 +633,7 @@
let field = def.all_fields().nth(field.index())?;
// Use the HIR types to construct the diagnostic message.
let hir_id = tcx.hir().as_local_hir_id(field.did)?;
- let node = tcx.hir().find_by_hir_id(hir_id)?;
+ let node = tcx.hir().find(hir_id)?;
// Now we're dealing with the actual struct that we're going to suggest a change to,
// we can expect a field that is an immutable reference to a type.
if let hir::Node::Field(field) = node {
diff --git a/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs b/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs
index 4bc2f70..ed88b16 100644
--- a/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs
@@ -252,7 +252,7 @@
Some(Cause::LiveVar(local, location)) => {
let span = body.source_info(location).span;
let spans = self
- .move_spans(&Place::Base(PlaceBase::Local(local)), location)
+ .move_spans(&Place::from(local), location)
.or_else(|| self.borrow_spans(span, location));
let borrow_location = location;
diff --git a/src/librustc_mir/borrow_check/nll/invalidation.rs b/src/librustc_mir/borrow_check/nll/invalidation.rs
index c45c28c..c7b4a40 100644
--- a/src/librustc_mir/borrow_check/nll/invalidation.rs
+++ b/src/librustc_mir/borrow_check/nll/invalidation.rs
@@ -11,7 +11,7 @@
use crate::dataflow::indexes::BorrowIndex;
use rustc::ty::TyCtxt;
use rustc::mir::visit::Visitor;
-use rustc::mir::{BasicBlock, Location, Body, Place, PlaceBase, Rvalue};
+use rustc::mir::{BasicBlock, Location, Body, Place, Rvalue};
use rustc::mir::{Statement, StatementKind};
use rustc::mir::TerminatorKind;
use rustc::mir::{Operand, BorrowKind};
@@ -124,7 +124,7 @@
StatementKind::StorageDead(local) => {
self.access_place(
location,
- &Place::Base(PlaceBase::Local(local)),
+ &Place::from(local),
(Shallow(None), Write(WriteKind::StorageDeadOrDrop)),
LocalMutationIsAllowed::Yes,
);
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs
index 46b6901..3f5b2f4 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs
+++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs
@@ -237,7 +237,7 @@
if let DefiningTy::Closure(def_id, substs) = def_ty {
let args_span = if let hir::ExprKind::Closure(_, _, _, span, _) =
- tcx.hir().expect_expr_by_hir_id(mir_hir_id).node
+ tcx.hir().expect_expr(mir_hir_id).node
{
span
} else {
@@ -698,7 +698,7 @@
let mir_hir_id = tcx.hir().as_local_hir_id(mir_def_id).expect("non-local mir");
- let (return_span, mir_description) = match tcx.hir().get_by_hir_id(mir_hir_id) {
+ let (return_span, mir_description) = match tcx.hir().get(mir_hir_id) {
hir::Node::Expr(hir::Expr {
node: hir::ExprKind::Closure(_, return_ty, _, span, gen_move),
..
@@ -761,7 +761,7 @@
let mir_hir_id = tcx.hir().as_local_hir_id(mir_def_id).expect("non-local mir");
- let yield_span = match tcx.hir().get_by_hir_id(mir_hir_id) {
+ let yield_span = match tcx.hir().get(mir_hir_id) {
hir::Node::Expr(hir::Expr {
node: hir::ExprKind::Closure(_, _, _, span, _),
..
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs
index 59fc411..750a132 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs
+++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs
@@ -72,7 +72,7 @@
let upvar_hir_id = upvars[upvar_index].var_hir_id;
debug!("get_upvar_name_and_span_for_region: upvar_hir_id={:?}", upvar_hir_id);
- let upvar_name = tcx.hir().name_by_hir_id(upvar_hir_id);
+ let upvar_name = tcx.hir().name(upvar_hir_id);
let upvar_span = tcx.hir().span(upvar_hir_id);
debug!("get_upvar_name_and_span_for_region: upvar_name={:?} upvar_span={:?}",
upvar_name, upvar_span);
diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
index e1f5964..9409fef 100644
--- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
@@ -632,7 +632,7 @@
)
}
ProjectionElem::Index(i) => {
- let index_ty = Place::Base(PlaceBase::Local(i)).ty(self.body, tcx).ty;
+ let index_ty = Place::from(i).ty(self.body, tcx).ty;
if index_ty != tcx.types.usize {
PlaceTy::from_ty(
span_mirbug_and_err!(self, i, "index by non-usize {:?}", i),
diff --git a/src/librustc_mir/borrow_check/nll/universal_regions.rs b/src/librustc_mir/borrow_check/nll/universal_regions.rs
index fa3c7b9..a85f477 100644
--- a/src/librustc_mir/borrow_check/nll/universal_regions.rs
+++ b/src/librustc_mir/borrow_check/nll/universal_regions.rs
@@ -767,7 +767,7 @@
owner: fn_def_id.index,
local_id: *late_bound,
};
- let name = tcx.hir().name_by_hir_id(hir_id).as_interned_str();
+ let name = tcx.hir().name(hir_id).as_interned_str();
let region_def_id = tcx.hir().local_def_id_from_hir_id(hir_id);
let liberated_region = tcx.mk_region(ty::ReFree(ty::FreeRegion {
scope: fn_def_id,
diff --git a/src/librustc_mir/build/expr/as_operand.rs b/src/librustc_mir/build/expr/as_operand.rs
index dd78e7e..207399f 100644
--- a/src/librustc_mir/build/expr/as_operand.rs
+++ b/src/librustc_mir/build/expr/as_operand.rs
@@ -74,7 +74,7 @@
}
Category::Place | Category::Rvalue(..) => {
let operand = unpack!(block = this.as_temp(block, scope, expr, Mutability::Mut));
- block.and(Operand::Move(Place::Base(PlaceBase::Local(operand))))
+ block.and(Operand::Move(Place::from(operand)))
}
}
}
diff --git a/src/librustc_mir/build/expr/as_place.rs b/src/librustc_mir/build/expr/as_place.rs
index 51808ef..0640c01 100644
--- a/src/librustc_mir/build/expr/as_place.rs
+++ b/src/librustc_mir/build/expr/as_place.rs
@@ -98,26 +98,26 @@
<,
Rvalue::BinaryOp(
BinOp::Lt,
- Operand::Copy(Place::Base(PlaceBase::Local(idx))),
+ Operand::Copy(Place::from(idx)),
Operand::Copy(len.clone()),
),
);
let msg = BoundsCheck {
len: Operand::Move(len),
- index: Operand::Copy(Place::Base(PlaceBase::Local(idx))),
+ index: Operand::Copy(Place::from(idx)),
};
let success = this.assert(block, Operand::Move(lt), true, msg, expr_span);
success.and(slice.index(idx))
}
- ExprKind::SelfRef => block.and(Place::Base(PlaceBase::Local(Local::new(1)))),
+ ExprKind::SelfRef => block.and(Place::from(Local::new(1))),
ExprKind::VarRef { id } => {
let place = if this.is_bound_var_in_guard(id) {
let index = this.var_local_id(id, RefWithinGuard);
- Place::Base(PlaceBase::Local(index)).deref()
+ Place::from(index).deref()
} else {
let index = this.var_local_id(id, OutsideGuard);
- Place::Base(PlaceBase::Local(index))
+ Place::from(index)
};
block.and(place)
}
@@ -168,14 +168,14 @@
Statement {
source_info,
kind: StatementKind::AscribeUserType(
- Place::Base(PlaceBase::Local(temp.clone())),
+ Place::from(temp.clone()),
Variance::Invariant,
box UserTypeProjection { base: annotation_index, projs: vec![], },
),
},
);
}
- block.and(Place::Base(PlaceBase::Local(temp)))
+ block.and(Place::from(temp))
}
ExprKind::Array { .. }
@@ -211,7 +211,7 @@
});
let temp =
unpack!(block = this.as_temp(block, expr.temp_lifetime, expr, mutability));
- block.and(Place::Base(PlaceBase::Local(temp)))
+ block.and(Place::from(temp))
}
}
}
diff --git a/src/librustc_mir/build/expr/as_rvalue.rs b/src/librustc_mir/build/expr/as_rvalue.rs
index 243c13c..73ce2a5 100644
--- a/src/librustc_mir/build/expr/as_rvalue.rs
+++ b/src/librustc_mir/build/expr/as_rvalue.rs
@@ -127,7 +127,7 @@
this.schedule_drop_storage_and_value(
expr_span,
scope,
- &Place::Base(PlaceBase::Local(result)),
+ &Place::from(result),
value.ty,
);
}
@@ -135,16 +135,16 @@
// malloc some memory of suitable type (thus far, uninitialized):
let box_ = Rvalue::NullaryOp(NullOp::Box, value.ty);
this.cfg
- .push_assign(block, source_info, &Place::Base(PlaceBase::Local(result)), box_);
+ .push_assign(block, source_info, &Place::from(result), box_);
// initialize the box contents:
unpack!(
block = this.into(
- &Place::Base(PlaceBase::Local(result)).deref(),
+ &Place::from(result).deref(),
block, value
)
);
- block.and(Rvalue::Use(Operand::Move(Place::Base(PlaceBase::Local(result)))))
+ block.and(Rvalue::Use(Operand::Move(Place::from(result))))
}
ExprKind::Cast { source } => {
let source = unpack!(block = this.as_operand(block, scope, source));
@@ -548,7 +548,7 @@
this.cfg.push_assign(
block,
source_info,
- &Place::Base(PlaceBase::Local(temp)),
+ &Place::from(temp),
Rvalue::Ref(this.hir.tcx().lifetimes.re_erased, borrow_kind, arg_place),
);
@@ -559,12 +559,12 @@
this.schedule_drop_storage_and_value(
upvar_span,
temp_lifetime,
- &Place::Base(PlaceBase::Local(temp)),
+ &Place::from(temp),
upvar_ty,
);
}
- block.and(Operand::Move(Place::Base(PlaceBase::Local(temp))))
+ block.and(Operand::Move(Place::from(temp)))
}
// Helper to get a `-1` value of the appropriate type
diff --git a/src/librustc_mir/build/expr/as_temp.rs b/src/librustc_mir/build/expr/as_temp.rs
index 9d907c6..1b3ebac 100644
--- a/src/librustc_mir/build/expr/as_temp.rs
+++ b/src/librustc_mir/build/expr/as_temp.rs
@@ -64,7 +64,7 @@
}
this.local_decls.push(local_decl)
};
- let temp_place = &Place::Base(PlaceBase::Local(temp));
+ let temp_place = &Place::from(temp);
if !expr_ty.is_never() {
this.cfg.push(
diff --git a/src/librustc_mir/build/expr/into.rs b/src/librustc_mir/build/expr/into.rs
index a397623..f70ecef 100644
--- a/src/librustc_mir/build/expr/into.rs
+++ b/src/librustc_mir/build/expr/into.rs
@@ -258,7 +258,7 @@
is_user_variable: None,
is_block_tail: None,
});
- let ptr_temp = Place::Base(PlaceBase::Local(ptr_temp));
+ let ptr_temp = Place::from(ptr_temp);
let block = unpack!(this.into(&ptr_temp, block, ptr));
this.into(&ptr_temp.deref(), block, val)
} else {
diff --git a/src/librustc_mir/build/expr/stmt.rs b/src/librustc_mir/build/expr/stmt.rs
index 74338de..4463e7f 100644
--- a/src/librustc_mir/build/expr/stmt.rs
+++ b/src/librustc_mir/build/expr/stmt.rs
@@ -235,7 +235,7 @@
}
}
let temp = this.local_decls.push(local_decl);
- let place = Place::Base(PlaceBase::Local(temp));
+ let place = Place::from(temp);
debug!("created temp {:?} for expr {:?} in block_context: {:?}",
temp, expr, this.block_context);
place
diff --git a/src/librustc_mir/build/matches/mod.rs b/src/librustc_mir/build/matches/mod.rs
index 55093f2..d2e56c4 100644
--- a/src/librustc_mir/build/matches/mod.rs
+++ b/src/librustc_mir/build/matches/mod.rs
@@ -531,7 +531,7 @@
kind: StatementKind::StorageLive(local_id),
},
);
- let place = Place::Base(PlaceBase::Local(local_id));
+ let place = Place::from(local_id);
let var_ty = self.local_decls[local_id].ty;
let region_scope = self.hir.region_scope_tree.var_scope(var.local_id);
self.schedule_drop(span, region_scope, &place, var_ty, DropKind::Storage);
@@ -545,7 +545,7 @@
self.schedule_drop(
span,
region_scope,
- &Place::Base(PlaceBase::Local(local_id)),
+ &Place::from(local_id),
var_ty,
DropKind::Value,
);
@@ -1478,7 +1478,7 @@
self.cfg.push_assign(
block,
scrutinee_source_info,
- &Place::Base(PlaceBase::Local(temp)),
+ &Place::from(temp),
borrow,
);
}
@@ -1502,7 +1502,7 @@
source_info: guard_end,
kind: StatementKind::FakeRead(
FakeReadCause::ForMatchGuard,
- Place::Base(PlaceBase::Local(temp)),
+ Place::from(temp),
),
});
}
@@ -1575,7 +1575,7 @@
// place they refer to can't be modified by the guard.
for binding in by_value_bindings.clone() {
let local_id = self.var_local_id(binding.var_id, RefWithinGuard);
- let place = Place::Base(PlaceBase::Local(local_id));
+ let place = Place::from(local_id);
self.cfg.push(
block,
Statement {
diff --git a/src/librustc_mir/build/misc.rs b/src/librustc_mir/build/misc.rs
index ad891b1..56025ee 100644
--- a/src/librustc_mir/build/misc.rs
+++ b/src/librustc_mir/build/misc.rs
@@ -16,7 +16,7 @@
/// call `schedule_drop` once the temporary is initialized.
pub fn temp(&mut self, ty: Ty<'tcx>, span: Span) -> Place<'tcx> {
let temp = self.local_decls.push(LocalDecl::new_temp(ty, span));
- let place = Place::Base(PlaceBase::Local(temp));
+ let place = Place::from(temp);
debug!("temp: created temp {:?} with type {:?}",
place, self.local_decls[temp].ty);
place
diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs
index f795843..0957dcbf 100644
--- a/src/librustc_mir/build/mod.rs
+++ b/src/librustc_mir/build/mod.rs
@@ -26,7 +26,7 @@
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
// Figure out what primary body this item has.
- let (body_id, return_ty_span) = match tcx.hir().get_by_hir_id(id) {
+ let (body_id, return_ty_span) = match tcx.hir().get(id) {
Node::Expr(hir::Expr { node: hir::ExprKind::Closure(_, decl, body_id, _, _), .. })
| Node::Item(hir::Item { node: hir::ItemKind::Fn(decl, _, _, body_id), .. })
| Node::ImplItem(
@@ -552,7 +552,6 @@
.into_iter()
.flatten()
.map(|(&var_hir_id, &upvar_id)| {
- let var_node_id = tcx_hir.hir_to_node_id(var_hir_id);
let capture = hir_tables.upvar_capture(upvar_id);
let by_ref = match capture {
ty::UpvarCapture::ByValue => false,
@@ -563,7 +562,7 @@
by_ref,
};
let mut mutability = Mutability::Not;
- if let Some(Node::Binding(pat)) = tcx_hir.find(var_node_id) {
+ if let Some(Node::Binding(pat)) = tcx_hir.find(var_hir_id) {
if let hir::PatKind::Binding(_, _, ident, _) = pat.node {
debuginfo.debug_name = ident.name;
if let Some(&bm) = hir.tables.pat_binding_modes().get(pat.hir_id) {
@@ -809,7 +808,7 @@
for (index, arg_info) in arguments.iter().enumerate() {
// Function arguments always get the first Local indices after the return place
let local = Local::new(index + 1);
- let place = Place::Base(PlaceBase::Local(local));
+ let place = Place::from(local);
let &ArgInfo(ty, opt_ty_info, pattern, ref self_binding) = arg_info;
// Make sure we drop (parts of) the argument even when not matched on.
diff --git a/src/librustc_mir/const_eval.rs b/src/librustc_mir/const_eval.rs
index 284a8f4..887ef4b 100644
--- a/src/librustc_mir/const_eval.rs
+++ b/src/librustc_mir/const_eval.rs
@@ -15,7 +15,6 @@
use rustc::ty::layout::{self, LayoutOf, VariantIdx};
use rustc::ty::subst::Subst;
use rustc::traits::Reveal;
-use rustc::util::common::ErrorReported;
use rustc_data_structures::fx::FxHashMap;
use syntax::source_map::{Span, DUMMY_SP};
@@ -24,7 +23,7 @@
PlaceTy, MPlaceTy, OpTy, ImmTy, Immediate, Scalar,
RawConst, ConstValue,
InterpResult, InterpErrorInfo, InterpError, GlobalId, InterpretCx, StackPopCleanup,
- Allocation, AllocId, MemoryKind,
+ Allocation, AllocId, MemoryKind, Memory,
snapshot, RefTracking, intern_const_alloc_recursive,
};
@@ -99,7 +98,7 @@
Ok(mplace) => {
let ptr = mplace.ptr.to_ptr().unwrap();
let alloc = ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id);
- ConstValue::ByRef(ptr, mplace.align, alloc)
+ ConstValue::ByRef { offset: ptr.offset, align: mplace.align, alloc }
},
// see comment on `let try_as_immediate` above
Err(ImmTy { imm: Immediate::Scalar(x), .. }) => match x {
@@ -113,7 +112,7 @@
let mplace = op.to_mem_place();
let ptr = mplace.ptr.to_ptr().unwrap();
let alloc = ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id);
- ConstValue::ByRef(ptr, mplace.align, alloc)
+ ConstValue::ByRef { offset: ptr.offset, align: mplace.align, alloc }
},
},
Err(ImmTy { imm: Immediate::ScalarPair(a, b), .. }) => {
@@ -410,7 +409,7 @@
_id: AllocId,
alloc: Cow<'b, Allocation>,
_kind: Option<MemoryKind<!>>,
- _memory_extra: &(),
+ _memory: &Memory<'mir, 'tcx, Self>,
) -> (Cow<'b, Allocation<Self::PointerTag>>, Self::PointerTag) {
// We do not use a tag so we can just cheaply forward the allocation
(alloc, ())
@@ -419,7 +418,7 @@
#[inline(always)]
fn tag_static_base_pointer(
_id: AllocId,
- _memory_extra: &(),
+ _memory: &Memory<'mir, 'tcx, Self>,
) -> Self::PointerTag {
()
}
@@ -541,11 +540,11 @@
if tcx.is_static(def_id) || cid.promoted.is_some() {
let ptr = mplace.ptr.to_ptr()?;
Ok(tcx.mk_const(ty::Const {
- val: ConstValue::ByRef(
- ptr,
- mplace.align,
- ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id),
- ),
+ val: ConstValue::ByRef {
+ offset: ptr.offset,
+ align: mplace.align,
+ alloc: ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id),
+ },
ty: mplace.layout.ty,
}))
} else {
@@ -655,19 +654,12 @@
if tcx.is_static(def_id) {
// Ensure that if the above error was either `TooGeneric` or `Reported`
// an error must be reported.
- let reported_err = tcx.sess.track_errors(|| {
- err.report_as_error(ecx.tcx,
- "could not evaluate static initializer")
- });
- match reported_err {
- Ok(v) => {
- tcx.sess.delay_span_bug(err.span,
- &format!("static eval failure did not emit an error: {:#?}",
- v));
- v
- },
- Err(ErrorReported) => ErrorHandled::Reported,
- }
+ let v = err.report_as_error(ecx.tcx, "could not evaluate static initializer");
+ tcx.sess.delay_span_bug(
+ err.span,
+ &format!("static eval failure did not emit an error: {:#?}", v)
+ );
+ v
} else if def_id.is_local() {
// constant defined in this crate, we can figure out a lint level!
match tcx.def_kind(def_id) {
diff --git a/src/librustc_mir/dataflow/at_location.rs b/src/librustc_mir/dataflow/at_location.rs
index 9cba34b..7735528 100644
--- a/src/librustc_mir/dataflow/at_location.rs
+++ b/src/librustc_mir/dataflow/at_location.rs
@@ -4,7 +4,7 @@
use rustc::mir::{BasicBlock, Location};
use rustc_data_structures::bit_set::{BitIter, BitSet, HybridBitSet};
-use crate::dataflow::{BitDenotation, BlockSets, DataflowResults};
+use crate::dataflow::{BitDenotation, DataflowResults, GenKillSet};
use crate::dataflow::move_paths::{HasMoveData, MovePathIndex};
use std::iter;
@@ -66,8 +66,7 @@
{
base_results: DataflowResults<'tcx, BD>,
curr_state: BitSet<BD::Idx>,
- stmt_gen: HybridBitSet<BD::Idx>,
- stmt_kill: HybridBitSet<BD::Idx>,
+ stmt_trans: GenKillSet<BD::Idx>,
}
impl<'tcx, BD> FlowAtLocation<'tcx, BD>
@@ -89,19 +88,17 @@
where
F: FnMut(BD::Idx),
{
- self.stmt_gen.iter().for_each(f)
+ self.stmt_trans.gen_set.iter().for_each(f)
}
pub fn new(results: DataflowResults<'tcx, BD>) -> Self {
let bits_per_block = results.sets().bits_per_block();
let curr_state = BitSet::new_empty(bits_per_block);
- let stmt_gen = HybridBitSet::new_empty(bits_per_block);
- let stmt_kill = HybridBitSet::new_empty(bits_per_block);
+ let stmt_trans = GenKillSet::from_elem(HybridBitSet::new_empty(bits_per_block));
FlowAtLocation {
base_results: results,
- curr_state: curr_state,
- stmt_gen: stmt_gen,
- stmt_kill: stmt_kill,
+ curr_state,
+ stmt_trans,
}
}
@@ -127,8 +124,7 @@
F: FnOnce(BitIter<'_, BD::Idx>),
{
let mut curr_state = self.curr_state.clone();
- curr_state.union(&self.stmt_gen);
- curr_state.subtract(&self.stmt_kill);
+ self.stmt_trans.apply(&mut curr_state);
f(curr_state.iter());
}
@@ -142,68 +138,41 @@
where BD: BitDenotation<'tcx>
{
fn reset_to_entry_of(&mut self, bb: BasicBlock) {
- self.curr_state.overwrite(self.base_results.sets().on_entry_set_for(bb.index()));
+ self.curr_state.overwrite(self.base_results.sets().entry_set_for(bb.index()));
}
fn reset_to_exit_of(&mut self, bb: BasicBlock) {
self.reset_to_entry_of(bb);
- self.curr_state.union(self.base_results.sets().gen_set_for(bb.index()));
- self.curr_state.subtract(self.base_results.sets().kill_set_for(bb.index()));
+ let trans = self.base_results.sets().trans_for(bb.index());
+ trans.apply(&mut self.curr_state)
}
fn reconstruct_statement_effect(&mut self, loc: Location) {
- self.stmt_gen.clear();
- self.stmt_kill.clear();
- {
- let mut sets = BlockSets {
- on_entry: &mut self.curr_state,
- gen_set: &mut self.stmt_gen,
- kill_set: &mut self.stmt_kill,
- };
- self.base_results
- .operator()
- .before_statement_effect(&mut sets, loc);
- }
- self.apply_local_effect(loc);
-
- let mut sets = BlockSets {
- on_entry: &mut self.curr_state,
- gen_set: &mut self.stmt_gen,
- kill_set: &mut self.stmt_kill,
- };
+ self.stmt_trans.clear();
self.base_results
.operator()
- .statement_effect(&mut sets, loc);
+ .before_statement_effect(&mut self.stmt_trans, loc);
+ self.stmt_trans.apply(&mut self.curr_state);
+
+ self.base_results
+ .operator()
+ .statement_effect(&mut self.stmt_trans, loc);
}
fn reconstruct_terminator_effect(&mut self, loc: Location) {
- self.stmt_gen.clear();
- self.stmt_kill.clear();
- {
- let mut sets = BlockSets {
- on_entry: &mut self.curr_state,
- gen_set: &mut self.stmt_gen,
- kill_set: &mut self.stmt_kill,
- };
- self.base_results
- .operator()
- .before_terminator_effect(&mut sets, loc);
- }
- self.apply_local_effect(loc);
-
- let mut sets = BlockSets {
- on_entry: &mut self.curr_state,
- gen_set: &mut self.stmt_gen,
- kill_set: &mut self.stmt_kill,
- };
+ self.stmt_trans.clear();
self.base_results
.operator()
- .terminator_effect(&mut sets, loc);
+ .before_terminator_effect(&mut self.stmt_trans, loc);
+ self.stmt_trans.apply(&mut self.curr_state);
+
+ self.base_results
+ .operator()
+ .terminator_effect(&mut self.stmt_trans, loc);
}
fn apply_local_effect(&mut self, _loc: Location) {
- self.curr_state.union(&self.stmt_gen);
- self.curr_state.subtract(&self.stmt_kill);
+ self.stmt_trans.apply(&mut self.curr_state)
}
}
diff --git a/src/librustc_mir/dataflow/drop_flag_effects.rs b/src/librustc_mir/dataflow/drop_flag_effects.rs
index 37f2a91..a73ec2e 100644
--- a/src/librustc_mir/dataflow/drop_flag_effects.rs
+++ b/src/librustc_mir/dataflow/drop_flag_effects.rs
@@ -170,7 +170,7 @@
{
let move_data = &ctxt.move_data;
for arg in body.args_iter() {
- let place = mir::Place::Base(mir::PlaceBase::Local(arg));
+ let place = mir::Place::from(arg);
let lookup_result = move_data.rev_lookup.find(&place);
on_lookup_result_bits(tcx, body, move_data,
lookup_result,
diff --git a/src/librustc_mir/dataflow/graphviz.rs b/src/librustc_mir/dataflow/graphviz.rs
index f62ad2f..b0d8581 100644
--- a/src/librustc_mir/dataflow/graphviz.rs
+++ b/src/librustc_mir/dataflow/graphviz.rs
@@ -30,7 +30,7 @@
fn flow_state(&self) -> &DataflowState<'tcx, Self::BD> { &self.flow_state.flow_state }
}
-struct Graph<'a, 'tcx, MWF:'a, P> where
+struct Graph<'a, 'tcx, MWF, P> where
MWF: MirWithFlowState<'tcx>
{
mbcx: &'a MWF,
@@ -170,7 +170,7 @@
write!(w, "<tr>")?;
// Entry
- dump_set_for!(on_entry_set_for, interpret_set);
+ dump_set_for!(entry_set_for, interpret_set);
// MIR statements
write!(w, "<td>")?;
@@ -208,7 +208,7 @@
write!(w, "<tr>")?;
// Entry
- let set = flow.sets.on_entry_set_for(i);
+ let set = flow.sets.entry_set_for(i);
write!(w, "<td>{:?}</td>", dot::escape_html(&set.to_string()))?;
// Terminator
@@ -221,13 +221,10 @@
}
write!(w, "</td>")?;
- // Gen
- let set = flow.sets.gen_set_for(i);
- write!(w, "<td>{:?}</td>", dot::escape_html(&format!("{:?}", set)))?;
-
- // Kill
- let set = flow.sets.kill_set_for(i);
- write!(w, "<td>{:?}</td>", dot::escape_html(&format!("{:?}", set)))?;
+ // Gen/Kill
+ let trans = flow.sets.trans_for(i);
+ write!(w, "<td>{:?}</td>", dot::escape_html(&format!("{:?}", trans.gen_set)))?;
+ write!(w, "<td>{:?}</td>", dot::escape_html(&format!("{:?}", trans.kill_set)))?;
write!(w, "</tr>")?;
diff --git a/src/librustc_mir/dataflow/impls/borrowed_locals.rs b/src/librustc_mir/dataflow/impls/borrowed_locals.rs
index 069ce3a..0f7f37f 100644
--- a/src/librustc_mir/dataflow/impls/borrowed_locals.rs
+++ b/src/librustc_mir/dataflow/impls/borrowed_locals.rs
@@ -2,7 +2,7 @@
use rustc::mir::*;
use rustc::mir::visit::Visitor;
-use crate::dataflow::BitDenotation;
+use crate::dataflow::{BitDenotation, GenKillSet};
/// This calculates if any part of a MIR local could have previously been borrowed.
/// This means that once a local has been borrowed, its bit will be set
@@ -33,39 +33,39 @@
self.body.local_decls.len()
}
- fn start_block_effect(&self, _sets: &mut BitSet<Local>) {
+ fn start_block_effect(&self, _on_entry: &mut BitSet<Local>) {
// Nothing is borrowed on function entry
}
fn statement_effect(&self,
- sets: &mut BlockSets<'_, Local>,
+ trans: &mut GenKillSet<Local>,
loc: Location) {
let stmt = &self.body[loc.block].statements[loc.statement_index];
BorrowedLocalsVisitor {
- sets,
+ trans,
}.visit_statement(stmt, loc);
// StorageDead invalidates all borrows and raw pointers to a local
match stmt.kind {
- StatementKind::StorageDead(l) => sets.kill(l),
+ StatementKind::StorageDead(l) => trans.kill(l),
_ => (),
}
}
fn terminator_effect(&self,
- sets: &mut BlockSets<'_, Local>,
+ trans: &mut GenKillSet<Local>,
loc: Location) {
let terminator = self.body[loc.block].terminator();
BorrowedLocalsVisitor {
- sets,
+ trans,
}.visit_terminator(terminator, loc);
match &terminator.kind {
// Drop terminators borrows the location
TerminatorKind::Drop { location, .. } |
TerminatorKind::DropAndReplace { location, .. } => {
if let Some(local) = find_local(location) {
- sets.gen(local);
+ trans.gen(local);
}
}
_ => (),
@@ -83,22 +83,13 @@
}
}
-impl<'a, 'tcx> BitSetOperator for HaveBeenBorrowedLocals<'a, 'tcx> {
- #[inline]
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
- inout_set.union(in_set) // "maybe" means we union effects of both preds
- }
+impl<'a, 'tcx> BottomValue for HaveBeenBorrowedLocals<'a, 'tcx> {
+ // bottom = unborrowed
+ const BOTTOM_VALUE: bool = false;
}
-impl<'a, 'tcx> InitialFlow for HaveBeenBorrowedLocals<'a, 'tcx> {
- #[inline]
- fn bottom_value() -> bool {
- false // bottom = unborrowed
- }
-}
-
-struct BorrowedLocalsVisitor<'b, 'c> {
- sets: &'b mut BlockSets<'c, Local>,
+struct BorrowedLocalsVisitor<'gk> {
+ trans: &'gk mut GenKillSet<Local>,
}
fn find_local<'tcx>(place: &Place<'tcx>) -> Option<Local> {
@@ -117,13 +108,13 @@
})
}
-impl<'tcx, 'b, 'c> Visitor<'tcx> for BorrowedLocalsVisitor<'b, 'c> {
+impl<'tcx> Visitor<'tcx> for BorrowedLocalsVisitor<'_> {
fn visit_rvalue(&mut self,
rvalue: &Rvalue<'tcx>,
location: Location) {
if let Rvalue::Ref(_, _, ref place) = *rvalue {
if let Some(local) = find_local(place) {
- self.sets.gen(local);
+ self.trans.gen(local);
}
}
diff --git a/src/librustc_mir/dataflow/impls/borrows.rs b/src/librustc_mir/dataflow/impls/borrows.rs
index 899765a..dcc6ba5 100644
--- a/src/librustc_mir/dataflow/impls/borrows.rs
+++ b/src/librustc_mir/dataflow/impls/borrows.rs
@@ -5,11 +5,11 @@
use rustc::ty::TyCtxt;
use rustc::ty::RegionVid;
-use rustc_data_structures::bit_set::{BitSet, BitSetOperator};
+use rustc_data_structures::bit_set::BitSet;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
-use crate::dataflow::{BitDenotation, BlockSets, InitialFlow};
+use crate::dataflow::{BitDenotation, BottomValue, GenKillSet};
use crate::borrow_check::nll::region_infer::RegionInferenceContext;
use crate::borrow_check::nll::ToRegionVid;
use crate::borrow_check::places_conflict;
@@ -168,7 +168,7 @@
/// Add all borrows to the kill set, if those borrows are out of scope at `location`.
/// That means they went out of a nonlexical scope
fn kill_loans_out_of_scope_at_location(&self,
- sets: &mut BlockSets<'_, BorrowIndex>,
+ trans: &mut GenKillSet<BorrowIndex>,
location: Location) {
// NOTE: The state associated with a given `location`
// reflects the dataflow on entry to the statement.
@@ -182,54 +182,49 @@
// region, then setting that gen-bit will override any
// potential kill introduced here.
if let Some(indices) = self.borrows_out_of_scope_at_location.get(&location) {
- sets.kill_all(indices);
+ trans.kill_all(indices);
}
}
/// Kill any borrows that conflict with `place`.
fn kill_borrows_on_place(
&self,
- sets: &mut BlockSets<'_, BorrowIndex>,
+ trans: &mut GenKillSet<BorrowIndex>,
place: &Place<'tcx>
) {
debug!("kill_borrows_on_place: place={:?}", place);
- // Handle the `Place::Local(..)` case first and exit early.
- if let Place::Base(PlaceBase::Local(local)) = place {
- if let Some(borrow_indices) = self.borrow_set.local_map.get(&local) {
- debug!("kill_borrows_on_place: borrow_indices={:?}", borrow_indices);
- sets.kill_all(borrow_indices);
+
+ if let Some(local) = place.base_local() {
+ let other_borrows_of_local = self
+ .borrow_set
+ .local_map
+ .get(&local)
+ .into_iter()
+ .flat_map(|bs| bs.into_iter());
+
+ // If the borrowed place is a local with no projections, all other borrows of this
+ // local must conflict. This is purely an optimization so we don't have to call
+ // `places_conflict` for every borrow.
+ if let Place::Base(PlaceBase::Local(_)) = place {
+ trans.kill_all(other_borrows_of_local);
return;
}
- }
-
- // Otherwise, look at all borrows that are live and if they conflict with the assignment
- // into our place then we can kill them.
- let mut borrows = sets.on_entry.clone();
- let _ = borrows.union(sets.gen_set);
- for borrow_index in borrows.iter() {
- let borrow_data = &self.borrows()[borrow_index];
- debug!(
- "kill_borrows_on_place: borrow_index={:?} borrow_data={:?}",
- borrow_index, borrow_data,
- );
// By passing `PlaceConflictBias::NoOverlap`, we conservatively assume that any given
// pair of array indices are unequal, so that when `places_conflict` returns true, we
// will be assured that two places being compared definitely denotes the same sets of
// locations.
- if places_conflict::places_conflict(
- self.tcx,
- self.body,
- &borrow_data.borrowed_place,
- place,
- places_conflict::PlaceConflictBias::NoOverlap,
- ) {
- debug!(
- "kill_borrows_on_place: (kill) borrow_index={:?} borrow_data={:?}",
- borrow_index, borrow_data,
- );
- sets.kill(borrow_index);
- }
+ let definitely_conflicting_borrows = other_borrows_of_local
+ .filter(|&&i| {
+ places_conflict::places_conflict(
+ self.tcx,
+ self.body,
+ &self.borrow_set.borrows[i].borrowed_place,
+ place,
+ places_conflict::PlaceConflictBias::NoOverlap)
+ });
+
+ trans.kill_all(definitely_conflicting_borrows);
}
}
}
@@ -241,21 +236,24 @@
self.borrow_set.borrows.len() * 2
}
- fn start_block_effect(&self, _entry_set: &mut BitSet<BorrowIndex>) {
+ fn start_block_effect(&self, _entry_set: &mut BitSet<Self::Idx>) {
// no borrows of code region_scopes have been taken prior to
- // function execution, so this method has no effect on
- // `_sets`.
+ // function execution, so this method has no effect.
}
fn before_statement_effect(&self,
- sets: &mut BlockSets<'_, BorrowIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location) {
- debug!("Borrows::before_statement_effect sets: {:?} location: {:?}", sets, location);
- self.kill_loans_out_of_scope_at_location(sets, location);
+ debug!("Borrows::before_statement_effect trans: {:?} location: {:?}",
+ trans, location);
+ self.kill_loans_out_of_scope_at_location(trans, location);
}
- fn statement_effect(&self, sets: &mut BlockSets<'_, BorrowIndex>, location: Location) {
- debug!("Borrows::statement_effect: sets={:?} location={:?}", sets, location);
+ fn statement_effect(&self,
+ trans: &mut GenKillSet<Self::Idx>,
+ location: Location) {
+ debug!("Borrows::statement_effect: trans={:?} location={:?}",
+ trans, location);
let block = &self.body.basic_blocks().get(location.block).unwrap_or_else(|| {
panic!("could not find block at location {:?}", location);
@@ -269,7 +267,7 @@
mir::StatementKind::Assign(ref lhs, ref rhs) => {
// Make sure there are no remaining borrows for variables
// that are assigned over.
- self.kill_borrows_on_place(sets, lhs);
+ self.kill_borrows_on_place(trans, lhs);
if let mir::Rvalue::Ref(_, _, ref place) = **rhs {
if place.ignore_borrow(
@@ -283,20 +281,20 @@
panic!("could not find BorrowIndex for location {:?}", location);
});
- sets.gen(*index);
+ trans.gen(*index);
}
}
mir::StatementKind::StorageDead(local) => {
// Make sure there are no remaining borrows for locals that
// are gone out of scope.
- self.kill_borrows_on_place(sets, &Place::Base(PlaceBase::Local(local)));
+ self.kill_borrows_on_place(trans, &Place::from(local));
}
mir::StatementKind::InlineAsm(ref asm) => {
for (output, kind) in asm.outputs.iter().zip(&asm.asm.outputs) {
if !kind.is_indirect && !kind.is_rw {
- self.kill_borrows_on_place(sets, output);
+ self.kill_borrows_on_place(trans, output);
}
}
}
@@ -312,13 +310,16 @@
}
fn before_terminator_effect(&self,
- sets: &mut BlockSets<'_, BorrowIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location) {
- debug!("Borrows::before_terminator_effect sets: {:?} location: {:?}", sets, location);
- self.kill_loans_out_of_scope_at_location(sets, location);
+ debug!("Borrows::before_terminator_effect: trans={:?} location={:?}",
+ trans, location);
+ self.kill_loans_out_of_scope_at_location(trans, location);
}
- fn terminator_effect(&self, _: &mut BlockSets<'_, BorrowIndex>, _: Location) {}
+ fn terminator_effect(&self,
+ _: &mut GenKillSet<Self::Idx>,
+ _: Location) {}
fn propagate_call_return(
&self,
@@ -330,16 +331,7 @@
}
}
-impl<'a, 'tcx> BitSetOperator for Borrows<'a, 'tcx> {
- #[inline]
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
- inout_set.union(in_set) // "maybe" means we union effects of both preds
- }
-}
-
-impl<'a, 'tcx> InitialFlow for Borrows<'a, 'tcx> {
- #[inline]
- fn bottom_value() -> bool {
- false // bottom = nothing is reserved or activated yet
- }
+impl<'a, 'tcx> BottomValue for Borrows<'a, 'tcx> {
+ /// bottom = nothing is reserved or activated yet;
+ const BOTTOM_VALUE: bool = false;
}
diff --git a/src/librustc_mir/dataflow/impls/mod.rs b/src/librustc_mir/dataflow/impls/mod.rs
index 0a572d2..065cfe8 100644
--- a/src/librustc_mir/dataflow/impls/mod.rs
+++ b/src/librustc_mir/dataflow/impls/mod.rs
@@ -4,7 +4,7 @@
use rustc::ty::TyCtxt;
use rustc::mir::{self, Body, Location};
-use rustc_data_structures::bit_set::{BitSet, BitSetOperator};
+use rustc_data_structures::bit_set::BitSet;
use rustc_data_structures::indexed_vec::Idx;
use super::MoveDataParamEnv;
@@ -12,7 +12,7 @@
use crate::util::elaborate_drops::DropFlagState;
use super::move_paths::{HasMoveData, MoveData, MovePathIndex, InitIndex, InitKind};
-use super::{BitDenotation, BlockSets, InitialFlow};
+use super::{BitDenotation, BottomValue, GenKillSet};
use super::drop_flag_effects_for_function_entry;
use super::drop_flag_effects_for_location;
@@ -226,34 +226,37 @@
}
impl<'a, 'tcx> MaybeInitializedPlaces<'a, 'tcx> {
- fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex,
+ fn update_bits(trans: &mut GenKillSet<MovePathIndex>,
+ path: MovePathIndex,
state: DropFlagState)
{
match state {
- DropFlagState::Absent => sets.kill(path),
- DropFlagState::Present => sets.gen(path),
+ DropFlagState::Absent => trans.kill(path),
+ DropFlagState::Present => trans.gen(path),
}
}
}
impl<'a, 'tcx> MaybeUninitializedPlaces<'a, 'tcx> {
- fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex,
+ fn update_bits(trans: &mut GenKillSet<MovePathIndex>,
+ path: MovePathIndex,
state: DropFlagState)
{
match state {
- DropFlagState::Absent => sets.gen(path),
- DropFlagState::Present => sets.kill(path),
+ DropFlagState::Absent => trans.gen(path),
+ DropFlagState::Present => trans.kill(path),
}
}
}
impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {
- fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex,
+ fn update_bits(trans: &mut GenKillSet<MovePathIndex>,
+ path: MovePathIndex,
state: DropFlagState)
{
match state {
- DropFlagState::Absent => sets.kill(path),
- DropFlagState::Present => sets.gen(path),
+ DropFlagState::Absent => trans.kill(path),
+ DropFlagState::Present => trans.gen(path),
}
}
}
@@ -275,24 +278,24 @@
}
fn statement_effect(&self,
- sets: &mut BlockSets<'_, MovePathIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location)
{
drop_flag_effects_for_location(
self.tcx, self.body, self.mdpe,
location,
- |path, s| Self::update_bits(sets, path, s)
+ |path, s| Self::update_bits(trans, path, s)
)
}
fn terminator_effect(&self,
- sets: &mut BlockSets<'_, MovePathIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location)
{
drop_flag_effects_for_location(
self.tcx, self.body, self.mdpe,
location,
- |path, s| Self::update_bits(sets, path, s)
+ |path, s| Self::update_bits(trans, path, s)
)
}
@@ -333,24 +336,24 @@
}
fn statement_effect(&self,
- sets: &mut BlockSets<'_, MovePathIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location)
{
drop_flag_effects_for_location(
self.tcx, self.body, self.mdpe,
location,
- |path, s| Self::update_bits(sets, path, s)
+ |path, s| Self::update_bits(trans, path, s)
)
}
fn terminator_effect(&self,
- sets: &mut BlockSets<'_, MovePathIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location)
{
drop_flag_effects_for_location(
self.tcx, self.body, self.mdpe,
location,
- |path, s| Self::update_bits(sets, path, s)
+ |path, s| Self::update_bits(trans, path, s)
)
}
@@ -389,24 +392,24 @@
}
fn statement_effect(&self,
- sets: &mut BlockSets<'_, MovePathIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location)
{
drop_flag_effects_for_location(
self.tcx, self.body, self.mdpe,
location,
- |path, s| Self::update_bits(sets, path, s)
+ |path, s| Self::update_bits(trans, path, s)
)
}
fn terminator_effect(&self,
- sets: &mut BlockSets<'_, MovePathIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location)
{
drop_flag_effects_for_location(
self.tcx, self.body, self.mdpe,
location,
- |path, s| Self::update_bits(sets, path, s)
+ |path, s| Self::update_bits(trans, path, s)
)
}
@@ -439,7 +442,7 @@
}
fn statement_effect(&self,
- sets: &mut BlockSets<'_, InitIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location) {
let (_, body, move_data) = (self.tcx, self.body, self.move_data());
let stmt = &body[location.block].statements[location.statement_index];
@@ -449,7 +452,7 @@
debug!("statement {:?} at loc {:?} initializes move_indexes {:?}",
stmt, location, &init_loc_map[location]);
- sets.gen_all(&init_loc_map[location]);
+ trans.gen_all(&init_loc_map[location]);
match stmt.kind {
mir::StatementKind::StorageDead(local) => {
@@ -458,14 +461,14 @@
let move_path_index = rev_lookup.find_local(local);
debug!("stmt {:?} at loc {:?} clears the ever initialized status of {:?}",
stmt, location, &init_path_map[move_path_index]);
- sets.kill_all(&init_path_map[move_path_index]);
+ trans.kill_all(&init_path_map[move_path_index]);
}
_ => {}
}
}
fn terminator_effect(&self,
- sets: &mut BlockSets<'_, InitIndex>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location)
{
let (body, move_data) = (self.body, self.move_data());
@@ -473,7 +476,7 @@
let init_loc_map = &move_data.init_loc_map;
debug!("terminator {:?} at loc {:?} initializes move_indexes {:?}",
term, location, &init_loc_map[location]);
- sets.gen_all(
+ trans.gen_all(
init_loc_map[location].iter().filter(|init_index| {
move_data.inits[**init_index].kind != InitKind::NonPanicPathOnly
})
@@ -502,68 +505,22 @@
}
}
-impl<'a, 'tcx> BitSetOperator for MaybeInitializedPlaces<'a, 'tcx> {
- #[inline]
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
- inout_set.union(in_set) // "maybe" means we union effects of both preds
- }
+impl<'a, 'tcx> BottomValue for MaybeInitializedPlaces<'a, 'tcx> {
+ /// bottom = uninitialized
+ const BOTTOM_VALUE: bool = false;
}
-impl<'a, 'tcx> BitSetOperator for MaybeUninitializedPlaces<'a, 'tcx> {
- #[inline]
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
- inout_set.union(in_set) // "maybe" means we union effects of both preds
- }
+impl<'a, 'tcx> BottomValue for MaybeUninitializedPlaces<'a, 'tcx> {
+ /// bottom = initialized (start_block_effect counters this at outset)
+ const BOTTOM_VALUE: bool = false;
}
-impl<'a, 'tcx> BitSetOperator for DefinitelyInitializedPlaces<'a, 'tcx> {
- #[inline]
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
- inout_set.intersect(in_set) // "definitely" means we intersect effects of both preds
- }
+impl<'a, 'tcx> BottomValue for DefinitelyInitializedPlaces<'a, 'tcx> {
+ /// bottom = initialized (start_block_effect counters this at outset)
+ const BOTTOM_VALUE: bool = true;
}
-impl<'a, 'tcx> BitSetOperator for EverInitializedPlaces<'a, 'tcx> {
- #[inline]
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
- inout_set.union(in_set) // inits from both preds are in scope
- }
-}
-
-// The way that dataflow fixed point iteration works, you want to
-// start at bottom and work your way to a fixed point. Control-flow
-// merges will apply the `join` operator to each block entry's current
-// state (which starts at that bottom value).
-//
-// This means, for propagation across the graph, that you either want
-// to start at all-zeroes and then use Union as your merge when
-// propagating, or you start at all-ones and then use Intersect as
-// your merge when propagating.
-
-impl<'a, 'tcx> InitialFlow for MaybeInitializedPlaces<'a, 'tcx> {
- #[inline]
- fn bottom_value() -> bool {
- false // bottom = uninitialized
- }
-}
-
-impl<'a, 'tcx> InitialFlow for MaybeUninitializedPlaces<'a, 'tcx> {
- #[inline]
- fn bottom_value() -> bool {
- false // bottom = initialized (start_block_effect counters this at outset)
- }
-}
-
-impl<'a, 'tcx> InitialFlow for DefinitelyInitializedPlaces<'a, 'tcx> {
- #[inline]
- fn bottom_value() -> bool {
- true // bottom = initialized (start_block_effect counters this at outset)
- }
-}
-
-impl<'a, 'tcx> InitialFlow for EverInitializedPlaces<'a, 'tcx> {
- #[inline]
- fn bottom_value() -> bool {
- false // bottom = no initialized variables by default
- }
+impl<'a, 'tcx> BottomValue for EverInitializedPlaces<'a, 'tcx> {
+ /// bottom = no initialized variables by default
+ const BOTTOM_VALUE: bool = false;
}
diff --git a/src/librustc_mir/dataflow/impls/storage_liveness.rs b/src/librustc_mir/dataflow/impls/storage_liveness.rs
index d7575b0..d200399 100644
--- a/src/librustc_mir/dataflow/impls/storage_liveness.rs
+++ b/src/librustc_mir/dataflow/impls/storage_liveness.rs
@@ -26,24 +26,24 @@
self.body.local_decls.len()
}
- fn start_block_effect(&self, _sets: &mut BitSet<Local>) {
+ fn start_block_effect(&self, _on_entry: &mut BitSet<Local>) {
// Nothing is live on function entry
}
fn statement_effect(&self,
- sets: &mut BlockSets<'_, Local>,
+ trans: &mut GenKillSet<Local>,
loc: Location) {
let stmt = &self.body[loc.block].statements[loc.statement_index];
match stmt.kind {
- StatementKind::StorageLive(l) => sets.gen(l),
- StatementKind::StorageDead(l) => sets.kill(l),
+ StatementKind::StorageLive(l) => trans.gen(l),
+ StatementKind::StorageDead(l) => trans.kill(l),
_ => (),
}
}
fn terminator_effect(&self,
- _sets: &mut BlockSets<'_, Local>,
+ _trans: &mut GenKillSet<Local>,
_loc: Location) {
// Terminators have no effect
}
@@ -59,16 +59,7 @@
}
}
-impl<'a, 'tcx> BitSetOperator for MaybeStorageLive<'a, 'tcx> {
- #[inline]
- fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
- inout_set.union(in_set) // "maybe" means we union effects of both preds
- }
-}
-
-impl<'a, 'tcx> InitialFlow for MaybeStorageLive<'a, 'tcx> {
- #[inline]
- fn bottom_value() -> bool {
- false // bottom = dead
- }
+impl<'a, 'tcx> BottomValue for MaybeStorageLive<'a, 'tcx> {
+ /// bottom = dead
+ const BOTTOM_VALUE: bool = false;
}
diff --git a/src/librustc_mir/dataflow/mod.rs b/src/librustc_mir/dataflow/mod.rs
index 0728d5b2..80f65a9 100644
--- a/src/librustc_mir/dataflow/mod.rs
+++ b/src/librustc_mir/dataflow/mod.rs
@@ -1,7 +1,7 @@
use syntax::ast::{self, MetaItem};
use syntax::symbol::{Symbol, sym};
-use rustc_data_structures::bit_set::{BitSet, BitSetOperator, HybridBitSet};
+use rustc_data_structures::bit_set::{BitSet, HybridBitSet};
use rustc_data_structures::indexed_vec::Idx;
use rustc_data_structures::work_queue::WorkQueue;
@@ -131,7 +131,7 @@
p: P,
) -> DataflowResults<'tcx, BD>
where
- BD: BitDenotation<'tcx> + InitialFlow,
+ BD: BitDenotation<'tcx>,
P: Fn(&BD, BD::Idx) -> DebugFormatted,
{
let flow_state = DataflowAnalysis::new(body, dead_unwinds, bd);
@@ -181,7 +181,7 @@
struct PropagationContext<'b, 'a, 'tcx, O>
where
- O: 'b + BitDenotation<'tcx>,
+ O: BitDenotation<'tcx>,
{
builder: &'b mut DataflowAnalysis<'a, 'tcx, O>,
}
@@ -199,42 +199,27 @@
}
fn build_sets(&mut self) {
- // First we need to build the entry-, gen- and kill-sets.
-
- {
- let sets = &mut self.flow_state.sets.for_block(mir::START_BLOCK.index());
- self.flow_state.operator.start_block_effect(&mut sets.on_entry);
- }
-
+ // Build the transfer function for each block.
for (bb, data) in self.body.basic_blocks().iter_enumerated() {
let &mir::BasicBlockData { ref statements, ref terminator, is_cleanup: _ } = data;
- let mut interim_state;
- let sets = &mut self.flow_state.sets.for_block(bb.index());
- let track_intrablock = BD::accumulates_intrablock_state();
- if track_intrablock {
- debug!("swapping in mutable on_entry, initially {:?}", sets.on_entry);
- interim_state = sets.on_entry.to_owned();
- sets.on_entry = &mut interim_state;
- }
+ let trans = self.flow_state.sets.trans_mut_for(bb.index());
for j_stmt in 0..statements.len() {
let location = Location { block: bb, statement_index: j_stmt };
- self.flow_state.operator.before_statement_effect(sets, location);
- self.flow_state.operator.statement_effect(sets, location);
- if track_intrablock {
- sets.apply_local_effect();
- }
+ self.flow_state.operator.before_statement_effect(trans, location);
+ self.flow_state.operator.statement_effect(trans, location);
}
if terminator.is_some() {
let location = Location { block: bb, statement_index: statements.len() };
- self.flow_state.operator.before_terminator_effect(sets, location);
- self.flow_state.operator.terminator_effect(sets, location);
- if track_intrablock {
- sets.apply_local_effect();
- }
+ self.flow_state.operator.before_terminator_effect(trans, location);
+ self.flow_state.operator.terminator_effect(trans, location);
}
}
+
+ // Initialize the flow state at entry to the start block.
+ let on_entry = self.flow_state.sets.entry_set_mut_for(mir::START_BLOCK.index());
+ self.flow_state.operator.start_block_effect(on_entry);
}
}
@@ -247,14 +232,12 @@
WorkQueue::with_all(self.builder.body.basic_blocks().len());
let body = self.builder.body;
while let Some(bb) = dirty_queue.pop() {
+ let (on_entry, trans) = self.builder.flow_state.sets.get_mut(bb.index());
+ debug_assert!(in_out.words().len() == on_entry.words().len());
+ in_out.overwrite(on_entry);
+ trans.apply(in_out);
+
let bb_data = &body[bb];
- {
- let sets = self.builder.flow_state.sets.for_block(bb.index());
- debug_assert!(in_out.words().len() == sets.on_entry.words().len());
- in_out.overwrite(sets.on_entry);
- in_out.union(sets.gen_set);
- in_out.subtract(sets.kill_set);
- }
self.builder.propagate_bits_into_graph_successors_of(
in_out, (bb, bb_data), &mut dirty_queue);
}
@@ -366,33 +349,27 @@
result: &DataflowResults<'tcx, T>,
body: &Body<'tcx>)
-> BitSet<T::Idx> {
- let mut on_entry = result.sets().on_entry_set_for(loc.block.index()).to_owned();
- let mut kill_set = on_entry.to_hybrid();
- let mut gen_set = kill_set.clone();
+ let mut trans = GenKill::from_elem(HybridBitSet::new_empty(analysis.bits_per_block()));
- {
- let mut sets = BlockSets {
- on_entry: &mut on_entry,
- kill_set: &mut kill_set,
- gen_set: &mut gen_set,
- };
-
- for stmt in 0..loc.statement_index {
- let mut stmt_loc = loc;
- stmt_loc.statement_index = stmt;
- analysis.before_statement_effect(&mut sets, stmt_loc);
- analysis.statement_effect(&mut sets, stmt_loc);
- }
-
- // Apply the pre-statement effect of the statement we're evaluating.
- if loc.statement_index == body[loc.block].statements.len() {
- analysis.before_terminator_effect(&mut sets, loc);
- } else {
- analysis.before_statement_effect(&mut sets, loc);
- }
+ for stmt in 0..loc.statement_index {
+ let mut stmt_loc = loc;
+ stmt_loc.statement_index = stmt;
+ analysis.before_statement_effect(&mut trans, stmt_loc);
+ analysis.statement_effect(&mut trans, stmt_loc);
}
- gen_set.to_dense()
+ // Apply the pre-statement effect of the statement we're evaluating.
+ if loc.statement_index == body[loc.block].statements.len() {
+ analysis.before_terminator_effect(&mut trans, loc);
+ } else {
+ analysis.before_statement_effect(&mut trans, loc);
+ }
+
+ // Apply the transfer function for all preceding statements to the fixpoint
+ // at the start of the block.
+ let mut state = result.sets().entry_set_for(loc.block.index()).to_owned();
+ trans.apply(&mut state);
+ state
}
pub struct DataflowAnalysis<'a, 'tcx, O>
@@ -462,36 +439,8 @@
}
}
-#[derive(Debug)]
-pub struct AllSets<E: Idx> {
- /// Analysis bitwidth for each block.
- bits_per_block: usize,
-
- /// For each block, bits valid on entry to the block.
- on_entry_sets: Vec<BitSet<E>>,
-
- /// For each block, bits generated by executing the statements +
- /// terminator in the block -- with one caveat. In particular, for
- /// *call terminators*, the effect of storing the destination is
- /// not included, since that only takes effect on the **success**
- /// edge (and not the unwind edge).
- gen_sets: Vec<HybridBitSet<E>>,
-
- /// For each block, bits killed by executing the statements +
- /// terminator in the block -- with one caveat. In particular, for
- /// *call terminators*, the effect of storing the destination is
- /// not included, since that only takes effect on the **success**
- /// edge (and not the unwind edge).
- kill_sets: Vec<HybridBitSet<E>>,
-}
-
-/// Triple of sets associated with a given block.
-///
-/// Generally, one sets up `on_entry`, `gen_set`, and `kill_set` for
-/// each block individually, and then runs the dataflow analysis which
-/// iteratively modifies the various `on_entry` sets (but leaves the
-/// other two sets unchanged, since they represent the effect of the
-/// block, which should be invariant over the course of the analysis).
+/// A 2-tuple representing the "gen" and "kill" bitsets during
+/// dataflow analysis.
///
/// It is best to ensure that the intersection of `gen_set` and
/// `kill_set` is empty; otherwise the results of the dataflow will
@@ -499,21 +448,32 @@
/// killed during the iteration. (This is such a good idea that the
/// `fn gen` and `fn kill` methods that set their state enforce this
/// for you.)
-#[derive(Debug)]
-pub struct BlockSets<'a, E: Idx> {
- /// Dataflow state immediately before control flow enters the given block.
- pub(crate) on_entry: &'a mut BitSet<E>,
-
- /// Bits that are set to 1 by the time we exit the given block. Hybrid
- /// because it usually contains only 0 or 1 elements.
- pub(crate) gen_set: &'a mut HybridBitSet<E>,
-
- /// Bits that are set to 0 by the time we exit the given block. Hybrid
- /// because it usually contains only 0 or 1 elements.
- pub(crate) kill_set: &'a mut HybridBitSet<E>,
+#[derive(Debug, Clone, Copy)]
+pub struct GenKill<T> {
+ pub(crate) gen_set: T,
+ pub(crate) kill_set: T,
}
-impl<'a, E:Idx> BlockSets<'a, E> {
+type GenKillSet<T> = GenKill<HybridBitSet<T>>;
+
+impl<T> GenKill<T> {
+ /// Creates a new tuple where `gen_set == kill_set == elem`.
+ pub(crate) fn from_elem(elem: T) -> Self
+ where T: Clone
+ {
+ GenKill {
+ gen_set: elem.clone(),
+ kill_set: elem,
+ }
+ }
+}
+
+impl<E:Idx> GenKillSet<E> {
+ pub(crate) fn clear(&mut self) {
+ self.gen_set.clear();
+ self.kill_set.clear();
+ }
+
fn gen(&mut self, e: E) {
self.gen_set.insert(e);
self.kill_set.remove(e);
@@ -541,73 +501,93 @@
}
}
- fn apply_local_effect(&mut self) {
- self.on_entry.union(self.gen_set);
- self.on_entry.subtract(self.kill_set);
+ /// Computes `(set ∪ gen) - kill` and assigns the result to `set`.
+ pub(crate) fn apply(&self, set: &mut BitSet<E>) {
+ set.union(&self.gen_set);
+ set.subtract(&self.kill_set);
}
}
+#[derive(Debug)]
+pub struct AllSets<E: Idx> {
+ /// Analysis bitwidth for each block.
+ bits_per_block: usize,
+
+ /// For each block, bits valid on entry to the block.
+ on_entry: Vec<BitSet<E>>,
+
+ /// The transfer function of each block expressed as the set of bits
+ /// generated and killed by executing the statements + terminator in the
+ /// block -- with one caveat. In particular, for *call terminators*, the
+ /// effect of storing the destination is not included, since that only takes
+ /// effect on the **success** edge (and not the unwind edge).
+ trans: Vec<GenKillSet<E>>,
+}
+
impl<E:Idx> AllSets<E> {
pub fn bits_per_block(&self) -> usize { self.bits_per_block }
- pub fn for_block(&mut self, block_idx: usize) -> BlockSets<'_, E> {
- BlockSets {
- on_entry: &mut self.on_entry_sets[block_idx],
- gen_set: &mut self.gen_sets[block_idx],
- kill_set: &mut self.kill_sets[block_idx],
- }
+
+ pub fn get_mut(&mut self, block_idx: usize) -> (&mut BitSet<E>, &mut GenKillSet<E>) {
+ (&mut self.on_entry[block_idx], &mut self.trans[block_idx])
}
- pub fn on_entry_set_for(&self, block_idx: usize) -> &BitSet<E> {
- &self.on_entry_sets[block_idx]
+ pub fn trans_for(&self, block_idx: usize) -> &GenKillSet<E> {
+ &self.trans[block_idx]
+ }
+ pub fn trans_mut_for(&mut self, block_idx: usize) -> &mut GenKillSet<E> {
+ &mut self.trans[block_idx]
+ }
+ pub fn entry_set_for(&self, block_idx: usize) -> &BitSet<E> {
+ &self.on_entry[block_idx]
+ }
+ pub fn entry_set_mut_for(&mut self, block_idx: usize) -> &mut BitSet<E> {
+ &mut self.on_entry[block_idx]
}
pub fn gen_set_for(&self, block_idx: usize) -> &HybridBitSet<E> {
- &self.gen_sets[block_idx]
+ &self.trans_for(block_idx).gen_set
}
pub fn kill_set_for(&self, block_idx: usize) -> &HybridBitSet<E> {
- &self.kill_sets[block_idx]
+ &self.trans_for(block_idx).kill_set
}
}
/// Parameterization for the precise form of data flow that is used.
-/// `InitialFlow` handles initializing the bitvectors before any
-/// code is inspected by the analysis. Analyses that need more nuanced
-/// initialization (e.g., they need to consult the results of some other
-/// dataflow analysis to set up the initial bitvectors) should not
-/// implement this.
-pub trait InitialFlow {
- /// Specifies the initial value for each bit in the `on_entry` set
- fn bottom_value() -> bool;
+///
+/// `BottomValue` determines whether the initial entry set for each basic block is empty or full.
+/// This also determines the semantics of the lattice `join` operator used to merge dataflow
+/// results, since dataflow works by starting at the bottom and moving monotonically to a fixed
+/// point.
+///
+/// This means, for propagation across the graph, that you either want to start at all-zeroes and
+/// then use Union as your merge when propagating, or you start at all-ones and then use Intersect
+/// as your merge when propagating.
+pub trait BottomValue {
+ /// Specifies the initial value for each bit in the entry set for each basic block.
+ const BOTTOM_VALUE: bool;
+
+ /// Merges `in_set` into `inout_set`, returning `true` if `inout_set` changed.
+ #[inline]
+ fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
+ if Self::BOTTOM_VALUE == false {
+ inout_set.union(in_set)
+ } else {
+ inout_set.intersect(in_set)
+ }
+ }
}
-pub trait BitDenotation<'tcx>: BitSetOperator {
+/// A specific flavor of dataflow analysis.
+///
+/// To run a dataflow analysis, one sets up an initial state for the
+/// `START_BLOCK` via `start_block_effect` and a transfer function (`trans`)
+/// for each block individually. The entry set for all other basic blocks is
+/// initialized to `Self::BOTTOM_VALUE`. The dataflow analysis then
+/// iteratively modifies the various entry sets (but leaves the the transfer
+/// function unchanged).
+pub trait BitDenotation<'tcx>: BottomValue {
/// Specifies what index type is used to access the bitvector.
type Idx: Idx;
- /// Some analyses want to accumulate knowledge within a block when
- /// analyzing its statements for building the gen/kill sets. Override
- /// this method to return true in such cases.
- ///
- /// When this returns true, the statement-effect (re)construction
- /// will clone the `on_entry` state and pass along a reference via
- /// `sets.on_entry` to that local clone into `statement_effect` and
- /// `terminator_effect`).
- ///
- /// When it's false, no local clone is constructed; instead a
- /// reference directly into `on_entry` is passed along via
- /// `sets.on_entry` instead, which represents the flow state at
- /// the block's start, not necessarily the state immediately prior
- /// to the statement/terminator under analysis.
- ///
- /// In either case, the passed reference is mutable, but this is a
- /// wart from using the `BlockSets` type in the API; the intention
- /// is that the `statement_effect` and `terminator_effect` methods
- /// mutate only the gen/kill sets.
- //
- // FIXME: we should consider enforcing the intention described in
- // the previous paragraph by passing the three sets in separate
- // parameters to encode their distinct mutabilities.
- fn accumulates_intrablock_state() -> bool { false }
-
/// A name describing the dataflow analysis that this
/// `BitDenotation` is supporting. The name should be something
/// suitable for plugging in as part of a filename (i.e., avoid
@@ -640,7 +620,7 @@
/// applied, in that order, before moving for the next
/// statement.
fn before_statement_effect(&self,
- _sets: &mut BlockSets<'_, Self::Idx>,
+ _trans: &mut GenKillSet<Self::Idx>,
_location: Location) {}
/// Mutates the block-sets (the flow sets for the given
@@ -654,7 +634,7 @@
/// `bb_data` is the sequence of statements identified by `bb` in
/// the MIR.
fn statement_effect(&self,
- sets: &mut BlockSets<'_, Self::Idx>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location);
/// Similar to `terminator_effect`, except it applies
@@ -669,7 +649,7 @@
/// applied, in that order, before moving for the next
/// terminator.
fn before_terminator_effect(&self,
- _sets: &mut BlockSets<'_, Self::Idx>,
+ _trans: &mut GenKillSet<Self::Idx>,
_location: Location) {}
/// Mutates the block-sets (the flow sets for the given
@@ -683,7 +663,7 @@
/// The effects applied here cannot depend on which branch the
/// terminator took.
fn terminator_effect(&self,
- sets: &mut BlockSets<'_, Self::Idx>,
+ trans: &mut GenKillSet<Self::Idx>,
location: Location);
/// Mutates the block-sets according to the (flow-dependent)
@@ -718,17 +698,16 @@
{
pub fn new(body: &'a Body<'tcx>,
dead_unwinds: &'a BitSet<mir::BasicBlock>,
- denotation: D) -> Self where D: InitialFlow {
+ denotation: D) -> Self {
let bits_per_block = denotation.bits_per_block();
let num_blocks = body.basic_blocks().len();
- let on_entry_sets = if D::bottom_value() {
+ let on_entry = if D::BOTTOM_VALUE == true {
vec![BitSet::new_filled(bits_per_block); num_blocks]
} else {
vec![BitSet::new_empty(bits_per_block); num_blocks]
};
- let gen_sets = vec![HybridBitSet::new_empty(bits_per_block); num_blocks];
- let kill_sets = gen_sets.clone();
+ let nop = GenKill::from_elem(HybridBitSet::new_empty(bits_per_block));
DataflowAnalysis {
body,
@@ -736,9 +715,8 @@
flow_state: DataflowState {
sets: AllSets {
bits_per_block,
- on_entry_sets,
- gen_sets,
- kill_sets,
+ on_entry,
+ trans: vec![nop; num_blocks],
},
operator: denotation,
}
@@ -836,7 +814,7 @@
in_out: &BitSet<D::Idx>,
bb: mir::BasicBlock,
dirty_queue: &mut WorkQueue<mir::BasicBlock>) {
- let entry_set = &mut self.flow_state.sets.for_block(bb.index()).on_entry;
+ let entry_set = self.flow_state.sets.entry_set_mut_for(bb.index());
let set_changed = self.flow_state.operator.join(entry_set, &in_out);
if set_changed {
dirty_queue.insert(bb);
diff --git a/src/librustc_mir/dataflow/move_paths/builder.rs b/src/librustc_mir/dataflow/move_paths/builder.rs
index e8386e8..f282c27 100644
--- a/src/librustc_mir/dataflow/move_paths/builder.rs
+++ b/src/librustc_mir/dataflow/move_paths/builder.rs
@@ -33,13 +33,13 @@
moves: IndexVec::new(),
loc_map: LocationMap::new(body),
rev_lookup: MovePathLookup {
- locals: body.local_decls.indices().map(PlaceBase::Local).map(|v| {
+ locals: body.local_decls.indices().map(|i| {
Self::new_move_path(
&mut move_paths,
&mut path_map,
&mut init_path_map,
None,
- Place::Base(v),
+ Place::from(i),
)
}).collect(),
projections: Default::default(),
@@ -289,7 +289,7 @@
}
StatementKind::StorageLive(_) => {}
StatementKind::StorageDead(local) => {
- self.gather_move(&Place::Base(PlaceBase::Local(local)));
+ self.gather_move(&Place::from(local));
}
StatementKind::SetDiscriminant{ .. } => {
span_bug!(stmt.source_info.span,
diff --git a/src/librustc_mir/hair/cx/expr.rs b/src/librustc_mir/hair/cx/expr.rs
index baf9086..94b4f6e 100644
--- a/src/librustc_mir/hair/cx/expr.rs
+++ b/src/librustc_mir/hair/cx/expr.rs
@@ -909,12 +909,12 @@
Res::Def(DefKind::ConstParam, def_id) => {
let hir_id = cx.tcx.hir().as_local_hir_id(def_id).unwrap();
- let item_id = cx.tcx.hir().get_parent_node_by_hir_id(hir_id);
+ let item_id = cx.tcx.hir().get_parent_node(hir_id);
let item_def_id = cx.tcx.hir().local_def_id_from_hir_id(item_id);
let generics = cx.tcx.generics_of(item_def_id);
let local_def_id = cx.tcx.hir().local_def_id_from_hir_id(hir_id);
let index = generics.param_def_id_to_index[&local_def_id];
- let name = cx.tcx.hir().name_by_hir_id(hir_id).as_interned_str();
+ let name = cx.tcx.hir().name(hir_id).as_interned_str();
let val = ConstValue::Param(ty::ParamConst::new(index, name));
ExprKind::Literal {
literal: cx.tcx.mk_const(
diff --git a/src/librustc_mir/hair/cx/mod.rs b/src/librustc_mir/hair/cx/mod.rs
index 4e197f1..a21d900 100644
--- a/src/librustc_mir/hair/cx/mod.rs
+++ b/src/librustc_mir/hair/cx/mod.rs
@@ -155,7 +155,7 @@
pub fn pattern_from_hir(&mut self, p: &hir::Pat) -> Pattern<'tcx> {
let tcx = self.tcx.global_tcx();
- let p = match tcx.hir().get_by_hir_id(p.hir_id) {
+ let p = match tcx.hir().get(p.hir_id) {
Node::Pat(p) | Node::Binding(p) => p,
node => bug!("pattern became {:?}", node)
};
diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs
index 974c863..fc29518 100644
--- a/src/librustc_mir/hair/pattern/_match.rs
+++ b/src/librustc_mir/hair/pattern/_match.rs
@@ -217,12 +217,12 @@
// the easy case, deref a reference
(ConstValue::Scalar(Scalar::Ptr(p)), x, y) if x == y => {
let alloc = self.tcx.alloc_map.lock().unwrap_memory(p.alloc_id);
- ConstValue::ByRef(
- p,
+ ConstValue::ByRef {
+ offset: p.offset,
// FIXME(oli-obk): this should be the type's layout
- alloc.align,
+ align: alloc.align,
alloc,
- )
+ }
},
// unsize array to slice if pattern is array but match value or other patterns are slice
(ConstValue::Scalar(Scalar::Ptr(p)), ty::Array(t, n), ty::Slice(u)) => {
@@ -1436,9 +1436,10 @@
suffix: &[Pattern<'tcx>],
) -> Result<bool, ErrorReported> {
let data: &[u8] = match (const_val.val, &const_val.ty.sty) {
- (ConstValue::ByRef(ptr, _, alloc), ty::Array(t, n)) => {
+ (ConstValue::ByRef { offset, alloc, .. }, ty::Array(t, n)) => {
assert_eq!(*t, tcx.types.u8);
let n = n.assert_usize(tcx).unwrap();
+ let ptr = Pointer::new(AllocId(0), offset);
alloc.get_bytes(&tcx, ptr, Size::from_bytes(n)).unwrap()
},
(ConstValue::Slice { data, start, end }, ty::Slice(t)) => {
@@ -1758,9 +1759,9 @@
let (alloc, offset, n, ty) = match value.ty.sty {
ty::Array(t, n) => {
match value.val {
- ConstValue::ByRef(ptr, _, alloc) => (
+ ConstValue::ByRef { offset, alloc, .. } => (
alloc,
- ptr.offset,
+ offset,
n.unwrap_usize(cx.tcx),
t,
),
@@ -1778,7 +1779,7 @@
(end - start) as u64,
t,
),
- ConstValue::ByRef(..) => {
+ ConstValue::ByRef { .. } => {
// FIXME(oli-obk): implement `deref` for `ConstValue`
return None;
},
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 4afa4a0..c6e762b 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -319,7 +319,7 @@
t: T,
) -> InterpResult<'tcx, T> {
match self.stack.last() {
- Some(frame) => Ok(self.monomorphize_with_substs(t, frame.instance.substs)),
+ Some(frame) => Ok(self.monomorphize_with_substs(t, frame.instance.substs)?),
None => if t.needs_subst() {
err!(TooGeneric).into()
} else {
@@ -332,11 +332,16 @@
&self,
t: T,
substs: SubstsRef<'tcx>
- ) -> T {
+ ) -> InterpResult<'tcx, T> {
// miri doesn't care about lifetimes, and will choke on some crazy ones
// let's simply get rid of them
let substituted = t.subst(*self.tcx, substs);
- self.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), substituted)
+
+ if substituted.needs_subst() {
+ return err!(TooGeneric);
+ }
+
+ Ok(self.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), substituted))
}
pub fn layout_of_local(
@@ -349,7 +354,7 @@
None => {
let layout = crate::interpret::operand::from_known_layout(layout, || {
let local_ty = frame.body.local_decls[local].ty;
- let local_ty = self.monomorphize_with_substs(local_ty, frame.instance.substs);
+ let local_ty = self.monomorphize_with_substs(local_ty, frame.instance.substs)?;
self.layout_of(local_ty)
})?;
// Layouts of locals are requested a lot, so we cache them.
@@ -437,7 +442,7 @@
Ok(Some((size.align_to(align), align)))
}
ty::Dynamic(..) => {
- let vtable = metadata.expect("dyn trait fat ptr must have vtable").to_ptr()?;
+ let vtable = metadata.expect("dyn trait fat ptr must have vtable");
// the second entry in the vtable is the dynamic size of the object.
Ok(Some(self.read_size_and_align_from_vtable(vtable)?))
}
diff --git a/src/librustc_mir/interpret/intern.rs b/src/librustc_mir/interpret/intern.rs
index d998f40..f0d64e2 100644
--- a/src/librustc_mir/interpret/intern.rs
+++ b/src/librustc_mir/interpret/intern.rs
@@ -3,7 +3,6 @@
//! After a const evaluation has computed a value, before we destroy the const evaluator's session
//! memory, we need to extract all memory allocations to the global memory pool so they stay around.
-use rustc::ty::layout::LayoutOf;
use rustc::ty::{Ty, TyCtxt, ParamEnv, self};
use rustc::mir::interpret::{
InterpResult, ErrorHandled,
@@ -21,7 +20,7 @@
};
use crate::const_eval::{CompileTimeInterpreter, CompileTimeEvalContext};
-struct InternVisitor<'rt, 'mir: 'rt, 'tcx: 'rt + 'mir> {
+struct InternVisitor<'rt, 'mir, 'tcx> {
/// previously encountered safe references
ref_tracking: &'rt mut RefTracking<(MPlaceTy<'tcx>, Mutability, InternMode)>,
ecx: &'rt mut CompileTimeEvalContext<'mir, 'tcx>,
@@ -143,18 +142,15 @@
// Handle Reference types, as these are the only relocations supported by const eval.
// Raw pointers (and boxes) are handled by the `leftover_relocations` logic.
let ty = mplace.layout.ty;
- if let ty::Ref(_, _, mutability) = ty.sty {
+ if let ty::Ref(_, referenced_ty, mutability) = ty.sty {
let value = self.ecx.read_immediate(mplace.into())?;
// Handle trait object vtables
if let Ok(meta) = value.to_meta() {
- let layout = self.ecx.layout_of(ty.builtin_deref(true).unwrap().ty)?;
- if layout.is_unsized() {
- if let ty::Dynamic(..) = self.ecx.tcx.struct_tail(layout.ty).sty {
- if let Ok(vtable) = meta.unwrap().to_ptr() {
- // explitly choose `Immutable` here, since vtables are immutable, even
- // if the reference of the fat pointer is mutable
- self.intern_shallow(vtable, Mutability::Immutable)?;
- }
+ if let ty::Dynamic(..) = self.ecx.tcx.struct_tail(referenced_ty).sty {
+ if let Ok(vtable) = meta.unwrap().to_ptr() {
+ // explitly choose `Immutable` here, since vtables are immutable, even
+ // if the reference of the fat pointer is mutable
+ self.intern_shallow(vtable, Mutability::Immutable)?;
}
}
}
@@ -178,8 +174,14 @@
(InternMode::Static, hir::Mutability::MutMutable) => {},
// we statically prevent `&mut T` via `const_qualif` and double check this here
(InternMode::ConstBase, hir::Mutability::MutMutable) |
- (InternMode::Const, hir::Mutability::MutMutable) =>
- bug!("const qualif failed to prevent mutable references"),
+ (InternMode::Const, hir::Mutability::MutMutable) => {
+ match referenced_ty.sty {
+ ty::Array(_, n) if n.unwrap_usize(self.ecx.tcx.tcx) == 0 => {}
+ ty::Slice(_)
+ if value.to_meta().unwrap().unwrap().to_usize(self.ecx)? == 0 => {}
+ _ => bug!("const qualif failed to prevent mutable references"),
+ }
+ },
}
// Compute the mutability with which we'll start visiting the allocation. This is
// what gets changed when we encounter an `UnsafeCell`
diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs
index 2581c13..4eb95f2 100644
--- a/src/librustc_mir/interpret/machine.rs
+++ b/src/librustc_mir/interpret/machine.rs
@@ -11,8 +11,7 @@
use super::{
Allocation, AllocId, InterpResult, Scalar, AllocationExtra,
- InterpretCx, PlaceTy, OpTy, ImmTy, MemoryKind, Pointer,
- InterpErrorInfo, InterpError
+ InterpretCx, PlaceTy, OpTy, ImmTy, MemoryKind, Pointer, Memory
};
/// Whether this kind of memory is allowed to leak
@@ -178,7 +177,7 @@
id: AllocId,
alloc: Cow<'b, Allocation>,
kind: Option<MemoryKind<Self::MemoryKinds>>,
- memory_extra: &Self::MemoryExtra,
+ memory: &Memory<'mir, 'tcx, Self>,
) -> (Cow<'b, Allocation<Self::PointerTag, Self::AllocExtra>>, Self::PointerTag);
/// Return the "base" tag for the given static allocation: the one that is used for direct
@@ -188,7 +187,7 @@
/// for cyclic statics!
fn tag_static_base_pointer(
id: AllocId,
- memory_extra: &Self::MemoryExtra,
+ memory: &Memory<'mir, 'tcx, Self>,
) -> Self::PointerTag;
/// Executes a retagging operation
@@ -212,19 +211,19 @@
fn int_to_ptr(
int: u64,
- _extra: &Self::MemoryExtra,
+ _mem: &Memory<'mir, 'tcx, Self>,
) -> InterpResult<'tcx, Pointer<Self::PointerTag>> {
if int == 0 {
- Err(InterpErrorInfo::from(InterpError::InvalidNullPointerUsage))
+ err!(InvalidNullPointerUsage)
} else {
- Err(InterpErrorInfo::from(InterpError::ReadBytesAsPointer))
+ err!(ReadBytesAsPointer)
}
}
fn ptr_to_int(
_ptr: Pointer<Self::PointerTag>,
- _extra: &Self::MemoryExtra,
+ _mem: &Memory<'mir, 'tcx, Self>,
) -> InterpResult<'tcx, u64> {
- Err(InterpErrorInfo::from(InterpError::ReadPointerAsBytes))
+ err!(ReadPointerAsBytes)
}
}
diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
index f2a115f..c3eec67 100644
--- a/src/librustc_mir/interpret/memory.rs
+++ b/src/librustc_mir/interpret/memory.rs
@@ -19,8 +19,7 @@
use super::{
Pointer, AllocId, Allocation, GlobalId, AllocationExtra,
InterpResult, Scalar, InterpError, GlobalAlloc, PointerArithmetic,
- Machine, AllocMap, MayLeak, ErrorHandled, CheckInAllocMsg, InboundsCheck,
- InterpError::ValidationFailure,
+ Machine, AllocMap, MayLeak, ErrorHandled, CheckInAllocMsg,
};
#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
@@ -44,6 +43,17 @@
}
}
+/// Used by `get_size_and_align` to indicate whether the allocation needs to be live.
+#[derive(Debug, Copy, Clone)]
+pub enum AllocCheck {
+ /// Allocation must be live and not a function pointer.
+ Dereferencable,
+ /// Allocations needs to be live, but may be a function pointer.
+ Live,
+ /// Allocation may be dead.
+ MaybeDead,
+}
+
// `Memory` has to depend on the `Machine` because some of its operations
// (e.g., `get`) call a `Machine` hook.
pub struct Memory<'mir, 'tcx, M: Machine<'mir, 'tcx>> {
@@ -107,7 +117,7 @@
#[inline]
pub fn tag_static_base_pointer(&self, ptr: Pointer) -> Pointer<M::PointerTag> {
- ptr.with_tag(M::tag_static_base_pointer(ptr.alloc_id, &self.extra))
+ ptr.with_tag(M::tag_static_base_pointer(ptr.alloc_id, &self))
}
pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> Pointer<M::PointerTag> {
@@ -140,7 +150,7 @@
kind: MemoryKind<M::MemoryKinds>,
) -> Pointer<M::PointerTag> {
let id = self.tcx.alloc_map.lock().reserve();
- let (alloc, tag) = M::tag_allocation(id, Cow::Owned(alloc), Some(kind), &self.extra);
+ let (alloc, tag) = M::tag_allocation(id, Cow::Owned(alloc), Some(kind), &self);
self.alloc_map.insert(id, (kind, alloc.into_owned()));
Pointer::from(id).with_tag(tag)
}
@@ -248,63 +258,93 @@
Ok(())
}
- /// Checks that the pointer is aligned AND non-NULL. This supports ZSTs in two ways:
- /// You can pass a scalar, and a `Pointer` does not have to actually still be allocated.
- pub fn check_align(
+ /// Check if the given scalar is allowed to do a memory access of given `size`
+ /// and `align`. On success, returns `None` for zero-sized accesses (where
+ /// nothing else is left to do) and a `Pointer` to use for the actual access otherwise.
+ /// Crucially, if the input is a `Pointer`, we will test it for liveness
+ /// *even of* the size is 0.
+ ///
+ /// Everyone accessing memory based on a `Scalar` should use this method to get the
+ /// `Pointer` they need. And even if you already have a `Pointer`, call this method
+ /// to make sure it is sufficiently aligned and not dangling. Not doing that may
+ /// cause ICEs.
+ pub fn check_ptr_access(
&self,
- ptr: Scalar<M::PointerTag>,
- required_align: Align
- ) -> InterpResult<'tcx> {
- // Check non-NULL/Undef, extract offset
- let (offset, alloc_align) = match ptr.to_bits_or_ptr(self.pointer_size(), self) {
- Err(ptr) => {
- // check this is not NULL -- which we can ensure only if this is in-bounds
- // of some (potentially dead) allocation.
- let align = self.check_bounds_ptr(ptr, InboundsCheck::MaybeDead,
- CheckInAllocMsg::NullPointerTest)?;
- (ptr.offset.bytes(), align)
+ sptr: Scalar<M::PointerTag>,
+ size: Size,
+ align: Align,
+ ) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> {
+ fn check_offset_align(offset: u64, align: Align) -> InterpResult<'static> {
+ if offset % align.bytes() == 0 {
+ Ok(())
+ } else {
+ // The biggest power of two through which `offset` is divisible.
+ let offset_pow2 = 1 << offset.trailing_zeros();
+ err!(AlignmentCheckFailed {
+ has: Align::from_bytes(offset_pow2).unwrap(),
+ required: align,
+ })
}
- Ok(data) => {
- // check this is not NULL
- if data == 0 {
+ }
+
+ // Normalize to a `Pointer` if we definitely need one.
+ let normalized = if size.bytes() == 0 {
+ // Can be an integer, just take what we got. We do NOT `force_bits` here;
+ // if this is already a `Pointer` we want to do the bounds checks!
+ sptr
+ } else {
+ // A "real" access, we must get a pointer.
+ Scalar::Ptr(self.force_ptr(sptr)?)
+ };
+ Ok(match normalized.to_bits_or_ptr(self.pointer_size(), self) {
+ Ok(bits) => {
+ let bits = bits as u64; // it's ptr-sized
+ assert!(size.bytes() == 0);
+ // Must be non-NULL and aligned.
+ if bits == 0 {
return err!(InvalidNullPointerUsage);
}
- // the "base address" is 0 and hence always aligned
- (data as u64, required_align)
+ check_offset_align(bits, align)?;
+ None
}
- };
- // Check alignment
- if alloc_align.bytes() < required_align.bytes() {
- return err!(AlignmentCheckFailed {
- has: alloc_align,
- required: required_align,
- });
- }
- if offset % required_align.bytes() == 0 {
- Ok(())
- } else {
- let has = offset % required_align.bytes();
- err!(AlignmentCheckFailed {
- has: Align::from_bytes(has).unwrap(),
- required: required_align,
- })
- }
+ Err(ptr) => {
+ let (allocation_size, alloc_align) =
+ self.get_size_and_align(ptr.alloc_id, AllocCheck::Dereferencable)?;
+ // Test bounds. This also ensures non-NULL.
+ // It is sufficient to check this for the end pointer. The addition
+ // checks for overflow.
+ let end_ptr = ptr.offset(size, self)?;
+ end_ptr.check_in_alloc(allocation_size, CheckInAllocMsg::MemoryAccessTest)?;
+ // Test align. Check this last; if both bounds and alignment are violated
+ // we want the error to be about the bounds.
+ if alloc_align.bytes() < align.bytes() {
+ // The allocation itself is not aligned enough.
+ // FIXME: Alignment check is too strict, depending on the base address that
+ // got picked we might be aligned even if this check fails.
+ // We instead have to fall back to converting to an integer and checking
+ // the "real" alignment.
+ return err!(AlignmentCheckFailed {
+ has: alloc_align,
+ required: align,
+ });
+ }
+ check_offset_align(ptr.offset.bytes(), align)?;
+
+ // We can still be zero-sized in this branch, in which case we have to
+ // return `None`.
+ if size.bytes() == 0 { None } else { Some(ptr) }
+ }
+ })
}
- /// Checks if the pointer is "in-bounds". Notice that a pointer pointing at the end
- /// of an allocation (i.e., at the first *inaccessible* location) *is* considered
- /// in-bounds! This follows C's/LLVM's rules.
- /// If you want to check bounds before doing a memory access, better first obtain
- /// an `Allocation` and call `check_bounds`.
- pub fn check_bounds_ptr(
+ /// Test if the pointer might be NULL.
+ pub fn ptr_may_be_null(
&self,
ptr: Pointer<M::PointerTag>,
- liveness: InboundsCheck,
- msg: CheckInAllocMsg,
- ) -> InterpResult<'tcx, Align> {
- let (allocation_size, align) = self.get_size_and_align(ptr.alloc_id, liveness)?;
- ptr.check_in_alloc(allocation_size, msg)?;
- Ok(align)
+ ) -> bool {
+ let (size, _align) = self.get_size_and_align(ptr.alloc_id, AllocCheck::MaybeDead)
+ .expect("alloc info with MaybeDead cannot fail");
+ ptr.check_in_alloc(size, CheckInAllocMsg::NullPointerTest).is_err()
}
}
@@ -327,7 +367,7 @@
fn get_static_alloc(
id: AllocId,
tcx: TyCtxtAt<'tcx>,
- memory_extra: &M::MemoryExtra,
+ memory: &Memory<'mir, 'tcx, M>,
) -> InterpResult<'tcx, Cow<'tcx, Allocation<M::PointerTag, M::AllocExtra>>> {
let alloc = tcx.alloc_map.lock().get(id);
let alloc = match alloc {
@@ -374,7 +414,7 @@
id, // always use the ID we got as input, not the "hidden" one.
alloc,
M::STATIC_KIND.map(MemoryKind::Machine),
- memory_extra
+ memory
).0)
}
@@ -387,7 +427,7 @@
// `get_static_alloc` that we can actually use directly without inserting anything anywhere.
// So the error type is `InterpResult<'tcx, &Allocation<M::PointerTag>>`.
let a = self.alloc_map.get_or(id, || {
- let alloc = Self::get_static_alloc(id, self.tcx, &self.extra).map_err(Err)?;
+ let alloc = Self::get_static_alloc(id, self.tcx, &self).map_err(Err)?;
match alloc {
Cow::Borrowed(alloc) => {
// We got a ref, cheaply return that as an "error" so that the
@@ -416,11 +456,11 @@
id: AllocId,
) -> InterpResult<'tcx, &mut Allocation<M::PointerTag, M::AllocExtra>> {
let tcx = self.tcx;
- let memory_extra = &self.extra;
+ let alloc = Self::get_static_alloc(id, tcx, &self);
let a = self.alloc_map.get_mut_or(id, || {
// Need to make a copy, even if `get_static_alloc` is able
// to give us a cheap reference.
- let alloc = Self::get_static_alloc(id, tcx, memory_extra)?;
+ let alloc = alloc?;
if alloc.mutability == Mutability::Immutable {
return err!(ModifiedConstantMemory);
}
@@ -443,13 +483,14 @@
}
}
- /// Obtain the size and alignment of an allocation, even if that allocation has been deallocated
+ /// Obtain the size and alignment of an allocation, even if that allocation has
+ /// been deallocated.
///
- /// If `liveness` is `InboundsCheck::MaybeDead`, this function always returns `Ok`
+ /// If `liveness` is `AllocCheck::MaybeDead`, this function always returns `Ok`.
pub fn get_size_and_align(
&self,
id: AllocId,
- liveness: InboundsCheck,
+ liveness: AllocCheck,
) -> InterpResult<'static, (Size, Align)> {
if let Ok(alloc) = self.get(id) {
return Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align));
@@ -459,7 +500,14 @@
let alloc = self.tcx.alloc_map.lock().get(id);
// Could also be a fn ptr or extern static
match alloc {
- Some(GlobalAlloc::Function(..)) => Ok((Size::ZERO, Align::from_bytes(1).unwrap())),
+ Some(GlobalAlloc::Function(..)) => {
+ if let AllocCheck::Dereferencable = liveness {
+ // The caller requested no function pointers.
+ err!(DerefFunctionPointer)
+ } else {
+ Ok((Size::ZERO, Align::from_bytes(1).unwrap()))
+ }
+ }
// `self.get` would also work, but can cause cycles if a static refers to itself
Some(GlobalAlloc::Static(did)) => {
// The only way `get` couldn't have worked here is if this is an extern static
@@ -471,17 +519,15 @@
}
_ => {
if let Ok(alloc) = self.get(id) {
- return Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align));
+ Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align))
}
- match liveness {
- InboundsCheck::MaybeDead => {
- // Must be a deallocated pointer
- self.dead_alloc_map.get(&id).cloned().ok_or_else(||
- ValidationFailure("allocation missing in dead_alloc_map".to_string())
- .into()
- )
- },
- InboundsCheck::Live => err!(DanglingPointerDeref),
+ else if let AllocCheck::MaybeDead = liveness {
+ // Deallocated pointers are allowed, we should be able to find
+ // them in the map.
+ Ok(*self.dead_alloc_map.get(&id)
+ .expect("deallocated pointers should all be recorded in `dead_alloc_map`"))
+ } else {
+ err!(DanglingPointerDeref)
}
},
}
@@ -629,24 +675,22 @@
}
}
-/// Byte Accessors
+/// Reading and writing.
impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
+ /// Performs appropriate bounds checks.
pub fn read_bytes(
&self,
ptr: Scalar<M::PointerTag>,
size: Size,
) -> InterpResult<'tcx, &[u8]> {
- if size.bytes() == 0 {
- Ok(&[])
- } else {
- let ptr = self.force_ptr(ptr)?;
- self.get(ptr.alloc_id)?.get_bytes(self, ptr, size)
- }
+ let ptr = match self.check_ptr_access(ptr, size, Align::from_bytes(1).unwrap())? {
+ Some(ptr) => ptr,
+ None => return Ok(&[]), // zero-sized access
+ };
+ self.get(ptr.alloc_id)?.get_bytes(self, ptr, size)
}
-}
-/// Reading and writing.
-impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
+ /// Performs appropriate bounds checks.
pub fn copy(
&mut self,
src: Scalar<M::PointerTag>,
@@ -659,6 +703,7 @@
self.copy_repeatedly(src, src_align, dest, dest_align, size, 1, nonoverlapping)
}
+ /// Performs appropriate bounds checks.
pub fn copy_repeatedly(
&mut self,
src: Scalar<M::PointerTag>,
@@ -669,15 +714,14 @@
length: u64,
nonoverlapping: bool,
) -> InterpResult<'tcx> {
- self.check_align(src, src_align)?;
- self.check_align(dest, dest_align)?;
- if size.bytes() == 0 {
- // Nothing to do for ZST, other than checking alignment and
- // non-NULLness which already happened.
- return Ok(());
- }
- let src = self.force_ptr(src)?;
- let dest = self.force_ptr(dest)?;
+ // We need to check *both* before early-aborting due to the size being 0.
+ let (src, dest) = match (self.check_ptr_access(src, size, src_align)?,
+ self.check_ptr_access(dest, size * length, dest_align)?)
+ {
+ (Some(src), Some(dest)) => (src, dest),
+ // One of the two sizes is 0.
+ _ => return Ok(()),
+ };
// first copy the relocations to a temporary buffer, because
// `get_bytes_mut` will clear the relocations, which is correct,
@@ -843,7 +887,7 @@
) -> InterpResult<'tcx, Pointer<M::PointerTag>> {
match scalar {
Scalar::Ptr(ptr) => Ok(ptr),
- _ => M::int_to_ptr(scalar.to_usize(self)?, &self.extra)
+ _ => M::int_to_ptr(scalar.to_usize(self)?, self)
}
}
@@ -854,7 +898,7 @@
) -> InterpResult<'tcx, u128> {
match scalar.to_bits_or_ptr(size, self) {
Ok(bits) => Ok(bits),
- Err(ptr) => Ok(M::ptr_to_int(ptr, &self.extra)? as u128)
+ Err(ptr) => Ok(M::ptr_to_int(ptr, self)? as u128)
}
}
}
diff --git a/src/librustc_mir/interpret/mod.rs b/src/librustc_mir/interpret/mod.rs
index 0293a83..259bd6a 100644
--- a/src/librustc_mir/interpret/mod.rs
+++ b/src/librustc_mir/interpret/mod.rs
@@ -24,7 +24,7 @@
pub use self::place::{Place, PlaceTy, MemPlace, MPlaceTy};
-pub use self::memory::{Memory, MemoryKind};
+pub use self::memory::{Memory, MemoryKind, AllocCheck};
pub use self::machine::{Machine, AllocMap, MayLeak};
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
index 1b451e0..c72078f 100644
--- a/src/librustc_mir/interpret/operand.rs
+++ b/src/librustc_mir/interpret/operand.rs
@@ -9,9 +9,9 @@
};
use rustc::mir::interpret::{
- GlobalId, AllocId, CheckInAllocMsg,
+ GlobalId, AllocId,
ConstValue, Pointer, Scalar,
- InterpResult, InterpError, InboundsCheck,
+ InterpResult, InterpError,
sign_extend, truncate,
};
use super::{
@@ -226,19 +226,14 @@
}
let (ptr, ptr_align) = mplace.to_scalar_ptr_align();
- if mplace.layout.is_zst() {
- // Not all ZSTs have a layout we would handle below, so just short-circuit them
- // all here.
- self.memory.check_align(ptr, ptr_align)?;
- return Ok(Some(ImmTy {
+ let ptr = match self.memory.check_ptr_access(ptr, mplace.layout.size, ptr_align)? {
+ Some(ptr) => ptr,
+ None => return Ok(Some(ImmTy { // zero-sized type
imm: Immediate::Scalar(Scalar::zst().into()),
layout: mplace.layout,
- }));
- }
+ })),
+ };
- // check for integer pointers before alignment to report better errors
- let ptr = self.force_ptr(ptr)?;
- self.memory.check_align(ptr.into(), ptr_align)?;
match mplace.layout.abi {
layout::Abi::Scalar(..) => {
let scalar = self.memory
@@ -250,17 +245,18 @@
}))
}
layout::Abi::ScalarPair(ref a, ref b) => {
+ // We checked `ptr_align` above, so all fields will have the alignment they need.
+ // We would anyway check against `ptr_align.restrict_for_offset(b_offset)`,
+ // which `ptr.offset(b_offset)` cannot possibly fail to satisfy.
let (a, b) = (&a.value, &b.value);
let (a_size, b_size) = (a.size(self), b.size(self));
let a_ptr = ptr;
let b_offset = a_size.align_to(b.align(self).abi);
- assert!(b_offset.bytes() > 0); // we later use the offset to test which field to use
+ assert!(b_offset.bytes() > 0); // we later use the offset to tell apart the fields
let b_ptr = ptr.offset(b_offset, self)?;
let a_val = self.memory
.get(ptr.alloc_id)?
.read_scalar(self, a_ptr, a_size)?;
- let b_align = ptr_align.restrict_for_offset(b_offset);
- self.memory.check_align(b_ptr.into(), b_align)?;
let b_val = self.memory
.get(ptr.alloc_id)?
.read_scalar(self, b_ptr, b_size)?;
@@ -538,10 +534,11 @@
self.layout_of(self.monomorphize(val.ty)?)
})?;
let op = match val.val {
- ConstValue::ByRef(ptr, align, _alloc) => {
+ ConstValue::ByRef { offset, align, alloc } => {
+ let id = self.tcx.alloc_map.lock().create_memory_alloc(alloc);
// We rely on mutability being set correctly in that allocation to prevent writes
// where none should happen.
- let ptr = self.tag_static_base_pointer(ptr);
+ let ptr = self.tag_static_base_pointer(Pointer::new(id, offset));
Operand::Indirect(MemPlace::from_ptr(ptr, align))
},
ConstValue::Scalar(x) =>
@@ -638,8 +635,7 @@
Err(ptr) => {
// The niche must be just 0 (which an inbounds pointer value never is)
let ptr_valid = niche_start == 0 && variants_start == variants_end &&
- self.memory.check_bounds_ptr(ptr, InboundsCheck::MaybeDead,
- CheckInAllocMsg::NullPointerTest).is_ok();
+ !self.memory.ptr_may_be_null(ptr);
if !ptr_valid {
return err!(InvalidDiscriminant(raw_discr.erase_tag().into()));
}
diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs
index 1285549..1351b5b 100644
--- a/src/librustc_mir/interpret/place.rs
+++ b/src/librustc_mir/interpret/place.rs
@@ -222,9 +222,9 @@
}
#[inline]
- pub(super) fn vtable(self) -> InterpResult<'tcx, Pointer<Tag>> {
+ pub(super) fn vtable(self) -> Scalar<Tag> {
match self.layout.ty.sty {
- ty::Dynamic(..) => self.mplace.meta.unwrap().to_ptr(),
+ ty::Dynamic(..) => self.mplace.meta.unwrap(),
_ => bug!("vtable not supported on type {:?}", self.layout.ty),
}
}
@@ -746,15 +746,13 @@
// type things are read at. In case `src_val` is a `ScalarPair`, we don't do any magic here
// to handle padding properly, which is only correct if we never look at this data with the
// wrong type.
+ assert!(!dest.layout.is_unsized());
- // Nothing to do for ZSTs, other than checking alignment
- if dest.layout.is_zst() {
- return self.memory.check_align(ptr, ptr_align);
- }
+ let ptr = match self.memory.check_ptr_access(ptr, dest.layout.size, ptr_align)? {
+ Some(ptr) => ptr,
+ None => return Ok(()), // zero-sized access
+ };
- // check for integer pointers before alignment to report better errors
- let ptr = self.force_ptr(ptr)?;
- self.memory.check_align(ptr.into(), ptr_align)?;
let tcx = &*self.tcx;
// FIXME: We should check that there are dest.layout.size many bytes available in
// memory. The code below is not sufficient, with enough padding it might not
@@ -771,6 +769,9 @@
)
}
Immediate::ScalarPair(a_val, b_val) => {
+ // We checked `ptr_align` above, so all fields will have the alignment they need.
+ // We would anyway check against `ptr_align.restrict_for_offset(b_offset)`,
+ // which `ptr.offset(b_offset)` cannot possibly fail to satisfy.
let (a, b) = match dest.layout.abi {
layout::Abi::ScalarPair(ref a, ref b) => (&a.value, &b.value),
_ => bug!("write_immediate_to_mplace: invalid ScalarPair layout: {:#?}",
@@ -778,11 +779,8 @@
};
let (a_size, b_size) = (a.size(self), b.size(self));
let b_offset = a_size.align_to(b.align(self).abi);
- let b_align = ptr_align.restrict_for_offset(b_offset);
let b_ptr = ptr.offset(b_offset, self)?;
- self.memory.check_align(b_ptr.into(), b_align)?;
-
// It is tempting to verify `b_offset` against `layout.fields.offset(1)`,
// but that does not work: We could be a newtype around a pair, then the
// fields do not match the `ScalarPair` components.
@@ -1053,7 +1051,7 @@
/// Also return some more information so drop doesn't have to run the same code twice.
pub(super) fn unpack_dyn_trait(&self, mplace: MPlaceTy<'tcx, M::PointerTag>)
-> InterpResult<'tcx, (ty::Instance<'tcx>, MPlaceTy<'tcx, M::PointerTag>)> {
- let vtable = mplace.vtable()?; // also sanity checks the type
+ let vtable = mplace.vtable(); // also sanity checks the type
let (instance, ty) = self.read_drop_type_from_vtable(vtable)?;
let layout = self.layout_of(ty)?;
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
index 190f781..13baf24 100644
--- a/src/librustc_mir/interpret/terminator.rs
+++ b/src/librustc_mir/interpret/terminator.rs
@@ -355,7 +355,7 @@
let mut locals_iter = body.args_iter();
while let Some(local) = locals_iter.next() {
let dest = self.eval_place(
- &mir::Place::Base(mir::PlaceBase::Local(local))
+ &mir::Place::from(local)
)?;
if Some(local) == body.spread_arg {
// Must be a tuple
@@ -388,12 +388,10 @@
));
}
} else {
- let callee_layout =
- self.layout_of_local(self.frame(), mir::RETURN_PLACE, None)?;
- if !callee_layout.abi.is_uninhabited() {
- return err!(FunctionRetMismatch(
- self.tcx.types.never, callee_layout.ty
- ));
+ let local = mir::RETURN_PLACE;
+ let ty = self.frame().body.local_decls[local].ty;
+ if !self.tcx.is_ty_uninhabited_from_any_module(ty) {
+ return err!(FunctionRetMismatch(self.tcx.types.never, ty));
}
}
Ok(())
@@ -425,12 +423,15 @@
}
};
// Find and consult vtable
- let vtable = receiver_place.vtable()?;
- self.memory.check_align(vtable.into(), self.tcx.data_layout.pointer_align.abi)?;
- let fn_ptr = self.memory.get(vtable.alloc_id)?.read_ptr_sized(
- self,
- vtable.offset(ptr_size * (idx as u64 + 3), self)?,
- )?.to_ptr()?;
+ let vtable = receiver_place.vtable();
+ let vtable_slot = vtable.ptr_offset(ptr_size * (idx as u64 + 3), self)?;
+ let vtable_slot = self.memory.check_ptr_access(
+ vtable_slot,
+ ptr_size,
+ self.tcx.data_layout.pointer_align.abi,
+ )?.expect("cannot be a ZST");
+ let fn_ptr = self.memory.get(vtable_slot.alloc_id)?
+ .read_ptr_sized(self, vtable_slot)?.to_ptr()?;
let instance = self.memory.get_fn(fn_ptr)?;
// `*mut receiver_place.layout.ty` is almost the layout that we
diff --git a/src/librustc_mir/interpret/traits.rs b/src/librustc_mir/interpret/traits.rs
index 4ae0ee5..5d2f268 100644
--- a/src/librustc_mir/interpret/traits.rs
+++ b/src/librustc_mir/interpret/traits.rs
@@ -101,10 +101,14 @@
/// Returns the drop fn instance as well as the actual dynamic type
pub fn read_drop_type_from_vtable(
&self,
- vtable: Pointer<M::PointerTag>,
+ vtable: Scalar<M::PointerTag>,
) -> InterpResult<'tcx, (ty::Instance<'tcx>, Ty<'tcx>)> {
// we don't care about the pointee type, we just want a pointer
- self.memory.check_align(vtable.into(), self.tcx.data_layout.pointer_align.abi)?;
+ let vtable = self.memory.check_ptr_access(
+ vtable,
+ self.tcx.data_layout.pointer_size,
+ self.tcx.data_layout.pointer_align.abi,
+ )?.expect("cannot be a ZST");
let drop_fn = self.memory
.get(vtable.alloc_id)?
.read_ptr_sized(self, vtable)?
@@ -113,20 +117,28 @@
trace!("Found drop fn: {:?}", drop_instance);
let fn_sig = drop_instance.ty(*self.tcx).fn_sig(*self.tcx);
let fn_sig = self.tcx.normalize_erasing_late_bound_regions(self.param_env, &fn_sig);
- // the drop function takes *mut T where T is the type being dropped, so get that
+ // The drop function takes `*mut T` where `T` is the type being dropped, so get that.
let ty = fn_sig.inputs()[0].builtin_deref(true).unwrap().ty;
Ok((drop_instance, ty))
}
pub fn read_size_and_align_from_vtable(
&self,
- vtable: Pointer<M::PointerTag>,
+ vtable: Scalar<M::PointerTag>,
) -> InterpResult<'tcx, (Size, Align)> {
let pointer_size = self.pointer_size();
- self.memory.check_align(vtable.into(), self.tcx.data_layout.pointer_align.abi)?;
+ // We check for size = 3*ptr_size, that covers the drop fn (unused here),
+ // the size, and the align (which we read below).
+ let vtable = self.memory.check_ptr_access(
+ vtable,
+ 3*pointer_size,
+ self.tcx.data_layout.pointer_align.abi,
+ )?.expect("cannot be a ZST");
let alloc = self.memory.get(vtable.alloc_id)?;
- let size = alloc.read_ptr_sized(self, vtable.offset(pointer_size, self)?)?
- .to_bits(pointer_size)? as u64;
+ let size = alloc.read_ptr_sized(
+ self,
+ vtable.offset(pointer_size, self)?
+ )?.to_bits(pointer_size)? as u64;
let align = alloc.read_ptr_sized(
self,
vtable.offset(pointer_size * 2, self)?,
diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs
index d747edd..b2a159f 100644
--- a/src/librustc_mir/interpret/validity.rs
+++ b/src/librustc_mir/interpret/validity.rs
@@ -3,11 +3,11 @@
use syntax_pos::symbol::{sym, Symbol};
use rustc::hir;
-use rustc::ty::layout::{self, Size, Align, TyLayout, LayoutOf, VariantIdx};
+use rustc::ty::layout::{self, TyLayout, LayoutOf, VariantIdx};
use rustc::ty;
use rustc_data_structures::fx::FxHashSet;
use rustc::mir::interpret::{
- Scalar, GlobalAlloc, InterpResult, InterpError, CheckInAllocMsg,
+ GlobalAlloc, InterpResult, InterpError,
};
use std::hash::Hash;
@@ -193,7 +193,7 @@
// Sometimes the index is beyond the number of upvars (seen
// for a generator).
if let Some((&var_hir_id, _)) = upvars.get_index(field) {
- let node = self.ecx.tcx.hir().get_by_hir_id(var_hir_id);
+ let node = self.ecx.tcx.hir().get(var_hir_id);
if let hir::Node::Binding(pat) = node {
if let hir::PatKind::Binding(_, _, ident, _) = pat.node {
name = Some(ident.name);
@@ -365,8 +365,16 @@
let tail = self.ecx.tcx.struct_tail(layout.ty);
match tail.sty {
ty::Dynamic(..) => {
- let vtable = try_validation!(meta.unwrap().to_ptr(),
- "non-pointer vtable in fat pointer", self.path);
+ let vtable = meta.unwrap();
+ try_validation!(
+ self.ecx.memory.check_ptr_access(
+ vtable,
+ 3*self.ecx.tcx.data_layout.pointer_size, // drop, size, align
+ self.ecx.tcx.data_layout.pointer_align.abi,
+ ),
+ "dangling or unaligned vtable pointer or too small vtable",
+ self.path
+ );
try_validation!(self.ecx.read_drop_type_from_vtable(vtable),
"invalid drop fn in vtable", self.path);
try_validation!(self.ecx.read_size_and_align_from_vtable(vtable),
@@ -384,16 +392,19 @@
bug!("Unexpected unsized type tail: {:?}", tail),
}
}
- // Make sure this is non-NULL and aligned
+ // Make sure this is dereferencable and all.
let (size, align) = self.ecx.size_and_align_of(meta, layout)?
// for the purpose of validity, consider foreign types to have
// alignment and size determined by the layout (size will be 0,
// alignment should take attributes into account).
.unwrap_or_else(|| (layout.size, layout.align.abi));
- match self.ecx.memory.check_align(ptr, align) {
- Ok(_) => {},
+ let ptr: Option<_> = match self.ecx.memory.check_ptr_access(ptr, size, align) {
+ Ok(ptr) => ptr,
Err(err) => {
- info!("{:?} is not aligned to {:?}", ptr, align);
+ info!(
+ "{:?} did not pass access check for size {:?}, align {:?}",
+ ptr, size, align
+ );
match err.kind {
InterpError::InvalidNullPointerUsage =>
return validation_failure!("NULL reference", self.path),
@@ -401,23 +412,23 @@
return validation_failure!(format!("unaligned reference \
(required {} byte alignment but found {})",
required.bytes(), has.bytes()), self.path),
+ InterpError::ReadBytesAsPointer =>
+ return validation_failure!(
+ "integer pointer in non-ZST reference",
+ self.path
+ ),
_ =>
return validation_failure!(
- "dangling (out-of-bounds) reference (might be NULL at \
- run-time)",
+ "dangling (not entirely in bounds) reference",
self.path
),
}
}
- }
+ };
// Recursive checking
if let Some(ref mut ref_tracking) = self.ref_tracking_for_consts {
let place = self.ecx.ref_to_mplace(value)?;
- // FIXME(RalfJ): check ZST for inbound pointers
- if size != Size::ZERO {
- // Non-ZST also have to be dereferencable
- let ptr = try_validation!(place.ptr.to_ptr(),
- "integer pointer in non-ZST reference", self.path);
+ if let Some(ptr) = ptr { // not a ZST
// Skip validation entirely for some external statics
let alloc_kind = self.ecx.tcx.alloc_map.lock().get(ptr.alloc_id);
if let Some(GlobalAlloc::Static(did)) = alloc_kind {
@@ -429,18 +440,10 @@
return Ok(());
}
}
- // Maintain the invariant that the place we are checking is
- // already verified to be in-bounds.
- try_validation!(
- self.ecx.memory
- .get(ptr.alloc_id)?
- .check_bounds(self.ecx, ptr, size, CheckInAllocMsg::InboundsTest),
- "dangling (not entirely in bounds) reference", self.path);
}
// Check if we have encountered this pointer+layout combination
- // before. Proceed recursively even for integer pointers, no
- // reason to skip them! They are (recursively) valid for some ZST,
- // but not for others (e.g., `!` is a ZST).
+ // before. Proceed recursively even for ZST, no
+ // reason to skip them! E.g., `!` is a ZST and we want to validate it.
let path = &self.path;
ref_tracking.track(place, || {
// We need to clone the path anyway, make sure it gets created
@@ -499,14 +502,8 @@
let bits = match value.to_bits_or_ptr(op.layout.size, self.ecx) {
Err(ptr) => {
if lo == 1 && hi == max_hi {
- // only NULL is not allowed.
- // We can call `check_align` to check non-NULL-ness, but have to also look
- // for function pointers.
- let non_null =
- self.ecx.memory.check_align(
- Scalar::Ptr(ptr), Align::from_bytes(1).unwrap()
- ).is_ok();
- if !non_null {
+ // Only NULL is the niche. So make sure the ptr is NOT NULL.
+ if self.ecx.memory.ptr_may_be_null(ptr) {
// These conditions are just here to improve the diagnostics so we can
// differentiate between null pointers and dangling pointers
if self.ref_tracking_for_consts.is_some() &&
diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs
index a7cbe84..cb02e1a 100644
--- a/src/librustc_mir/lib.rs
+++ b/src/librustc_mir/lib.rs
@@ -30,7 +30,6 @@
#![deny(rust_2018_idioms)]
#![deny(internal)]
#![deny(unused_lifetimes)]
-#![allow(explicit_outlives_requirements)]
#[macro_use] extern crate log;
#[macro_use]
diff --git a/src/librustc_mir/lints.rs b/src/librustc_mir/lints.rs
index a712088..8c815a5 100644
--- a/src/librustc_mir/lints.rs
+++ b/src/librustc_mir/lints.rs
@@ -10,7 +10,7 @@
pub fn check(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId) {
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
- if let Some(fn_like_node) = FnLikeNode::from_node(tcx.hir().get_by_hir_id(hir_id)) {
+ if let Some(fn_like_node) = FnLikeNode::from_node(tcx.hir().get(hir_id)) {
check_fn_for_unconditional_recursion(tcx, fn_like_node.kind(), body, def_id);
}
}
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index c64bb73..bb2738d 100644
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -1262,7 +1262,7 @@
ConstValue::Scalar(Scalar::Ptr(ptr)) =>
collect_miri(tcx, ptr.alloc_id, output),
ConstValue::Slice { data: alloc, start: _, end: _ } |
- ConstValue::ByRef(_, _, alloc) => {
+ ConstValue::ByRef { alloc, .. } => {
for &((), id) in alloc.relocations.values() {
collect_miri(tcx, id, output);
}
diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs
index c04672f..7987095 100644
--- a/src/librustc_mir/shim.rs
+++ b/src/librustc_mir/shim.rs
@@ -213,7 +213,7 @@
if let Some(..) = ty {
// The first argument (index 0), but add 1 for the return value.
- let dropee_ptr = Place::Base(PlaceBase::Local(Local::new(1+0)));
+ let dropee_ptr = Place::from(Local::new(1+0));
if tcx.sess.opts.debugging_opts.mir_emit_retag {
// Function arguments should be retagged, and we make this one raw.
body.basic_blocks_mut()[START_BLOCK].statements.insert(0, Statement {
@@ -308,7 +308,7 @@
let is_copy = self_ty.is_copy_modulo_regions(tcx, tcx.param_env(def_id), builder.span);
let dest = Place::RETURN_PLACE;
- let src = Place::Base(PlaceBase::Local(Local::new(1+0))).deref();
+ let src = Place::from(Local::new(1+0)).deref();
match self_ty.sty {
_ if is_copy => builder.copy_shim(),
@@ -412,7 +412,7 @@
}
fn copy_shim(&mut self) {
- let rcvr = Place::Base(PlaceBase::Local(Local::new(1+0))).deref();
+ let rcvr = Place::from(Local::new(1+0)).deref();
let ret_statement = self.make_statement(
StatementKind::Assign(
Place::RETURN_PLACE,
@@ -424,9 +424,7 @@
fn make_place(&mut self, mutability: Mutability, ty: Ty<'tcx>) -> Place<'tcx> {
let span = self.span;
- Place::Base(PlaceBase::Local(
- self.local_decls.push(temp_decl(mutability, ty, span))
- ))
+ Place::from(self.local_decls.push(temp_decl(mutability, ty, span)))
}
fn make_clone_call(
@@ -525,7 +523,7 @@
let inits = vec![
self.make_statement(
StatementKind::Assign(
- Place::Base(PlaceBase::Local(beg)),
+ Place::from(beg),
box Rvalue::Use(Operand::Constant(self.make_usize(0)))
)
),
@@ -543,7 +541,7 @@
// BB #3;
// }
// BB #4;
- self.loop_header(Place::Base(PlaceBase::Local(beg)),
+ self.loop_header(Place::from(beg),
end,
BasicBlock::new(2),
BasicBlock::new(4),
@@ -563,10 +561,10 @@
let statements = vec![
self.make_statement(
StatementKind::Assign(
- Place::Base(PlaceBase::Local(beg)),
+ Place::from(beg),
box Rvalue::BinaryOp(
BinOp::Add,
- Operand::Copy(Place::Base(PlaceBase::Local(beg))),
+ Operand::Copy(Place::from(beg)),
Operand::Constant(self.make_usize(1))
)
)
@@ -586,7 +584,7 @@
let beg = self.local_decls.push(temp_decl(Mutability::Mut, tcx.types.usize, span));
let init = self.make_statement(
StatementKind::Assign(
- Place::Base(PlaceBase::Local(beg)),
+ Place::from(beg),
box Rvalue::Use(Operand::Constant(self.make_usize(0)))
)
);
@@ -597,7 +595,7 @@
// BB #8;
// }
// BB #9;
- self.loop_header(Place::Base(PlaceBase::Local(beg)), Place::Base(PlaceBase::Local(end)),
+ self.loop_header(Place::from(beg), Place::from(end),
BasicBlock::new(7), BasicBlock::new(9), true);
// BB #7 (cleanup)
@@ -613,10 +611,10 @@
// `goto #6;`
let statement = self.make_statement(
StatementKind::Assign(
- Place::Base(PlaceBase::Local(beg)),
+ Place::from(beg),
box Rvalue::BinaryOp(
BinOp::Add,
- Operand::Copy(Place::Base(PlaceBase::Local(beg))),
+ Operand::Copy(Place::from(beg)),
Operand::Constant(self.make_usize(1))
)
)
@@ -701,7 +699,7 @@
let source_info = SourceInfo { span, scope: OUTERMOST_SOURCE_SCOPE };
let rcvr_arg = Local::new(1+0);
- let rcvr_l = Place::Base(PlaceBase::Local(rcvr_arg));
+ let rcvr_l = Place::from(rcvr_arg);
let mut statements = vec![];
let rcvr = match rcvr_adjustment {
@@ -731,11 +729,11 @@
statements.push(Statement {
source_info,
kind: StatementKind::Assign(
- Place::Base(PlaceBase::Local(ref_rcvr)),
+ Place::from(ref_rcvr),
box Rvalue::Ref(tcx.lifetimes.re_erased, borrow_kind, rcvr_l)
)
});
- Operand::Move(Place::Base(PlaceBase::Local(ref_rcvr)))
+ Operand::Move(Place::from(ref_rcvr))
}
};
@@ -755,12 +753,12 @@
if let Some(untuple_args) = untuple_args {
args.extend(untuple_args.iter().enumerate().map(|(i, ity)| {
- let arg_place = Place::Base(PlaceBase::Local(Local::new(1+1)));
+ let arg_place = Place::from(Local::new(1+1));
Operand::Move(arg_place.field(Field::new(i), *ity))
}));
} else {
args.extend((1..sig.inputs().len()).map(|i| {
- Operand::Move(Place::Base(PlaceBase::Local(Local::new(1+i))))
+ Operand::Move(Place::from(Local::new(1+i)))
}));
}
@@ -791,7 +789,7 @@
if let Adjustment::RefMut = rcvr_adjustment {
// BB #1 - drop for Self
block(&mut blocks, vec![], TerminatorKind::Drop {
- location: Place::Base(PlaceBase::Local(rcvr_arg)),
+ location: Place::from(rcvr_arg),
target: BasicBlock::new(2),
unwind: None
}, false);
@@ -801,7 +799,7 @@
if let Adjustment::RefMut = rcvr_adjustment {
// BB #3 - drop if closure panics
block(&mut blocks, vec![], TerminatorKind::Drop {
- location: Place::Base(PlaceBase::Local(rcvr_arg)),
+ location: Place::from(rcvr_arg),
target: BasicBlock::new(4),
unwind: None
}, true);
@@ -881,7 +879,7 @@
.iter()
.enumerate()
.map(|(idx, field_def)| (
- Operand::Move(Place::Base(PlaceBase::Local(Local::new(idx + 1)))),
+ Operand::Move(Place::from(Local::new(idx + 1))),
field_def.ty(tcx, substs),
)),
AggregateKind::Adt(adt_def, variant_index, substs, None, None),
diff --git a/src/librustc_mir/transform/add_moves_for_packed_drops.rs b/src/librustc_mir/transform/add_moves_for_packed_drops.rs
index a111669..426e166 100644
--- a/src/librustc_mir/transform/add_moves_for_packed_drops.rs
+++ b/src/librustc_mir/transform/add_moves_for_packed_drops.rs
@@ -112,10 +112,10 @@
patch.add_statement(
loc, StatementKind::StorageLive(temp));
- patch.add_assign(loc, Place::Base(PlaceBase::Local(temp)),
+ patch.add_assign(loc, Place::from(temp),
Rvalue::Use(Operand::Move(location.clone())));
patch.patch_terminator(loc.block, TerminatorKind::Drop {
- location: Place::Base(PlaceBase::Local(temp)),
+ location: Place::from(temp),
target: storage_dead_block,
unwind
});
diff --git a/src/librustc_mir/transform/add_retag.rs b/src/librustc_mir/transform/add_retag.rs
index ee040bf..e01017d 100644
--- a/src/librustc_mir/transform/add_retag.rs
+++ b/src/librustc_mir/transform/add_retag.rs
@@ -96,7 +96,7 @@
};
// Gather all arguments, skip return value.
let places = local_decls.iter_enumerated().skip(1).take(arg_count)
- .map(|(local, _)| Place::Base(PlaceBase::Local(local)))
+ .map(|(local, _)| Place::from(local))
.filter(needs_retag)
.collect::<Vec<_>>();
// Emit their retags.
diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs
index 9c78d76..24df354 100644
--- a/src/librustc_mir/transform/check_unsafety.rs
+++ b/src/librustc_mir/transform/check_unsafety.rs
@@ -570,14 +570,14 @@
used_unsafe: &FxHashSet<hir::HirId>,
id: hir::HirId,
) -> Option<(String, hir::HirId)> {
- let parent_id = tcx.hir().get_parent_node_by_hir_id(id);
+ let parent_id = tcx.hir().get_parent_node(id);
if parent_id != id {
if used_unsafe.contains(&parent_id) {
Some(("block".to_string(), parent_id))
} else if let Some(Node::Item(&hir::Item {
node: hir::ItemKind::Fn(_, header, _, _),
..
- })) = tcx.hir().find_by_hir_id(parent_id) {
+ })) = tcx.hir().find(parent_id) {
match header.unsafety {
hir::Unsafety::Unsafe => Some(("fn".to_string(), parent_id)),
hir::Unsafety::Normal => None,
diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs
index 5b56751..c7a2fdd 100644
--- a/src/librustc_mir/transform/const_prop.rs
+++ b/src/librustc_mir/transform/const_prop.rs
@@ -1,6 +1,8 @@
//! Propagates constants for early reporting of statically known
//! assertion failures
+use std::cell::Cell;
+
use rustc::hir::def::DefKind;
use rustc::mir::{
AggregateKind, Constant, Location, Place, PlaceBase, Body, Operand, Rvalue,
@@ -21,7 +23,8 @@
};
use crate::interpret::{
- self, InterpretCx, ScalarMaybeUndef, Immediate, OpTy, ImmTy, MemoryKind,
+ self, InterpretCx, ScalarMaybeUndef, Immediate, OpTy,
+ ImmTy, MemoryKind, StackPopCleanup, LocalValue, LocalState,
};
use crate::const_eval::{
CompileTimeInterpreter, error_to_const_error, eval_promoted, mk_eval_cx,
@@ -41,7 +44,7 @@
let hir_id = tcx.hir().as_local_hir_id(source.def_id())
.expect("Non-local call to local provider is_const_fn");
- let is_fn_like = FnLikeNode::from_node(tcx.hir().get_by_hir_id(hir_id)).is_some();
+ let is_fn_like = FnLikeNode::from_node(tcx.hir().get(hir_id)).is_some();
let is_assoc_const = match tcx.def_kind(source.def_id()) {
Some(DefKind::AssocConst) => true,
_ => false,
@@ -56,21 +59,54 @@
trace!("ConstProp starting for {:?}", source.def_id());
+ // Steal some data we need from `body`.
+ let source_scope_local_data = std::mem::replace(
+ &mut body.source_scope_local_data,
+ ClearCrossCrate::Clear
+ );
+ let promoted = std::mem::replace(
+ &mut body.promoted,
+ IndexVec::new()
+ );
+
+ let dummy_body =
+ &Body::new(
+ body.basic_blocks().clone(),
+ Default::default(),
+ ClearCrossCrate::Clear,
+ Default::default(),
+ None,
+ body.local_decls.clone(),
+ Default::default(),
+ body.arg_count,
+ Default::default(),
+ tcx.def_span(source.def_id()),
+ Default::default(),
+ );
+
// FIXME(oli-obk, eddyb) Optimize locals (or even local paths) to hold
// constants, instead of just checking for const-folding succeeding.
// That would require an uniform one-def no-mutation analysis
// and RPO (or recursing when needing the value of a local).
- let mut optimization_finder = ConstPropagator::new(body, tcx, source);
+ let mut optimization_finder = ConstPropagator::new(
+ body,
+ dummy_body,
+ source_scope_local_data,
+ promoted,
+ tcx,
+ source
+ );
optimization_finder.visit_body(body);
// put back the data we stole from `mir`
+ let (source_scope_local_data, promoted) = optimization_finder.release_stolen_data();
std::mem::replace(
&mut body.source_scope_local_data,
- optimization_finder.source_scope_local_data
+ source_scope_local_data
);
std::mem::replace(
&mut body.promoted,
- optimization_finder.promoted
+ promoted
);
trace!("ConstProp done for {:?}", source.def_id());
@@ -84,7 +120,6 @@
ecx: InterpretCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>>,
tcx: TyCtxt<'tcx>,
source: MirSource<'tcx>,
- places: IndexVec<Local, Option<Const<'tcx>>>,
can_const_prop: IndexVec<Local, bool>,
param_env: ParamEnv<'tcx>,
source_scope_local_data: ClearCrossCrate<IndexVec<SourceScope, SourceScopeLocalData>>,
@@ -117,21 +152,28 @@
impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
fn new(
- body: &mut Body<'tcx>,
+ body: &Body<'tcx>,
+ dummy_body: &'mir Body<'tcx>,
+ source_scope_local_data: ClearCrossCrate<IndexVec<SourceScope, SourceScopeLocalData>>,
+ promoted: IndexVec<Promoted, Body<'tcx>>,
tcx: TyCtxt<'tcx>,
source: MirSource<'tcx>,
) -> ConstPropagator<'mir, 'tcx> {
- let param_env = tcx.param_env(source.def_id());
- let ecx = mk_eval_cx(tcx, tcx.def_span(source.def_id()), param_env);
+ let def_id = source.def_id();
+ let param_env = tcx.param_env(def_id);
+ let span = tcx.def_span(def_id);
+ let mut ecx = mk_eval_cx(tcx, span, param_env);
let can_const_prop = CanConstProp::check(body);
- let source_scope_local_data = std::mem::replace(
- &mut body.source_scope_local_data,
- ClearCrossCrate::Clear
- );
- let promoted = std::mem::replace(
- &mut body.promoted,
- IndexVec::new()
- );
+
+ ecx.push_stack_frame(
+ Instance::new(def_id, &InternalSubsts::identity_for_item(tcx, def_id)),
+ span,
+ dummy_body,
+ None,
+ StackPopCleanup::None {
+ cleanup: false,
+ },
+ ).expect("failed to push initial stack frame");
ConstPropagator {
ecx,
@@ -139,7 +181,6 @@
source,
param_env,
can_const_prop,
- places: IndexVec::from_elem(None, &body.local_decls),
source_scope_local_data,
//FIXME(wesleywiser) we can't steal this because `Visitor::super_visit_body()` needs it
local_decls: body.local_decls.clone(),
@@ -147,6 +188,51 @@
}
}
+ fn release_stolen_data(
+ self,
+ ) -> (
+ ClearCrossCrate<IndexVec<SourceScope, SourceScopeLocalData>>,
+ IndexVec<Promoted, Body<'tcx>>,
+ ) {
+ (self.source_scope_local_data, self.promoted)
+ }
+
+ fn get_const(&self, local: Local) -> Option<Const<'tcx>> {
+ let l = &self.ecx.frame().locals[local];
+
+ // If the local is `Unitialized` or `Dead` then we haven't propagated a value into it.
+ //
+ // `InterpretCx::access_local()` mostly takes care of this for us however, for ZSTs,
+ // it will synthesize a value for us. In doing so, that will cause the
+ // `get_const(l).is_empty()` assert right before we call `set_const()` in `visit_statement`
+ // to fail.
+ if let LocalValue::Uninitialized | LocalValue::Dead = l.value {
+ return None;
+ }
+
+ self.ecx.access_local(self.ecx.frame(), local, None).ok()
+ }
+
+ fn set_const(&mut self, local: Local, c: Const<'tcx>) {
+ let frame = self.ecx.frame_mut();
+
+ if let Some(layout) = frame.locals[local].layout.get() {
+ debug_assert_eq!(c.layout, layout);
+ }
+
+ frame.locals[local] = LocalState {
+ value: LocalValue::Live(*c),
+ layout: Cell::new(Some(c.layout)),
+ };
+ }
+
+ fn remove_const(&mut self, local: Local) {
+ self.ecx.frame_mut().locals[local] = LocalState {
+ value: LocalValue::Uninitialized,
+ layout: Cell::new(None),
+ };
+ }
+
fn use_ecx<F, T>(
&mut self,
source_info: SourceInfo,
@@ -296,7 +382,7 @@
trace!("eval_place(place={:?})", place);
place.iterate(|place_base, place_projection| {
let mut eval = match place_base {
- PlaceBase::Local(loc) => self.places[*loc].clone()?,
+ PlaceBase::Local(loc) => self.get_const(*loc).clone()?,
PlaceBase::Static(box Static {kind: StaticKind::Promoted(promoted), ..}) => {
let generics = self.tcx.generics_of(self.source.def_id());
if generics.requires_monomorphization(self.tcx) {
@@ -699,8 +785,8 @@
trace!("checking whether {:?} can be stored to {:?}", value, local);
if self.can_const_prop[local] {
trace!("storing {:?} to {:?}", value, local);
- assert!(self.places[local].is_none());
- self.places[local] = Some(value);
+ assert!(self.get_const(local).is_none());
+ self.set_const(local, value);
if self.should_const_prop() {
self.replace_with_const(
@@ -740,7 +826,7 @@
place = &proj.base;
}
if let Place::Base(PlaceBase::Local(local)) = *place {
- self.places[local] = None;
+ self.remove_const(local);
}
},
Operand::Constant(_) => {}
diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs
index d805c66..ad19b97 100644
--- a/src/librustc_mir/transform/elaborate_drops.rs
+++ b/src/librustc_mir/transform/elaborate_drops.rs
@@ -95,7 +95,7 @@
};
let mut init_data = InitializationData {
- live: flow_inits.sets().on_entry_set_for(bb.index()).to_owned(),
+ live: flow_inits.sets().entry_set_for(bb.index()).to_owned(),
dead: BitSet::new_empty(env.move_data.move_paths.len()),
};
debug!("find_dead_unwinds @ {:?}: {:?}; init_data={:?}",
@@ -304,9 +304,9 @@
fn initialization_data_at(&self, loc: Location) -> InitializationData {
let mut data = InitializationData {
- live: self.flow_inits.sets().on_entry_set_for(loc.block.index())
+ live: self.flow_inits.sets().entry_set_for(loc.block.index())
.to_owned(),
- dead: self.flow_uninits.sets().on_entry_set_for(loc.block.index())
+ dead: self.flow_uninits.sets().entry_set_for(loc.block.index())
.to_owned(),
};
for stmt in 0..loc.statement_index {
@@ -326,7 +326,7 @@
}
fn drop_flag(&mut self, index: MovePathIndex) -> Option<Place<'tcx>> {
- self.drop_flags.get(&index).map(|t| Place::Base(PlaceBase::Local(*t)))
+ self.drop_flags.get(&index).map(|t| Place::from(*t))
}
/// create a patch that elaborates all drops in the input
@@ -537,7 +537,7 @@
if let Some(&flag) = self.drop_flags.get(&path) {
let span = self.patch.source_info_for_location(self.body, loc).span;
let val = self.constant_bool(span, val.value());
- self.patch.add_assign(loc, Place::Base(PlaceBase::Local(flag)), val);
+ self.patch.add_assign(loc, Place::from(flag), val);
}
}
@@ -546,7 +546,7 @@
let span = self.patch.source_info_for_location(self.body, loc).span;
let false_ = self.constant_bool(span, false);
for flag in self.drop_flags.values() {
- self.patch.add_assign(loc, Place::Base(PlaceBase::Local(*flag)), false_.clone());
+ self.patch.add_assign(loc, Place::from(*flag), false_.clone());
}
}
diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs
index ba8c47c..7b961e9 100644
--- a/src/librustc_mir/transform/generator.rs
+++ b/src/librustc_mir/transform/generator.rs
@@ -200,7 +200,7 @@
// Create a Place referencing a generator struct field
fn make_field(&self, variant_index: VariantIdx, idx: usize, ty: Ty<'tcx>) -> Place<'tcx> {
- let self_place = Place::Base(PlaceBase::Local(self_arg()));
+ let self_place = Place::from(self_arg());
let base = self_place.downcast_unnamed(variant_index);
let field = Projection {
base: base,
@@ -211,7 +211,7 @@
// Create a statement which changes the discriminant
fn set_discr(&self, state_disc: VariantIdx, source_info: SourceInfo) -> Statement<'tcx> {
- let self_place = Place::Base(PlaceBase::Local(self_arg()));
+ let self_place = Place::from(self_arg());
Statement {
source_info,
kind: StatementKind::SetDiscriminant { place: self_place, variant_index: state_disc },
@@ -222,9 +222,9 @@
fn get_discr(&self, body: &mut Body<'tcx>) -> (Statement<'tcx>, Place<'tcx>) {
let temp_decl = LocalDecl::new_internal(self.tcx.types.isize, body.span);
let local_decls_len = body.local_decls.push(temp_decl);
- let temp = Place::Base(PlaceBase::Local(local_decls_len));
+ let temp = Place::from(local_decls_len);
- let self_place = Place::Base(PlaceBase::Local(self_arg()));
+ let self_place = Place::from(self_arg());
let assign = Statement {
source_info: source_info(body),
kind: StatementKind::Assign(temp.clone(), box Rvalue::Discriminant(self_place)),
@@ -271,7 +271,7 @@
let ret_val = match data.terminator().kind {
TerminatorKind::Return => Some((VariantIdx::new(1),
None,
- Operand::Move(Place::Base(PlaceBase::Local(self.new_ret_local))),
+ Operand::Move(Place::from(self.new_ret_local)),
None)),
TerminatorKind::Yield { ref value, resume, drop } => Some((VariantIdx::new(0),
Some(resume),
@@ -840,7 +840,7 @@
elaborate_drop(
&mut elaborator,
source_info,
- &Place::Base(PlaceBase::Local(gen)),
+ &Place::from(gen),
(),
target,
unwind,
@@ -913,7 +913,7 @@
// Alias tracking must know we changed the type
body.basic_blocks_mut()[START_BLOCK].statements.insert(0, Statement {
source_info,
- kind: StatementKind::Retag(RetagKind::Raw, Place::Base(PlaceBase::Local(self_arg()))),
+ kind: StatementKind::Retag(RetagKind::Raw, Place::from(self_arg())),
})
}
@@ -1031,7 +1031,7 @@
// Create a block to destroy an unresumed generators. This can only destroy upvars.
let drop_clean = BasicBlock::new(body.basic_blocks().len());
let term = TerminatorKind::Drop {
- location: Place::Base(PlaceBase::Local(self_arg())),
+ location: Place::from(self_arg()),
target: return_block,
unwind: None,
};
diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs
index e2f98e4..dc73e58 100644
--- a/src/librustc_mir/transform/inline.rs
+++ b/src/librustc_mir/transform/inline.rs
@@ -467,7 +467,7 @@
let temp = LocalDecl::new_temp(ty, callsite.location.span);
let tmp = caller_body.local_decls.push(temp);
- let tmp = Place::Base(PlaceBase::Local(tmp));
+ let tmp = Place::from(tmp);
let stmt = Statement {
source_info: callsite.location,
@@ -561,7 +561,7 @@
let tuple = self.create_temp_if_necessary(args.next().unwrap(), callsite, caller_body);
assert!(args.next().is_none());
- let tuple = Place::Base(PlaceBase::Local(tuple));
+ let tuple = Place::from(tuple);
let tuple_tys = if let ty::Tuple(s) = tuple.ty(caller_body, tcx).ty.sty {
s
} else {
@@ -621,7 +621,7 @@
let stmt = Statement {
source_info: callsite.location,
- kind: StatementKind::Assign(Place::Base(PlaceBase::Local(arg_tmp)), box arg),
+ kind: StatementKind::Assign(Place::from(arg_tmp), box arg),
};
caller_body[callsite.bb].statements.push(stmt);
arg_tmp
diff --git a/src/librustc_mir/transform/lower_128bit.rs b/src/librustc_mir/transform/lower_128bit.rs
index f0aa189..f09a77d 100644
--- a/src/librustc_mir/transform/lower_128bit.rs
+++ b/src/librustc_mir/transform/lower_128bit.rs
@@ -83,13 +83,13 @@
block.statements.push(Statement {
source_info: source_info,
kind: StatementKind::Assign(
- Place::Base(PlaceBase::Local(local)),
+ Place::from(local),
box Rvalue::Cast(
CastKind::Misc,
rhs,
rhs_override_ty.unwrap())),
});
- rhs = Operand::Move(Place::Base(PlaceBase::Local(local)));
+ rhs = Operand::Move(Place::from(local));
}
let call_did = check_lang_item_type(
diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
index d78adfe..b1804fb 100644
--- a/src/librustc_mir/transform/promote_consts.rs
+++ b/src/librustc_mir/transform/promote_consts.rs
@@ -182,7 +182,7 @@
span,
scope: OUTERMOST_SOURCE_SCOPE
},
- kind: StatementKind::Assign(Place::Base(PlaceBase::Local(dest)), box rvalue)
+ kind: StatementKind::Assign(Place::from(dest), box rvalue)
});
}
@@ -273,7 +273,7 @@
args,
cleanup: None,
destination: Some(
- (Place::Base(PlaceBase::Local(new_temp)), new_target)
+ (Place::from(new_temp), new_target)
),
from_hir_call,
},
diff --git a/src/librustc_mir/transform/rustc_peek.rs b/src/librustc_mir/transform/rustc_peek.rs
index c4601229..f12309c 100644
--- a/src/librustc_mir/transform/rustc_peek.rs
+++ b/src/librustc_mir/transform/rustc_peek.rs
@@ -18,7 +18,6 @@
};
use crate::dataflow::move_paths::{MovePathIndex, LookupResult};
use crate::dataflow::move_paths::{HasMoveData, MoveData};
-use crate::dataflow;
use crate::dataflow::has_rustc_mir_with;
@@ -133,9 +132,8 @@
}
};
- let mut on_entry = results.0.sets.on_entry_set_for(bb.index()).to_owned();
- let mut gen_set = results.0.sets.gen_set_for(bb.index()).clone();
- let mut kill_set = results.0.sets.kill_set_for(bb.index()).clone();
+ let mut on_entry = results.0.sets.entry_set_for(bb.index()).to_owned();
+ let mut trans = results.0.sets.trans_for(bb.index()).clone();
// Emulate effect of all statements in the block up to (but not
// including) the borrow within `peek_arg_place`. Do *not* include
@@ -143,10 +141,6 @@
// of the argument at time immediate preceding Call to
// `rustc_peek`).
- let mut sets = dataflow::BlockSets { on_entry: &mut on_entry,
- gen_set: &mut gen_set,
- kill_set: &mut kill_set };
-
for (j, stmt) in statements.iter().enumerate() {
debug!("rustc_peek: ({:?},{}) {:?}", bb, j, stmt);
let (place, rvalue) = match stmt.kind {
@@ -170,7 +164,7 @@
// Okay, our search is over.
match move_data.rev_lookup.find(peeking_at_place) {
LookupResult::Exact(peek_mpi) => {
- let bit_state = sets.on_entry.contains(peek_mpi);
+ let bit_state = on_entry.contains(peek_mpi);
debug!("rustc_peek({:?} = &{:?}) bit_state: {}",
place, peeking_at_place, bit_state);
if !bit_state {
@@ -197,18 +191,18 @@
debug!("rustc_peek: computing effect on place: {:?} ({:?}) in stmt: {:?}",
place, lhs_mpi, stmt);
// reset GEN and KILL sets before emulating their effect.
- sets.gen_set.clear();
- sets.kill_set.clear();
+ trans.clear();
results.0.operator.before_statement_effect(
- &mut sets, Location { block: bb, statement_index: j });
+ &mut trans,
+ Location { block: bb, statement_index: j });
results.0.operator.statement_effect(
- &mut sets, Location { block: bb, statement_index: j });
- sets.on_entry.union(sets.gen_set);
- sets.on_entry.subtract(sets.kill_set);
+ &mut trans,
+ Location { block: bb, statement_index: j });
+ trans.apply(&mut on_entry);
}
results.0.operator.before_terminator_effect(
- &mut sets,
+ &mut trans,
Location { block: bb, statement_index: statements.len() });
tcx.sess.span_err(span, &format!("rustc_peek: MIR did not match \
diff --git a/src/librustc_mir/transform/uniform_array_move_out.rs b/src/librustc_mir/transform/uniform_array_move_out.rs
index 812a024..6878ece 100644
--- a/src/librustc_mir/transform/uniform_array_move_out.rs
+++ b/src/librustc_mir/transform/uniform_array_move_out.rs
@@ -97,7 +97,7 @@
let temp = self.patch.new_temp(item_ty, self.body.source_info(location).span);
self.patch.add_statement(location, StatementKind::StorageLive(temp));
self.patch.add_assign(location,
- Place::Base(PlaceBase::Local(temp)),
+ Place::from(temp),
Rvalue::Use(
Operand::Move(
Place::Projection(box Projection{
@@ -115,7 +115,7 @@
Rvalue::Aggregate(
box AggregateKind::Array(item_ty),
temps.iter().map(
- |x| Operand::Move(Place::Base(PlaceBase::Local(*x)))
+ |x| Operand::Move(Place::from(*x))
).collect()
)
);
diff --git a/src/librustc_mir/util/elaborate_drops.rs b/src/librustc_mir/util/elaborate_drops.rs
index 815d210..dac90d3 100644
--- a/src/librustc_mir/util/elaborate_drops.rs
+++ b/src/librustc_mir/util/elaborate_drops.rs
@@ -92,7 +92,7 @@
#[derive(Debug)]
struct DropCtxt<'l, 'b, 'tcx, D>
where
- D: DropElaborator<'b, 'tcx> + 'l,
+ D: DropElaborator<'b, 'tcx>,
{
elaborator: &'l mut D,
@@ -486,7 +486,7 @@
// discriminant after it is free-ed, because that
// way lies only trouble.
let discr_ty = adt.repr.discr_type().to_ty(self.tcx());
- let discr = Place::Base(PlaceBase::Local(self.new_temp(discr_ty)));
+ let discr = Place::from(self.new_temp(discr_ty));
let discr_rv = Rvalue::Discriminant(self.place.clone());
let switch_block = BasicBlockData {
statements: vec![self.assign(&discr, discr_rv)],
@@ -518,11 +518,11 @@
mutbl: hir::Mutability::MutMutable
});
let ref_place = self.new_temp(ref_ty);
- let unit_temp = Place::Base(PlaceBase::Local(self.new_temp(tcx.mk_unit())));
+ let unit_temp = Place::from(self.new_temp(tcx.mk_unit()));
let result = BasicBlockData {
statements: vec![self.assign(
- &Place::Base(PlaceBase::Local(ref_place)),
+ &Place::from(ref_place),
Rvalue::Ref(tcx.lifetimes.re_erased,
BorrowKind::Mut { allow_two_phase_borrow: false },
self.place.clone())
@@ -531,7 +531,7 @@
kind: TerminatorKind::Call {
func: Operand::function_handle(tcx, drop_fn.def_id, substs,
self.source_info.span),
- args: vec![Operand::Move(Place::Base(PlaceBase::Local(ref_place)))],
+ args: vec![Operand::Move(Place::from(ref_place))],
destination: Some((unit_temp, succ)),
cleanup: unwind.into_option(),
from_hir_call: true,
@@ -576,8 +576,8 @@
ty: ety,
mutbl: hir::Mutability::MutMutable
});
- let ptr = &Place::Base(PlaceBase::Local(self.new_temp(ref_ty)));
- let can_go = &Place::Base(PlaceBase::Local(self.new_temp(tcx.types.bool)));
+ let ptr = &Place::from(self.new_temp(ref_ty));
+ let can_go = &Place::from(self.new_temp(tcx.types.bool));
let one = self.constant_usize(1);
let (ptr_next, cur_next) = if ptr_based {
@@ -589,19 +589,19 @@
elem: ProjectionElem::Deref,
}))
),
- Rvalue::BinaryOp(BinOp::Offset, move_(&Place::Base(PlaceBase::Local(cur))), one))
+ Rvalue::BinaryOp(BinOp::Offset, move_(&Place::from(cur)), one))
} else {
(Rvalue::Ref(
tcx.lifetimes.re_erased,
BorrowKind::Mut { allow_two_phase_borrow: false },
self.place.clone().index(cur)),
- Rvalue::BinaryOp(BinOp::Add, move_(&Place::Base(PlaceBase::Local(cur))), one))
+ Rvalue::BinaryOp(BinOp::Add, move_(&Place::from(cur)), one))
};
let drop_block = BasicBlockData {
statements: vec![
self.assign(ptr, ptr_next),
- self.assign(&Place::Base(PlaceBase::Local(cur)), cur_next)
+ self.assign(&Place::from(cur), cur_next)
],
is_cleanup: unwind.is_cleanup(),
terminator: Some(Terminator {
@@ -615,7 +615,7 @@
let loop_block = BasicBlockData {
statements: vec![
self.assign(can_go, Rvalue::BinaryOp(BinOp::Eq,
- copy(&Place::Base(PlaceBase::Local(cur))),
+ copy(&Place::from(cur)),
copy(length_or_end)))
],
is_cleanup: unwind.is_cleanup(),
@@ -665,8 +665,8 @@
let move_ = |place: &Place<'tcx>| Operand::Move(place.clone());
let tcx = self.tcx();
- let elem_size = &Place::Base(PlaceBase::Local(self.new_temp(tcx.types.usize)));
- let len = &Place::Base(PlaceBase::Local(self.new_temp(tcx.types.usize)));
+ let elem_size = &Place::from(self.new_temp(tcx.types.usize));
+ let len = &Place::from(self.new_temp(tcx.types.usize));
static USIZE_SWITCH_ZERO: &[u128] = &[0];
@@ -713,8 +713,7 @@
let length_or_end = if ptr_based {
// FIXME check if we want to make it return a `Place` directly
// if all use sites want a `Place::Base` anyway.
- let temp = self.new_temp(iter_ty);
- Place::Base(PlaceBase::Local(temp))
+ Place::from(self.new_temp(iter_ty))
} else {
length.clone()
};
@@ -736,10 +735,10 @@
unwind,
ptr_based);
- let cur = Place::Base(PlaceBase::Local(cur));
+ let cur = Place::from(cur);
let drop_block_stmts = if ptr_based {
let tmp_ty = tcx.mk_mut_ptr(self.place_ty(self.place));
- let tmp = Place::Base(PlaceBase::Local(self.new_temp(tmp_ty)));
+ let tmp = Place::from(self.new_temp(tmp_ty));
// tmp = &mut P;
// cur = tmp as *mut T;
// end = Offset(cur, len);
@@ -894,7 +893,7 @@
unwind: Unwind,
) -> BasicBlock {
let tcx = self.tcx();
- let unit_temp = Place::Base(PlaceBase::Local(self.new_temp(tcx.mk_unit())));
+ let unit_temp = Place::from(self.new_temp(tcx.mk_unit()));
let free_func = tcx.require_lang_item(lang_items::BoxFreeFnLangItem);
let args = adt.variants[VariantIdx::new(0)].fields.iter().enumerate().map(|(i, f)| {
let field = Field::new(i);
diff --git a/src/librustc_mir/util/graphviz.rs b/src/librustc_mir/util/graphviz.rs
index 7b154a9..1d876d7 100644
--- a/src/librustc_mir/util/graphviz.rs
+++ b/src/librustc_mir/util/graphviz.rs
@@ -153,7 +153,7 @@
}
write!(w,
"{:?}: {}",
- Place::Base(PlaceBase::Local(arg)),
+ Place::from(arg),
escape(&body.local_decls[arg].ty)
)?;
}
@@ -171,10 +171,10 @@
if let Some(name) = decl.name {
write!(w, r#"{:?}: {}; // {}<br align="left"/>"#,
- Place::Base(PlaceBase::Local(local)), escape(&decl.ty), name)?;
+ Place::from(local), escape(&decl.ty), name)?;
} else {
write!(w, r#"{:?}: {};<br align="left"/>"#,
- Place::Base(PlaceBase::Local(local)), escape(&decl.ty))?;
+ Place::from(local), escape(&decl.ty))?;
}
}
diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs
index fc46adb..d66f35f 100644
--- a/src/librustc_mir/util/pretty.rs
+++ b/src/librustc_mir/util/pretty.rs
@@ -601,7 +601,7 @@
if i != 0 {
write!(w, ", ")?;
}
- write!(w, "{:?}: {}", Place::Base(PlaceBase::Local(arg)), body.local_decls[arg].ty)?;
+ write!(w, "{:?}: {}", Place::from(arg), body.local_decls[arg].ty)?;
}
write!(w, ") -> {}", body.return_ty())?;
diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs
index 00b6db0..2da9c5a 100644
--- a/src/librustc_passes/ast_validation.rs
+++ b/src/librustc_passes/ast_validation.rs
@@ -17,13 +17,11 @@
use syntax::feature_gate::is_builtin_attr;
use syntax::source_map::Spanned;
use syntax::symbol::{kw, sym};
-use syntax::ptr::P;
use syntax::visit::{self, Visitor};
use syntax::{span_err, struct_span_err, walk_list};
use syntax_ext::proc_macro_decls::is_proc_macro_attr;
use syntax_pos::{Span, MultiSpan};
use errors::{Applicability, FatalError};
-use log::debug;
#[derive(Copy, Clone, Debug)]
struct OuterImplTrait {
@@ -319,54 +317,6 @@
}
}
- /// With eRFC 2497, we need to check whether an expression is ambiguous and warn or error
- /// depending on the edition, this function handles that.
- fn while_if_let_ambiguity(&self, expr: &P<Expr>) {
- if let Some((span, op_kind)) = self.while_if_let_expr_ambiguity(&expr) {
- let mut err = self.err_handler().struct_span_err(
- span, &format!("ambiguous use of `{}`", op_kind.to_string())
- );
-
- err.note(
- "this will be a error until the `let_chains` feature is stabilized"
- );
- err.note(
- "see rust-lang/rust#53668 for more information"
- );
-
- if let Ok(snippet) = self.session.source_map().span_to_snippet(span) {
- err.span_suggestion(
- span, "consider adding parentheses", format!("({})", snippet),
- Applicability::MachineApplicable,
- );
- }
-
- err.emit();
- }
- }
-
- /// With eRFC 2497 adding if-let chains, there is a requirement that the parsing of
- /// `&&` and `||` in a if-let statement be unambiguous. This function returns a span and
- /// a `BinOpKind` (either `&&` or `||` depending on what was ambiguous) if it is determined
- /// that the current expression parsed is ambiguous and will break in future.
- fn while_if_let_expr_ambiguity(&self, expr: &P<Expr>) -> Option<(Span, BinOpKind)> {
- debug!("while_if_let_expr_ambiguity: expr.node: {:?}", expr.node);
- match &expr.node {
- ExprKind::Binary(op, _, _) if op.node == BinOpKind::And || op.node == BinOpKind::Or => {
- Some((expr.span, op.node))
- },
- ExprKind::Range(ref lhs, ref rhs, _) => {
- let lhs_ambiguous = lhs.as_ref()
- .and_then(|lhs| self.while_if_let_expr_ambiguity(lhs));
- let rhs_ambiguous = rhs.as_ref()
- .and_then(|rhs| self.while_if_let_expr_ambiguity(rhs));
-
- lhs_ambiguous.or(rhs_ambiguous)
- }
- _ => None,
- }
- }
-
fn check_fn_decl(&self, fn_decl: &FnDecl) {
fn_decl
.inputs
@@ -493,19 +443,17 @@
impl<'a> Visitor<'a> for AstValidator<'a> {
fn visit_expr(&mut self, expr: &'a Expr) {
- match expr.node {
- ExprKind::Closure(_, _, _, ref fn_decl, _, _) => {
+ match &expr.node {
+ ExprKind::Closure(_, _, _, fn_decl, _, _) => {
self.check_fn_decl(fn_decl);
}
- ExprKind::IfLet(_, ref expr, _, _) | ExprKind::WhileLet(_, ref expr, _, _) =>
- self.while_if_let_ambiguity(&expr),
ExprKind::InlineAsm(..) if !self.session.target.target.options.allow_asm => {
span_err!(self.session, expr.span, E0472, "asm! is unsupported on this target");
}
_ => {}
}
- visit::walk_expr(self, expr)
+ visit::walk_expr(self, expr);
}
fn visit_ty(&mut self, ty: &'a Ty) {
diff --git a/src/librustc_passes/lib.rs b/src/librustc_passes/lib.rs
index bf2f763..5f3d715 100644
--- a/src/librustc_passes/lib.rs
+++ b/src/librustc_passes/lib.rs
@@ -8,6 +8,7 @@
#![feature(in_band_lifetimes)]
#![feature(nll)]
+#![feature(bind_by_move_pattern_guards)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]
diff --git a/src/librustc_passes/loops.rs b/src/librustc_passes/loops.rs
index e1e4195..ed0a78b 100644
--- a/src/librustc_passes/loops.rs
+++ b/src/librustc_passes/loops.rs
@@ -107,7 +107,7 @@
};
if loop_id != hir::DUMMY_HIR_ID {
- if let Node::Block(_) = self.hir_map.find_by_hir_id(loop_id).unwrap() {
+ if let Node::Block(_) = self.hir_map.find(loop_id).unwrap() {
return
}
}
@@ -116,7 +116,7 @@
let loop_kind = if loop_id == hir::DUMMY_HIR_ID {
None
} else {
- Some(match self.hir_map.expect_expr_by_hir_id(loop_id).node {
+ Some(match self.hir_map.expect_expr(loop_id).node {
hir::ExprKind::While(..) => LoopKind::WhileLoop,
hir::ExprKind::Loop(_, _, source) => LoopKind::Loop(source),
ref r => span_bug!(e.span,
@@ -155,7 +155,7 @@
match destination.target_id {
Ok(loop_id) => {
- if let Node::Block(block) = self.hir_map.find_by_hir_id(loop_id).unwrap() {
+ if let Node::Block(block) = self.hir_map.find(loop_id).unwrap() {
struct_span_err!(self.sess, e.span, E0696,
"`continue` pointing to a labeled block")
.span_label(e.span,
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index ba834bf..3e98200 100644
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -229,14 +229,14 @@
) -> (ty::Visibility, Span, &'static str) {
match tcx.hir().as_local_hir_id(def_id) {
Some(hir_id) => {
- let vis = match tcx.hir().get_by_hir_id(hir_id) {
+ let vis = match tcx.hir().get(hir_id) {
Node::Item(item) => &item.vis,
Node::ForeignItem(foreign_item) => &foreign_item.vis,
Node::TraitItem(..) | Node::Variant(..) => {
return def_id_visibility(tcx, tcx.hir().get_parent_did(hir_id));
}
Node::ImplItem(impl_item) => {
- match tcx.hir().get_by_hir_id(tcx.hir().get_parent_item(hir_id)) {
+ match tcx.hir().get(tcx.hir().get_parent_item(hir_id)) {
Node::Item(item) => match &item.node {
hir::ItemKind::Impl(.., None, _, _) => &impl_item.vis,
hir::ItemKind::Impl(.., Some(trait_ref), _, _)
@@ -247,8 +247,8 @@
}
}
Node::Ctor(vdata) => {
- let parent_hir_id = tcx.hir().get_parent_node_by_hir_id(hir_id);
- match tcx.hir().get_by_hir_id(parent_hir_id) {
+ let parent_hir_id = tcx.hir().get_parent_node(hir_id);
+ match tcx.hir().get(parent_hir_id) {
Node::Variant(..) => {
let parent_did = tcx.hir().local_def_id_from_hir_id(parent_hir_id);
let (mut ctor_vis, mut span, mut descr) = def_id_visibility(
@@ -274,7 +274,7 @@
return (ctor_vis, span, descr);
}
Node::Item(..) => {
- let item = match tcx.hir().get_by_hir_id(parent_hir_id) {
+ let item = match tcx.hir().get(parent_hir_id) {
Node::Item(item) => item,
node => bug!("unexpected node kind: {:?}", node),
};
@@ -784,7 +784,7 @@
if module_id == hir::CRATE_HIR_ID {
break
}
- module_id = self.tcx.hir().get_parent_node_by_hir_id(module_id);
+ module_id = self.tcx.hir().get_parent_node(module_id);
}
}
}
@@ -1233,7 +1233,7 @@
if let Some(hir_id) = self.tcx.hir().as_local_hir_id(did) {
// .. and it corresponds to a private type in the AST (this returns
// `None` for type parameters).
- match self.tcx.hir().find_by_hir_id(hir_id) {
+ match self.tcx.hir().find(hir_id) {
Some(Node::Item(ref item)) => !item.vis.node.is_pub(),
Some(_) | None => false,
}
@@ -1674,7 +1674,7 @@
has_old_errors = true;
break;
}
- let parent = self.tcx.hir().get_parent_node_by_hir_id(id);
+ let parent = self.tcx.hir().get_parent_node(id);
if parent == id {
break;
}
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 0fbd066..81adfac 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -485,8 +485,6 @@
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum PatternSource {
Match,
- IfLet,
- WhileLet,
Let,
For,
FnParam,
@@ -496,8 +494,6 @@
fn descr(self) -> &'static str {
match self {
PatternSource::Match => "match binding",
- PatternSource::IfLet => "if let binding",
- PatternSource::WhileLet => "while let binding",
PatternSource::Let => "let binding",
PatternSource::For => "for binding",
PatternSource::FnParam => "function parameter",
@@ -1748,12 +1744,12 @@
/// This interface is used through the AST→HIR step, to embed full paths into the HIR. After that
/// the resolver is no longer needed as all the relevant information is inline.
impl<'a> hir::lowering::Resolver for Resolver<'a> {
- fn resolve_hir_path(
+ fn resolve_ast_path(
&mut self,
path: &ast::Path,
is_value: bool,
- ) -> hir::Path {
- self.resolve_hir_path_cb(path, is_value,
+ ) -> Res {
+ self.resolve_ast_path_cb(path, is_value,
|resolver, span, error| resolve_error(resolver, span, error))
}
@@ -1763,7 +1759,7 @@
crate_root: Option<Symbol>,
components: &[Symbol],
is_value: bool
- ) -> hir::Path {
+ ) -> (ast::Path, Res) {
let root = if crate_root.is_some() {
kw::PathRoot
} else {
@@ -1781,7 +1777,8 @@
segments,
};
- self.resolve_hir_path(&path, is_value)
+ let res = self.resolve_ast_path(&path, is_value);
+ (path, res)
}
fn get_partial_res(&mut self, id: NodeId) -> Option<PartialRes> {
@@ -1807,7 +1804,7 @@
/// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
/// just that an error occurred.
pub fn resolve_str_path_error(&mut self, span: Span, path_str: &str, is_value: bool)
- -> Result<hir::Path, ()> {
+ -> Result<(ast::Path, Res), ()> {
let mut errored = false;
let path = if path_str.starts_with("::") {
@@ -1830,29 +1827,29 @@
.collect(),
}
};
- let path = self.resolve_hir_path_cb(&path, is_value, |_, _, _| errored = true);
- if errored || path.res == def::Res::Err {
+ let res = self.resolve_ast_path_cb(&path, is_value, |_, _, _| errored = true);
+ if errored || res == def::Res::Err {
Err(())
} else {
- Ok(path)
+ Ok((path, res))
}
}
- /// Like `resolve_hir_path`, but takes a callback in case there was an error.
- fn resolve_hir_path_cb<F>(
+ /// Like `resolve_ast_path`, but takes a callback in case there was an error.
+ // FIXME(eddyb) use `Result` or something instead of callbacks.
+ fn resolve_ast_path_cb<F>(
&mut self,
path: &ast::Path,
is_value: bool,
error_callback: F,
- ) -> hir::Path
+ ) -> Res
where F: for<'c, 'b> FnOnce(&'c mut Resolver<'_>, Span, ResolutionError<'b>)
{
let namespace = if is_value { ValueNS } else { TypeNS };
let span = path.span;
- let segments = &path.segments;
let path = Segment::from_path(&path);
// FIXME(Manishearth): intra-doc links won't get warned of epoch changes.
- let res = match self.resolve_path_without_parent_scope(&path, Some(namespace), true,
+ match self.resolve_path_without_parent_scope(&path, Some(namespace), true,
span, CrateLint::No) {
PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
module.res().unwrap(),
@@ -1873,19 +1870,6 @@
});
Res::Err
}
- };
-
- let segments: Vec<_> = segments.iter().map(|seg| {
- let mut hir_seg = hir::PathSegment::from_ident(seg.ident);
- hir_seg.res = Some(self.partial_res_map.get(&seg.id).map_or(def::Res::Err, |p| {
- p.base_res().map_id(|_| panic!("unexpected node_id"))
- }));
- hir_seg
- }).collect();
- hir::Path {
- span,
- res: res.map_id(|_| panic!("unexpected node_id")),
- segments: segments.into(),
}
}
@@ -3057,15 +3041,9 @@
fn resolve_arm(&mut self, arm: &Arm) {
self.ribs[ValueNS].push(Rib::new(NormalRibKind));
- let mut bindings_list = FxHashMap::default();
- for pattern in &arm.pats {
- self.resolve_pattern(&pattern, PatternSource::Match, &mut bindings_list);
- }
+ self.resolve_pats(&arm.pats, PatternSource::Match);
- // This has to happen *after* we determine which pat_idents are variants.
- self.check_consistent_bindings(&arm.pats);
-
- if let Some(ast::Guard::If(ref expr)) = arm.guard {
+ if let Some(ref expr) = arm.guard {
self.visit_expr(expr)
}
self.visit_expr(&arm.body);
@@ -3073,6 +3051,16 @@
self.ribs[ValueNS].pop();
}
+ /// Arising from `source`, resolve a sequence of patterns (top level or-patterns).
+ fn resolve_pats(&mut self, pats: &[P<Pat>], source: PatternSource) {
+ let mut bindings_list = FxHashMap::default();
+ for pat in pats {
+ self.resolve_pattern(pat, source, &mut bindings_list);
+ }
+ // This has to happen *after* we determine which pat_idents are variants
+ self.check_consistent_bindings(pats);
+ }
+
fn resolve_block(&mut self, block: &Block) {
debug!("(resolving block) entering block");
// Move down in the graph, if there's an anonymous module rooted here.
@@ -3151,8 +3139,7 @@
);
}
Some(..) if pat_src == PatternSource::Match ||
- pat_src == PatternSource::IfLet ||
- pat_src == PatternSource::WhileLet => {
+ pat_src == PatternSource::Let => {
// `Variant1(a) | Variant2(a)`, ok
// Reuse definition from the first `a`.
res = self.ribs[ValueNS].last_mut().unwrap().bindings[&ident];
@@ -4345,41 +4332,26 @@
visit::walk_expr(self, expr);
}
- ExprKind::IfLet(ref pats, ref subexpression, ref if_block, ref optional_else) => {
- self.visit_expr(subexpression);
+ ExprKind::Let(ref pats, ref scrutinee) => {
+ self.visit_expr(scrutinee);
+ self.resolve_pats(pats, PatternSource::Let);
+ }
+ ExprKind::If(ref cond, ref then, ref opt_else) => {
self.ribs[ValueNS].push(Rib::new(NormalRibKind));
- let mut bindings_list = FxHashMap::default();
- for pat in pats {
- self.resolve_pattern(pat, PatternSource::IfLet, &mut bindings_list);
- }
- // This has to happen *after* we determine which pat_idents are variants
- self.check_consistent_bindings(pats);
- self.visit_block(if_block);
+ self.visit_expr(cond);
+ self.visit_block(then);
self.ribs[ValueNS].pop();
- optional_else.as_ref().map(|expr| self.visit_expr(expr));
+ opt_else.as_ref().map(|expr| self.visit_expr(expr));
}
ExprKind::Loop(ref block, label) => self.resolve_labeled_block(label, expr.id, &block),
ExprKind::While(ref subexpression, ref block, label) => {
self.with_resolved_label(label, expr.id, |this| {
- this.visit_expr(subexpression);
- this.visit_block(block);
- });
- }
-
- ExprKind::WhileLet(ref pats, ref subexpression, ref block, label) => {
- self.with_resolved_label(label, expr.id, |this| {
- this.visit_expr(subexpression);
this.ribs[ValueNS].push(Rib::new(NormalRibKind));
- let mut bindings_list = FxHashMap::default();
- for pat in pats {
- this.resolve_pattern(pat, PatternSource::WhileLet, &mut bindings_list);
- }
- // This has to happen *after* we determine which pat_idents are variants.
- this.check_consistent_bindings(pats);
+ this.visit_expr(subexpression);
this.visit_block(block);
this.ribs[ValueNS].pop();
});
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index 5623016..392a46a 100644
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -1022,6 +1022,12 @@
fn suggest_macro_name(&mut self, name: Symbol, kind: MacroKind,
err: &mut DiagnosticBuilder<'a>, span: Span) {
+ if kind == MacroKind::Derive && (name.as_str() == "Send" || name.as_str() == "Sync") {
+ let msg = format!("unsafe traits like `{}` should be implemented explicitly", name);
+ err.span_note(span, &msg);
+ return;
+ }
+
// First check if this is a locally-defined bang macro.
let suggestion = if let MacroKind::Bang = kind {
find_best_match_for_name(
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
index a7f46e8..beef9f1 100644
--- a/src/librustc_save_analysis/dump_visitor.rs
+++ b/src/librustc_save_analysis/dump_visitor.rs
@@ -1531,7 +1531,8 @@
self.process_macro_use(ex.span);
match ex.node {
ast::ExprKind::Struct(ref path, ref fields, ref base) => {
- let hir_expr = self.save_ctxt.tcx.hir().expect_expr(ex.id);
+ let expr_hir_id = self.save_ctxt.tcx.hir().node_to_hir_id(ex.id);
+ let hir_expr = self.save_ctxt.tcx.hir().expect_expr(expr_hir_id);
let adt = match self.save_ctxt.tables.expr_ty_opt(&hir_expr) {
Some(ty) if ty.ty_adt_def().is_some() => ty.ty_adt_def().unwrap(),
_ => {
@@ -1579,17 +1580,9 @@
self.visit_expr(subexpression);
visit::walk_block(self, block);
}
- ast::ExprKind::WhileLet(ref pats, ref subexpression, ref block, _) => {
+ ast::ExprKind::Let(ref pats, ref scrutinee) => {
self.process_var_decl_multi(pats);
- debug!("for loop, walk sub-expr: {:?}", subexpression.node);
- self.visit_expr(subexpression);
- visit::walk_block(self, block);
- }
- ast::ExprKind::IfLet(ref pats, ref subexpression, ref block, ref opt_else) => {
- self.process_var_decl_multi(pats);
- self.visit_expr(subexpression);
- visit::walk_block(self, block);
- opt_else.as_ref().map(|el| self.visit_expr(el));
+ self.visit_expr(scrutinee);
}
ast::ExprKind::Repeat(ref element, ref count) => {
self.visit_expr(element);
@@ -1616,9 +1609,8 @@
fn visit_arm(&mut self, arm: &'l ast::Arm) {
self.process_var_decl_multi(&arm.pats);
- match arm.guard {
- Some(ast::Guard::If(ref expr)) => self.visit_expr(expr),
- _ => {}
+ if let Some(expr) = &arm.guard {
+ self.visit_expr(expr);
}
self.visit_expr(&arm.body);
}
diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs
index bc813b3..19ed9e2 100644
--- a/src/librustc_save_analysis/lib.rs
+++ b/src/librustc_save_analysis/lib.rs
@@ -410,7 +410,10 @@
let mut decl_id = None;
let mut docs = String::new();
let mut attrs = vec![];
- if let Some(Node::ImplItem(item)) = self.tcx.hir().find(id) {
+ let hir_id = self.tcx.hir().node_to_hir_id(id);
+ if let Some(Node::ImplItem(item)) =
+ self.tcx.hir().find(hir_id)
+ {
docs = self.docs_for_attrs(&item.attrs);
attrs = item.attrs.to_vec();
}
@@ -451,8 +454,9 @@
Some(def_id) => {
let mut docs = String::new();
let mut attrs = vec![];
+ let hir_id = self.tcx.hir().node_to_hir_id(id);
- if let Some(Node::TraitItem(item)) = self.tcx.hir().find(id) {
+ if let Some(Node::TraitItem(item)) = self.tcx.hir().find(hir_id) {
docs = self.docs_for_attrs(&item.attrs);
attrs = item.attrs.to_vec();
}
@@ -513,14 +517,16 @@
}
pub fn get_expr_data(&self, expr: &ast::Expr) -> Option<Data> {
- let hir_node = self.tcx.hir().expect_expr(expr.id);
+ let expr_hir_id = self.tcx.hir().node_to_hir_id(expr.id);
+ let hir_node = self.tcx.hir().expect_expr(expr_hir_id);
let ty = self.tables.expr_ty_adjusted_opt(&hir_node);
if ty.is_none() || ty.unwrap().sty == ty::Error {
return None;
}
match expr.node {
ast::ExprKind::Field(ref sub_ex, ident) => {
- let hir_node = match self.tcx.hir().find(sub_ex.id) {
+ let sub_ex_hir_id = self.tcx.hir().node_to_hir_id(sub_ex.id);
+ let hir_node = match self.tcx.hir().find(sub_ex_hir_id) {
Some(Node::Expr(expr)) => expr,
_ => {
debug!(
@@ -606,7 +612,8 @@
}
pub fn get_path_res(&self, id: NodeId) -> Res {
- match self.tcx.hir().get(id) {
+ let hir_id = self.tcx.hir().node_to_hir_id(id);
+ match self.tcx.hir().get(hir_id) {
Node::TraitRef(tr) => tr.path.res,
Node::Item(&hir::Item {
@@ -619,7 +626,10 @@
Node::PathSegment(seg) => {
match seg.res {
Some(res) if res != Res::Err => res,
- _ => self.get_path_res(self.tcx.hir().get_parent_node(id)),
+ _ => {
+ let parent_node = self.tcx.hir().get_parent_node(hir_id);
+ self.get_path_res(self.tcx.hir().hir_to_node_id(parent_node))
+ },
}
}
@@ -627,7 +637,6 @@
node: hir::ExprKind::Struct(ref qpath, ..),
..
}) => {
- let hir_id = self.tcx.hir().node_to_hir_id(id);
self.tables.qpath_res(qpath, hir_id)
}
@@ -651,7 +660,6 @@
node: hir::TyKind::Path(ref qpath),
..
}) => {
- let hir_id = self.tcx.hir().node_to_hir_id(id);
self.tables.qpath_res(qpath, hir_id)
}
diff --git a/src/librustc_save_analysis/span_utils.rs b/src/librustc_save_analysis/span_utils.rs
index 5831b0b..8905f47 100644
--- a/src/librustc_save_analysis/span_utils.rs
+++ b/src/librustc_save_analysis/span_utils.rs
@@ -2,8 +2,6 @@
use crate::generated_code;
-use std::cell::Cell;
-
use syntax::parse::lexer::{self, StringReader};
use syntax::parse::token::{self, TokenKind};
use syntax_pos::*;
@@ -11,16 +9,12 @@
#[derive(Clone)]
pub struct SpanUtils<'a> {
pub sess: &'a Session,
- // FIXME given that we clone SpanUtils all over the place, this err_count is
- // probably useless and any logic relying on it is bogus.
- pub err_count: Cell<isize>,
}
impl<'a> SpanUtils<'a> {
pub fn new(sess: &'a Session) -> SpanUtils<'a> {
SpanUtils {
sess,
- err_count: Cell::new(0),
}
}
diff --git a/src/librustc_target/spec/mod.rs b/src/librustc_target/spec/mod.rs
index 08cf062..75821ab 100644
--- a/src/librustc_target/spec/mod.rs
+++ b/src/librustc_target/spec/mod.rs
@@ -119,19 +119,19 @@
($((($($flavor:tt)*), $string:expr),)*) => (
impl LinkerFlavor {
pub const fn one_of() -> &'static str {
- concat!("one of: ", $($string, " ",)+)
+ concat!("one of: ", $($string, " ",)*)
}
pub fn from_str(s: &str) -> Option<Self> {
Some(match s {
- $($string => $($flavor)*,)+
+ $($string => $($flavor)*,)*
_ => return None,
})
}
pub fn desc(&self) -> &str {
match *self {
- $($($flavor)* => $string,)+
+ $($($flavor)* => $string,)*
}
}
}
diff --git a/src/librustc_traits/lowering/environment.rs b/src/librustc_traits/lowering/environment.rs
index d1bad6b..0173685 100644
--- a/src/librustc_traits/lowering/environment.rs
+++ b/src/librustc_traits/lowering/environment.rs
@@ -185,7 +185,7 @@
.map(Clause::ForAll);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
- let node = tcx.hir().get_by_hir_id(hir_id);
+ let node = tcx.hir().get(hir_id);
enum NodeKind {
TraitImpl,
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index 267f379..0375ad4 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -123,7 +123,7 @@
{
let tcx = self.tcx();
let lifetime_name = |def_id| {
- tcx.hir().name_by_hir_id(tcx.hir().as_local_hir_id(def_id).unwrap()).as_interned_str()
+ tcx.hir().name(tcx.hir().as_local_hir_id(def_id).unwrap()).as_interned_str()
};
let r = match tcx.named_region(lifetime.hir_id) {
@@ -1253,7 +1253,7 @@
if regular_traits.is_empty() && auto_traits.is_empty() {
span_err!(tcx.sess, span, E0224,
- "at least one non-builtin trait is required for an object type");
+ "at least one trait is required for an object type");
return tcx.types.err;
}
@@ -2000,11 +2000,11 @@
self.prohibit_generics(&path.segments);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
- let item_id = tcx.hir().get_parent_node_by_hir_id(hir_id);
+ let item_id = tcx.hir().get_parent_node(hir_id);
let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
let generics = tcx.generics_of(item_def_id);
let index = generics.param_def_id_to_index[&def_id];
- tcx.mk_ty_param(index, tcx.hir().name_by_hir_id(hir_id).as_interned_str())
+ tcx.mk_ty_param(index, tcx.hir().name(hir_id).as_interned_str())
}
Res::SelfTy(Some(_), None) => {
// `Self` in trait or type alias.
@@ -2190,11 +2190,11 @@
// Find the name and index of the const parameter by indexing the generics of the
// parent item and construct a `ParamConst`.
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
- let item_id = tcx.hir().get_parent_node_by_hir_id(hir_id);
+ let item_id = tcx.hir().get_parent_node(hir_id);
let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
let generics = tcx.generics_of(item_def_id);
let index = generics.param_def_id_to_index[&tcx.hir().local_def_id_from_hir_id(hir_id)];
- let name = tcx.hir().name_by_hir_id(hir_id).as_interned_str();
+ let name = tcx.hir().name(hir_id).as_interned_str();
const_.val = ConstValue::Param(ty::ParamConst::new(index, name));
}
diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs
index 65a36d9..b435c99 100644
--- a/src/librustc_typeck/check/_match.rs
+++ b/src/librustc_typeck/check/_match.rs
@@ -546,8 +546,8 @@
) {
let tcx = self.tcx;
if let PatKind::Binding(..) = inner.node {
- let parent_id = tcx.hir().get_parent_node_by_hir_id(pat.hir_id);
- let parent = tcx.hir().get_by_hir_id(parent_id);
+ let parent_id = tcx.hir().get_parent_node(pat.hir_id);
+ let parent = tcx.hir().get(parent_id);
debug!("inner {:?} pat {:?} parent {:?}", inner, pat, parent);
match parent {
hir::Node::Item(hir::Item { node: hir::ItemKind::Fn(..), .. }) |
@@ -808,16 +808,16 @@
use hir::Node::{Block, Item, Local};
let hir = self.tcx.hir();
- let arm_id = hir.get_parent_node_by_hir_id(hir_id);
- let match_id = hir.get_parent_node_by_hir_id(arm_id);
- let containing_id = hir.get_parent_node_by_hir_id(match_id);
+ let arm_id = hir.get_parent_node(hir_id);
+ let match_id = hir.get_parent_node(arm_id);
+ let containing_id = hir.get_parent_node(match_id);
- let node = hir.get_by_hir_id(containing_id);
+ let node = hir.get(containing_id);
if let Block(block) = node {
// check that the body's parent is an fn
- let parent = hir.get_by_hir_id(
- hir.get_parent_node_by_hir_id(
- hir.get_parent_node_by_hir_id(block.hir_id),
+ let parent = hir.get(
+ hir.get_parent_node(
+ hir.get_parent_node(block.hir_id),
),
);
if let (Some(expr), Item(hir::Item {
diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
index 42c7ff6..e6999f9 100644
--- a/src/librustc_typeck/check/callee.rs
+++ b/src/librustc_typeck/check/callee.rs
@@ -244,8 +244,8 @@
callee_node: &hir::ExprKind,
callee_span: Span,
) {
- let hir_id = self.tcx.hir().get_parent_node_by_hir_id(hir_id);
- let parent_node = self.tcx.hir().get_by_hir_id(hir_id);
+ let hir_id = self.tcx.hir().get_parent_node(hir_id);
+ let parent_node = self.tcx.hir().get(hir_id);
if let (
hir::Node::Expr(hir::Expr { node: hir::ExprKind::Closure(_, _, _, sp, ..), .. }),
hir::ExprKind::Block(..),
diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs
index a56196c..4bd2f21 100644
--- a/src/librustc_typeck/check/coercion.rs
+++ b/src/librustc_typeck/check/coercion.rs
@@ -1231,7 +1231,7 @@
db.span_label(cause.span, "return type is not `()`");
}
ObligationCauseCode::BlockTailExpression(blk_id) => {
- let parent_id = fcx.tcx.hir().get_parent_node_by_hir_id(blk_id);
+ let parent_id = fcx.tcx.hir().get_parent_node(blk_id);
db = self.report_return_mismatched_types(
cause,
expected,
@@ -1281,7 +1281,7 @@
// Verify that this is a tail expression of a function, otherwise the
// label pointing out the cause for the type coercion will be wrong
// as prior return coercions would not be relevant (#57664).
- let parent_id = fcx.tcx.hir().get_parent_node_by_hir_id(id);
+ let parent_id = fcx.tcx.hir().get_parent_node(id);
let fn_decl = if let Some((expr, blk_id)) = expression {
pointing_at_return_type = fcx.suggest_mismatched_types_on_tail(
&mut db,
@@ -1291,7 +1291,7 @@
cause.span,
blk_id,
);
- let parent = fcx.tcx.hir().get_by_hir_id(parent_id);
+ let parent = fcx.tcx.hir().get(parent_id);
fcx.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
} else {
fcx.get_fn_decl(parent_id)
diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs
index aff8eba..c469d35 100644
--- a/src/librustc_typeck/check/demand.rs
+++ b/src/librustc_typeck/check/demand.rs
@@ -236,17 +236,17 @@
) -> Option<(Span, &'static str, String)> {
if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.node {
if let hir::def::Res::Local(id) = path.res {
- let parent = self.tcx.hir().get_parent_node_by_hir_id(id);
+ let parent = self.tcx.hir().get_parent_node(id);
if let Some(Node::Expr(hir::Expr {
hir_id,
node: hir::ExprKind::Closure(_, decl, ..),
..
- })) = self.tcx.hir().find_by_hir_id(parent) {
- let parent = self.tcx.hir().get_parent_node_by_hir_id(*hir_id);
+ })) = self.tcx.hir().find(parent) {
+ let parent = self.tcx.hir().get_parent_node(*hir_id);
if let (Some(Node::Expr(hir::Expr {
node: hir::ExprKind::MethodCall(path, span, expr),
..
- })), 1) = (self.tcx.hir().find_by_hir_id(parent), decl.inputs.len()) {
+ })), 1) = (self.tcx.hir().find(parent), decl.inputs.len()) {
let self_ty = self.tables.borrow().node_type(expr[0].hir_id);
let self_ty = format!("{:?}", self_ty);
let name = path.ident.as_str();
@@ -276,8 +276,8 @@
sp: Span,
) -> bool {
let cm = self.sess().source_map();
- let parent_id = self.tcx.hir().get_parent_node_by_hir_id(hir_id);
- if let Some(parent) = self.tcx.hir().find_by_hir_id(parent_id) {
+ let parent_id = self.tcx.hir().get_parent_node(hir_id);
+ if let Some(parent) = self.tcx.hir().find(parent_id) {
// Account for fields
if let Node::Expr(hir::Expr {
node: hir::ExprKind::Struct(_, fields, ..), ..
@@ -421,8 +421,8 @@
if let Some(hir::Node::Expr(hir::Expr {
node: hir::ExprKind::Assign(left_expr, _),
..
- })) = self.tcx.hir().find_by_hir_id(
- self.tcx.hir().get_parent_node_by_hir_id(expr.hir_id),
+ })) = self.tcx.hir().find(
+ self.tcx.hir().get_parent_node(expr.hir_id),
) {
if mutability == hir::Mutability::MutMutable {
// Found the following case:
@@ -551,7 +551,7 @@
if let Some(hir::Node::Expr(hir::Expr {
node: hir::ExprKind::Struct(_, fields, _),
..
- })) = self.tcx.hir().find_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr.hir_id)) {
+ })) = self.tcx.hir().find(self.tcx.hir().get_parent_node(expr.hir_id)) {
// `expr` is a literal field for a struct, only suggest if appropriate
for field in fields {
if field.expr.hir_id == expr.hir_id && field.is_shorthand {
diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs
index 8ca1b85..85da325 100644
--- a/src/librustc_typeck/check/expr.rs
+++ b/src/librustc_typeck/check/expr.rs
@@ -565,7 +565,7 @@
// else an error would have been flagged by the
// `loops` pass for using break with an expression
// where you are not supposed to.
- assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
+ assert!(expr_opt.is_none() || self.tcx.sess.has_errors());
}
ctxt.may_break = true;
@@ -577,10 +577,8 @@
// this can only happen if the `break` was not
// inside a loop at all, which is caught by the
// loop-checking pass.
- if self.tcx.sess.err_count() == 0 {
- self.tcx.sess.delay_span_bug(expr.span,
- "break was outside loop, but no error was emitted");
- }
+ self.tcx.sess.delay_span_bug(expr.span,
+ "break was outside loop, but no error was emitted");
// We still need to assign a type to the inner expression to
// prevent the ICE in #43162.
diff --git a/src/librustc_typeck/check/generator_interior.rs b/src/librustc_typeck/check/generator_interior.rs
index 72f42c8..0bd078d 100644
--- a/src/librustc_typeck/check/generator_interior.rs
+++ b/src/librustc_typeck/check/generator_interior.rs
@@ -28,6 +28,10 @@
source_span: Span) {
use syntax_pos::DUMMY_SP;
+ debug!("generator_interior: attempting to record type {:?} {:?} {:?} {:?}",
+ ty, scope, expr, source_span);
+
+
let live_across_yield = scope.map(|s| {
self.region_scope_tree.yield_in_scope(s).and_then(|yield_data| {
// If we are recording an expression that is the last yield
diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs
index 5943302..fa1b07d 100644
--- a/src/librustc_typeck/check/method/suggest.rs
+++ b/src/librustc_typeck/check/method/suggest.rs
@@ -268,8 +268,8 @@
let snippet = tcx.sess.source_map().span_to_snippet(span);
let filename = tcx.sess.source_map().span_to_filename(span);
- let parent_node = self.tcx.hir().get_by_hir_id(
- self.tcx.hir().get_parent_node_by_hir_id(hir_id),
+ let parent_node = self.tcx.hir().get(
+ self.tcx.hir().get_parent_node(hir_id),
);
let msg = format!(
"you must specify a type for this binding, like `{}`",
@@ -389,8 +389,8 @@
Applicability::MachineApplicable,
);
} else {
- let call_expr = self.tcx.hir().expect_expr_by_hir_id(
- self.tcx.hir().get_parent_node_by_hir_id(expr.hir_id),
+ let call_expr = self.tcx.hir().expect_expr(
+ self.tcx.hir().get_parent_node(expr.hir_id),
);
if let Some(span) = call_expr.span.trim_start(item_name.span) {
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 0e83db4..5ae26c4 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -527,6 +527,8 @@
/// checking this function. On exit, if we find that *more* errors
/// have been reported, we will skip regionck and other work that
/// expects the types within the function to be consistent.
+ // FIXME(matthewjasper) This should not exist, and it's not correct
+ // if type checking is run in parallel.
err_count_on_creation: usize,
ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
@@ -696,11 +698,9 @@
fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
}
-pub fn check_wf_new<'tcx>(tcx: TyCtxt<'tcx>) -> Result<(), ErrorReported> {
- tcx.sess.track_errors(|| {
- let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
- tcx.hir().krate().par_visit_all_item_likes(&mut visit);
- })
+pub fn check_wf_new<'tcx>(tcx: TyCtxt<'tcx>) {
+ let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
+ tcx.hir().krate().par_visit_all_item_likes(&mut visit);
}
fn check_mod_item_types<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) {
@@ -759,7 +759,7 @@
tcx: TyCtxt<'tcx>,
id: hir::HirId,
) -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)> {
- match tcx.hir().get_by_hir_id(id) {
+ match tcx.hir().get(id) {
Node::Item(item) => {
match item.node {
hir::ItemKind::Const(_, body) |
@@ -993,10 +993,9 @@
if let PatKind::Binding(_, _, ident, _) = p.node {
let var_ty = self.assign(p.span, p.hir_id, None);
- let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
if !self.fcx.tcx.features().unsized_locals {
self.fcx.require_type_is_sized(var_ty, p.span,
- traits::VariableType(node_id));
+ traits::VariableType(p.hir_id));
}
debug!("Pattern binding {} is assigned to {} with type {:?}",
@@ -1214,7 +1213,7 @@
);
}
- if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
+ if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
if let ItemKind::Fn(_, _, ref generics, _) = item.node {
if !generics.params.is_empty() {
fcx.tcx.sess.span_err(
@@ -1262,7 +1261,7 @@
);
}
- if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
+ if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
if let ItemKind::Fn(_, _, ref generics, _) = item.node {
if !generics.params.is_empty() {
fcx.tcx.sess.span_err(
@@ -1448,8 +1447,8 @@
};
let param_env = ty::ParamEnv::reveal_all();
if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
- let alloc = if let ConstValue::ByRef(_, _, allocation) = static_.val {
- allocation
+ let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
+ alloc
} else {
bug!("Matching on non-ByRef static")
};
@@ -1936,6 +1935,25 @@
}
}
+ if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
+ let is_unit =
+ |var: &hir::Variant| match var.node.data {
+ hir::VariantData::Unit(..) => true,
+ _ => false
+ };
+
+ let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some();
+ let has_non_units = vs.iter().any(|var| !is_unit(var));
+ let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
+ let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
+
+ if disr_non_unit || (disr_units && has_non_units) {
+ let mut err = struct_span_err!(tcx.sess, sp, E0732,
+ "`#[repr(inttype)]` must be specified");
+ err.emit();
+ }
+ }
+
let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
// Check for duplicate discriminant values
@@ -2129,8 +2147,8 @@
&self.tcx.sess
}
- pub fn err_count_since_creation(&self) -> usize {
- self.tcx.sess.err_count() - self.err_count_on_creation
+ pub fn errors_reported_since_creation(&self) -> bool {
+ self.tcx.sess.err_count() > self.err_count_on_creation
}
/// Produces warning on the given node, if the current point in the
@@ -3677,7 +3695,7 @@
}
fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
- let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
+ let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
match node {
Node::Item(&hir::Item {
node: hir::ItemKind::Fn(_, _, _, body_id), ..
@@ -3697,7 +3715,7 @@
/// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
- let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
+ let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
}
@@ -3732,7 +3750,7 @@
// Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
// `while` before reaching it, as block tail returns are not available in them.
self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
- let parent = self.tcx.hir().get_by_hir_id(blk_id);
+ let parent = self.tcx.hir().get(blk_id);
self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
})
}
@@ -4259,8 +4277,8 @@
// If our calling expression is indeed the function itself, we're good!
// If not, generate an error that this can only be called directly.
- if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
- self.tcx.hir().get_parent_node_by_hir_id(hir_id))
+ if let Node::Expr(expr) = self.tcx.hir().get(
+ self.tcx.hir().get_parent_node(hir_id))
{
if let ExprKind::Call(ref callee, ..) = expr.node {
if callee.hir_id == hir_id {
@@ -4335,7 +4353,7 @@
let mut contained_in_place = false;
while let hir::Node::Expr(parent_expr) =
- self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
+ self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
{
match &parent_expr.node {
hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
@@ -4376,7 +4394,7 @@
} else if let ty::Error = leaf_ty.sty {
// If there is already another error, do not emit
// an error for not using a type Parameter.
- assert!(tcx.sess.err_count() > 0);
+ assert!(tcx.sess.has_errors());
return;
}
}
diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs
index 5c71039..5313e1d 100644
--- a/src/librustc_typeck/check/regionck.rs
+++ b/src/librustc_typeck/check/regionck.rs
@@ -123,7 +123,7 @@
// standalone expr (e.g., the `E` in a type like `[u32; E]`).
rcx.outlives_environment.save_implied_bounds(id);
- if self.err_count_since_creation() == 0 {
+ if !self.errors_reported_since_creation() {
// regionck assumes typeck succeeded
rcx.visit_body(body);
rcx.visit_region_obligations(id);
@@ -173,7 +173,7 @@
self.param_env,
);
- if self.err_count_since_creation() == 0 {
+ if !self.errors_reported_since_creation() {
// regionck assumes typeck succeeded
rcx.visit_fn_body(fn_id, body, self.tcx.hir().span(fn_id));
}
diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs
index bba108a..ac39757 100644
--- a/src/librustc_typeck/check/upvar.rs
+++ b/src/librustc_typeck/check/upvar.rs
@@ -652,5 +652,5 @@
}
fn var_name(tcx: TyCtxt<'_>, var_hir_id: hir::HirId) -> ast::Name {
- tcx.hir().name_by_hir_id(var_hir_id)
+ tcx.hir().name(var_hir_id)
}
diff --git a/src/librustc_typeck/check_unused.rs b/src/librustc_typeck/check_unused.rs
index 8f89a77..7e781ee 100644
--- a/src/librustc_typeck/check_unused.rs
+++ b/src/librustc_typeck/check_unused.rs
@@ -95,7 +95,7 @@
// below it'll cause a panic because `def_id` is actually bogus at this
// point in time otherwise.
if let Some(id) = tcx.hir().as_local_hir_id(def_id) {
- if tcx.hir().find_by_hir_id(id).is_none() {
+ if tcx.hir().find(id).is_none() {
return false;
}
}
diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs
index e392622..42deeaf 100644
--- a/src/librustc_typeck/coherence/builtin.rs
+++ b/src/librustc_typeck/coherence/builtin.rs
@@ -52,7 +52,7 @@
} else {
// Destructors only work on nominal types.
if let Some(impl_hir_id) = tcx.hir().as_local_hir_id(impl_did) {
- if let Some(Node::Item(item)) = tcx.hir().find_by_hir_id(impl_hir_id) {
+ if let Some(Node::Item(item)) = tcx.hir().find(impl_hir_id) {
let span = match item.node {
ItemKind::Impl(.., ref ty, _) => ty.span,
_ => item.span,
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 52cda4a..87e1166 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -284,7 +284,7 @@
let mut extend = None;
let item_hir_id = tcx.hir().as_local_hir_id(item_def_id).unwrap();
- let ast_generics = match tcx.hir().get_by_hir_id(item_hir_id) {
+ let ast_generics = match tcx.hir().get(item_hir_id) {
Node::TraitItem(item) => &item.generics,
Node::ImplItem(item) => &item.generics,
@@ -623,7 +623,7 @@
use rustc::hir::*;
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
- let item = match tcx.hir().get_by_hir_id(hir_id) {
+ let item = match tcx.hir().get(hir_id) {
Node::Item(item) => item,
_ => bug!(),
};
@@ -693,7 +693,7 @@
debug!("super_predicates(trait_def_id={:?})", trait_def_id);
let trait_hir_id = tcx.hir().as_local_hir_id(trait_def_id).unwrap();
- let item = match tcx.hir().get_by_hir_id(trait_hir_id) {
+ let item = match tcx.hir().get(trait_hir_id) {
Node::Item(item) => item,
_ => bug!("trait_node_id {} is not an item", trait_hir_id),
};
@@ -884,7 +884,7 @@
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
- let node = tcx.hir().get_by_hir_id(hir_id);
+ let node = tcx.hir().get(hir_id);
let parent_def_id = match node {
Node::ImplItem(_) | Node::TraitItem(_) | Node::Variant(_) |
Node::Ctor(..) | Node::Field(_) => {
@@ -1154,7 +1154,7 @@
let icx = ItemCtxt::new(tcx, def_id);
- Some(match tcx.hir().get_by_hir_id(hir_id) {
+ Some(match tcx.hir().get(hir_id) {
Node::TraitItem(item) => match item.node {
TraitItemKind::Method(..) => {
let substs = InternalSubsts::identity_for_item(tcx, def_id);
@@ -1298,7 +1298,7 @@
}
Node::AnonConst(_) => {
- let parent_node = tcx.hir().get_by_hir_id(tcx.hir().get_parent_node_by_hir_id(hir_id));
+ let parent_node = tcx.hir().get(tcx.hir().get_parent_node(hir_id));
match parent_node {
Node::Ty(&hir::Ty {
node: hir::TyKind::Array(_, ref constant),
@@ -1660,8 +1660,8 @@
if scope == hir::CRATE_HIR_ID {
intravisit::walk_crate(&mut locator, tcx.hir().krate());
} else {
- debug!("find_existential_constraints: scope={:?}", tcx.hir().get_by_hir_id(scope));
- match tcx.hir().get_by_hir_id(scope) {
+ debug!("find_existential_constraints: scope={:?}", tcx.hir().get(scope));
+ match tcx.hir().get(scope) {
Node::Item(ref it) => intravisit::walk_item(&mut locator, it),
Node::ImplItem(ref it) => intravisit::walk_impl_item(&mut locator, it),
Node::TraitItem(ref it) => intravisit::walk_trait_item(&mut locator, it),
@@ -1690,7 +1690,7 @@
let icx = ItemCtxt::new(tcx, def_id);
- match tcx.hir().get_by_hir_id(hir_id) {
+ match tcx.hir().get(hir_id) {
TraitItem(hir::TraitItem {
node: TraitItemKind::Method(sig, _),
..
@@ -1903,7 +1903,7 @@
Some(hir_id) => hir_id,
None => return tcx.predicates_of(def_id),
};
- let node = tcx.hir().get_by_hir_id(hir_id);
+ let node = tcx.hir().get(hir_id);
let mut is_trait = None;
let mut is_default_impl_trait = None;
diff --git a/src/librustc_typeck/error_codes.rs b/src/librustc_typeck/error_codes.rs
index 115ee0f..d61cef7 100644
--- a/src/librustc_typeck/error_codes.rs
+++ b/src/librustc_typeck/error_codes.rs
@@ -4733,6 +4733,38 @@
represented.
"##,
+E0732: r##"
+An `enum` with a discriminant must specify a `#[repr(inttype)]`.
+
+A `#[repr(inttype)]` must be provided on an `enum` if it has a non-unit
+variant with a discriminant, or where there are both unit variants with
+discriminants and non-unit variants. This restriction ensures that there
+is a well-defined way to extract a variant's discriminant from a value;
+for instance:
+
+```
+#![feature(arbitrary_enum_discriminant)]
+
+#[repr(u8)]
+enum Enum {
+ Unit = 3,
+ Tuple(u16) = 2,
+ Struct {
+ a: u8,
+ b: u16,
+ } = 1,
+}
+
+fn discriminant(v : &Enum) -> u8 {
+ unsafe { *(v as *const Enum as *const u8) }
+}
+
+assert_eq!(3, discriminant(&Enum::Unit));
+assert_eq!(2, discriminant(&Enum::Tuple(5)));
+assert_eq!(1, discriminant(&Enum::Struct{a: 7, b: 11}));
+```
+"##,
+
}
register_diagnostics! {
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index cc6f7a0..182594e 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -75,7 +75,6 @@
#![deny(rust_2018_idioms)]
#![deny(internal)]
#![deny(unused_lifetimes)]
-#![allow(explicit_outlives_requirements)]
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
@@ -183,7 +182,7 @@
let main_t = tcx.type_of(main_def_id);
match main_t.sty {
ty::FnDef(..) => {
- if let Some(Node::Item(it)) = tcx.hir().find_by_hir_id(main_id) {
+ if let Some(Node::Item(it)) = tcx.hir().find(main_id) {
if let hir::ItemKind::Fn(.., ref generics, _) = it.node {
let mut error = false;
if !generics.params.is_empty() {
@@ -248,7 +247,7 @@
let start_t = tcx.type_of(start_def_id);
match start_t.sty {
ty::FnDef(..) => {
- if let Some(Node::Item(it)) = tcx.hir().find_by_hir_id(start_id) {
+ if let Some(Node::Item(it)) = tcx.hir().find(start_id) {
if let hir::ItemKind::Fn(.., ref generics, _) = it.node {
let mut error = false;
if !generics.params.is_empty() {
@@ -321,6 +320,7 @@
// this ensures that later parts of type checking can assume that items
// have valid types and not error
+ // FIXME(matthewjasper) We shouldn't need to do this.
tcx.sess.track_errors(|| {
time(tcx.sess, "type collecting", || {
for &module in tcx.hir().krate().modules.keys() {
@@ -353,7 +353,9 @@
})?;
}
- time(tcx.sess, "wf checking", || check::check_wf_new(tcx))?;
+ tcx.sess.track_errors(|| {
+ time(tcx.sess, "wf checking", || check::check_wf_new(tcx));
+ })?;
time(tcx.sess, "item-types checking", || {
for &module in tcx.hir().krate().modules.keys() {
diff --git a/src/librustc_typeck/outlives/implicit_infer.rs b/src/librustc_typeck/outlives/implicit_infer.rs
index 1c2bb8c..f2661b4 100644
--- a/src/librustc_typeck/outlives/implicit_infer.rs
+++ b/src/librustc_typeck/outlives/implicit_infer.rs
@@ -61,7 +61,7 @@
.hir()
.as_local_hir_id(item_did)
.expect("expected local def-id");
- let item = match self.tcx.hir().get_by_hir_id(hir_id) {
+ let item = match self.tcx.hir().get(hir_id) {
Node::Item(item) => item,
_ => bug!(),
};
diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs
index ad538b0..63e41e0 100644
--- a/src/librustc_typeck/outlives/mod.rs
+++ b/src/librustc_typeck/outlives/mod.rs
@@ -29,7 +29,7 @@
.as_local_hir_id(item_def_id)
.expect("expected local def-id");
- match tcx.hir().get_by_hir_id(id) {
+ match tcx.hir().get(id) {
Node::Item(item) => match item.node {
hir::ItemKind::Struct(..) | hir::ItemKind::Enum(..) | hir::ItemKind::Union(..) => {
let crate_map = tcx.inferred_outlives_crate(LOCAL_CRATE);
diff --git a/src/librustc_typeck/variance/mod.rs b/src/librustc_typeck/variance/mod.rs
index 5dbd667..1a8871a 100644
--- a/src/librustc_typeck/variance/mod.rs
+++ b/src/librustc_typeck/variance/mod.rs
@@ -48,7 +48,7 @@
// Variance not relevant.
span_bug!(tcx.hir().span(id), "asked to compute variance for wrong kind of item")
};
- match tcx.hir().get_by_hir_id(id) {
+ match tcx.hir().get(id) {
Node::Item(item) => match item.node {
hir::ItemKind::Enum(..) |
hir::ItemKind::Struct(..) |
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index b75212d..3158ec3 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -11,5 +11,6 @@
[dependencies]
pulldown-cmark = { version = "0.5.2", default-features = false }
minifier = "0.0.30"
+rayon = { version = "0.2.0", package = "rustc-rayon" }
tempfile = "3"
parking_lot = "0.7"
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 7da501e..29ee59d 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -346,7 +346,7 @@
// current architecture.
let resolver = abort_on_err(compiler.expansion(), sess).peek().1.clone();
- if sess.err_count() > 0 {
+ if sess.has_errors() {
sess.fatal("Compilation failed, aborting rustdoc");
}
diff --git a/src/librustdoc/docfs.rs b/src/librustdoc/docfs.rs
new file mode 100644
index 0000000..740947f
--- /dev/null
+++ b/src/librustdoc/docfs.rs
@@ -0,0 +1,116 @@
+//! Rustdoc's FileSystem abstraction module.
+//!
+//! On Windows this indirects IO into threads to work around performance issues
+//! with Defender (and other similar virus scanners that do blocking operations).
+//! On other platforms this is a thin shim to fs.
+//!
+//! Only calls needed to permit this workaround have been abstracted: thus
+//! fs::read is still done directly via the fs module; if in future rustdoc
+//! needs to read-after-write from a file, then it would be added to this
+//! abstraction.
+
+use errors;
+
+use std::fs;
+use std::io;
+use std::path::Path;
+use std::sync::Arc;
+use std::sync::mpsc::{channel, Receiver, Sender};
+
+macro_rules! try_err {
+ ($e:expr, $file:expr) => {{
+ match $e {
+ Ok(e) => e,
+ Err(e) => return Err(E::new(e, $file)),
+ }
+ }};
+}
+
+pub trait PathError {
+ fn new<P: AsRef<Path>>(e: io::Error, path: P) -> Self;
+}
+
+pub struct ErrorStorage {
+ sender: Option<Sender<Option<String>>>,
+ receiver: Receiver<Option<String>>,
+}
+
+impl ErrorStorage {
+ pub fn new() -> ErrorStorage {
+ let (sender, receiver) = channel();
+ ErrorStorage {
+ sender: Some(sender),
+ receiver,
+ }
+ }
+
+ /// Prints all stored errors. Returns the number of printed errors.
+ pub fn write_errors(&mut self, diag: &errors::Handler) -> usize {
+ let mut printed = 0;
+ // In order to drop the sender part of the channel.
+ self.sender = None;
+
+ for msg in self.receiver.iter() {
+ if let Some(ref error) = msg {
+ diag.struct_err(&error).emit();
+ printed += 1;
+ }
+ }
+ printed
+ }
+}
+
+pub struct DocFS {
+ sync_only: bool,
+ errors: Arc<ErrorStorage>,
+}
+
+impl DocFS {
+ pub fn new(errors: &Arc<ErrorStorage>) -> DocFS {
+ DocFS {
+ sync_only: false,
+ errors: Arc::clone(errors),
+ }
+ }
+
+ pub fn set_sync_only(&mut self, sync_only: bool) {
+ self.sync_only = sync_only;
+ }
+
+ pub fn create_dir_all<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
+ // For now, dir creation isn't a huge time consideration, do it
+ // synchronously, which avoids needing ordering between write() actions
+ // and directory creation.
+ fs::create_dir_all(path)
+ }
+
+ pub fn write<P, C, E>(&self, path: P, contents: C) -> Result<(), E>
+ where
+ P: AsRef<Path>,
+ C: AsRef<[u8]>,
+ E: PathError,
+ {
+ if !self.sync_only && cfg!(windows) {
+ // A possible future enhancement after more detailed profiling would
+ // be to create the file sync so errors are reported eagerly.
+ let contents = contents.as_ref().to_vec();
+ let path = path.as_ref().to_path_buf();
+ let sender = self.errors.sender.clone().unwrap();
+ rayon::spawn(move || {
+ match fs::write(&path, &contents) {
+ Ok(_) => {
+ sender.send(None)
+ .expect(&format!("failed to send error on \"{}\"", path.display()));
+ }
+ Err(e) => {
+ sender.send(Some(format!("\"{}\": {}", path.display(), e)))
+ .expect(&format!("failed to send non-error on \"{}\"", path.display()));
+ }
+ }
+ });
+ Ok(())
+ } else {
+ Ok(try_err!(fs::write(&path, contents), path))
+ }
+ }
+}
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index b42a78f..f0aff96 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -35,9 +35,9 @@
use std::error;
use std::fmt::{self, Display, Formatter, Write as FmtWrite};
use std::ffi::OsStr;
-use std::fs::{self, File, OpenOptions};
+use std::fs::{self, File};
use std::io::prelude::*;
-use std::io::{self, BufWriter, BufReader};
+use std::io::{self, BufReader};
use std::mem;
use std::path::{PathBuf, Path, Component};
use std::str;
@@ -61,6 +61,7 @@
use crate::clean::{self, AttributesExt, Deprecation, GetDefId, SelfTy, Mutability};
use crate::config::RenderOptions;
+use crate::docfs::{DocFS, ErrorStorage, PathError};
use crate::doctree;
use crate::fold::DocFolder;
use crate::html::escape::Escape;
@@ -89,6 +90,58 @@
}
}
+#[derive(Debug)]
+pub struct Error {
+ pub file: PathBuf,
+ pub error: io::Error,
+}
+
+impl error::Error for Error {
+ fn description(&self) -> &str {
+ self.error.description()
+ }
+}
+
+impl Display for Error {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ let file = self.file.display().to_string();
+ if file.is_empty() {
+ write!(f, "{}", self.error)
+ } else {
+ write!(f, "\"{}\": {}", self.file.display(), self.error)
+ }
+ }
+}
+
+impl PathError for Error {
+ fn new<P: AsRef<Path>>(e: io::Error, path: P) -> Error {
+ Error {
+ file: path.as_ref().to_path_buf(),
+ error: e,
+ }
+ }
+}
+
+macro_rules! try_none {
+ ($e:expr, $file:expr) => ({
+ use std::io;
+ match $e {
+ Some(e) => e,
+ None => return Err(Error::new(io::Error::new(io::ErrorKind::Other, "not found"),
+ $file))
+ }
+ })
+}
+
+macro_rules! try_err {
+ ($e:expr, $file:expr) => ({
+ match $e {
+ Ok(e) => e,
+ Err(e) => return Err(Error::new(e, $file)),
+ }
+ })
+}
+
/// Major driving force in all rustdoc rendering. This contains information
/// about where in the tree-like hierarchy rendering is occurring and controls
/// how the current page is being rendered.
@@ -156,13 +209,15 @@
pub generate_search_filter: bool,
/// Option disabled by default to generate files used by RLS and some other tools.
pub generate_redirect_pages: bool,
+ /// The fs handle we are working with.
+ pub fs: DocFS,
}
impl SharedContext {
- fn ensure_dir(&self, dst: &Path) -> io::Result<()> {
+ fn ensure_dir(&self, dst: &Path) -> Result<(), Error> {
let mut dirs = self.created_dirs.borrow_mut();
if !dirs.contains(dst) {
- fs::create_dir_all(dst)?;
+ try_err!(self.fs.create_dir_all(dst), dst);
dirs.insert(dst.to_path_buf());
}
@@ -216,53 +271,6 @@
}
}
-#[derive(Debug)]
-pub struct Error {
- pub file: PathBuf,
- pub error: io::Error,
-}
-
-impl error::Error for Error {
- fn description(&self) -> &str {
- self.error.description()
- }
-}
-
-impl Display for Error {
- fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
- write!(f, "\"{}\": {}", self.file.display(), self.error)
- }
-}
-
-impl Error {
- pub fn new(e: io::Error, file: &Path) -> Error {
- Error {
- file: file.to_path_buf(),
- error: e,
- }
- }
-}
-
-macro_rules! try_none {
- ($e:expr, $file:expr) => ({
- use std::io;
- match $e {
- Some(e) => e,
- None => return Err(Error::new(io::Error::new(io::ErrorKind::Other, "not found"),
- $file))
- }
- })
-}
-
-macro_rules! try_err {
- ($e:expr, $file:expr) => ({
- match $e {
- Ok(e) => e,
- Err(e) => return Err(Error::new(e, $file)),
- }
- })
-}
-
/// This cache is used to store information about the `clean::Crate` being
/// rendered in order to provide more useful documentation. This contains
/// information like all implementors of a trait, all traits a type implements,
@@ -544,6 +552,7 @@
},
_ => PathBuf::new(),
};
+ let mut errors = Arc::new(ErrorStorage::new());
let mut scx = SharedContext {
src_root,
passes,
@@ -564,6 +573,7 @@
static_root_path,
generate_search_filter,
generate_redirect_pages,
+ fs: DocFS::new(&errors),
};
// If user passed in `--playground-url` arg, we fill in crate name here
@@ -601,9 +611,9 @@
}
}
let dst = output;
- try_err!(fs::create_dir_all(&dst), &dst);
+ scx.ensure_dir(&dst)?;
krate = render_sources(&dst, &mut scx, krate)?;
- let cx = Context {
+ let mut cx = Context {
current: Vec::new(),
dst,
render_redirect_pages: false,
@@ -705,10 +715,21 @@
CACHE_KEY.with(|v| *v.borrow_mut() = cache.clone());
CURRENT_LOCATION_KEY.with(|s| s.borrow_mut().clear());
+ // Write shared runs within a flock; disable thread dispatching of IO temporarily.
+ Arc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(true);
write_shared(&cx, &krate, &*cache, index, &md_opts, diag)?;
+ Arc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false);
// And finally render the whole crate's documentation
- cx.krate(krate)
+ let ret = cx.krate(krate);
+ let nb_errors = Arc::get_mut(&mut errors).map_or_else(|| 0, |errors| errors.write_errors(diag));
+ if ret.is_err() {
+ ret
+ } else if nb_errors > 0 {
+ Err(Error::new(io::Error::new(io::ErrorKind::Other, "I/O error"), ""))
+ } else {
+ Ok(())
+ }
}
/// Builds the search index from the collected metadata
@@ -797,13 +818,13 @@
// Add all the static files. These may already exist, but we just
// overwrite them anyway to make sure that they're fresh and up-to-date.
- write_minify(cx.dst.join(&format!("rustdoc{}.css", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("rustdoc{}.css", cx.shared.resource_suffix)),
static_files::RUSTDOC_CSS,
options.enable_minification)?;
- write_minify(cx.dst.join(&format!("settings{}.css", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("settings{}.css", cx.shared.resource_suffix)),
static_files::SETTINGS_CSS,
options.enable_minification)?;
- write_minify(cx.dst.join(&format!("noscript{}.css", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("noscript{}.css", cx.shared.resource_suffix)),
static_files::NOSCRIPT_CSS,
options.enable_minification)?;
@@ -815,11 +836,13 @@
let content = try_err!(fs::read(&entry), &entry);
let theme = try_none!(try_none!(entry.file_stem(), &entry).to_str(), &entry);
let extension = try_none!(try_none!(entry.extension(), &entry).to_str(), &entry);
- write(cx.dst.join(format!("{}{}.{}", theme, cx.shared.resource_suffix, extension)),
- content.as_slice())?;
+ cx.shared.fs.write(
+ cx.dst.join(format!("{}{}.{}", theme, cx.shared.resource_suffix, extension)),
+ content.as_slice())?;
themes.insert(theme.to_owned());
}
+ let write = |p, c| { cx.shared.fs.write(p, c) };
if (*cx.shared).layout.logo.is_empty() {
write(cx.dst.join(&format!("rust-logo{}.png", cx.shared.resource_suffix)),
static_files::RUST_LOGO)?;
@@ -834,11 +857,11 @@
static_files::WHEEL_SVG)?;
write(cx.dst.join(&format!("down-arrow{}.svg", cx.shared.resource_suffix)),
static_files::DOWN_ARROW_SVG)?;
- write_minify(cx.dst.join(&format!("light{}.css", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("light{}.css", cx.shared.resource_suffix)),
static_files::themes::LIGHT,
options.enable_minification)?;
themes.insert("light".to_owned());
- write_minify(cx.dst.join(&format!("dark{}.css", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("dark{}.css", cx.shared.resource_suffix)),
static_files::themes::DARK,
options.enable_minification)?;
themes.insert("dark".to_owned());
@@ -847,8 +870,7 @@
themes.sort();
// To avoid theme switch latencies as much as possible, we put everything theme related
// at the beginning of the html files into another js file.
- write(cx.dst.join(&format!("theme{}.js", cx.shared.resource_suffix)),
- format!(
+ let theme_js = format!(
r#"var themes = document.getElementById("theme-choices");
var themePicker = document.getElementById("theme-picker");
@@ -891,39 +913,45 @@
themes.iter()
.map(|s| format!("\"{}\"", s))
.collect::<Vec<String>>()
- .join(",")).as_bytes(),
+ .join(","));
+ write(cx.dst.join(&format!("theme{}.js", cx.shared.resource_suffix)),
+ theme_js.as_bytes()
)?;
- write_minify(cx.dst.join(&format!("main{}.js", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("main{}.js", cx.shared.resource_suffix)),
static_files::MAIN_JS,
options.enable_minification)?;
- write_minify(cx.dst.join(&format!("settings{}.js", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("settings{}.js", cx.shared.resource_suffix)),
static_files::SETTINGS_JS,
options.enable_minification)?;
if cx.shared.include_sources {
- write_minify(cx.dst.join(&format!("source-script{}.js", cx.shared.resource_suffix)),
- static_files::sidebar::SOURCE_SCRIPT,
- options.enable_minification)?;
+ write_minify(
+ &cx.shared.fs,
+ cx.dst.join(&format!("source-script{}.js", cx.shared.resource_suffix)),
+ static_files::sidebar::SOURCE_SCRIPT,
+ options.enable_minification)?;
}
{
- write_minify(cx.dst.join(&format!("storage{}.js", cx.shared.resource_suffix)),
- &format!("var resourcesSuffix = \"{}\";{}",
- cx.shared.resource_suffix,
- static_files::STORAGE_JS),
- options.enable_minification)?;
+ write_minify(
+ &cx.shared.fs,
+ cx.dst.join(&format!("storage{}.js", cx.shared.resource_suffix)),
+ &format!("var resourcesSuffix = \"{}\";{}",
+ cx.shared.resource_suffix,
+ static_files::STORAGE_JS),
+ options.enable_minification)?;
}
if let Some(ref css) = cx.shared.css_file_extension {
let out = cx.dst.join(&format!("theme{}.css", cx.shared.resource_suffix));
+ let buffer = try_err!(fs::read_to_string(css), css);
if !options.enable_minification {
- try_err!(fs::copy(css, out), css);
+ cx.shared.fs.write(&out, &buffer)?;
} else {
- let buffer = try_err!(fs::read_to_string(css), css);
- write_minify(out, &buffer, options.enable_minification)?;
+ write_minify(&cx.shared.fs, out, &buffer, options.enable_minification)?;
}
}
- write_minify(cx.dst.join(&format!("normalize{}.css", cx.shared.resource_suffix)),
+ write_minify(&cx.shared.fs, cx.dst.join(&format!("normalize{}.css", cx.shared.resource_suffix)),
static_files::NORMALIZE_CSS,
options.enable_minification)?;
write(cx.dst.join("FiraSans-Regular.woff"),
@@ -999,7 +1027,6 @@
let dst = cx.dst.join(&format!("aliases{}.js", cx.shared.resource_suffix));
{
let (mut all_aliases, _, _) = try_err!(collect(&dst, &krate.name, "ALIASES", false), &dst);
- let mut w = try_err!(File::create(&dst), &dst);
let mut output = String::with_capacity(100);
for (alias, items) in &cache.aliases {
if items.is_empty() {
@@ -1014,10 +1041,12 @@
}
all_aliases.push(format!("ALIASES[\"{}\"] = {{{}}};", krate.name, output));
all_aliases.sort();
- try_err!(writeln!(&mut w, "var ALIASES = {{}};"), &dst);
+ let mut v = Vec::new();
+ try_err!(writeln!(&mut v, "var ALIASES = {{}};"), &dst);
for aliases in &all_aliases {
- try_err!(writeln!(&mut w, "{}", aliases), &dst);
+ try_err!(writeln!(&mut v, "{}", aliases), &dst);
}
+ cx.shared.fs.write(&dst, &v)?;
}
use std::ffi::OsString;
@@ -1101,11 +1130,12 @@
&krate.name,
hierarchy.to_json_string()));
all_sources.sort();
- let mut w = try_err!(File::create(&dst), &dst);
- try_err!(writeln!(&mut w,
+ let mut v = Vec::new();
+ try_err!(writeln!(&mut v,
"var N = null;var sourcesIndex = {{}};\n{}\ncreateSourceSidebar();",
all_sources.join("\n")),
&dst);
+ cx.shared.fs.write(&dst, &v)?;
}
// Update the search index
@@ -1119,14 +1149,17 @@
// Sort the indexes by crate so the file will be generated identically even
// with rustdoc running in parallel.
all_indexes.sort();
- let mut w = try_err!(File::create(&dst), &dst);
- try_err!(writeln!(&mut w, "var N=null,E=\"\",T=\"t\",U=\"u\",searchIndex={{}};"), &dst);
- try_err!(write_minify_replacer(&mut w,
- &format!("{}\n{}", variables.join(""), all_indexes.join("\n")),
- options.enable_minification),
- &dst);
- try_err!(write!(&mut w, "initSearch(searchIndex);addSearchOptions(searchIndex);"), &dst);
-
+ {
+ let mut v = Vec::new();
+ try_err!(writeln!(&mut v, "var N=null,E=\"\",T=\"t\",U=\"u\",searchIndex={{}};"), &dst);
+ try_err!(write_minify_replacer(
+ &mut v,
+ &format!("{}\n{}", variables.join(""), all_indexes.join("\n")),
+ options.enable_minification),
+ &dst);
+ try_err!(write!(&mut v, "initSearch(searchIndex);addSearchOptions(searchIndex);"), &dst);
+ cx.shared.fs.write(&dst, &v)?;
+ }
if options.enable_index_page {
if let Some(index_page) = options.index_page.clone() {
let mut md_opts = options.clone();
@@ -1136,7 +1169,6 @@
crate::markdown::render(index_page, md_opts, diag, cx.edition);
} else {
let dst = cx.dst.join("index.html");
- let mut w = BufWriter::new(try_err!(File::create(&dst), &dst));
let page = layout::Page {
title: "Index of crates",
css_class: "mod",
@@ -1163,12 +1195,13 @@
SlashChecker(s), s)
})
.collect::<String>());
- try_err!(layout::render(&mut w, &cx.shared.layout,
+ let mut v = Vec::new();
+ try_err!(layout::render(&mut v, &cx.shared.layout,
&page, &(""), &content,
cx.shared.css_file_extension.is_some(),
&cx.shared.themes,
cx.shared.generate_search_filter), &dst);
- try_err!(w.flush(), &dst);
+ cx.shared.fs.write(&dst, &v)?;
}
}
@@ -1220,7 +1253,7 @@
for part in &remote_path[..remote_path.len() - 1] {
mydst.push(part);
}
- try_err!(fs::create_dir_all(&mydst), &mydst);
+ cx.shared.ensure_dir(&mydst)?;
mydst.push(&format!("{}.{}.js",
remote_item_type.css_class(),
remote_path[remote_path.len() - 1]));
@@ -1233,19 +1266,20 @@
// identically even with rustdoc running in parallel.
all_implementors.sort();
- let mut f = try_err!(File::create(&mydst), &mydst);
- try_err!(writeln!(&mut f, "(function() {{var implementors = {{}};"), &mydst);
+ let mut v = Vec::new();
+ try_err!(writeln!(&mut v, "(function() {{var implementors = {{}};"), &mydst);
for implementor in &all_implementors {
- try_err!(writeln!(&mut f, "{}", *implementor), &mydst);
+ try_err!(writeln!(&mut v, "{}", *implementor), &mydst);
}
- try_err!(writeln!(&mut f, "{}", r"
+ try_err!(writeln!(&mut v, "{}", r"
if (window.register_implementors) {
window.register_implementors(implementors);
} else {
window.pending_implementors = implementors;
}
"), &mydst);
- try_err!(writeln!(&mut f, r"}})()"), &mydst);
+ try_err!(writeln!(&mut v, r"}})()"), &mydst);
+ cx.shared.fs.write(&mydst, &v)?;
}
Ok(())
}
@@ -1254,7 +1288,7 @@
krate: clean::Crate) -> Result<clean::Crate, Error> {
info!("emitting source files");
let dst = dst.join("src").join(&krate.name);
- try_err!(fs::create_dir_all(&dst), &dst);
+ scx.ensure_dir(&dst)?;
let mut folder = SourceCollector {
dst,
scx,
@@ -1262,22 +1296,17 @@
Ok(folder.fold_crate(krate))
}
-/// Writes the entire contents of a string to a destination, not attempting to
-/// catch any errors.
-fn write(dst: PathBuf, contents: &[u8]) -> Result<(), Error> {
- Ok(try_err!(fs::write(&dst, contents), &dst))
-}
-
-fn write_minify(dst: PathBuf, contents: &str, enable_minification: bool) -> Result<(), Error> {
+fn write_minify(fs:&DocFS, dst: PathBuf, contents: &str, enable_minification: bool
+ ) -> Result<(), Error> {
if enable_minification {
if dst.extension() == Some(&OsStr::new("css")) {
let res = try_none!(minifier::css::minify(contents).ok(), &dst);
- write(dst, res.as_bytes())
+ fs.write(dst, res.as_bytes())
} else {
- write(dst, minifier::js::minify(contents).as_bytes())
+ fs.write(dst, minifier::js::minify(contents).as_bytes())
}
} else {
- write(dst, contents.as_bytes())
+ fs.write(dst, contents.as_bytes())
}
}
@@ -1439,7 +1468,7 @@
impl<'a> SourceCollector<'a> {
/// Renders the given filename into its corresponding HTML source file.
- fn emit_source(&mut self, filename: &FileName) -> io::Result<()> {
+ fn emit_source(&mut self, filename: &FileName) -> Result<(), Error> {
let p = match *filename {
FileName::Real(ref file) => file,
_ => return Ok(()),
@@ -1449,7 +1478,7 @@
return Ok(());
}
- let contents = fs::read_to_string(&p)?;
+ let contents = try_err!(fs::read_to_string(&p), &p);
// Remove the utf-8 BOM if any
let contents = if contents.starts_with("\u{feff}") {
@@ -1468,7 +1497,7 @@
href.push_str(&component.to_string_lossy());
href.push('/');
});
- fs::create_dir_all(&cur)?;
+ self.scx.ensure_dir(&cur)?;
let mut fname = p.file_name()
.expect("source has no filename")
.to_os_string();
@@ -1476,7 +1505,7 @@
cur.push(&fname);
href.push_str(&fname.to_string_lossy());
- let mut w = BufWriter::new(File::create(&cur)?);
+ let mut v = Vec::new();
let title = format!("{} -- source", cur.file_name().expect("failed to get file name")
.to_string_lossy());
let desc = format!("Source to the Rust file `{}`.", filename);
@@ -1491,12 +1520,12 @@
extra_scripts: &[&format!("source-files{}", self.scx.resource_suffix)],
static_extra_scripts: &[&format!("source-script{}", self.scx.resource_suffix)],
};
- layout::render(&mut w, &self.scx.layout,
+ try_err!(layout::render(&mut v, &self.scx.layout,
&page, &(""), &Source(contents),
self.scx.css_file_extension.is_some(),
&self.scx.themes,
- self.scx.generate_search_filter)?;
- w.flush()?;
+ self.scx.generate_search_filter), &cur);
+ self.scx.fs.write(&cur, &v)?;
self.scx.local_sources.insert(p.clone(), href);
Ok(())
}
@@ -2073,7 +2102,6 @@
}
}
- let mut w = BufWriter::new(try_err!(File::create(&final_file), &final_file));
let mut root_path = self.dst.to_str().expect("invalid path").to_owned();
if !root_path.ends_with('/') {
root_path.push('/');
@@ -2099,12 +2127,14 @@
} else {
String::new()
};
- try_err!(layout::render(&mut w, &self.shared.layout,
+ let mut v = Vec::new();
+ try_err!(layout::render(&mut v, &self.shared.layout,
&page, &sidebar, &all,
self.shared.css_file_extension.is_some(),
&self.shared.themes,
self.shared.generate_search_filter),
&final_file);
+ self.shared.fs.write(&final_file, &v)?;
// Generating settings page.
let settings = Settings::new(self.shared.static_root_path.deref().unwrap_or("./"),
@@ -2113,17 +2143,18 @@
page.description = "Settings of Rustdoc";
page.root_path = "./";
- let mut w = BufWriter::new(try_err!(File::create(&settings_file), &settings_file));
let mut themes = self.shared.themes.clone();
let sidebar = "<p class='location'>Settings</p><div class='sidebar-elems'></div>";
themes.push(PathBuf::from("settings.css"));
let layout = self.shared.layout.clone();
- try_err!(layout::render(&mut w, &layout,
+ let mut v = Vec::new();
+ try_err!(layout::render(&mut v, &layout,
&page, &sidebar, &settings,
self.shared.css_file_extension.is_some(),
&themes,
self.shared.generate_search_filter),
&settings_file);
+ self.shared.fs.write(&settings_file, &v)?;
Ok(())
}
@@ -2223,6 +2254,7 @@
// recurse into the items of the module as well.
let name = item.name.as_ref().unwrap().to_string();
let mut item = Some(item);
+ let scx = self.shared.clone();
self.recurse(name, |this| {
let item = item.take().unwrap();
@@ -2230,9 +2262,9 @@
this.render_item(&mut buf, &item, false).unwrap();
// buf will be empty if the module is stripped and there is no redirect for it
if !buf.is_empty() {
- try_err!(this.shared.ensure_dir(&this.dst), &this.dst);
+ this.shared.ensure_dir(&this.dst)?;
let joint_dst = this.dst.join("index.html");
- try_err!(fs::write(&joint_dst, buf), &joint_dst);
+ scx.fs.write(&joint_dst, buf)?;
}
let m = match item.inner {
@@ -2245,9 +2277,10 @@
if !this.render_redirect_pages {
let items = this.build_sidebar_items(&m);
let js_dst = this.dst.join("sidebar-items.js");
- let mut js_out = BufWriter::new(try_err!(File::create(&js_dst), &js_dst));
- try_err!(write!(&mut js_out, "initSidebarItems({});",
+ let mut v = Vec::new();
+ try_err!(write!(&mut v, "initSidebarItems({});",
as_json(&items)), &js_dst);
+ scx.fs.write(&js_dst, &v)?;
}
for item in m.items {
@@ -2264,9 +2297,9 @@
let name = item.name.as_ref().unwrap();
let item_type = item.type_();
let file_name = &item_path(item_type, name);
- try_err!(self.shared.ensure_dir(&self.dst), &self.dst);
+ self.shared.ensure_dir(&self.dst)?;
let joint_dst = self.dst.join(file_name);
- try_err!(fs::write(&joint_dst, buf), &joint_dst);
+ self.shared.fs.write(&joint_dst, buf)?;
if !self.render_redirect_pages {
all.append(full_path(self, &item), &item_type);
@@ -2276,21 +2309,18 @@
// URL for the page.
let redir_name = format!("{}.{}.html", name, item_type.name_space());
let redir_dst = self.dst.join(redir_name);
- if let Ok(redirect_out) = OpenOptions::new().create_new(true)
- .write(true)
- .open(&redir_dst) {
- let mut redirect_out = BufWriter::new(redirect_out);
- try_err!(layout::redirect(&mut redirect_out, file_name), &redir_dst);
- }
+ let mut v = Vec::new();
+ try_err!(layout::redirect(&mut v, file_name), &redir_dst);
+ self.shared.fs.write(&redir_dst, &v)?;
}
// If the item is a macro, redirect from the old macro URL (with !)
// to the new one (without).
if item_type == ItemType::Macro {
let redir_name = format!("{}.{}!.html", item_type, name);
let redir_dst = self.dst.join(redir_name);
- let redirect_out = try_err!(File::create(&redir_dst), &redir_dst);
- let mut redirect_out = BufWriter::new(redirect_out);
- try_err!(layout::redirect(&mut redirect_out, file_name), &redir_dst);
+ let mut v = Vec::new();
+ try_err!(layout::redirect(&mut v, file_name), &redir_dst);
+ self.shared.fs.write(&redir_dst, &v)?;
}
}
}
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 3b4d653..7a8b088 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -59,6 +59,7 @@
mod clean;
mod config;
mod core;
+mod docfs;
mod doctree;
mod fold;
pub mod html {
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 68b96a4..bb85fe8 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -71,15 +71,16 @@
})
});
- if let Ok(result) = result {
+ if let Ok((_, res)) = result {
+ let res = res.map_id(|_| panic!("unexpected node_id"));
// In case this is a trait item, skip the
// early return and try looking for the trait.
- let value = match result.res {
+ let value = match res {
Res::Def(DefKind::Method, _) | Res::Def(DefKind::AssocConst, _) => true,
Res::Def(DefKind::AssocTy, _) => false,
- Res::Def(DefKind::Variant, _) => return handle_variant(cx, result.res),
+ Res::Def(DefKind::Variant, _) => return handle_variant(cx, res),
// Not a trait item; just return what we found.
- _ => return Ok((result.res, None))
+ _ => return Ok((res, None))
};
if value != (ns == ValueNS) {
@@ -129,10 +130,11 @@
// FIXME: `with_scope` requires the `NodeId` of a module.
let node_id = cx.tcx.hir().hir_to_node_id(id);
- let ty = cx.enter_resolver(|resolver| resolver.with_scope(node_id, |resolver| {
+ let (_, ty_res) = cx.enter_resolver(|resolver| resolver.with_scope(node_id, |resolver| {
resolver.resolve_str_path_error(DUMMY_SP, &path, false)
}))?;
- match ty.res {
+ let ty_res = ty_res.map_id(|_| panic!("unexpected node_id"));
+ match ty_res {
Res::Def(DefKind::Struct, did)
| Res::Def(DefKind::Union, did)
| Res::Def(DefKind::Enum, did)
@@ -147,7 +149,7 @@
ty::AssocKind::Const if ns == ValueNS => "associatedconstant",
_ => return Err(())
};
- Ok((ty.res, Some(format!("{}.{}", out, item_name))))
+ Ok((ty_res, Some(format!("{}.{}", out, item_name))))
} else {
match cx.tcx.type_of(did).sty {
ty::Adt(def, _) => {
@@ -159,7 +161,7 @@
.iter()
.find(|item| item.ident.name == item_name)
} {
- Ok((ty.res,
+ Ok((ty_res,
Some(format!("{}.{}",
if def.is_enum() {
"variant"
@@ -193,7 +195,7 @@
_ => return Err(())
};
- Ok((ty.res, Some(format!("{}.{}", kind, item_name))))
+ Ok((ty_res, Some(format!("{}.{}", kind, item_name))))
} else {
Err(())
}
@@ -246,7 +248,7 @@
match parent_node.or(self.mod_ids.last().cloned()) {
Some(parent) if parent != hir::CRATE_HIR_ID => {
// FIXME: can we pull the parent module's name from elsewhere?
- Some(self.cx.tcx.hir().name_by_hir_id(parent).to_string())
+ Some(self.cx.tcx.hir().name(parent).to_string())
}
_ => None,
}
diff --git a/src/librustdoc/theme.rs b/src/librustdoc/theme.rs
index 7a0ccf6..7220a05 100644
--- a/src/librustdoc/theme.rs
+++ b/src/librustdoc/theme.rs
@@ -103,16 +103,16 @@
if let Some(&Events::StartComment(_)) = events.last() {
return false;
}
- pos + 1 < v.len() && v[pos + 1] == b'/'
+ v[pos + 1] == b'/'
}
fn load_css_events(v: &[u8]) -> Vec<Events> {
let mut pos = 0;
let mut events = Vec::with_capacity(100);
- while pos < v.len() - 1 {
+ while pos + 1 < v.len() {
match v[pos] {
- b'/' if pos + 1 < v.len() && v[pos + 1] == b'*' => {
+ b'/' if v[pos + 1] == b'*' => {
events.push(Events::StartComment(pos));
pos += 1;
}
@@ -123,7 +123,7 @@
b'\n' if previous_is_line_comment(&events) => {
events.push(Events::EndComment(pos));
}
- b'*' if pos + 1 < v.len() && v[pos + 1] == b'/' => {
+ b'*' if v[pos + 1] == b'/' => {
events.push(Events::EndComment(pos + 2));
pos += 1;
}
@@ -264,9 +264,11 @@
}
}
-pub fn test_theme_against<P: AsRef<Path>>(f: &P, against: &CssPath, diag: &Handler)
- -> (bool, Vec<String>)
-{
+pub fn test_theme_against<P: AsRef<Path>>(
+ f: &P,
+ against: &CssPath,
+ diag: &Handler,
+) -> (bool, Vec<String>) {
let data = try_something!(fs::read(f), diag, (false, vec![]));
let paths = load_css_paths(&data);
let mut ret = vec![];
@@ -366,4 +368,16 @@
get_differences(&other, &against, &mut ret);
assert_eq!(ret, vec![" Missing \"c\" rule".to_owned()]);
}
+
+ #[test]
+ fn check_empty_css() {
+ let events = load_css_events(&[]);
+ assert_eq!(events.len(), 0);
+ }
+
+ #[test]
+ fn check_invalid_css() {
+ let events = load_css_events(b"*");
+ assert_eq!(events.len(), 0);
+ }
}
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index c94149d..781e62c 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -337,7 +337,7 @@
if !self.view_item_stack.insert(res_hir_id) { return false }
- let ret = match tcx.hir().get_by_hir_id(res_hir_id) {
+ let ret = match tcx.hir().get(res_hir_id) {
Node::Item(&hir::Item { node: hir::ItemKind::Mod(ref m), .. }) if glob => {
let prev = mem::replace(&mut self.inlining, true);
for i in &m.item_ids {
diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs
index 95095c7..2def2a4 100644
--- a/src/libserialize/serialize.rs
+++ b/src/libserialize/serialize.rs
@@ -739,33 +739,33 @@
macro_rules! tuple {
() => ();
( $($name:ident,)+ ) => (
- impl<$($name:Decodable),*> Decodable for ($($name,)*) {
+ impl<$($name:Decodable),+> Decodable for ($($name,)+) {
#[allow(non_snake_case)]
- fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
- let len: usize = count!($($name)*);
+ fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)+), D::Error> {
+ let len: usize = count!($($name)+);
d.read_tuple(len, |d| {
let mut i = 0;
let ret = ($(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name, D::Error> {
Decodable::decode(d)
- })?,)*);
+ })?,)+);
Ok(ret)
})
}
}
- impl<$($name:Encodable),*> Encodable for ($($name,)*) {
+ impl<$($name:Encodable),+> Encodable for ($($name,)+) {
#[allow(non_snake_case)]
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- let ($(ref $name,)*) = *self;
+ let ($(ref $name,)+) = *self;
let mut n = 0;
- $(let $name = $name; n += 1;)*
+ $(let $name = $name; n += 1;)+
s.emit_tuple(n, |s| {
let mut i = 0;
- $(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s))?;)*
+ $(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s))?;)+
Ok(())
})
}
}
- peel! { $($name,)* }
+ peel! { $($name,)+ }
)
}
diff --git a/src/libstd/primitive_docs.rs b/src/libstd/primitive_docs.rs
index e78a5de..65fd8c8 100644
--- a/src/libstd/primitive_docs.rs
+++ b/src/libstd/primitive_docs.rs
@@ -120,7 +120,7 @@
/// When implementing this trait for [`String`] we need to pick a type for [`Err`]. And since
/// converting a string into a string will never result in an error, the appropriate type is `!`.
/// (Currently the type actually used is an enum with no variants, though this is only because `!`
-/// was added to Rust at a later date and it may change in the future). With an [`Err`] type of
+/// was added to Rust at a later date and it may change in the future.) With an [`Err`] type of
/// `!`, if we have to call [`String::from_str`] for some reason the result will be a
/// [`Result<String, !>`] which we can unpack like this:
///
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index b1a62ac..f2fac16 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -893,17 +893,12 @@
pub struct Arm {
pub attrs: Vec<Attribute>,
pub pats: Vec<P<Pat>>,
- pub guard: Option<Guard>,
+ pub guard: Option<P<Expr>>,
pub body: P<Expr>,
pub span: Span,
}
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
-pub enum Guard {
- If(P<Expr>),
-}
-
-#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Field {
pub ident: Ident,
pub expr: P<Expr>,
@@ -1032,10 +1027,9 @@
ExprKind::Unary(..) => ExprPrecedence::Unary,
ExprKind::Lit(_) => ExprPrecedence::Lit,
ExprKind::Type(..) | ExprKind::Cast(..) => ExprPrecedence::Cast,
+ ExprKind::Let(..) => ExprPrecedence::Let,
ExprKind::If(..) => ExprPrecedence::If,
- ExprKind::IfLet(..) => ExprPrecedence::IfLet,
ExprKind::While(..) => ExprPrecedence::While,
- ExprKind::WhileLet(..) => ExprPrecedence::WhileLet,
ExprKind::ForLoop(..) => ExprPrecedence::ForLoop,
ExprKind::Loop(..) => ExprPrecedence::Loop,
ExprKind::Match(..) => ExprPrecedence::Match,
@@ -1116,26 +1110,20 @@
Cast(P<Expr>, P<Ty>),
/// A type ascription (e.g., `42: usize`).
Type(P<Expr>, P<Ty>),
+ /// A `let pats = expr` expression that is only semantically allowed in the condition
+ /// of `if` / `while` expressions. (e.g., `if let 0 = x { .. }`).
+ ///
+ /// The `Vec<P<Pat>>` is for or-patterns at the top level.
+ /// FIXME(54883): Change this to just `P<Pat>`.
+ Let(Vec<P<Pat>>, P<Expr>),
/// An `if` block, with an optional `else` block.
///
/// `if expr { block } else { expr }`
If(P<Expr>, P<Block>, Option<P<Expr>>),
- /// An `if let` expression with an optional else block
- ///
- /// `if let pat = expr { block } else { expr }`
- ///
- /// This is desugared to a `match` expression.
- IfLet(Vec<P<Pat>>, P<Expr>, P<Block>, Option<P<Expr>>),
- /// A while loop, with an optional label
+ /// A while loop, with an optional label.
///
/// `'label: while expr { block }`
While(P<Expr>, P<Block>, Option<Label>),
- /// A `while let` loop, with an optional label.
- ///
- /// `'label: while let pat = expr { block }`
- ///
- /// This is desugared to a combination of `loop` and `match` expressions.
- WhileLet(Vec<P<Pat>>, P<Expr>, P<Block>, Option<Label>),
/// A `for` loop, with an optional label.
///
/// `'label: for pat in expr { block }`
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
index 3b42e1d..1ab367f 100644
--- a/src/libsyntax/config.rs
+++ b/src/libsyntax/config.rs
@@ -91,10 +91,10 @@
/// is in the original source file. Gives a compiler error if the syntax of
/// the attribute is incorrect.
fn process_cfg_attr(&mut self, attr: ast::Attribute) -> Vec<ast::Attribute> {
- if !attr.check_name(sym::cfg_attr) {
+ if attr.path != sym::cfg_attr {
return vec![attr];
}
- if attr.tokens.len() == 0 {
+ if attr.tokens.is_empty() {
self.sess.span_diagnostic
.struct_span_err(
attr.span,
@@ -108,7 +108,7 @@
<https://doc.rust-lang.org/reference/conditional-compilation.html\
#the-cfg_attr-attribute>")
.emit();
- return Vec::new();
+ return vec![];
}
let (cfg_predicate, expanded_attrs) = match attr.parse(self.sess, |parser| {
@@ -133,17 +133,18 @@
Ok(result) => result,
Err(mut e) => {
e.emit();
- return Vec::new();
+ return vec![];
}
};
- // Check feature gate and lint on zero attributes in source. Even if the feature is gated,
- // we still compute as if it wasn't, since the emitted error will stop compilation further
- // along the compilation.
- if expanded_attrs.len() == 0 {
- // FIXME: Emit unused attribute lint here.
+ // Lint on zero attributes in source.
+ if expanded_attrs.is_empty() {
+ return vec![attr];
}
+ // At this point we know the attribute is considered used.
+ attr::mark_used(&attr);
+
if attr::cfg_matches(&cfg_predicate, self.sess, self.features) {
// We call `process_cfg_attr` recursively in case there's a
// `cfg_attr` inside of another `cfg_attr`. E.g.
@@ -159,7 +160,7 @@
}))
.collect()
} else {
- Vec::new()
+ vec![]
}
}
diff --git a/src/libsyntax/ext/derive.rs b/src/libsyntax/ext/derive.rs
index abc451c..3b4243e 100644
--- a/src/libsyntax/ext/derive.rs
+++ b/src/libsyntax/ext/derive.rs
@@ -30,10 +30,6 @@
match attr.parse_list(cx.parse_sess,
|parser| parser.parse_path_allowing_meta(PathStyle::Mod)) {
- Ok(ref traits) if traits.is_empty() => {
- cx.span_warn(attr.span, "empty trait list in `derive`");
- false
- }
Ok(traits) => {
result.extend(traits);
true
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index cfd6757..945cf36 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -98,9 +98,9 @@
}
});
}
- $($(AstFragment::$Kind(ast) => vis.$mut_visit_ast(ast),)*)*
+ $($(AstFragment::$Kind(ast) => vis.$mut_visit_ast(ast),)?)*
$($(AstFragment::$Kind(ast) =>
- ast.flat_map_in_place(|ast| vis.$flat_map_ast_elt(ast)),)*)*
+ ast.flat_map_in_place(|ast| vis.$flat_map_ast_elt(ast)),)?)*
}
}
@@ -108,10 +108,10 @@
match *self {
AstFragment::OptExpr(Some(ref expr)) => visitor.visit_expr(expr),
AstFragment::OptExpr(None) => {}
- $($(AstFragment::$Kind(ref ast) => visitor.$visit_ast(ast),)*)*
+ $($(AstFragment::$Kind(ref ast) => visitor.$visit_ast(ast),)?)*
$($(AstFragment::$Kind(ref ast) => for ast_elt in &ast[..] {
visitor.$visit_ast_elt(ast_elt);
- })*)*
+ })?)*
}
}
}
@@ -122,10 +122,10 @@
}
$($(fn $mut_visit_ast(&mut self, ast: &mut $AstTy) {
visit_clobber(ast, |ast| self.expand_fragment(AstFragment::$Kind(ast)).$make_ast());
- })*)*
+ })?)*
$($(fn $flat_map_ast_elt(&mut self, ast_elt: <$AstTy as IntoIterator>::Item) -> $AstTy {
self.expand_fragment(AstFragment::$Kind(smallvec![ast_elt])).$make_ast()
- })*)*
+ })?)*
}
impl<'a> MacResult for crate::ext::tt::macro_rules::ParserAnyMacro<'a> {
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index d5da4c9..92ce377 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -825,7 +825,9 @@
}
match name {
- sym::expr => token.can_begin_expr(),
+ sym::expr => token.can_begin_expr()
+ // This exception is here for backwards compatibility.
+ && !token.is_keyword(kw::Let),
sym::ty => token.can_begin_type(),
sym::ident => get_macro_name(token).is_some(),
sym::literal => token.can_begin_literal_or_bool(),
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 7f051c2..1a448cb 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -1,37 +1,37 @@
-use crate::{ast, attr};
use crate::edition::Edition;
-use crate::ext::base::{SyntaxExtension, SyntaxExtensionKind};
use crate::ext::base::{DummyResult, ExtCtxt, MacResult, TTMacroExpander};
+use crate::ext::base::{SyntaxExtension, SyntaxExtensionKind};
use crate::ext::expand::{AstFragment, AstFragmentKind};
use crate::ext::hygiene::Transparency;
-use crate::ext::tt::macro_parser::{Success, Error, Failure};
-use crate::ext::tt::macro_parser::{MatchedSeq, MatchedNonterminal};
use crate::ext::tt::macro_parser::{parse, parse_failure_msg};
+use crate::ext::tt::macro_parser::{Error, Failure, Success};
+use crate::ext::tt::macro_parser::{MatchedNonterminal, MatchedSeq};
use crate::ext::tt::quoted;
use crate::ext::tt::transcribe::transcribe;
use crate::feature_gate::Features;
-use crate::parse::{Directory, ParseSess};
use crate::parse::parser::Parser;
-use crate::parse::token::{self, Token, NtTT};
use crate::parse::token::TokenKind::*;
-use crate::symbol::{Symbol, kw, sym};
+use crate::parse::token::{self, NtTT, Token};
+use crate::parse::{Directory, ParseSess};
+use crate::symbol::{kw, sym, Symbol};
use crate::tokenstream::{DelimSpan, TokenStream, TokenTree};
+use crate::{ast, attr};
use errors::FatalError;
-use syntax_pos::{Span, symbol::Ident};
use log::debug;
+use syntax_pos::{symbol::Ident, Span};
-use rustc_data_structures::fx::{FxHashMap};
+use rustc_data_structures::fx::FxHashMap;
use std::borrow::Cow;
use std::collections::hash_map::Entry;
use std::slice;
-use rustc_data_structures::sync::Lrc;
use errors::Applicability;
+use rustc_data_structures::sync::Lrc;
const VALID_FRAGMENT_NAMES_MSG: &str = "valid fragment specifiers are \
- `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, \
- `path`, `meta`, `tt`, `item` and `vis`";
+ `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, \
+ `literal`, `path`, `meta`, `tt`, `item` and `vis`";
pub struct ParserAnyMacro<'a> {
parser: Parser<'a>,
@@ -48,7 +48,8 @@
let ParserAnyMacro { site_span, macro_ident, ref mut parser, arm_span } = *self;
let fragment = panictry!(parser.parse_ast_fragment(kind, true).map_err(|mut e| {
if parser.token == token::Eof && e.message().ends_with(", found `<eof>`") {
- if !e.span.is_dummy() { // early end of macro arm (#52866)
+ if !e.span.is_dummy() {
+ // early end of macro arm (#52866)
e.replace_span_with(parser.sess.source_map().next_point(parser.token.span));
}
let msg = &e.message[0];
@@ -60,7 +61,8 @@
msg.1,
);
}
- if e.span.is_dummy() { // Get around lack of span in error (#30128)
+ if e.span.is_dummy() {
+ // Get around lack of span in error (#30128)
e.replace_span_with(site_span);
if parser.sess.source_map().span_to_filename(arm_span).is_real() {
e.span_label(arm_span, "in this macro arm");
@@ -99,17 +101,11 @@
sp: Span,
input: TokenStream,
def_span: Option<Span>,
- ) -> Box<dyn MacResult+'cx> {
+ ) -> Box<dyn MacResult + 'cx> {
if !self.valid {
return DummyResult::any(sp);
}
- generic_extension(cx,
- sp,
- def_span,
- self.name,
- input,
- &self.lhses,
- &self.rhses)
+ generic_extension(cx, sp, def_span, self.name, input, &self.lhses, &self.rhses)
}
}
@@ -119,14 +115,15 @@
}
/// Given `lhses` and `rhses`, this is the new macro we create
-fn generic_extension<'cx>(cx: &'cx mut ExtCtxt<'_>,
- sp: Span,
- def_span: Option<Span>,
- name: ast::Ident,
- arg: TokenStream,
- lhses: &[quoted::TokenTree],
- rhses: &[quoted::TokenTree])
- -> Box<dyn MacResult+'cx> {
+fn generic_extension<'cx>(
+ cx: &'cx mut ExtCtxt<'_>,
+ sp: Span,
+ def_span: Option<Span>,
+ name: ast::Ident,
+ arg: TokenStream,
+ lhses: &[quoted::TokenTree],
+ rhses: &[quoted::TokenTree],
+) -> Box<dyn MacResult + 'cx> {
if cx.trace_macros() {
trace_macros_note(cx, sp, format!("expanding `{}! {{ {} }}`", name, arg));
}
@@ -134,10 +131,11 @@
// Which arm's failure should we report? (the one furthest along)
let mut best_failure: Option<(Token, &str)> = None;
- for (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
+ for (i, lhs) in lhses.iter().enumerate() {
+ // try each arm's matchers
let lhs_tt = match *lhs {
quoted::TokenTree::Delimited(_, ref delim) => &delim.tts[..],
- _ => cx.span_bug(sp, "malformed macro lhs")
+ _ => cx.span_bug(sp, "malformed macro lhs"),
};
match TokenTree::parse(cx, lhs_tt, arg.clone()) {
@@ -173,8 +171,8 @@
ownership: cx.current_expansion.directory_ownership,
};
let mut p = Parser::new(cx.parse_sess(), tts, Some(directory), true, false, None);
- p.root_module_name = cx.current_expansion.module.mod_path.last()
- .map(|id| id.as_str().to_string());
+ p.root_module_name =
+ cx.current_expansion.module.mod_path.last().map(|id| id.as_str().to_string());
p.process_potential_macro_variable();
// Let the context choose how to interpret the result.
@@ -188,15 +186,13 @@
site_span: sp,
macro_ident: name,
arm_span,
- })
+ });
}
Failure(token, msg) => match best_failure {
Some((ref best_token, _)) if best_token.span.lo() >= token.span.lo() => {}
- _ => best_failure = Some((token, msg))
- }
- Error(err_sp, ref msg) => {
- cx.span_fatal(err_sp.substitute_dummy(sp), &msg[..])
- }
+ _ => best_failure = Some((token, msg)),
+ },
+ Error(err_sp, ref msg) => cx.span_fatal(err_sp.substitute_dummy(sp), &msg[..]),
}
}
@@ -212,7 +208,8 @@
// Check whether there's a missing comma in this macro call, like `println!("{}" a);`
if let Some((arg, comma_span)) = arg.add_comma() {
- for lhs in lhses { // try each arm's matchers
+ for lhs in lhses {
+ // try each arm's matchers
let lhs_tt = match *lhs {
quoted::TokenTree::Delimited(_, ref delim) => &delim.tts[..],
_ => continue,
@@ -249,7 +246,7 @@
sess: &ParseSess,
features: &Features,
def: &ast::Item,
- edition: Edition
+ edition: Edition,
) -> SyntaxExtension {
let lhs_nm = ast::Ident::new(sym::lhs, def.span);
let rhs_nm = ast::Ident::new(sym::rhs, def.span);
@@ -267,25 +264,32 @@
// ...quasiquoting this would be nice.
// These spans won't matter, anyways
let argument_gram = vec![
- quoted::TokenTree::Sequence(DelimSpan::dummy(), Lrc::new(quoted::SequenceRepetition {
- tts: vec![
- quoted::TokenTree::MetaVarDecl(def.span, lhs_nm, tt_spec),
- quoted::TokenTree::token(token::FatArrow, def.span),
- quoted::TokenTree::MetaVarDecl(def.span, rhs_nm, tt_spec),
- ],
- separator: Some(Token::new(
- if body.legacy { token::Semi } else { token::Comma }, def.span
- )),
- op: quoted::KleeneOp::OneOrMore,
- num_captures: 2,
- })),
+ quoted::TokenTree::Sequence(
+ DelimSpan::dummy(),
+ Lrc::new(quoted::SequenceRepetition {
+ tts: vec![
+ quoted::TokenTree::MetaVarDecl(def.span, lhs_nm, tt_spec),
+ quoted::TokenTree::token(token::FatArrow, def.span),
+ quoted::TokenTree::MetaVarDecl(def.span, rhs_nm, tt_spec),
+ ],
+ separator: Some(Token::new(
+ if body.legacy { token::Semi } else { token::Comma },
+ def.span,
+ )),
+ op: quoted::KleeneOp::OneOrMore,
+ num_captures: 2,
+ }),
+ ),
// to phase into semicolon-termination instead of semicolon-separation
- quoted::TokenTree::Sequence(DelimSpan::dummy(), Lrc::new(quoted::SequenceRepetition {
- tts: vec![quoted::TokenTree::token(token::Semi, def.span)],
- separator: None,
- op: quoted::KleeneOp::ZeroOrMore,
- num_captures: 0
- })),
+ quoted::TokenTree::Sequence(
+ DelimSpan::dummy(),
+ Lrc::new(quoted::SequenceRepetition {
+ tts: vec![quoted::TokenTree::token(token::Semi, def.span)],
+ separator: None,
+ op: quoted::KleeneOp::ZeroOrMore,
+ num_captures: 0,
+ }),
+ ),
];
let argument_map = match parse(sess, body.stream(), &argument_gram, None, true) {
@@ -307,8 +311,9 @@
// Extract the arguments:
let lhses = match *argument_map[&lhs_nm] {
- MatchedSeq(ref s, _) => {
- s.iter().map(|m| {
+ MatchedSeq(ref s, _) => s
+ .iter()
+ .map(|m| {
if let MatchedNonterminal(ref nt) = *m {
if let NtTT(ref tt) = **nt {
let tt = quoted::parse(
@@ -327,14 +332,15 @@
}
}
sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs")
- }).collect::<Vec<quoted::TokenTree>>()
- }
- _ => sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs")
+ })
+ .collect::<Vec<quoted::TokenTree>>(),
+ _ => sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs"),
};
let rhses = match *argument_map[&rhs_nm] {
- MatchedSeq(ref s, _) => {
- s.iter().map(|m| {
+ MatchedSeq(ref s, _) => s
+ .iter()
+ .map(|m| {
if let MatchedNonterminal(ref nt) = *m {
if let NtTT(ref tt) = **nt {
return quoted::parse(
@@ -345,14 +351,15 @@
&def.attrs,
edition,
def.id,
- ).pop()
- .unwrap();
+ )
+ .pop()
+ .unwrap();
}
}
sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs")
- }).collect::<Vec<quoted::TokenTree>>()
- }
- _ => sess.span_diagnostic.span_bug(def.span, "wrong-structured rhs")
+ })
+ .collect::<Vec<quoted::TokenTree>>(),
+ _ => sess.span_diagnostic.span_bug(def.span, "wrong-structured rhs"),
};
for rhs in &rhses {
@@ -366,16 +373,12 @@
sess,
slice::from_ref(lhs),
&mut FxHashMap::default(),
- def.id
+ def.id,
);
}
- let expander: Box<_> = Box::new(MacroRulesMacroExpander {
- name: def.ident,
- lhses,
- rhses,
- valid,
- });
+ let expander: Box<_> =
+ Box::new(MacroRulesMacroExpander { name: def.ident, lhses, rhses, valid });
let default_transparency = if attr::contains_name(&def.attrs, sym::rustc_transparent_macro) {
Transparency::Transparent
@@ -385,29 +388,34 @@
Transparency::Opaque
};
- let allow_internal_unstable = attr::find_by_name(&def.attrs, sym::allow_internal_unstable)
- .map(|attr| attr
- .meta_item_list()
- .map(|list| list.iter()
- .filter_map(|it| {
- let name = it.ident().map(|ident| ident.name);
- if name.is_none() {
- sess.span_diagnostic.span_err(it.span(),
- "allow internal unstable expects feature names")
- }
- name
+ let allow_internal_unstable =
+ attr::find_by_name(&def.attrs, sym::allow_internal_unstable).map(|attr| {
+ attr.meta_item_list()
+ .map(|list| {
+ list.iter()
+ .filter_map(|it| {
+ let name = it.ident().map(|ident| ident.name);
+ if name.is_none() {
+ sess.span_diagnostic.span_err(
+ it.span(),
+ "allow internal unstable expects feature names",
+ )
+ }
+ name
+ })
+ .collect::<Vec<Symbol>>()
+ .into()
})
- .collect::<Vec<Symbol>>().into()
- )
- .unwrap_or_else(|| {
- sess.span_diagnostic.span_warn(
- attr.span, "allow_internal_unstable expects list of feature names. In the \
- future this will become a hard error. Please use `allow_internal_unstable(\
- foo, bar)` to only allow the `foo` and `bar` features",
- );
- vec![sym::allow_internal_unstable_backcompat_hack].into()
- })
- );
+ .unwrap_or_else(|| {
+ sess.span_diagnostic.span_warn(
+ attr.span,
+ "allow_internal_unstable expects list of feature names. In the \
+ future this will become a hard error. Please use `allow_internal_unstable(\
+ foo, bar)` to only allow the `foo` and `bar` features",
+ );
+ vec![sym::allow_internal_unstable_backcompat_hack].into()
+ })
+ });
let allow_internal_unsafe = attr::contains_name(&def.attrs, sym::allow_internal_unsafe);
@@ -418,14 +426,14 @@
}
}
- let unstable_feature = attr::find_stability(&sess,
- &def.attrs, def.span).and_then(|stability| {
- if let attr::StabilityLevel::Unstable { issue, .. } = stability.level {
- Some((stability.feature, issue))
- } else {
- None
- }
- });
+ let unstable_feature =
+ attr::find_stability(&sess, &def.attrs, def.span).and_then(|stability| {
+ if let attr::StabilityLevel::Unstable { issue, .. } = stability.level {
+ Some((stability.feature, issue))
+ } else {
+ None
+ }
+ });
SyntaxExtension {
kind: SyntaxExtensionKind::LegacyBang(expander),
@@ -440,10 +448,12 @@
}
}
-fn check_lhs_nt_follows(sess: &ParseSess,
- features: &Features,
- attrs: &[ast::Attribute],
- lhs: "ed::TokenTree) -> bool {
+fn check_lhs_nt_follows(
+ sess: &ParseSess,
+ features: &Features,
+ attrs: &[ast::Attribute],
+ lhs: "ed::TokenTree,
+) -> bool {
// lhs is going to be like TokenTree::Delimited(...), where the
// entire lhs is those tts. Or, it can be a "bare sequence", not wrapped in parens.
if let quoted::TokenTree::Delimited(_, ref tts) = *lhs {
@@ -464,19 +474,22 @@
for tt in tts {
match *tt {
TokenTree::Token(..) | TokenTree::MetaVar(..) | TokenTree::MetaVarDecl(..) => (),
- TokenTree::Delimited(_, ref del) => if !check_lhs_no_empty_seq(sess, &del.tts) {
- return false;
- },
+ TokenTree::Delimited(_, ref del) => {
+ if !check_lhs_no_empty_seq(sess, &del.tts) {
+ return false;
+ }
+ }
TokenTree::Sequence(span, ref seq) => {
- if seq.separator.is_none() && seq.tts.iter().all(|seq_tt| {
- match *seq_tt {
+ if seq.separator.is_none()
+ && seq.tts.iter().all(|seq_tt| match *seq_tt {
TokenTree::MetaVarDecl(_, _, id) => id.name == sym::vis,
- TokenTree::Sequence(_, ref sub_seq) =>
+ TokenTree::Sequence(_, ref sub_seq) => {
sub_seq.op == quoted::KleeneOp::ZeroOrMore
- || sub_seq.op == quoted::KleeneOp::ZeroOrOne,
+ || sub_seq.op == quoted::KleeneOp::ZeroOrOne
+ }
_ => false,
- }
- }) {
+ })
+ {
let sp = span.entire();
sess.span_diagnostic.span_err(sp, "repetition matches empty token tree");
return false;
@@ -517,7 +530,7 @@
if !check_lhs_duplicate_matcher_bindings(sess, &del.tts, metavar_names, node_id) {
return false;
}
- },
+ }
TokenTree::Sequence(_, ref seq) => {
if !check_lhs_duplicate_matcher_bindings(sess, &seq.tts, metavar_names, node_id) {
return false;
@@ -533,15 +546,17 @@
fn check_rhs(sess: &ParseSess, rhs: "ed::TokenTree) -> bool {
match *rhs {
quoted::TokenTree::Delimited(..) => return true,
- _ => sess.span_diagnostic.span_err(rhs.span(), "macro rhs must be delimited")
+ _ => sess.span_diagnostic.span_err(rhs.span(), "macro rhs must be delimited"),
}
false
}
-fn check_matcher(sess: &ParseSess,
- features: &Features,
- attrs: &[ast::Attribute],
- matcher: &[quoted::TokenTree]) -> bool {
+fn check_matcher(
+ sess: &ParseSess,
+ features: &Features,
+ attrs: &[ast::Attribute],
+ matcher: &[quoted::TokenTree],
+) -> bool {
let first_sets = FirstSets::new(matcher);
let empty_suffix = TokenSet::empty();
let err = sess.span_diagnostic.err_count();
@@ -620,8 +635,8 @@
// Reverse scan: Sequence comes before `first`.
if subfirst.maybe_empty
- || seq_rep.op == quoted::KleeneOp::ZeroOrMore
- || seq_rep.op == quoted::KleeneOp::ZeroOrOne
+ || seq_rep.op == quoted::KleeneOp::ZeroOrMore
+ || seq_rep.op == quoted::KleeneOp::ZeroOrOne
{
// If sequence is potentially empty, then
// union them (preserving first emptiness).
@@ -659,7 +674,6 @@
TokenTree::Sequence(sp, ref seq_rep) => {
match self.first.get(&sp.entire()) {
Some(&Some(ref subfirst)) => {
-
// If the sequence contents can be empty, then the first
// token could be the separator token itself.
@@ -670,8 +684,8 @@
assert!(first.maybe_empty);
first.add_all(subfirst);
if subfirst.maybe_empty
- || seq_rep.op == quoted::KleeneOp::ZeroOrMore
- || seq_rep.op == quoted::KleeneOp::ZeroOrOne
+ || seq_rep.op == quoted::KleeneOp::ZeroOrMore
+ || seq_rep.op == quoted::KleeneOp::ZeroOrOne
{
// continue scanning for more first
// tokens, but also make sure we
@@ -720,7 +734,9 @@
impl TokenSet {
// Returns a set for the empty sequence.
- fn empty() -> Self { TokenSet { tokens: Vec::new(), maybe_empty: true } }
+ fn empty() -> Self {
+ TokenSet { tokens: Vec::new(), maybe_empty: true }
+ }
// Returns the set `{ tok }` for the single-token (and thus
// non-empty) sequence [tok].
@@ -789,12 +805,14 @@
//
// Requires that `first_sets` is pre-computed for `matcher`;
// see `FirstSets::new`.
-fn check_matcher_core(sess: &ParseSess,
- features: &Features,
- attrs: &[ast::Attribute],
- first_sets: &FirstSets,
- matcher: &[quoted::TokenTree],
- follow: &TokenSet) -> TokenSet {
+fn check_matcher_core(
+ sess: &ParseSess,
+ features: &Features,
+ attrs: &[ast::Attribute],
+ first_sets: &FirstSets,
+ matcher: &[quoted::TokenTree],
+ follow: &TokenSet,
+) -> TokenSet {
use quoted::TokenTree;
let mut last = TokenSet::empty();
@@ -804,11 +822,13 @@
// then ensure T can also be followed by any element of FOLLOW.
'each_token: for i in 0..matcher.len() {
let token = &matcher[i];
- let suffix = &matcher[i+1..];
+ let suffix = &matcher[i + 1..];
let build_suffix_first = || {
let mut s = first_sets.first(suffix);
- if s.maybe_empty { s.add_all(follow); }
+ if s.maybe_empty {
+ s.add_all(follow);
+ }
s
};
@@ -824,7 +844,8 @@
let can_be_followed_by_any;
if let Err(bad_frag) = has_legal_fragment_specifier(sess, features, attrs, token) {
let msg = format!("invalid fragment specifier `{}`", bad_frag);
- sess.span_diagnostic.struct_span_err(token.span(), &msg)
+ sess.span_diagnostic
+ .struct_span_err(token.span(), &msg)
.help(VALID_FRAGMENT_NAMES_MSG)
.emit();
// (This eliminates false positives and duplicates
@@ -879,12 +900,8 @@
// At this point, `suffix_first` is built, and
// `my_suffix` is some TokenSet that we can use
// for checking the interior of `seq_rep`.
- let next = check_matcher_core(sess,
- features,
- attrs,
- first_sets,
- &seq_rep.tts,
- my_suffix);
+ let next =
+ check_matcher_core(sess, features, attrs, first_sets, &seq_rep.tts, my_suffix);
if next.maybe_empty {
last.add_all(&next);
} else {
@@ -906,16 +923,17 @@
for next_token in &suffix_first.tokens {
match is_in_follow(next_token, &frag_spec.as_str()) {
IsInFollow::Invalid(msg, help) => {
- sess.span_diagnostic.struct_span_err(next_token.span(), &msg)
- .help(help).emit();
+ sess.span_diagnostic
+ .struct_span_err(next_token.span(), &msg)
+ .help(help)
+ .emit();
// don't bother reporting every source of
// conflict for a particular element of `last`.
continue 'each_last;
}
IsInFollow::Yes => {}
IsInFollow::No(possible) => {
- let may_be = if last.tokens.len() == 1 &&
- suffix_first.tokens.len() == 1
+ let may_be = if last.tokens.len() == 1 && suffix_first.tokens.len() == 1
{
"is"
} else {
@@ -925,12 +943,14 @@
let sp = next_token.span();
let mut err = sess.span_diagnostic.struct_span_err(
sp,
- &format!("`${name}:{frag}` {may_be} followed by `{next}`, which \
- is not allowed for `{frag}` fragments",
- name=name,
- frag=frag_spec,
- next=quoted_tt_to_string(next_token),
- may_be=may_be),
+ &format!(
+ "`${name}:{frag}` {may_be} followed by `{next}`, which \
+ is not allowed for `{frag}` fragments",
+ name = name,
+ frag = frag_spec,
+ next = quoted_tt_to_string(next_token),
+ may_be = may_be
+ ),
);
err.span_label(
sp,
@@ -942,16 +962,18 @@
&[t] => {
err.note(&format!(
"only {} is allowed after `{}` fragments",
- t,
- frag_spec,
+ t, frag_spec,
));
}
ts => {
err.note(&format!(
"{}{} or {}",
msg,
- ts[..ts.len() - 1].iter().map(|s| *s)
- .collect::<Vec<_>>().join(", "),
+ ts[..ts.len() - 1]
+ .iter()
+ .map(|s| *s)
+ .collect::<Vec<_>>()
+ .join(", "),
ts[ts.len() - 1],
));
}
@@ -1026,13 +1048,13 @@
// since items *must* be followed by either a `;` or a `}`, we can
// accept anything after them
IsInFollow::Yes
- },
+ }
"block" => {
// anything can follow block, the braces provide an easy boundary to
// maintain
IsInFollow::Yes
- },
- "stmt" | "expr" => {
+ }
+ "stmt" | "expr" => {
const TOKENS: &[&str] = &["`=>`", "`,`", "`;`"];
match tok {
TokenTree::Token(token) => match token.kind {
@@ -1041,7 +1063,7 @@
},
_ => IsInFollow::No(TOKENS),
}
- },
+ }
"pat" => {
const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`|`", "`if`", "`in`"];
match tok {
@@ -1052,40 +1074,48 @@
},
_ => IsInFollow::No(TOKENS),
}
- },
+ }
"path" | "ty" => {
const TOKENS: &[&str] = &[
- "`{`", "`[`", "`=>`", "`,`", "`>`","`=`", "`:`", "`;`", "`|`", "`as`",
+ "`{`", "`[`", "`=>`", "`,`", "`>`", "`=`", "`:`", "`;`", "`|`", "`as`",
"`where`",
];
match tok {
TokenTree::Token(token) => match token.kind {
- OpenDelim(token::DelimToken::Brace) |
- OpenDelim(token::DelimToken::Bracket) |
- Comma | FatArrow | Colon | Eq | Gt | BinOp(token::Shr) | Semi |
- BinOp(token::Or) => IsInFollow::Yes,
- Ident(name, false) if name == kw::As ||
- name == kw::Where => IsInFollow::Yes,
+ OpenDelim(token::DelimToken::Brace)
+ | OpenDelim(token::DelimToken::Bracket)
+ | Comma
+ | FatArrow
+ | Colon
+ | Eq
+ | Gt
+ | BinOp(token::Shr)
+ | Semi
+ | BinOp(token::Or) => IsInFollow::Yes,
+ Ident(name, false) if name == kw::As || name == kw::Where => {
+ IsInFollow::Yes
+ }
_ => IsInFollow::No(TOKENS),
},
- TokenTree::MetaVarDecl(_, _, frag) if frag.name == sym::block =>
- IsInFollow::Yes,
+ TokenTree::MetaVarDecl(_, _, frag) if frag.name == sym::block => {
+ IsInFollow::Yes
+ }
_ => IsInFollow::No(TOKENS),
}
- },
+ }
"ident" | "lifetime" => {
// being a single token, idents and lifetimes are harmless
IsInFollow::Yes
- },
+ }
"literal" => {
// literals may be of a single token, or two tokens (negative numbers)
IsInFollow::Yes
- },
+ }
"meta" | "tt" => {
// being either a single token or a delimited sequence, tt is
// harmless
IsInFollow::Yes
- },
+ }
"vis" => {
// Explicitly disallow `priv`, on the off chance it comes back.
const TOKENS: &[&str] = &["`,`", "an ident", "a type"];
@@ -1093,30 +1123,39 @@
TokenTree::Token(token) => match token.kind {
Comma => IsInFollow::Yes,
Ident(name, is_raw) if is_raw || name != kw::Priv => IsInFollow::Yes,
- _ => if token.can_begin_type() {
- IsInFollow::Yes
- } else {
- IsInFollow::No(TOKENS)
+ _ => {
+ if token.can_begin_type() {
+ IsInFollow::Yes
+ } else {
+ IsInFollow::No(TOKENS)
+ }
}
},
- TokenTree::MetaVarDecl(_, _, frag) if frag.name == sym::ident
- || frag.name == sym::ty
- || frag.name == sym::path =>
- IsInFollow::Yes,
+ TokenTree::MetaVarDecl(_, _, frag)
+ if frag.name == sym::ident
+ || frag.name == sym::ty
+ || frag.name == sym::path =>
+ {
+ IsInFollow::Yes
+ }
_ => IsInFollow::No(TOKENS),
}
- },
+ }
"" => IsInFollow::Yes, // kw::Invalid
- _ => IsInFollow::Invalid(format!("invalid fragment specifier `{}`", frag),
- VALID_FRAGMENT_NAMES_MSG),
+ _ => IsInFollow::Invalid(
+ format!("invalid fragment specifier `{}`", frag),
+ VALID_FRAGMENT_NAMES_MSG,
+ ),
}
}
}
-fn has_legal_fragment_specifier(sess: &ParseSess,
- features: &Features,
- attrs: &[ast::Attribute],
- tok: "ed::TokenTree) -> Result<(), String> {
+fn has_legal_fragment_specifier(
+ sess: &ParseSess,
+ features: &Features,
+ attrs: &[ast::Attribute],
+ tok: "ed::TokenTree,
+) -> Result<(), String> {
debug!("has_legal_fragment_specifier({:?})", tok);
if let quoted::TokenTree::MetaVarDecl(_, _, ref frag_spec) = *tok {
let frag_span = tok.span();
@@ -1127,11 +1166,13 @@
Ok(())
}
-fn is_legal_fragment_specifier(_sess: &ParseSess,
- _features: &Features,
- _attrs: &[ast::Attribute],
- frag_name: Symbol,
- _frag_span: Span) -> bool {
+fn is_legal_fragment_specifier(
+ _sess: &ParseSess,
+ _features: &Features,
+ _attrs: &[ast::Attribute],
+ frag_name: Symbol,
+ _frag_span: Span,
+) -> bool {
/*
* If new fragment specifiers are invented in nightly, `_sess`,
* `_features`, `_attrs`, and `_frag_span` will be useful here
@@ -1139,9 +1180,20 @@
* this function.
*/
match frag_name {
- sym::item | sym::block | sym::stmt | sym::expr | sym::pat |
- sym::lifetime | sym::path | sym::ty | sym::ident | sym::meta | sym::tt |
- sym::vis | sym::literal | kw::Invalid => true,
+ sym::item
+ | sym::block
+ | sym::stmt
+ | sym::expr
+ | sym::pat
+ | sym::lifetime
+ | sym::path
+ | sym::ty
+ | sym::ident
+ | sym::meta
+ | sym::tt
+ | sym::vis
+ | sym::literal
+ | kw::Invalid => true,
_ => false,
}
}
@@ -1151,7 +1203,9 @@
quoted::TokenTree::Token(ref token) => crate::print::pprust::token_to_string(&token),
quoted::TokenTree::MetaVar(_, name) => format!("${}", name),
quoted::TokenTree::MetaVarDecl(_, name, kind) => format!("${}:{}", name, kind),
- _ => panic!("unexpected quoted::TokenTree::{{Sequence or Delimited}} \
- in follow set checker"),
+ _ => panic!(
+ "unexpected quoted::TokenTree::{{Sequence or Delimited}} \
+ in follow set checker"
+ ),
}
}
diff --git a/src/libsyntax/ext/tt/quoted.rs b/src/libsyntax/ext/tt/quoted.rs
index b52e3b7..6f5ce89 100644
--- a/src/libsyntax/ext/tt/quoted.rs
+++ b/src/libsyntax/ext/tt/quoted.rs
@@ -1,12 +1,12 @@
+use crate::ast;
use crate::ast::NodeId;
use crate::ext::tt::macro_parser;
use crate::feature_gate::Features;
use crate::parse::token::{self, Token, TokenKind};
use crate::parse::ParseSess;
use crate::print::pprust;
-use crate::tokenstream::{self, DelimSpan};
-use crate::ast;
use crate::symbol::kw;
+use crate::tokenstream::{self, DelimSpan};
use syntax_pos::{edition::Edition, BytePos, Span};
@@ -137,8 +137,7 @@
TokenTree::Token(Token { span, .. })
| TokenTree::MetaVar(span, _)
| TokenTree::MetaVarDecl(span, _, _) => span,
- TokenTree::Delimited(span, _)
- | TokenTree::Sequence(span, _) => span.entire(),
+ TokenTree::Delimited(span, _) | TokenTree::Sequence(span, _) => span.entire(),
}
}
@@ -199,7 +198,7 @@
match tree {
TokenTree::MetaVar(start_sp, ident) if expect_matchers => {
let span = match trees.next() {
- Some(tokenstream::TokenTree::Token(Token { kind: token::Colon, span })) =>
+ Some(tokenstream::TokenTree::Token(Token { kind: token::Colon, span })) => {
match trees.next() {
Some(tokenstream::TokenTree::Token(token)) => match token.ident() {
Some((kind, _)) => {
@@ -209,22 +208,13 @@
}
_ => token.span,
},
- tree => tree
- .as_ref()
- .map(tokenstream::TokenTree::span)
- .unwrap_or(span),
- },
- tree => tree
- .as_ref()
- .map(tokenstream::TokenTree::span)
- .unwrap_or(start_sp),
+ tree => tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(span),
+ }
+ }
+ tree => tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(start_sp),
};
sess.missing_fragment_specifiers.borrow_mut().insert(span);
- result.push(TokenTree::MetaVarDecl(
- span,
- ident,
- ast::Ident::invalid(),
- ));
+ result.push(TokenTree::MetaVarDecl(span, ident, ast::Ident::invalid()));
}
// Not a metavar or no matchers allowed, so just return the tree
@@ -311,10 +301,8 @@
// `tree` is followed by a random token. This is an error.
Some(tokenstream::TokenTree::Token(token)) => {
- let msg = format!(
- "expected identifier, found `{}`",
- pprust::token_to_string(&token),
- );
+ let msg =
+ format!("expected identifier, found `{}`", pprust::token_to_string(&token),);
sess.span_diagnostic.span_err(token.span, &msg);
TokenTree::MetaVar(token.span, ast::Ident::invalid())
}
@@ -371,10 +359,7 @@
Some(op) => Ok(Ok((op, token.span))),
None => Ok(Err(token)),
},
- tree => Err(tree
- .as_ref()
- .map(tokenstream::TokenTree::span)
- .unwrap_or(span)),
+ tree => Err(tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(span)),
}
}
@@ -426,8 +411,7 @@
};
// If we ever get to this point, we have experienced an "unexpected token" error
- sess.span_diagnostic
- .span_err(span, "expected one of: `*`, `+`, or `?`");
+ sess.span_diagnostic.span_err(span, "expected one of: `*`, `+`, or `?`");
// Return a dummy
(None, KleeneOp::ZeroOrMore)
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index 7f80e20..c405acd 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -25,13 +25,14 @@
use crate::edition::{ALL_EDITIONS, Edition};
use crate::visit::{self, FnKind, Visitor};
use crate::parse::{token, ParseSess};
+use crate::parse::parser::Parser;
use crate::symbol::{Symbol, sym};
use crate::tokenstream::TokenTree;
use errors::{Applicability, DiagnosticBuilder, Handler};
use rustc_data_structures::fx::FxHashMap;
use rustc_target::spec::abi::Abi;
-use syntax_pos::{Span, DUMMY_SP};
+use syntax_pos::{Span, DUMMY_SP, MultiSpan};
use log::debug;
use lazy_static::lazy_static;
@@ -560,12 +561,18 @@
// Allows calling constructor functions in `const fn`.
(active, const_constructor, "1.37.0", Some(61456), None),
+ // Allows `if/while p && let q = r && ...` chains.
+ (active, let_chains, "1.37.0", Some(53667), None),
+
// #[repr(transparent)] on enums.
(active, transparent_enums, "1.37.0", Some(60405), None),
// #[repr(transparent)] on unions.
(active, transparent_unions, "1.37.0", Some(60405), None),
+ // Allows explicit discriminants on non-unit enum variants.
+ (active, arbitrary_enum_discriminant, "1.37.0", Some(60553), None),
+
// -------------------------------------------------------------------------
// feature-group-end: actual feature gates
// -------------------------------------------------------------------------
@@ -577,7 +584,8 @@
const INCOMPLETE_FEATURES: &[Symbol] = &[
sym::impl_trait_in_bindings,
sym::generic_associated_types,
- sym::const_generics
+ sym::const_generics,
+ sym::let_chains,
];
declare_features! (
@@ -1705,20 +1713,20 @@
feature_err(sess, feature, span, issue, explain).emit();
}
-pub fn feature_err<'a>(
+pub fn feature_err<'a, S: Into<MultiSpan>>(
sess: &'a ParseSess,
feature: Symbol,
- span: Span,
+ span: S,
issue: GateIssue,
explain: &str,
) -> DiagnosticBuilder<'a> {
leveled_feature_err(sess, feature, span, issue, explain, GateStrength::Hard)
}
-fn leveled_feature_err<'a>(
+fn leveled_feature_err<'a, S: Into<MultiSpan>>(
sess: &'a ParseSess,
feature: Symbol,
- span: Span,
+ span: S,
issue: GateIssue,
explain: &str,
level: GateStrength,
@@ -2033,6 +2041,29 @@
}
}
+ ast::ItemKind::Enum(ast::EnumDef{ref variants, ..}, ..) => {
+ for variant in variants {
+ match (&variant.node.data, &variant.node.disr_expr) {
+ (ast::VariantData::Unit(..), _) => {},
+ (_, Some(disr_expr)) =>
+ gate_feature_post!(
+ &self,
+ arbitrary_enum_discriminant,
+ disr_expr.value.span,
+ "discriminants on non-unit variants are experimental"),
+ _ => {},
+ }
+ }
+
+ let has_feature = self.context.features.arbitrary_enum_discriminant;
+ if !has_feature && !i.span.allows_unstable(sym::arbitrary_enum_discriminant) {
+ Parser::maybe_report_invalid_custom_discriminants(
+ self.context.parse_sess,
+ &variants,
+ );
+ }
+ }
+
ast::ItemKind::Impl(_, polarity, defaultness, _, _, _, _) => {
if polarity == ast::ImplPolarity::Negative {
gate_feature_post!(&self, optin_builtin_traits,
@@ -2517,6 +2548,17 @@
"attributes on function parameters are unstable"
));
+ sess
+ .let_chains_spans
+ .borrow()
+ .iter()
+ .for_each(|span| gate_feature!(
+ &ctx,
+ let_chains,
+ *span,
+ "`let` expressions in this position are experimental"
+ ));
+
let visitor = &mut PostExpansionVisitor {
context: &ctx,
builtin_attributes: &*BUILTIN_ATTRIBUTE_MAP,
diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs
index 5a5b633..e23bc02 100644
--- a/src/libsyntax/mut_visit.rs
+++ b/src/libsyntax/mut_visit.rs
@@ -131,10 +131,6 @@
noop_visit_arm(a, self);
}
- fn visit_guard(&mut self, g: &mut Guard) {
- noop_visit_guard(g, self);
- }
-
fn visit_pat(&mut self, p: &mut P<Pat>) {
noop_visit_pat(p, self);
}
@@ -389,17 +385,11 @@
) {
visit_attrs(attrs, vis);
visit_vec(pats, |pat| vis.visit_pat(pat));
- visit_opt(guard, |guard| vis.visit_guard(guard));
+ visit_opt(guard, |guard| vis.visit_expr(guard));
vis.visit_expr(body);
vis.visit_span(span);
}
-pub fn noop_visit_guard<T: MutVisitor>(g: &mut Guard, vis: &mut T) {
- match g {
- Guard::If(e) => vis.visit_expr(e),
- }
-}
-
pub fn noop_visit_ty_constraint<T: MutVisitor>(
AssocTyConstraint { id, ident, kind, span }: &mut AssocTyConstraint,
vis: &mut T
@@ -1110,28 +1100,20 @@
vis.visit_ty(ty);
}
ExprKind::AddrOf(_m, ohs) => vis.visit_expr(ohs),
+ ExprKind::Let(pats, scrutinee) => {
+ visit_vec(pats, |pat| vis.visit_pat(pat));
+ vis.visit_expr(scrutinee);
+ }
ExprKind::If(cond, tr, fl) => {
vis.visit_expr(cond);
vis.visit_block(tr);
visit_opt(fl, |fl| vis.visit_expr(fl));
}
- ExprKind::IfLet(pats, expr, tr, fl) => {
- visit_vec(pats, |pat| vis.visit_pat(pat));
- vis.visit_expr(expr);
- vis.visit_block(tr);
- visit_opt(fl, |fl| vis.visit_expr(fl));
- }
ExprKind::While(cond, body, label) => {
vis.visit_expr(cond);
vis.visit_block(body);
visit_opt(label, |label| vis.visit_label(label));
}
- ExprKind::WhileLet(pats, expr, body, label) => {
- visit_vec(pats, |pat| vis.visit_pat(pat));
- vis.visit_expr(expr);
- vis.visit_block(body);
- visit_opt(label, |label| vis.visit_label(label));
- }
ExprKind::ForLoop(pat, iter, body, label) => {
vis.visit_pat(pat);
vis.visit_expr(iter);
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index dfd6f45..6ebfab3 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -14,11 +14,9 @@
pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
match e.node {
ast::ExprKind::If(..) |
- ast::ExprKind::IfLet(..) |
ast::ExprKind::Match(..) |
ast::ExprKind::Block(..) |
ast::ExprKind::While(..) |
- ast::ExprKind::WhileLet(..) |
ast::ExprKind::Loop(..) |
ast::ExprKind::ForLoop(..) |
ast::ExprKind::TryBlock(..) => false,
diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs
index 60544cc..07fe521 100644
--- a/src/libsyntax/parse/diagnostics.rs
+++ b/src/libsyntax/parse/diagnostics.rs
@@ -2,7 +2,7 @@
self, Arg, BinOpKind, BindingMode, BlockCheckMode, Expr, ExprKind, Ident, Item, ItemKind,
Mutability, Pat, PatKind, PathSegment, QSelf, Ty, TyKind, VariantData,
};
-use crate::parse::{SeqSep, PResult, Parser};
+use crate::parse::{SeqSep, PResult, Parser, ParseSess};
use crate::parse::parser::{BlockMode, PathStyle, SemiColonMode, TokenType, TokenExpectType};
use crate::parse::token::{self, TokenKind};
use crate::print::pprust;
@@ -539,8 +539,7 @@
}
crate fn maybe_report_invalid_custom_discriminants(
- &mut self,
- discriminant_spans: Vec<Span>,
+ sess: &ParseSess,
variants: &[Spanned<ast::Variant_>],
) {
let has_fields = variants.iter().any(|variant| match variant.node.data {
@@ -548,28 +547,39 @@
VariantData::Unit(..) => false,
});
+ let discriminant_spans = variants.iter().filter(|variant| match variant.node.data {
+ VariantData::Tuple(..) | VariantData::Struct(..) => false,
+ VariantData::Unit(..) => true,
+ })
+ .filter_map(|variant| variant.node.disr_expr.as_ref().map(|c| c.value.span))
+ .collect::<Vec<_>>();
+
if !discriminant_spans.is_empty() && has_fields {
- let mut err = self.struct_span_err(
+ let mut err = crate::feature_gate::feature_err(
+ sess,
+ sym::arbitrary_enum_discriminant,
discriminant_spans.clone(),
- "custom discriminant values are not allowed in enums with fields",
+ crate::feature_gate::GateIssue::Language,
+ "custom discriminant values are not allowed in enums with tuple or struct variants",
);
for sp in discriminant_spans {
- err.span_label(sp, "invalid custom discriminant");
+ err.span_label(sp, "disallowed custom discriminant");
}
for variant in variants.iter() {
- if let VariantData::Struct(fields, ..) | VariantData::Tuple(fields, ..) =
- &variant.node.data
- {
- let fields = if fields.len() > 1 {
- "fields"
- } else {
- "a field"
- };
- err.span_label(
- variant.span,
- &format!("variant with {fields} defined here", fields = fields),
- );
-
+ match &variant.node.data {
+ VariantData::Struct(..) => {
+ err.span_label(
+ variant.span,
+ "struct variant defined here",
+ );
+ }
+ VariantData::Tuple(..) => {
+ err.span_label(
+ variant.span,
+ "tuple variant defined here",
+ );
+ }
+ VariantData::Unit(..) => {}
}
}
err.emit();
diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs
index 1c44155..ead5d54 100644
--- a/src/libsyntax/parse/lexer/mod.rs
+++ b/src/libsyntax/parse/lexer/mod.rs
@@ -1491,6 +1491,7 @@
edition: Edition::from_session(),
ambiguous_block_expr_parse: Lock::new(FxHashMap::default()),
param_attr_spans: Lock::new(Vec::new()),
+ let_chains_spans: Lock::new(Vec::new()),
}
}
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index ba5d1d0..e19eab3 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -54,7 +54,9 @@
/// operation token that followed it, but that the parser cannot identify without further
/// analysis.
pub ambiguous_block_expr_parse: Lock<FxHashMap<Span, Span>>,
- pub param_attr_spans: Lock<Vec<Span>>
+ pub param_attr_spans: Lock<Vec<Span>>,
+ // Places where `let` exprs were used and should be feature gated according to `let_chains`.
+ pub let_chains_spans: Lock<Vec<Span>>,
}
impl ParseSess {
@@ -81,6 +83,7 @@
edition: Edition::from_session(),
ambiguous_block_expr_parse: Lock::new(FxHashMap::default()),
param_attr_spans: Lock::new(Vec::new()),
+ let_chains_spans: Lock::new(Vec::new()),
}
}
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index fa697e0..a1440f2 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -3,7 +3,7 @@
use crate::ast::{AngleBracketedArgs, ParenthesizedArgs, AttrStyle, BareFnTy};
use crate::ast::{GenericBound, TraitBoundModifier};
use crate::ast::Unsafety;
-use crate::ast::{Mod, AnonConst, Arg, Arm, Guard, Attribute, BindingMode, TraitItemKind};
+use crate::ast::{Mod, AnonConst, Arg, Arm, Attribute, BindingMode, TraitItemKind};
use crate::ast::Block;
use crate::ast::{BlockCheckMode, CaptureBy, Movability};
use crate::ast::{Constness, Crate};
@@ -41,7 +41,7 @@
use crate::parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
use crate::parse::token::{Token, TokenKind, DelimToken};
use crate::parse::{new_sub_parser_from_file, ParseSess, Directory, DirectoryOwnership};
-use crate::util::parser::{AssocOp, Fixity};
+use crate::util::parser::{AssocOp, Fixity, prec_let_scrutinee_needs_par};
use crate::print::pprust;
use crate::ptr::P;
use crate::parse::PResult;
@@ -2215,13 +2215,8 @@
} else {
ex = ExprKind::Yield(None);
}
- } else if self.token.is_keyword(kw::Let) {
- // Catch this syntax error here, instead of in `parse_ident`, so
- // that we can explicitly mention that let is not to be used as an expression
- let mut db = self.fatal("expected expression, found statement (`let`)");
- db.span_label(self.token.span, "expected expression");
- db.note("variable declaration using `let` is a statement");
- return Err(db);
+ } else if self.eat_keyword(kw::Let) {
+ return self.parse_let_expr(attrs);
} else if is_span_rust_2018 && self.eat_keyword(kw::Await) {
let (await_hi, e_kind) = self.parse_await_macro_or_alt(lo, self.prev_span)?;
hi = await_hi;
@@ -2483,15 +2478,13 @@
attrs.extend::<Vec<_>>(expr.attrs.into());
expr.attrs = attrs;
match expr.node {
- ExprKind::If(..) | ExprKind::IfLet(..) => {
- if !expr.attrs.is_empty() {
- // Just point to the first attribute in there...
- let span = expr.attrs[0].span;
+ ExprKind::If(..) if !expr.attrs.is_empty() => {
+ // Just point to the first attribute in there...
+ let span = expr.attrs[0].span;
- self.span_err(span,
- "attributes are not yet allowed on `if` \
- expressions");
- }
+ self.span_err(span,
+ "attributes are not yet allowed on `if` \
+ expressions");
}
_ => {}
}
@@ -3161,13 +3154,10 @@
}
}
- /// Parses an `if` or `if let` expression (`if` token already eaten).
+ /// Parses an `if` expression (`if` token already eaten).
fn parse_if_expr(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
- if self.check_keyword(kw::Let) {
- return self.parse_if_let_expr(attrs);
- }
let lo = self.prev_span;
- let cond = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
+ let cond = self.parse_cond_expr()?;
// Verify that the parsed `if` condition makes sense as a condition. If it is a block, then
// verify that the last statement is either an implicit return (no `;`) or an explicit
@@ -3197,22 +3187,32 @@
Ok(self.mk_expr(lo.to(hi), ExprKind::If(cond, thn, els), attrs))
}
- /// Parses an `if let` expression (`if` token already eaten).
- fn parse_if_let_expr(&mut self, attrs: ThinVec<Attribute>)
- -> PResult<'a, P<Expr>> {
+ /// Parse the condition of a `if`- or `while`-expression
+ fn parse_cond_expr(&mut self) -> PResult<'a, P<Expr>> {
+ let cond = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
+
+ if let ExprKind::Let(..) = cond.node {
+ // Remove the last feature gating of a `let` expression since it's stable.
+ let last = self.sess.let_chains_spans.borrow_mut().pop();
+ debug_assert_eq!(cond.span, last.unwrap());
+ }
+
+ Ok(cond)
+ }
+
+ /// Parses a `let $pats = $expr` pseudo-expression.
+ /// The `let` token has already been eaten.
+ fn parse_let_expr(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
let lo = self.prev_span;
- self.expect_keyword(kw::Let)?;
let pats = self.parse_pats()?;
self.expect(&token::Eq)?;
- let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
- let thn = self.parse_block()?;
- let (hi, els) = if self.eat_keyword(kw::Else) {
- let expr = self.parse_else_expr()?;
- (expr.span, Some(expr))
- } else {
- (thn.span, None)
- };
- Ok(self.mk_expr(lo.to(hi), ExprKind::IfLet(pats, expr, thn, els), attrs))
+ let expr = self.with_res(
+ Restrictions::NO_STRUCT_LITERAL,
+ |this| this.parse_assoc_expr_with(1 + prec_let_scrutinee_needs_par(), None.into())
+ )?;
+ let span = lo.to(expr.span);
+ self.sess.let_chains_spans.borrow_mut().push(span);
+ Ok(self.mk_expr(span, ExprKind::Let(pats, expr), attrs))
}
/// Parses `move |args| expr`.
@@ -3299,28 +3299,11 @@
fn parse_while_expr(&mut self, opt_label: Option<Label>,
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
- if self.token.is_keyword(kw::Let) {
- return self.parse_while_let_expr(opt_label, span_lo, attrs);
- }
- let cond = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
+ let cond = self.parse_cond_expr()?;
let (iattrs, body) = self.parse_inner_attrs_and_block()?;
attrs.extend(iattrs);
let span = span_lo.to(body.span);
- return Ok(self.mk_expr(span, ExprKind::While(cond, body, opt_label), attrs));
- }
-
- /// Parses a `while let` expression (`while` token already eaten).
- fn parse_while_let_expr(&mut self, opt_label: Option<Label>,
- span_lo: Span,
- mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
- self.expect_keyword(kw::Let)?;
- let pats = self.parse_pats()?;
- self.expect(&token::Eq)?;
- let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
- let (iattrs, body) = self.parse_inner_attrs_and_block()?;
- attrs.extend(iattrs);
- let span = span_lo.to(body.span);
- return Ok(self.mk_expr(span, ExprKind::WhileLet(pats, expr, body, opt_label), attrs));
+ Ok(self.mk_expr(span, ExprKind::While(cond, body, opt_label), attrs))
}
// parse `loop {...}`, `loop` token already eaten
@@ -3413,7 +3396,7 @@
let lo = self.token.span;
let pats = self.parse_pats()?;
let guard = if self.eat_keyword(kw::If) {
- Some(Guard::If(self.parse_expr()?))
+ Some(self.parse_expr()?)
} else {
None
};
@@ -6963,36 +6946,34 @@
/// Parses the part of an enum declaration following the `{`.
fn parse_enum_def(&mut self, _generics: &ast::Generics) -> PResult<'a, EnumDef> {
let mut variants = Vec::new();
- let mut any_disr = vec![];
while self.token != token::CloseDelim(token::Brace) {
let variant_attrs = self.parse_outer_attributes()?;
let vlo = self.token.span;
- let struct_def;
- let mut disr_expr = None;
self.eat_bad_pub();
let ident = self.parse_ident()?;
- if self.check(&token::OpenDelim(token::Brace)) {
+
+ let struct_def = if self.check(&token::OpenDelim(token::Brace)) {
// Parse a struct variant.
let (fields, recovered) = self.parse_record_struct_body()?;
- struct_def = VariantData::Struct(fields, recovered);
+ VariantData::Struct(fields, recovered)
} else if self.check(&token::OpenDelim(token::Paren)) {
- struct_def = VariantData::Tuple(
+ VariantData::Tuple(
self.parse_tuple_struct_body()?,
ast::DUMMY_NODE_ID,
- );
- } else if self.eat(&token::Eq) {
- disr_expr = Some(AnonConst {
+ )
+ } else {
+ VariantData::Unit(ast::DUMMY_NODE_ID)
+ };
+
+ let disr_expr = if self.eat(&token::Eq) {
+ Some(AnonConst {
id: ast::DUMMY_NODE_ID,
value: self.parse_expr()?,
- });
- if let Some(sp) = disr_expr.as_ref().map(|c| c.value.span) {
- any_disr.push(sp);
- }
- struct_def = VariantData::Unit(ast::DUMMY_NODE_ID);
+ })
} else {
- struct_def = VariantData::Unit(ast::DUMMY_NODE_ID);
- }
+ None
+ };
let vr = ast::Variant_ {
ident,
@@ -7020,7 +7001,6 @@
}
}
self.expect(&token::CloseDelim(token::Brace))?;
- self.maybe_report_invalid_custom_discriminants(any_disr, &variants);
Ok(ast::EnumDef { variants })
}
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index cc34883..ebd0dec 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -135,6 +135,7 @@
kw::False,
kw::For,
kw::If,
+ kw::Let,
kw::Loop,
kw::Match,
kw::Move,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 0aac4f8..3f05992 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1715,6 +1715,21 @@
self.ann.post(self, AnnNode::Block(blk))
}
+ /// Print a `let pats = scrutinee` expression.
+ pub fn print_let(&mut self, pats: &[P<ast::Pat>], scrutinee: &ast::Expr) -> io::Result<()> {
+ self.s.word("let ")?;
+
+ self.print_pats(pats)?;
+ self.s.space()?;
+
+ self.word_space("=")?;
+ self.print_expr_cond_paren(
+ scrutinee,
+ Self::cond_needs_par(scrutinee)
+ || parser::needs_par_as_let_scrutinee(scrutinee.precedence().order())
+ )
+ }
+
fn print_else(&mut self, els: Option<&ast::Expr>) -> io::Result<()> {
match els {
Some(_else) => {
@@ -1729,19 +1744,6 @@
self.print_block(then)?;
self.print_else(e.as_ref().map(|e| &**e))
}
- // Another `else if let` block.
- ast::ExprKind::IfLet(ref pats, ref expr, ref then, ref e) => {
- self.cbox(INDENT_UNIT - 1)?;
- self.ibox(0)?;
- self.s.word(" else if let ")?;
- self.print_pats(pats)?;
- self.s.space()?;
- self.word_space("=")?;
- self.print_expr_as_cond(expr)?;
- self.s.space()?;
- self.print_block(then)?;
- self.print_else(e.as_ref().map(|e| &**e))
- }
// Final `else` block.
ast::ExprKind::Block(ref b, _) => {
self.cbox(INDENT_UNIT - 1)?;
@@ -1762,20 +1764,10 @@
pub fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block,
elseopt: Option<&ast::Expr>) -> io::Result<()> {
self.head("if")?;
+
self.print_expr_as_cond(test)?;
self.s.space()?;
- self.print_block(blk)?;
- self.print_else(elseopt)
- }
- pub fn print_if_let(&mut self, pats: &[P<ast::Pat>], expr: &ast::Expr, blk: &ast::Block,
- elseopt: Option<&ast::Expr>) -> io::Result<()> {
- self.head("if let")?;
- self.print_pats(pats)?;
- self.s.space()?;
- self.word_space("=")?;
- self.print_expr_as_cond(expr)?;
- self.s.space()?;
self.print_block(blk)?;
self.print_else(elseopt)
}
@@ -1807,21 +1799,18 @@
}
pub fn print_expr_maybe_paren(&mut self, expr: &ast::Expr, prec: i8) -> io::Result<()> {
- let needs_par = expr.precedence().order() < prec;
- if needs_par {
- self.popen()?;
- }
- self.print_expr(expr)?;
- if needs_par {
- self.pclose()?;
- }
- Ok(())
+ self.print_expr_cond_paren(expr, expr.precedence().order() < prec)
}
/// Print an expr using syntax that's acceptable in a condition position, such as the `cond` in
/// `if cond { ... }`.
pub fn print_expr_as_cond(&mut self, expr: &ast::Expr) -> io::Result<()> {
- let needs_par = match expr.node {
+ self.print_expr_cond_paren(expr, Self::cond_needs_par(expr))
+ }
+
+ /// Does `expr` need parenthesis when printed in a condition position?
+ fn cond_needs_par(expr: &ast::Expr) -> bool {
+ match expr.node {
// These cases need parens due to the parse error observed in #26461: `if return {}`
// parses as the erroneous construct `if (return {})`, not `if (return) {}`.
ast::ExprKind::Closure(..) |
@@ -1829,8 +1818,11 @@
ast::ExprKind::Break(..) => true,
_ => parser::contains_exterior_struct_lit(expr),
- };
+ }
+ }
+ /// Print `expr` or `(expr)` when `needs_par` holds.
+ fn print_expr_cond_paren(&mut self, expr: &ast::Expr, needs_par: bool) -> io::Result<()> {
if needs_par {
self.popen()?;
}
@@ -1962,6 +1954,17 @@
// of `(x as i32) < ...`. We need to convince it _not_ to do that.
(&ast::ExprKind::Cast { .. }, ast::BinOpKind::Lt) |
(&ast::ExprKind::Cast { .. }, ast::BinOpKind::Shl) => parser::PREC_FORCE_PAREN,
+ // We are given `(let _ = a) OP b`.
+ //
+ // - When `OP <= LAnd` we should print `let _ = a OP b` to avoid redundant parens
+ // as the parser will interpret this as `(let _ = a) OP b`.
+ //
+ // - Otherwise, e.g. when we have `(let a = b) < c` in AST,
+ // parens are required since the parser would interpret `let a = b < c` as
+ // `let a = (b < c)`. To achieve this, we force parens.
+ (&ast::ExprKind::Let { .. }, _) if !parser::needs_par_as_let_scrutinee(prec) => {
+ parser::PREC_FORCE_PAREN
+ }
_ => left_prec,
};
@@ -2052,12 +2055,12 @@
self.word_space(":")?;
self.print_type(ty)?;
}
+ ast::ExprKind::Let(ref pats, ref scrutinee) => {
+ self.print_let(pats, scrutinee)?;
+ }
ast::ExprKind::If(ref test, ref blk, ref elseopt) => {
self.print_if(test, blk, elseopt.as_ref().map(|e| &**e))?;
}
- ast::ExprKind::IfLet(ref pats, ref expr, ref blk, ref elseopt) => {
- self.print_if_let(pats, expr, blk, elseopt.as_ref().map(|e| &**e))?;
- }
ast::ExprKind::While(ref test, ref blk, opt_label) => {
if let Some(label) = opt_label {
self.print_ident(label.ident)?;
@@ -2068,19 +2071,6 @@
self.s.space()?;
self.print_block_with_attrs(blk, attrs)?;
}
- ast::ExprKind::WhileLet(ref pats, ref expr, ref blk, opt_label) => {
- if let Some(label) = opt_label {
- self.print_ident(label.ident)?;
- self.word_space(":")?;
- }
- self.head("while let")?;
- self.print_pats(pats)?;
- self.s.space()?;
- self.word_space("=")?;
- self.print_expr_as_cond(expr)?;
- self.s.space()?;
- self.print_block_with_attrs(blk, attrs)?;
- }
ast::ExprKind::ForLoop(ref pat, ref iter, ref blk, opt_label) => {
if let Some(label) = opt_label {
self.print_ident(label.ident)?;
@@ -2663,14 +2653,10 @@
self.print_outer_attributes(&arm.attrs)?;
self.print_pats(&arm.pats)?;
self.s.space()?;
- if let Some(ref g) = arm.guard {
- match g {
- ast::Guard::If(ref e) => {
- self.word_space("if")?;
- self.print_expr(e)?;
- self.s.space()?;
- }
- }
+ if let Some(ref e) = arm.guard {
+ self.word_space("if")?;
+ self.print_expr(e)?;
+ self.s.space()?;
}
self.word_space("=>")?;
diff --git a/src/libsyntax/util/parser.rs b/src/libsyntax/util/parser.rs
index fcecee8..1e52186 100644
--- a/src/libsyntax/util/parser.rs
+++ b/src/libsyntax/util/parser.rs
@@ -260,6 +260,7 @@
Box,
AddrOf,
+ Let,
Unary,
Call,
@@ -277,9 +278,7 @@
Path,
Paren,
If,
- IfLet,
While,
- WhileLet,
ForLoop,
Loop,
Match,
@@ -318,6 +317,11 @@
// Unary, prefix
ExprPrecedence::Box |
ExprPrecedence::AddrOf |
+ // Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
+ // However, this is not exactly right. When `let _ = a` is the LHS of a binop we
+ // need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
+ // but we need to print `(let _ = a) < b` as-is with parens.
+ ExprPrecedence::Let |
ExprPrecedence::Unary => PREC_PREFIX,
// Unary, postfix
@@ -338,9 +342,7 @@
ExprPrecedence::Path |
ExprPrecedence::Paren |
ExprPrecedence::If |
- ExprPrecedence::IfLet |
ExprPrecedence::While |
- ExprPrecedence::WhileLet |
ExprPrecedence::ForLoop |
ExprPrecedence::Loop |
ExprPrecedence::Match |
@@ -353,6 +355,19 @@
}
}
+/// In `let p = e`, operators with precedence `<=` this one requires parenthesis in `e`.
+crate fn prec_let_scrutinee_needs_par() -> usize {
+ AssocOp::LAnd.precedence()
+}
+
+/// Suppose we have `let _ = e` and the `order` of `e`.
+/// Is the `order` such that `e` in `let _ = e` needs parenthesis when it is on the RHS?
+///
+/// Conversely, suppose that we have `(let _ = a) OP b` and `order` is that of `OP`.
+/// Can we print this as `let _ = a OP b`?
+crate fn needs_par_as_let_scrutinee(order: i8) -> bool {
+ order <= prec_let_scrutinee_needs_par() as i8
+}
/// Expressions that syntactically contain an "exterior" struct literal i.e., not surrounded by any
/// parens or other delimiters, e.g., `X { y: 1 }`, `X { y: 1 }.method()`, `foo == X { y: 1 }` and
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 8132024..9ec9550 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -719,6 +719,10 @@
visitor.visit_expr(subexpression);
visitor.visit_ty(typ)
}
+ ExprKind::Let(ref pats, ref scrutinee) => {
+ walk_list!(visitor, visit_pat, pats);
+ visitor.visit_expr(scrutinee);
+ }
ExprKind::If(ref head_expression, ref if_block, ref optional_else) => {
visitor.visit_expr(head_expression);
visitor.visit_block(if_block);
@@ -729,18 +733,6 @@
visitor.visit_expr(subexpression);
visitor.visit_block(block);
}
- ExprKind::IfLet(ref pats, ref subexpression, ref if_block, ref optional_else) => {
- walk_list!(visitor, visit_pat, pats);
- visitor.visit_expr(subexpression);
- visitor.visit_block(if_block);
- walk_list!(visitor, visit_expr, optional_else);
- }
- ExprKind::WhileLet(ref pats, ref subexpression, ref block, ref opt_label) => {
- walk_list!(visitor, visit_label, opt_label);
- walk_list!(visitor, visit_pat, pats);
- visitor.visit_expr(subexpression);
- visitor.visit_block(block);
- }
ExprKind::ForLoop(ref pattern, ref subexpression, ref block, ref opt_label) => {
walk_list!(visitor, visit_label, opt_label);
visitor.visit_pat(pattern);
@@ -834,10 +826,8 @@
pub fn walk_arm<'a, V: Visitor<'a>>(visitor: &mut V, arm: &'a Arm) {
walk_list!(visitor, visit_pat, &arm.pats);
- if let Some(ref g) = &arm.guard {
- match g {
- Guard::If(ref e) => visitor.visit_expr(e),
- }
+ if let Some(ref e) = &arm.guard {
+ visitor.visit_expr(e);
}
visitor.visit_expr(&arm.body);
walk_list!(visitor, visit_attribute, &arm.attrs);
diff --git a/src/libsyntax_ext/deriving/bounds.rs b/src/libsyntax_ext/deriving/bounds.rs
index c7b805e..d5b8a00 100644
--- a/src/libsyntax_ext/deriving/bounds.rs
+++ b/src/libsyntax_ext/deriving/bounds.rs
@@ -6,14 +6,6 @@
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax_pos::Span;
-pub fn expand_deriving_unsafe_bound(cx: &mut ExtCtxt<'_>,
- span: Span,
- _: &MetaItem,
- _: &Annotatable,
- _: &mut dyn FnMut(Annotatable)) {
- cx.span_err(span, "this unsafe trait should be implemented explicitly");
-}
-
pub fn expand_deriving_copy(cx: &mut ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs
index 1fe6094..aa9913d 100644
--- a/src/libsyntax_ext/deriving/mod.rs
+++ b/src/libsyntax_ext/deriving/mod.rs
@@ -88,7 +88,7 @@
)
}),
);
- )*
+ )+
}
}
}
@@ -111,8 +111,6 @@
"Default" => default::expand_deriving_default,
- "Send" => bounds::expand_deriving_unsafe_bound,
- "Sync" => bounds::expand_deriving_unsafe_bound,
"Copy" => bounds::expand_deriving_copy,
// deprecated
diff --git a/src/libsyntax_ext/proc_macro_server.rs b/src/libsyntax_ext/proc_macro_server.rs
index b5d5a38..c9d99e5 100644
--- a/src/libsyntax_ext/proc_macro_server.rs
+++ b/src/libsyntax_ext/proc_macro_server.rs
@@ -70,7 +70,7 @@
macro_rules! tt {
($ty:ident { $($field:ident $(: $value:expr)*),+ $(,)? }) => (
TokenTree::$ty(self::$ty {
- $($field $(: $value)*,)*
+ $($field $(: $value)*,)+
span,
})
);
diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs
index c25e65e..bd9a906 100644
--- a/src/libsyntax_pos/symbol.rs
+++ b/src/libsyntax_pos/symbol.rs
@@ -135,6 +135,7 @@
always,
and,
any,
+ arbitrary_enum_discriminant,
arbitrary_self_types,
Arguments,
ArgumentV1,
@@ -354,6 +355,7 @@
label_break_value,
lang,
lang_items,
+ let_chains,
lhs,
lib,
lifetime,
diff --git a/src/llvm-project b/src/llvm-project
index 788592f..1bbe0b3 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 788592fb2740d560d0614a77035b319b9d07aa38
+Subproject commit 1bbe0b3e1d756116cbf1fcf049555066ef929008
diff --git a/src/test/incremental/issue-59523-on-implemented-is-not-unused.rs b/src/test/incremental/issue-59523-on-implemented-is-not-unused.rs
index 3d16a15..afc0862 100644
--- a/src/test/incremental/issue-59523-on-implemented-is-not-unused.rs
+++ b/src/test/incremental/issue-59523-on-implemented-is-not-unused.rs
@@ -2,7 +2,7 @@
// rustc_on_unimplemented, but with this bug we are seeing it fire (on
// subsequent runs) if incremental compilation is enabled.
-// revisions: rpass1 rpass2
+// revisions: cfail1 cfail2
// compile-pass
#![feature(on_unimplemented)]
diff --git a/src/test/incremental/issue-59524-layout-scalar-valid-range-is-not-unused.rs b/src/test/incremental/issue-59524-layout-scalar-valid-range-is-not-unused.rs
index e4802cb..37bd8d0 100644
--- a/src/test/incremental/issue-59524-layout-scalar-valid-range-is-not-unused.rs
+++ b/src/test/incremental/issue-59524-layout-scalar-valid-range-is-not-unused.rs
@@ -3,7 +3,7 @@
// seeing it fire (on subsequent runs) if incremental compilation is
// enabled.
-// revisions: rpass1 rpass2
+// revisions: cfail1 cfail2
// compile-pass
#![feature(rustc_attrs)]
diff --git a/src/test/incremental/issue-61530.rs b/src/test/incremental/issue-61530.rs
new file mode 100644
index 0000000..06b2957
--- /dev/null
+++ b/src/test/incremental/issue-61530.rs
@@ -0,0 +1,17 @@
+#![feature(repr_simd, platform_intrinsics)]
+
+// revisions:rpass1 rpass2
+
+#[repr(simd)]
+struct I32x2(i32, i32);
+
+extern "platform-intrinsic" {
+ fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U;
+}
+
+fn main() {
+ unsafe {
+ let _: I32x2 = simd_shuffle2(I32x2(1, 2), I32x2(3, 4), [0, 0]);
+ let _: I32x2 = simd_shuffle2(I32x2(1, 2), I32x2(3, 4), [0, 0]);
+ }
+}
diff --git a/src/test/incremental/no_mangle.rs b/src/test/incremental/no_mangle.rs
index 1b17886..b1c9b2b 100644
--- a/src/test/incremental/no_mangle.rs
+++ b/src/test/incremental/no_mangle.rs
@@ -1,6 +1,6 @@
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
+// check-pass
// compile-flags: --crate-type cdylib
-// skip-codegen
#![deny(unused_attributes)]
diff --git a/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-box-dyn-error.rs b/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-box-dyn-error.rs
index 5f76caa..796729a 100644
--- a/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-box-dyn-error.rs
+++ b/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-box-dyn-error.rs
@@ -1,4 +1,4 @@
-// compile-pass
+// error-pattern:returned Box<dyn Error> from main()
// failure-status: 1
use std::error::Error;
diff --git a/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-result-box-error_err.rs b/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-result-box-error_err.rs
index bd47a97..2f3a73a 100644
--- a/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-result-box-error_err.rs
+++ b/src/test/run-fail/rfc-1937-termination-trait/termination-trait-for-result-box-error_err.rs
@@ -1,4 +1,4 @@
-// compile-pass
+// error-pattern:returned Box<Error> from main()
// failure-status: 1
use std::io::{Error, ErrorKind};
diff --git a/src/test/run-pass-fulldeps/auxiliary/issue-40001-plugin.rs b/src/test/run-pass-fulldeps/auxiliary/issue-40001-plugin.rs
index 76554ea..64b795a 100644
--- a/src/test/run-pass-fulldeps/auxiliary/issue-40001-plugin.rs
+++ b/src/test/run-pass-fulldeps/auxiliary/issue-40001-plugin.rs
@@ -43,7 +43,7 @@
span: source_map::Span,
id: hir::HirId) {
- let item = match cx.tcx.hir().get_by_hir_id(id) {
+ let item = match cx.tcx.hir().get(id) {
Node::Item(item) => item,
_ => cx.tcx.hir().expect_item(cx.tcx.hir().get_parent_item(id)),
};
diff --git a/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs b/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs
index 7e819e2..5716e6d 100644
--- a/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs
+++ b/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs
@@ -68,7 +68,7 @@
let mut g = |e| f(expr(e));
- for kind in 0 .. 16 {
+ for kind in 0..=19 {
match kind {
0 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Box(e))),
1 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Call(e, vec![]))),
@@ -79,25 +79,26 @@
iter_exprs(depth - 1, &mut |e| g(ExprKind::MethodCall(
seg.clone(), vec![make_x(), e])));
},
- 3 => {
- let op = Spanned { span: DUMMY_SP, node: BinOpKind::Add };
+ 3..=8 => {
+ let op = Spanned {
+ span: DUMMY_SP,
+ node: match kind {
+ 3 => BinOpKind::Add,
+ 4 => BinOpKind::Mul,
+ 5 => BinOpKind::Shl,
+ 6 => BinOpKind::And,
+ 7 => BinOpKind::Or,
+ 8 => BinOpKind::Lt,
+ _ => unreachable!(),
+ }
+ };
iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, e, make_x())));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, make_x(), e)));
},
- 4 => {
- let op = Spanned { span: DUMMY_SP, node: BinOpKind::Mul };
- iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, e, make_x())));
- iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, make_x(), e)));
- },
- 5 => {
- let op = Spanned { span: DUMMY_SP, node: BinOpKind::Shl };
- iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, e, make_x())));
- iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, make_x(), e)));
- },
- 6 => {
+ 9 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Unary(UnOp::Deref, e)));
},
- 7 => {
+ 10 => {
let block = P(Block {
stmts: Vec::new(),
id: DUMMY_NODE_ID,
@@ -106,7 +107,7 @@
});
iter_exprs(depth - 1, &mut |e| g(ExprKind::If(e, block.clone(), None)));
},
- 8 => {
+ 11 => {
let decl = P(FnDecl {
inputs: vec![],
output: FunctionRetTy::Default(DUMMY_SP),
@@ -120,33 +121,41 @@
e,
DUMMY_SP)));
},
- 9 => {
+ 12 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(e, make_x())));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(make_x(), e)));
},
- 10 => {
+ 13 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Field(e, Ident::from_str("f"))));
},
- 11 => {
+ 14 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Range(
Some(e), Some(make_x()), RangeLimits::HalfOpen)));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Range(
Some(make_x()), Some(e), RangeLimits::HalfOpen)));
},
- 12 => {
+ 15 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::AddrOf(Mutability::Immutable, e)));
},
- 13 => {
+ 16 => {
g(ExprKind::Ret(None));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Ret(Some(e))));
},
- 14 => {
+ 17 => {
let path = Path::from_ident(Ident::from_str("S"));
g(ExprKind::Struct(path, vec![], Some(make_x())));
},
- 15 => {
+ 18 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Try(e)));
},
+ 19 => {
+ let ps = vec![P(Pat {
+ id: DUMMY_NODE_ID,
+ node: PatKind::Wild,
+ span: DUMMY_SP,
+ })];
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Let(ps.clone(), e)))
+ },
_ => panic!("bad counter value in iter_exprs"),
}
}
diff --git a/src/test/run-pass/borrowck/issue-62007-assign-box.rs b/src/test/run-pass/borrowck/issue-62007-assign-box.rs
new file mode 100644
index 0000000..f6fbea8
--- /dev/null
+++ b/src/test/run-pass/borrowck/issue-62007-assign-box.rs
@@ -0,0 +1,27 @@
+// run-pass
+
+// Issue #62007: assigning over a deref projection of a box (in this
+// case, `*list = n;`) should be able to kill all borrows of `*list`,
+// so that `*list` can be borrowed on the next iteration through the
+// loop.
+
+#![allow(dead_code)]
+
+struct List<T> {
+ value: T,
+ next: Option<Box<List<T>>>,
+}
+
+fn to_refs<T>(mut list: Box<&mut List<T>>) -> Vec<&mut T> {
+ let mut result = vec![];
+ loop {
+ result.push(&mut list.value);
+ if let Some(n) = list.next.as_mut() {
+ *list = n;
+ } else {
+ return result;
+ }
+ }
+}
+
+fn main() {}
diff --git a/src/test/run-pass/borrowck/issue-62007-assign-field.rs b/src/test/run-pass/borrowck/issue-62007-assign-field.rs
new file mode 100644
index 0000000..5b21c083
--- /dev/null
+++ b/src/test/run-pass/borrowck/issue-62007-assign-field.rs
@@ -0,0 +1,26 @@
+// run-pass
+
+// Issue #62007: assigning over a field projection (`list.0 = n;` in
+// this case) should be able to kill all borrows of `list.0`, so that
+// `list.0` can be borrowed on the next iteration through the loop.
+
+#![allow(dead_code)]
+
+struct List<T> {
+ value: T,
+ next: Option<Box<List<T>>>,
+}
+
+fn to_refs<T>(mut list: (&mut List<T>,)) -> Vec<&mut T> {
+ let mut result = vec![];
+ loop {
+ result.push(&mut (list.0).value);
+ if let Some(n) = (list.0).next.as_mut() {
+ list.0 = n;
+ } else {
+ return result;
+ }
+ }
+}
+
+fn main() {}
diff --git a/src/test/run-pass/compiletest-skip-codegen.rs b/src/test/run-pass/compiletest-skip-codegen.rs
deleted file mode 100644
index 3c0e226..0000000
--- a/src/test/run-pass/compiletest-skip-codegen.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// Test that with the `skip-codegen` option the test isn't executed.
-
-// skip-codegen
-
-fn main() {
- unreachable!();
-}
diff --git a/src/test/run-pass/generator/addassign-yield.rs b/src/test/run-pass/generator/addassign-yield.rs
new file mode 100644
index 0000000..6a41793
--- /dev/null
+++ b/src/test/run-pass/generator/addassign-yield.rs
@@ -0,0 +1,34 @@
+// Regression test for broken MIR error (#61442)
+// Due to the two possible evaluation orders for
+// a '+=' expression (depending on whether or not the 'AddAssign' trait
+// is being used), we were failing to account for all types that might
+// possibly be live across a yield point.
+
+#![feature(generators)]
+
+fn foo() {
+ let _x = static || {
+ let mut s = String::new();
+ s += { yield; "" };
+ };
+
+ let _y = static || {
+ let x = &mut 0;
+ *{ yield; x } += match String::new() { _ => 0 };
+ };
+
+ // Please don't ever actually write something like this
+ let _z = static || {
+ let x = &mut 0;
+ *{
+ let inner = &mut 1;
+ *{ yield (); inner } += match String::new() { _ => 1};
+ yield;
+ x
+ } += match String::new() { _ => 2 };
+ };
+}
+
+fn main() {
+ foo()
+}
diff --git a/src/test/ui/asm/asm-misplaced-option.rs b/src/test/ui/asm/asm-misplaced-option.rs
index 5c202a1..14ff4c2 100644
--- a/src/test/ui/asm/asm-misplaced-option.rs
+++ b/src/test/ui/asm/asm-misplaced-option.rs
@@ -1,3 +1,4 @@
+// check-pass
// ignore-android
// ignore-arm
// ignore-aarch64
@@ -11,14 +12,11 @@
// ignore-mips
// ignore-mips64
-// compile-pass
-// skip-codegen
#![feature(asm)]
-#![allow(dead_code, non_upper_case_globals)]
#[cfg(any(target_arch = "x86",
target_arch = "x86_64"))]
-pub fn main() {
+fn main() {
// assignment not dead
let mut x: isize = 0;
unsafe {
diff --git a/src/test/ui/asm/asm-misplaced-option.stderr b/src/test/ui/asm/asm-misplaced-option.stderr
index 39d88e3..3d4b28c 100644
--- a/src/test/ui/asm/asm-misplaced-option.stderr
+++ b/src/test/ui/asm/asm-misplaced-option.stderr
@@ -1,11 +1,11 @@
warning: unrecognized option
- --> $DIR/asm-misplaced-option.rs:26:64
+ --> $DIR/asm-misplaced-option.rs:24:64
|
LL | asm!("mov $1, $0" : "=r"(x) : "r"(5_usize), "0"(x) : : "cc");
| ^^^^
warning: expected a clobber, found an option
- --> $DIR/asm-misplaced-option.rs:33:80
+ --> $DIR/asm-misplaced-option.rs:31:80
|
LL | asm!("add $2, $1; mov $1, $0" : "=r"(x) : "r"(x), "r"(8_usize) : "cc", "volatile");
| ^^^^^^^^^^
diff --git a/src/test/ui/associated-types/cache/chrono-scan.rs b/src/test/ui/associated-types/cache/chrono-scan.rs
index 00d47c9..8ddd347 100644
--- a/src/test/ui/associated-types/cache/chrono-scan.rs
+++ b/src/test/ui/associated-types/cache/chrono-scan.rs
@@ -1,10 +1,10 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
+
pub type ParseResult<T> = Result<T, ()>;
-pub enum Item<'a> { Literal(&'a str),
- }
+pub enum Item<'a> {
+ Literal(&'a str)
+}
pub fn colon_or_space(s: &str) -> ParseResult<&str> {
unimplemented!()
@@ -20,10 +20,9 @@
macro_rules! try_consume {
($e:expr) => ({ let (s_, v) = try!($e); s = s_; v })
}
- let offset = try_consume!(timezone_offset_zulu(s.trim_left(), colon_or_space));
- let offset = try_consume!(timezone_offset_zulu(s.trim_left(), colon_or_space));
+ let offset = try_consume!(timezone_offset_zulu(s.trim_start(), colon_or_space));
+ let offset = try_consume!(timezone_offset_zulu(s.trim_start(), colon_or_space));
Ok(())
}
-
-fn main() { }
+fn main() {}
diff --git a/src/test/ui/associated-types/cache/elision.rs b/src/test/ui/associated-types/cache/elision.rs
index 2b49cd3..b3e1ec8 100644
--- a/src/test/ui/associated-types/cache/elision.rs
+++ b/src/test/ui/associated-types/cache/elision.rs
@@ -1,10 +1,9 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
// Check that you are allowed to implement using elision but write
// trait without elision (a bug in this cropped up during
// bootstrapping, so this is a regression test).
+// check-pass
+
pub struct SplitWhitespace<'a> {
x: &'a u8
}
diff --git a/src/test/ui/bad/bad-lint-cap3.rs b/src/test/ui/bad/bad-lint-cap3.rs
index 4cfa0b2..c381058 100644
--- a/src/test/ui/bad/bad-lint-cap3.rs
+++ b/src/test/ui/bad/bad-lint-cap3.rs
@@ -1,10 +1,9 @@
+// check-pass
// compile-flags: --cap-lints warn
#![warn(unused)]
#![deny(warnings)]
-// compile-pass
-// skip-codegen
-use std::option; //~ WARN
+use std::option; //~ WARN
fn main() {}
diff --git a/src/test/ui/bad/bad-lint-cap3.stderr b/src/test/ui/bad/bad-lint-cap3.stderr
index a1ea3f7..b898d79 100644
--- a/src/test/ui/bad/bad-lint-cap3.stderr
+++ b/src/test/ui/bad/bad-lint-cap3.stderr
@@ -5,7 +5,7 @@
| ^^^^^^^^^^^
|
note: lint level defined here
- --> $DIR/bad-lint-cap3.rs:4:9
+ --> $DIR/bad-lint-cap3.rs:5:9
|
LL | #![deny(warnings)]
| ^^^^^^^^
diff --git a/src/test/ui/coherence/coherence-projection-ok-orphan.rs b/src/test/ui/coherence/coherence-projection-ok-orphan.rs
index 652b438..b34c31d 100644
--- a/src/test/ui/coherence/coherence-projection-ok-orphan.rs
+++ b/src/test/ui/coherence/coherence-projection-ok-orphan.rs
@@ -1,11 +1,10 @@
-// compile-pass
-// skip-codegen
+// Here we do not get a coherence conflict because `Baz: Iterator`
+// does not hold and (due to the orphan rules), we can rely on that.
+
+// check-pass
// revisions: old re
#![cfg_attr(re, feature(re_rebalance_coherence))]
-#![allow(dead_code)]
-// Here we do not get a coherence conflict because `Baz: Iterator`
-// does not hold and (due to the orphan rules), we can rely on that.
pub trait Foo<P> {}
@@ -18,5 +17,4 @@
impl<A:Iterator> Foo<A::Item> for A { }
-
fn main() {}
diff --git a/src/test/ui/coherence/coherence-projection-ok.rs b/src/test/ui/coherence/coherence-projection-ok.rs
index f759a9e..f4f5ca6 100644
--- a/src/test/ui/coherence/coherence-projection-ok.rs
+++ b/src/test/ui/coherence/coherence-projection-ok.rs
@@ -1,8 +1,8 @@
-// compile-pass
-// skip-codegen
+// check-pass
// revisions: old re
#![cfg_attr(re, feature(re_rebalance_coherence))]
+
pub trait Foo<P> {}
pub trait Bar {
@@ -17,5 +17,4 @@
type Output = u32;
}
-
fn main() {}
diff --git a/src/test/ui/coherence/coherence_copy_like_err_fundamental_struct_ref.rs b/src/test/ui/coherence/coherence_copy_like_err_fundamental_struct_ref.rs
index bd8317e..0d67780 100644
--- a/src/test/ui/coherence/coherence_copy_like_err_fundamental_struct_ref.rs
+++ b/src/test/ui/coherence/coherence_copy_like_err_fundamental_struct_ref.rs
@@ -1,13 +1,11 @@
// Test that we are able to introduce a negative constraint that
// `MyType: !MyTrait` along with other "fundamental" wrappers.
+// check-pass
// aux-build:coherence_copy_like_lib.rs
-// compile-pass
-// skip-codegen
// revisions: old re
#![cfg_attr(re, feature(re_rebalance_coherence))]
-#![allow(dead_code)]
extern crate coherence_copy_like_lib as lib;
@@ -23,5 +21,4 @@
// Huzzah.
impl<'a> MyTrait for lib::MyFundamentalStruct<&'a MyType> { }
-
fn main() { }
diff --git a/src/test/ui/coherence/coherence_local.rs b/src/test/ui/coherence/coherence_local.rs
index cac45b0..3eab6e0 100644
--- a/src/test/ui/coherence/coherence_local.rs
+++ b/src/test/ui/coherence/coherence_local.rs
@@ -1,13 +1,11 @@
// Test that we are able to introduce a negative constraint that
// `MyType: !MyTrait` along with other "fundamental" wrappers.
+// check-pass
// aux-build:coherence_copy_like_lib.rs
-// compile-pass
-// skip-codegen
// revisions: old re
#![cfg_attr(re, feature(re_rebalance_coherence))]
-#![allow(dead_code)]
extern crate coherence_copy_like_lib as lib;
@@ -22,5 +20,4 @@
impl lib::MyCopy for lib::MyFundamentalStruct<MyType> { }
impl lib::MyCopy for lib::MyFundamentalStruct<Box<MyType>> { }
-
-fn main() { }
+fn main() {}
diff --git a/src/test/ui/coherence/coherence_local_ref.rs b/src/test/ui/coherence/coherence_local_ref.rs
index a52510b..dff684c 100644
--- a/src/test/ui/coherence/coherence_local_ref.rs
+++ b/src/test/ui/coherence/coherence_local_ref.rs
@@ -1,13 +1,11 @@
// Test that we are able to introduce a negative constraint that
// `MyType: !MyTrait` along with other "fundamental" wrappers.
+// check-pass
// aux-build:coherence_copy_like_lib.rs
-// compile-pass
-// skip-codegen
// revisions: old re
#![cfg_attr(re, feature(re_rebalance_coherence))]
-#![allow(dead_code)]
extern crate coherence_copy_like_lib as lib;
@@ -16,5 +14,4 @@
// naturally, legal
impl lib::MyCopy for MyType { }
-
fn main() { }
diff --git a/src/test/ui/conditional-compilation/cfg-attr-empty-is-unused.rs b/src/test/ui/conditional-compilation/cfg-attr-empty-is-unused.rs
new file mode 100644
index 0000000..4c96d6e
--- /dev/null
+++ b/src/test/ui/conditional-compilation/cfg-attr-empty-is-unused.rs
@@ -0,0 +1,13 @@
+// Check that `#[cfg_attr($PREDICATE,)]` triggers the `unused_attribute` lint.
+
+// compile-flags: --cfg TRUE
+
+#![deny(unused)]
+
+#[cfg_attr(FALSE,)] //~ ERROR unused attribute
+fn _f() {}
+
+#[cfg_attr(TRUE,)] //~ ERROR unused attribute
+fn _g() {}
+
+fn main() {}
diff --git a/src/test/ui/conditional-compilation/cfg-attr-empty-is-unused.stderr b/src/test/ui/conditional-compilation/cfg-attr-empty-is-unused.stderr
new file mode 100644
index 0000000..cd3563e
--- /dev/null
+++ b/src/test/ui/conditional-compilation/cfg-attr-empty-is-unused.stderr
@@ -0,0 +1,21 @@
+error: unused attribute
+ --> $DIR/cfg-attr-empty-is-unused.rs:7:1
+ |
+LL | #[cfg_attr(FALSE,)]
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+note: lint level defined here
+ --> $DIR/cfg-attr-empty-is-unused.rs:5:9
+ |
+LL | #![deny(unused)]
+ | ^^^^^^
+ = note: #[deny(unused_attributes)] implied by #[deny(unused)]
+
+error: unused attribute
+ --> $DIR/cfg-attr-empty-is-unused.rs:10:1
+ |
+LL | #[cfg_attr(TRUE,)]
+ | ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/src/test/ui/conditional-compilation/cfg_attr_path.rs b/src/test/ui/conditional-compilation/cfg_attr_path.rs
index 9e9ff66..efb718b 100644
--- a/src/test/ui/conditional-compilation/cfg_attr_path.rs
+++ b/src/test/ui/conditional-compilation/cfg_attr_path.rs
@@ -1,13 +1,12 @@
-// compile-pass
-// skip-codegen
-#![allow(dead_code)]
+// check-pass
+
#![deny(unused_attributes)] // c.f #35584
+
mod auxiliary {
#[cfg_attr(any(), path = "nonexistent_file.rs")] pub mod namespaced_enums;
#[cfg_attr(all(), path = "namespaced_enums.rs")] pub mod nonexistent_file;
}
-
fn main() {
let _ = auxiliary::namespaced_enums::Foo::A;
let _ = auxiliary::nonexistent_file::Foo::A;
diff --git a/src/test/ui/consts/const-eval/const_transmute.rs b/src/test/ui/consts/const-eval/const_transmute.rs
index 4726f9d..0e0e003 100644
--- a/src/test/ui/consts/const-eval/const_transmute.rs
+++ b/src/test/ui/consts/const-eval/const_transmute.rs
@@ -1,4 +1,3 @@
-// compile-pass
// run-pass
#![feature(const_fn_union)]
diff --git a/src/test/ui/consts/const-eval/enum_discr.rs b/src/test/ui/consts/const-eval/enum_discr.rs
index 4851e75..e09258f 100644
--- a/src/test/ui/consts/const-eval/enum_discr.rs
+++ b/src/test/ui/consts/const-eval/enum_discr.rs
@@ -1,4 +1,3 @@
-// compile-pass
// run-pass
enum Foo {
diff --git a/src/test/ui/consts/const-eval/union-ub-fat-ptr.stderr b/src/test/ui/consts/const-eval/union-ub-fat-ptr.stderr
index 5048a97..19db90c 100644
--- a/src/test/ui/consts/const-eval/union-ub-fat-ptr.stderr
+++ b/src/test/ui/consts/const-eval/union-ub-fat-ptr.stderr
@@ -42,7 +42,7 @@
--> $DIR/union-ub-fat-ptr.rs:97:1
|
LL | const D: &dyn Trait = unsafe { DynTransmute { repr: DynRepr { ptr: &92, vtable: &3 } }.rust};
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered invalid drop fn in vtable
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered dangling or unaligned vtable pointer or too small vtable
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
@@ -50,7 +50,7 @@
--> $DIR/union-ub-fat-ptr.rs:100:1
|
LL | const E: &dyn Trait = unsafe { DynTransmute { repr2: DynRepr2 { ptr: &92, vtable: &3 } }.rust};
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered invalid drop fn in vtable
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered dangling or unaligned vtable pointer or too small vtable
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
@@ -58,7 +58,7 @@
--> $DIR/union-ub-fat-ptr.rs:103:1
|
LL | const F: &dyn Trait = unsafe { DynTransmute { bad: BadDynRepr { ptr: &92, vtable: 3 } }.rust};
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered non-pointer vtable in fat pointer
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered dangling or unaligned vtable pointer or too small vtable
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
diff --git a/src/test/ui/consts/const-fn-stability-calls-3.rs b/src/test/ui/consts/const-fn-stability-calls-3.rs
index 44bcca8..b831dee 100644
--- a/src/test/ui/consts/const-fn-stability-calls-3.rs
+++ b/src/test/ui/consts/const-fn-stability-calls-3.rs
@@ -1,15 +1,12 @@
// Test use of const fn from another crate without a feature gate.
-// compile-pass
-// skip-codegen
-#![allow(unused_variables)]
+// check-pass
// aux-build:const_fn_lib.rs
extern crate const_fn_lib;
use const_fn_lib::foo;
-
fn main() {
let x = foo(); // use outside a constant is ok
}
diff --git a/src/test/ui/consts/enum-discr-type-err.rs b/src/test/ui/consts/enum-discr-type-err.rs
new file mode 100644
index 0000000..d66c4f4
--- /dev/null
+++ b/src/test/ui/consts/enum-discr-type-err.rs
@@ -0,0 +1,29 @@
+// Test that we mark enum discriminant values as having errors, even when the
+// diagnostic is deduplicated.
+
+struct F;
+struct T;
+
+impl F {
+ const V: i32 = 0;
+}
+
+impl T {
+ const V: i32 = 0;
+}
+
+macro_rules! mac {
+ ($( $v: ident = $s: ident,)*) => {
+ enum E {
+ $( $v = $s::V, )*
+ //~^ ERROR mismatched types
+ }
+ }
+}
+
+mac! {
+ A = F,
+ B = T,
+}
+
+fn main() {}
diff --git a/src/test/ui/consts/enum-discr-type-err.stderr b/src/test/ui/consts/enum-discr-type-err.stderr
new file mode 100644
index 0000000..3c4fac7
--- /dev/null
+++ b/src/test/ui/consts/enum-discr-type-err.stderr
@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+ --> $DIR/enum-discr-type-err.rs:18:21
+ |
+LL | $( $v = $s::V, )*
+ | ^^^^^ expected isize, found i32
+...
+LL | / mac! {
+LL | | A = F,
+LL | | B = T,
+LL | | }
+ | |_- in this macro invocation
+help: you can convert an `i32` to `isize` and panic if the converted value wouldn't fit
+ |
+LL | $( $v = $s::V.try_into().unwrap(), )*
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/consts/issue-62045.rs b/src/test/ui/consts/issue-62045.rs
new file mode 100644
index 0000000..9f41ed9
--- /dev/null
+++ b/src/test/ui/consts/issue-62045.rs
@@ -0,0 +1,5 @@
+// compile-pass
+
+fn main() {
+ assert_eq!(&mut [0; 1][..], &mut []);
+}
diff --git a/src/test/ui/consts/miri_unleashed/mutable_references_ice.rs b/src/test/ui/consts/miri_unleashed/mutable_references_ice.rs
index 4a77534..4fcd89a 100644
--- a/src/test/ui/consts/miri_unleashed/mutable_references_ice.rs
+++ b/src/test/ui/consts/miri_unleashed/mutable_references_ice.rs
@@ -3,6 +3,7 @@
// rustc-env:RUST_BACKTRACE=0
// normalize-stderr-test "note: rustc 1.* running on .*" -> "note: rustc VERSION running on TARGET"
// normalize-stderr-test "note: compiler flags: .*" -> "note: compiler flags: FLAGS"
+// normalize-stderr-test "interpret/intern.rs:[0-9]*:[0-9]*" -> "interpret/intern.rs:LL:CC"
#![allow(const_err)]
diff --git a/src/test/ui/consts/miri_unleashed/mutable_references_ice.stderr b/src/test/ui/consts/miri_unleashed/mutable_references_ice.stderr
index ff2351e..82569e2 100644
--- a/src/test/ui/consts/miri_unleashed/mutable_references_ice.stderr
+++ b/src/test/ui/consts/miri_unleashed/mutable_references_ice.stderr
@@ -1,12 +1,12 @@
warning: skipping const checks
- --> $DIR/mutable_references_ice.rs:26:9
+ --> $DIR/mutable_references_ice.rs:27:9
|
LL | *MUH.x.get() = 99;
| ^^^^^^^^^^^^^^^^^
thread 'rustc' panicked at 'assertion failed: `(left != right)`
left: `Const`,
- right: `Const`: UnsafeCells are not allowed behind references in constants. This should have been prevented statically by const qualification. If this were allowed one would be able to change a constant at one use site and other use sites may arbitrarily decide to change, too.', src/librustc_mir/interpret/intern.rs:127:17
+ right: `Const`: UnsafeCells are not allowed behind references in constants. This should have been prevented statically by const qualification. If this were allowed one would be able to change a constant at one use site and other use sites may arbitrarily decide to change, too.', src/librustc_mir/interpret/intern.rs:LL:CC
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
error: internal compiler error: unexpected panic
diff --git a/src/test/ui/consts/uninhabited-const-issue-61744.rs b/src/test/ui/consts/uninhabited-const-issue-61744.rs
new file mode 100644
index 0000000..21fbbf8
--- /dev/null
+++ b/src/test/ui/consts/uninhabited-const-issue-61744.rs
@@ -0,0 +1,19 @@
+// compile-fail
+
+pub const unsafe fn fake_type<T>() -> T {
+ hint_unreachable()
+}
+
+pub const unsafe fn hint_unreachable() -> ! {
+ fake_type() //~ ERROR any use of this value will cause an error
+}
+
+trait Const {
+ const CONSTANT: i32 = unsafe { fake_type() };
+}
+
+impl <T> Const for T {}
+
+pub fn main() -> () {
+ dbg!(i32::CONSTANT); //~ ERROR erroneous constant used
+}
diff --git a/src/test/ui/consts/uninhabited-const-issue-61744.stderr b/src/test/ui/consts/uninhabited-const-issue-61744.stderr
new file mode 100644
index 0000000..5c28554
--- /dev/null
+++ b/src/test/ui/consts/uninhabited-const-issue-61744.stderr
@@ -0,0 +1,24 @@
+error: any use of this value will cause an error
+ --> $DIR/uninhabited-const-issue-61744.rs:8:5
+ |
+LL | fake_type()
+ | ^^^^^^^^^^^
+ | |
+ | tried to call a function with return type T passing return place of type !
+ | inside call to `hint_unreachable` at $DIR/uninhabited-const-issue-61744.rs:4:5
+ | inside call to `fake_type::<i32>` at $DIR/uninhabited-const-issue-61744.rs:12:36
+...
+LL | const CONSTANT: i32 = unsafe { fake_type() };
+ | ---------------------------------------------
+ |
+ = note: #[deny(const_err)] on by default
+
+error[E0080]: erroneous constant used
+ --> $DIR/uninhabited-const-issue-61744.rs:18:10
+ |
+LL | dbg!(i32::CONSTANT);
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/src/test/ui/derives/deriving-bounds.rs b/src/test/ui/derives/deriving-bounds.rs
index 607cfa1..52659bd 100644
--- a/src/test/ui/derives/deriving-bounds.rs
+++ b/src/test/ui/derives/deriving-bounds.rs
@@ -1,9 +1,9 @@
#[derive(Send)]
-//~^ ERROR this unsafe trait should be implemented explicitly
+//~^ ERROR cannot find derive macro `Send` in this scope
struct Test;
#[derive(Sync)]
-//~^ ERROR this unsafe trait should be implemented explicitly
+//~^ ERROR cannot find derive macro `Sync` in this scope
struct Test1;
pub fn main() {}
diff --git a/src/test/ui/derives/deriving-bounds.stderr b/src/test/ui/derives/deriving-bounds.stderr
index deb84fd..99976da 100644
--- a/src/test/ui/derives/deriving-bounds.stderr
+++ b/src/test/ui/derives/deriving-bounds.stderr
@@ -1,10 +1,22 @@
-error: this unsafe trait should be implemented explicitly
+error: cannot find derive macro `Send` in this scope
+ --> $DIR/deriving-bounds.rs:1:10
+ |
+LL | #[derive(Send)]
+ | ^^^^
+ |
+note: unsafe traits like `Send` should be implemented explicitly
--> $DIR/deriving-bounds.rs:1:10
|
LL | #[derive(Send)]
| ^^^^
-error: this unsafe trait should be implemented explicitly
+error: cannot find derive macro `Sync` in this scope
+ --> $DIR/deriving-bounds.rs:5:10
+ |
+LL | #[derive(Sync)]
+ | ^^^^
+ |
+note: unsafe traits like `Sync` should be implemented explicitly
--> $DIR/deriving-bounds.rs:5:10
|
LL | #[derive(Sync)]
diff --git a/src/test/ui/derives/deriving-meta-empty-trait-list.rs b/src/test/ui/derives/deriving-meta-empty-trait-list.rs
index 8824841..4f2e31e 100644
--- a/src/test/ui/derives/deriving-meta-empty-trait-list.rs
+++ b/src/test/ui/derives/deriving-meta-empty-trait-list.rs
@@ -1,6 +1,6 @@
-// compile-pass
+#![deny(unused)]
-#[derive()] //~ WARNING empty trait list in `derive`
-struct Bar;
+#[derive()] //~ ERROR unused attribute
+struct _Bar;
pub fn main() {}
diff --git a/src/test/ui/derives/deriving-meta-empty-trait-list.stderr b/src/test/ui/derives/deriving-meta-empty-trait-list.stderr
index f8414b6..95c94ded 100644
--- a/src/test/ui/derives/deriving-meta-empty-trait-list.stderr
+++ b/src/test/ui/derives/deriving-meta-empty-trait-list.stderr
@@ -1,6 +1,15 @@
-warning: empty trait list in `derive`
+error: unused attribute
--> $DIR/deriving-meta-empty-trait-list.rs:3:1
|
LL | #[derive()]
| ^^^^^^^^^^^
+ |
+note: lint level defined here
+ --> $DIR/deriving-meta-empty-trait-list.rs:1:9
+ |
+LL | #![deny(unused)]
+ | ^^^^^^
+ = note: #[deny(unused_attributes)] implied by #[deny(unused)]
+
+error: aborting due to previous error
diff --git a/src/test/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.rs b/src/test/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.rs
new file mode 100644
index 0000000..4da7b5a
--- /dev/null
+++ b/src/test/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.rs
@@ -0,0 +1,9 @@
+#![crate_type="lib"]
+#![feature(arbitrary_enum_discriminant)]
+
+enum Enum {
+//~^ ERROR `#[repr(inttype)]` must be specified
+ Unit = 1,
+ Tuple() = 2,
+ Struct{} = 3,
+}
diff --git a/src/test/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.stderr b/src/test/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.stderr
new file mode 100644
index 0000000..2db5372
--- /dev/null
+++ b/src/test/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.stderr
@@ -0,0 +1,14 @@
+error[E0732]: `#[repr(inttype)]` must be specified
+ --> $DIR/arbitrary_enum_discriminant-no-repr.rs:4:1
+ |
+LL | / enum Enum {
+LL | |
+LL | | Unit = 1,
+LL | | Tuple() = 2,
+LL | | Struct{} = 3,
+LL | | }
+ | |_^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0732`.
diff --git a/src/test/ui/enum-discriminant/arbitrary_enum_discriminant.rs b/src/test/ui/enum-discriminant/arbitrary_enum_discriminant.rs
new file mode 100644
index 0000000..f227060
--- /dev/null
+++ b/src/test/ui/enum-discriminant/arbitrary_enum_discriminant.rs
@@ -0,0 +1,56 @@
+// run-pass
+#![feature(arbitrary_enum_discriminant, const_raw_ptr_deref, test)]
+
+extern crate test;
+
+use test::black_box;
+
+#[allow(dead_code)]
+#[repr(u8)]
+enum Enum {
+ Unit = 3,
+ Tuple(u16) = 2,
+ Struct {
+ a: u8,
+ b: u16,
+ } = 1,
+}
+
+impl Enum {
+ const unsafe fn tag(&self) -> u8 {
+ *(self as *const Self as *const u8)
+ }
+}
+
+#[allow(dead_code)]
+#[repr(u8)]
+enum FieldlessEnum {
+ Unit = 3,
+ Tuple() = 2,
+ Struct {} = 1,
+}
+
+fn main() {
+ const UNIT: Enum = Enum::Unit;
+ const TUPLE: Enum = Enum::Tuple(5);
+ const STRUCT: Enum = Enum::Struct{a: 7, b: 11};
+
+ // Ensure discriminants are correct during runtime execution
+ assert_eq!(3, unsafe { black_box(UNIT).tag() });
+ assert_eq!(2, unsafe { black_box(TUPLE).tag() });
+ assert_eq!(1, unsafe { black_box(STRUCT).tag() });
+
+ // Ensure discriminants are correct during CTFE
+ const UNIT_TAG: u8 = unsafe { UNIT.tag() };
+ const TUPLE_TAG: u8 = unsafe { TUPLE.tag() };
+ const STRUCT_TAG: u8 = unsafe { STRUCT.tag() };
+
+ assert_eq!(3, UNIT_TAG);
+ assert_eq!(2, TUPLE_TAG);
+ assert_eq!(1, STRUCT_TAG);
+
+ // Ensure `as` conversions are correct
+ assert_eq!(3, FieldlessEnum::Unit as u8);
+ assert_eq!(2, FieldlessEnum::Tuple() as u8);
+ assert_eq!(1, FieldlessEnum::Struct{} as u8);
+}
diff --git a/src/test/run-pass/discriminant_value-wrapper.rs b/src/test/ui/enum-discriminant/discriminant_value-wrapper.rs
similarity index 96%
rename from src/test/run-pass/discriminant_value-wrapper.rs
rename to src/test/ui/enum-discriminant/discriminant_value-wrapper.rs
index 1fb0d1e..daef2de 100644
--- a/src/test/run-pass/discriminant_value-wrapper.rs
+++ b/src/test/ui/enum-discriminant/discriminant_value-wrapper.rs
@@ -1,3 +1,4 @@
+// run-pass
use std::mem;
enum ADT {
diff --git a/src/test/run-pass/discriminant_value.rs b/src/test/ui/enum-discriminant/discriminant_value.rs
similarity index 78%
rename from src/test/run-pass/discriminant_value.rs
rename to src/test/ui/enum-discriminant/discriminant_value.rs
index 162ab27..b700001 100644
--- a/src/test/run-pass/discriminant_value.rs
+++ b/src/test/ui/enum-discriminant/discriminant_value.rs
@@ -1,5 +1,6 @@
+// run-pass
#![allow(stable_features)]
-#![feature(core, core_intrinsics)]
+#![feature(arbitrary_enum_discriminant, core, core_intrinsics)]
extern crate core;
use core::intrinsics::discriminant_value;
@@ -38,6 +39,17 @@
static CONST : u32 = 0xBEEF;
+#[allow(dead_code)]
+#[repr(isize)]
+enum Mixed {
+ Unit = 3,
+ Tuple(u16) = 2,
+ Struct {
+ a: u8,
+ b: u16,
+ } = 1,
+}
+
pub fn main() {
unsafe {
@@ -64,5 +76,9 @@
assert_eq!(discriminant_value(&10), 0);
assert_eq!(discriminant_value(&"test"), 0);
+
+ assert_eq!(3, discriminant_value(&Mixed::Unit));
+ assert_eq!(2, discriminant_value(&Mixed::Tuple(5)));
+ assert_eq!(1, discriminant_value(&Mixed::Struct{a: 7, b: 11}));
}
}
diff --git a/src/test/ui/enum-discriminant/feature-gate-arbitrary_enum_discriminant.rs b/src/test/ui/enum-discriminant/feature-gate-arbitrary_enum_discriminant.rs
new file mode 100644
index 0000000..3e90af4
--- /dev/null
+++ b/src/test/ui/enum-discriminant/feature-gate-arbitrary_enum_discriminant.rs
@@ -0,0 +1,10 @@
+#![crate_type="lib"]
+
+enum Enum {
+ Unit = 1,
+ //~^ ERROR custom discriminant values are not allowed in enums with tuple or struct variants
+ Tuple() = 2,
+ //~^ ERROR discriminants on non-unit variants are experimental
+ Struct{} = 3,
+ //~^ ERROR discriminants on non-unit variants are experimental
+}
diff --git a/src/test/ui/enum-discriminant/feature-gate-arbitrary_enum_discriminant.stderr b/src/test/ui/enum-discriminant/feature-gate-arbitrary_enum_discriminant.stderr
new file mode 100644
index 0000000..f50ed2c
--- /dev/null
+++ b/src/test/ui/enum-discriminant/feature-gate-arbitrary_enum_discriminant.stderr
@@ -0,0 +1,36 @@
+error[E0658]: discriminants on non-unit variants are experimental
+ --> $DIR/feature-gate-arbitrary_enum_discriminant.rs:6:13
+ |
+LL | Tuple() = 2,
+ | ^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/60553
+ = help: add #![feature(arbitrary_enum_discriminant)] to the crate attributes to enable
+
+error[E0658]: discriminants on non-unit variants are experimental
+ --> $DIR/feature-gate-arbitrary_enum_discriminant.rs:8:14
+ |
+LL | Struct{} = 3,
+ | ^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/60553
+ = help: add #![feature(arbitrary_enum_discriminant)] to the crate attributes to enable
+
+error[E0658]: custom discriminant values are not allowed in enums with tuple or struct variants
+ --> $DIR/feature-gate-arbitrary_enum_discriminant.rs:4:10
+ |
+LL | Unit = 1,
+ | ^ disallowed custom discriminant
+LL |
+LL | Tuple() = 2,
+ | ----------- tuple variant defined here
+LL |
+LL | Struct{} = 3,
+ | ------------ struct variant defined here
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/60553
+ = help: add #![feature(arbitrary_enum_discriminant)] to the crate attributes to enable
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/expanded-cfg.rs b/src/test/ui/expanded-cfg.rs
index c98fd7f..baa161a 100644
--- a/src/test/ui/expanded-cfg.rs
+++ b/src/test/ui/expanded-cfg.rs
@@ -1,5 +1,4 @@
-// skip-codegen
-// compile-pass
+// check-pass
macro_rules! mac {
{} => {
@@ -19,5 +18,4 @@
mac! {}
-
fn main() {}
diff --git a/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs b/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs
index ca0a432..3187b4c 100644
--- a/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs
+++ b/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs
@@ -30,8 +30,9 @@
// inputs are handled by each, and (2.) to ease searching for related
// occurrences in the source text.
+// check-pass
+
#![warn(unused_attributes, unknown_lints)]
-#![allow(stable_features)]
// UNGATED WHITE-LISTED BUILT-IN ATTRIBUTES
@@ -75,7 +76,7 @@
// see issue-43106-gating-of-stable.rs
// see issue-43106-gating-of-unstable.rs
// see issue-43106-gating-of-deprecated.rs
-#![windows_subsystem = "1000"]
+#![windows_subsystem = "windows"]
// UNGATED CRATE-LEVEL BUILT-IN ATTRIBUTES
@@ -539,7 +540,7 @@
#[export_name = "2200"] impl S { }
}
-// Note that this test has a `skip-codegen`, so it
+// Note that this is a `check-pass` test, so it
// will never invoke the linker. These are here nonetheless to point
// out that we allow them at non-crate-level (though I do not know
// whether they have the same effect here as at crate-level).
@@ -611,17 +612,17 @@
#[must_use] impl S { }
}
-#[windows_subsystem = "1000"]
+#[windows_subsystem = "windows"]
mod windows_subsystem {
- mod inner { #![windows_subsystem="1000"] }
+ mod inner { #![windows_subsystem="windows"] }
- #[windows_subsystem = "1000"] fn f() { }
+ #[windows_subsystem = "windows"] fn f() { }
- #[windows_subsystem = "1000"] struct S;
+ #[windows_subsystem = "windows"] struct S;
- #[windows_subsystem = "1000"] type T = S;
+ #[windows_subsystem = "windows"] type T = S;
- #[windows_subsystem = "1000"] impl S { }
+ #[windows_subsystem = "windows"] impl S { }
}
// BROKEN USES OF CRATE-LEVEL BUILT-IN ATTRIBUTES
diff --git a/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.stderr b/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.stderr
index c708120..e03b712 100644
--- a/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.stderr
+++ b/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.stderr
@@ -1,1182 +1,1186 @@
warning: unknown lint: `x5400`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:38:9
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:39:9
|
LL | #![warn(x5400)]
| ^^^^^
|
note: lint level defined here
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:33:28
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:35:28
|
LL | #![warn(unused_attributes, unknown_lints)]
| ^^^^^^^^^^^^^
warning: unknown lint: `x5300`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:39:10
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:40:10
|
LL | #![allow(x5300)]
| ^^^^^
warning: unknown lint: `x5200`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:40:11
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:41:11
|
LL | #![forbid(x5200)]
| ^^^^^
warning: unknown lint: `x5100`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:41:9
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:42:9
|
LL | #![deny(x5100)]
| ^^^^^
warning: unknown lint: `x5400`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:99:8
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:100:8
|
LL | #[warn(x5400)]
| ^^^^^
warning: unknown lint: `x5400`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:102:25
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:103:25
|
LL | mod inner { #![warn(x5400)] }
| ^^^^^
warning: unknown lint: `x5400`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:105:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:106:12
|
LL | #[warn(x5400)] fn f() { }
| ^^^^^
warning: unknown lint: `x5400`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:108:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:109:12
|
LL | #[warn(x5400)] struct S;
| ^^^^^
warning: unknown lint: `x5400`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:111:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:112:12
|
LL | #[warn(x5400)] type T = S;
| ^^^^^
warning: unknown lint: `x5400`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:114:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:115:12
|
LL | #[warn(x5400)] impl S { }
| ^^^^^
warning: unknown lint: `x5300`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:118:9
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:119:9
|
LL | #[allow(x5300)]
| ^^^^^
warning: unknown lint: `x5300`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:121:26
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:122:26
|
LL | mod inner { #![allow(x5300)] }
| ^^^^^
warning: unknown lint: `x5300`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:124:13
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:125:13
|
LL | #[allow(x5300)] fn f() { }
| ^^^^^
warning: unknown lint: `x5300`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:127:13
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:128:13
|
LL | #[allow(x5300)] struct S;
| ^^^^^
warning: unknown lint: `x5300`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:130:13
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:131:13
|
LL | #[allow(x5300)] type T = S;
| ^^^^^
warning: unknown lint: `x5300`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:133:13
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:134:13
|
LL | #[allow(x5300)] impl S { }
| ^^^^^
warning: unknown lint: `x5200`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:137:10
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:138:10
|
LL | #[forbid(x5200)]
| ^^^^^
warning: unknown lint: `x5200`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:140:27
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:141:27
|
LL | mod inner { #![forbid(x5200)] }
| ^^^^^
warning: unknown lint: `x5200`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:143:14
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:144:14
|
LL | #[forbid(x5200)] fn f() { }
| ^^^^^
warning: unknown lint: `x5200`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:146:14
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:147:14
|
LL | #[forbid(x5200)] struct S;
| ^^^^^
warning: unknown lint: `x5200`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:149:14
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:150:14
|
LL | #[forbid(x5200)] type T = S;
| ^^^^^
warning: unknown lint: `x5200`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:152:14
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:153:14
|
LL | #[forbid(x5200)] impl S { }
| ^^^^^
warning: unknown lint: `x5100`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:156:8
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:157:8
|
LL | #[deny(x5100)]
| ^^^^^
warning: unknown lint: `x5100`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:159:25
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:160:25
|
LL | mod inner { #![deny(x5100)] }
| ^^^^^
warning: unknown lint: `x5100`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:162:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:163:12
|
LL | #[deny(x5100)] fn f() { }
| ^^^^^
warning: unknown lint: `x5100`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:165:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:166:12
|
LL | #[deny(x5100)] struct S;
| ^^^^^
warning: unknown lint: `x5100`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:168:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:169:12
|
LL | #[deny(x5100)] type T = S;
| ^^^^^
warning: unknown lint: `x5100`
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:171:12
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:172:12
|
LL | #[deny(x5100)] impl S { }
| ^^^^^
warning: macro_escape is a deprecated synonym for macro_use
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:455:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:456:1
|
LL | #[macro_escape]
| ^^^^^^^^^^^^^^^
warning: macro_escape is a deprecated synonym for macro_use
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:458:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:459:17
|
LL | mod inner { #![macro_escape] }
| ^^^^^^^^^^^^^^^^
|
= help: consider an outer attribute, #[macro_use] mod ...
+warning: the feature `rust1` has been stable since 1.0.0 and no longer requires an attribute to enable
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:89:12
+ |
+LL | #![feature(rust1)]
+ | ^^^^^
+ |
+ = note: #[warn(stable_features)] on by default
+
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:179:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:180:5
|
LL | #[macro_use] fn f() { }
| ^^^^^^^^^^^^
|
note: lint level defined here
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:33:9
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:35:9
|
LL | #![warn(unused_attributes, unknown_lints)]
| ^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:182:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:183:5
|
LL | #[macro_use] struct S;
| ^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:185:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:186:5
|
LL | #[macro_use] type T = S;
| ^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:188:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:189:5
|
LL | #[macro_use] impl S { }
| ^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:195:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:196:17
|
LL | mod inner { #![macro_export] }
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:198:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:199:5
|
LL | #[macro_export] fn f() { }
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:201:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:202:5
|
LL | #[macro_export] struct S;
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:204:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:205:5
|
LL | #[macro_export] type T = S;
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:207:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:208:5
|
LL | #[macro_export] impl S { }
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:192:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:193:1
|
LL | #[macro_export]
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:214:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:215:17
|
LL | mod inner { #![plugin_registrar] }
| ^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:219:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:220:5
|
LL | #[plugin_registrar] struct S;
| ^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:222:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:223:5
|
LL | #[plugin_registrar] type T = S;
| ^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:225:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:226:5
|
LL | #[plugin_registrar] impl S { }
| ^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:211:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:212:1
|
LL | #[plugin_registrar]
| ^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:232:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:233:17
|
LL | mod inner { #![main] }
| ^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:237:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:238:5
|
LL | #[main] struct S;
| ^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:240:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:241:5
|
LL | #[main] type T = S;
| ^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:243:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:244:5
|
LL | #[main] impl S { }
| ^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:229:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:230:1
|
LL | #[main]
| ^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:250:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:251:17
|
LL | mod inner { #![start] }
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:255:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:256:5
|
LL | #[start] struct S;
| ^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:258:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:259:5
|
LL | #[start] type T = S;
| ^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:261:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:262:5
|
LL | #[start] impl S { }
| ^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:247:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:248:1
|
LL | #[start]
| ^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:314:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:315:5
|
LL | #[path = "3800"] fn f() { }
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:317:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:318:5
|
LL | #[path = "3800"] struct S;
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:320:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:321:5
|
LL | #[path = "3800"] type T = S;
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:323:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:324:5
|
LL | #[path = "3800"] impl S { }
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:330:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:331:17
|
LL | mod inner { #![automatically_derived] }
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:333:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:334:5
|
LL | #[automatically_derived] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:336:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:337:5
|
LL | #[automatically_derived] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:339:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:340:5
|
LL | #[automatically_derived] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:342:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:343:5
|
LL | #[automatically_derived] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:327:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:328:1
|
LL | #[automatically_derived]
| ^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:362:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:363:17
|
LL | mod inner { #![no_link] }
| ^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:365:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:366:5
|
LL | #[no_link] fn f() { }
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:368:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:369:5
|
LL | #[no_link] struct S;
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:371:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:372:5
|
LL | #[no_link]type T = S;
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:374:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:375:5
|
LL | #[no_link] impl S { }
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:359:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:360:1
|
LL | #[no_link]
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:381:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:382:17
|
LL | mod inner { #![should_panic] }
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:384:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:385:5
|
LL | #[should_panic] fn f() { }
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:387:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:388:5
|
LL | #[should_panic] struct S;
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:390:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:391:5
|
LL | #[should_panic] type T = S;
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:393:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:394:5
|
LL | #[should_panic] impl S { }
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:378:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:379:1
|
LL | #[should_panic]
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:400:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:401:17
|
LL | mod inner { #![ignore] }
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:403:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:404:5
|
LL | #[ignore] fn f() { }
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:406:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:407:5
|
LL | #[ignore] struct S;
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:409:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:410:5
|
LL | #[ignore] type T = S;
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:412:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:413:5
|
LL | #[ignore] impl S { }
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:397:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:398:1
|
LL | #[ignore]
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:419:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:420:17
|
LL | mod inner { #![no_implicit_prelude] }
| ^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:422:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:423:5
|
LL | #[no_implicit_prelude] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:425:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:426:5
|
LL | #[no_implicit_prelude] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:428:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:429:5
|
LL | #[no_implicit_prelude] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:431:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:432:5
|
LL | #[no_implicit_prelude] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:416:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:417:1
|
LL | #[no_implicit_prelude]
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:438:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:439:17
|
LL | mod inner { #![reexport_test_harness_main="2900"] }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:441:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:442:5
|
LL | #[reexport_test_harness_main = "2900"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:444:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:445:5
|
LL | #[reexport_test_harness_main = "2900"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:447:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:448:5
|
LL | #[reexport_test_harness_main = "2900"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:450:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:451:5
|
LL | #[reexport_test_harness_main = "2900"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:435:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:436:1
|
LL | #[reexport_test_harness_main = "2900"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:461:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:462:5
|
LL | #[macro_escape] fn f() { }
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:464:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:465:5
|
LL | #[macro_escape] struct S;
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:467:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:468:5
|
LL | #[macro_escape] type T = S;
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:470:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:471:5
|
LL | #[macro_escape] impl S { }
| ^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:478:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:479:17
|
LL | mod inner { #![no_std] }
| ^^^^^^^^^^
warning: crate-level attribute should be in the root module
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:478:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:479:17
|
LL | mod inner { #![no_std] }
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:482:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:483:5
|
LL | #[no_std] fn f() { }
| ^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:482:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:483:5
|
LL | #[no_std] fn f() { }
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:486:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:487:5
|
LL | #[no_std] struct S;
| ^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:486:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:487:5
|
LL | #[no_std] struct S;
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:490:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:491:5
|
LL | #[no_std] type T = S;
| ^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:490:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:491:5
|
LL | #[no_std] type T = S;
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:494:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:495:5
|
LL | #[no_std] impl S { }
| ^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:494:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:495:5
|
LL | #[no_std] impl S { }
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:474:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:475:1
|
LL | #[no_std]
| ^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:474:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:475:1
|
LL | #[no_std]
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:633:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:634:17
|
LL | mod inner { #![crate_name="0900"] }
| ^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be in the root module
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:633:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:634:17
|
LL | mod inner { #![crate_name="0900"] }
| ^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:637:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:638:5
|
LL | #[crate_name = "0900"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:637:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:638:5
|
LL | #[crate_name = "0900"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:641:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:642:5
|
LL | #[crate_name = "0900"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:641:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:642:5
|
LL | #[crate_name = "0900"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:645:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:646:5
|
LL | #[crate_name = "0900"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:645:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:646:5
|
LL | #[crate_name = "0900"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:649:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:650:5
|
LL | #[crate_name = "0900"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:649:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:650:5
|
LL | #[crate_name = "0900"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:629:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:630:1
|
LL | #[crate_name = "0900"]
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:629:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:630:1
|
LL | #[crate_name = "0900"]
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:658:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:659:17
|
LL | mod inner { #![crate_type="0800"] }
| ^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be in the root module
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:658:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:659:17
|
LL | mod inner { #![crate_type="0800"] }
| ^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:662:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:663:5
|
LL | #[crate_type = "0800"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:662:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:663:5
|
LL | #[crate_type = "0800"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:666:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:667:5
|
LL | #[crate_type = "0800"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:666:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:667:5
|
LL | #[crate_type = "0800"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:670:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:671:5
|
LL | #[crate_type = "0800"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:670:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:671:5
|
LL | #[crate_type = "0800"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:674:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:675:5
|
LL | #[crate_type = "0800"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:674:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:675:5
|
LL | #[crate_type = "0800"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:654:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:655:1
|
LL | #[crate_type = "0800"]
| ^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:654:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:655:1
|
LL | #[crate_type = "0800"]
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:683:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:684:17
|
LL | mod inner { #![feature(x0600)] }
| ^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be in the root module
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:683:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:684:17
|
LL | mod inner { #![feature(x0600)] }
| ^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:687:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:688:5
|
LL | #[feature(x0600)] fn f() { }
| ^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:687:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:688:5
|
LL | #[feature(x0600)] fn f() { }
| ^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:691:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:692:5
|
LL | #[feature(x0600)] struct S;
| ^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:691:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:692:5
|
LL | #[feature(x0600)] struct S;
| ^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:695:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:696:5
|
LL | #[feature(x0600)] type T = S;
| ^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:695:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:696:5
|
LL | #[feature(x0600)] type T = S;
| ^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:699:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:700:5
|
LL | #[feature(x0600)] impl S { }
| ^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:699:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:700:5
|
LL | #[feature(x0600)] impl S { }
| ^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:679:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:680:1
|
LL | #[feature(x0600)]
| ^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:679:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:680:1
|
LL | #[feature(x0600)]
| ^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:709:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:710:17
|
LL | mod inner { #![no_main] }
| ^^^^^^^^^^^
warning: crate-level attribute should be in the root module
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:709:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:710:17
|
LL | mod inner { #![no_main] }
| ^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:713:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:714:5
|
LL | #[no_main] fn f() { }
| ^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:713:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:714:5
|
LL | #[no_main] fn f() { }
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:717:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:718:5
|
LL | #[no_main] struct S;
| ^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:717:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:718:5
|
LL | #[no_main] struct S;
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:721:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:722:5
|
LL | #[no_main] type T = S;
| ^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:721:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:722:5
|
LL | #[no_main] type T = S;
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:725:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:726:5
|
LL | #[no_main] impl S { }
| ^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:725:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:726:5
|
LL | #[no_main] impl S { }
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:705:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:706:1
|
LL | #[no_main]
| ^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:705:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:706:1
|
LL | #[no_main]
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:747:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:748:17
|
LL | mod inner { #![recursion_limit="0200"] }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be in the root module
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:747:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:748:17
|
LL | mod inner { #![recursion_limit="0200"] }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:751:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:752:5
|
LL | #[recursion_limit="0200"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:751:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:752:5
|
LL | #[recursion_limit="0200"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:755:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:756:5
|
LL | #[recursion_limit="0200"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:755:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:756:5
|
LL | #[recursion_limit="0200"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:759:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:760:5
|
LL | #[recursion_limit="0200"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:759:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:760:5
|
LL | #[recursion_limit="0200"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:763:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:764:5
|
LL | #[recursion_limit="0200"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:763:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:764:5
|
LL | #[recursion_limit="0200"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:743:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:744:1
|
LL | #[recursion_limit="0200"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:743:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:744:1
|
LL | #[recursion_limit="0200"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:772:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:773:17
|
LL | mod inner { #![type_length_limit="0100"] }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be in the root module
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:772:17
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:773:17
|
LL | mod inner { #![type_length_limit="0100"] }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:776:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:777:5
|
LL | #[type_length_limit="0100"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:776:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:777:5
|
LL | #[type_length_limit="0100"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:780:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:781:5
|
LL | #[type_length_limit="0100"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:780:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:781:5
|
LL | #[type_length_limit="0100"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:784:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:785:5
|
LL | #[type_length_limit="0100"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:784:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:785:5
|
LL | #[type_length_limit="0100"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:788:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:789:5
|
LL | #[type_length_limit="0100"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:788:5
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:789:5
|
LL | #[type_length_limit="0100"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:768:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:769:1
|
LL | #[type_length_limit="0100"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: crate-level attribute should be an inner attribute: add an exclamation mark: #![foo]
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:768:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:769:1
|
LL | #[type_length_limit="0100"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:43:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:44:1
|
LL | #![macro_export]
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:44:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:45:1
|
LL | #![plugin_registrar]
| ^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:47:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:48:1
|
LL | #![main]
| ^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:48:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:49:1
|
LL | #![start]
| ^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:51:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:52:1
|
LL | #![repr()]
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:53:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:54:1
|
LL | #![path = "3800"]
| ^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:54:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:55:1
|
LL | #![automatically_derived]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:56:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:57:1
|
LL | #![no_link]
| ^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:58:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:59:1
|
LL | #![should_panic]
| ^^^^^^^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:59:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:60:1
|
LL | #![ignore]
| ^^^^^^^^^^
warning: unused attribute
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:65:1
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:66:1
|
LL | #![proc_macro_derive()]
| ^^^^^^^^^^^^^^^^^^^^^^^
-error: invalid windows subsystem `1000`, only `windows` and `console` are allowed
-
-error: aborting due to previous error
-
diff --git a/src/test/ui/feature-gate/issue-43106-gating-of-deprecated.rs b/src/test/ui/feature-gate/issue-43106-gating-of-deprecated.rs
index 360d570..5e1d08d 100644
--- a/src/test/ui/feature-gate/issue-43106-gating-of-deprecated.rs
+++ b/src/test/ui/feature-gate/issue-43106-gating-of-deprecated.rs
@@ -5,8 +5,7 @@
//
// (For non-crate-level cases, see issue-43106-gating-of-builtin-attrs.rs)
-// compile-pass
-// skip-codegen
+// check-pass
#![deprecated]
diff --git a/src/test/ui/glob-cycles.rs b/src/test/ui/glob-cycles.rs
index 84f9e5d..f354cc8 100644
--- a/src/test/ui/glob-cycles.rs
+++ b/src/test/ui/glob-cycles.rs
@@ -1,5 +1,5 @@
-// compile-pass
-// skip-codegen
+// check-pass
+
mod foo {
pub use bar::*;
pub use main as f;
@@ -15,5 +15,4 @@
pub use super::*;
}
-
pub fn main() {}
diff --git a/src/test/ui/hygiene/assoc_ty_bindings.rs b/src/test/ui/hygiene/assoc_ty_bindings.rs
index eb0ca6a..93cf759 100644
--- a/src/test/ui/hygiene/assoc_ty_bindings.rs
+++ b/src/test/ui/hygiene/assoc_ty_bindings.rs
@@ -1,8 +1,8 @@
+// check-pass
// ignore-pretty pretty-printing is unhygienic
#![feature(decl_macro, associated_type_defaults)]
-// compile-pass
-// skip-codegen
+
trait Base {
type AssocTy;
fn f();
@@ -35,5 +35,4 @@
mac!();
-
fn main() {}
diff --git a/src/test/ui/if/if-loop.rs b/src/test/ui/if/if-loop.rs
index c799df2..06d0bdf 100644
--- a/src/test/ui/if/if-loop.rs
+++ b/src/test/ui/if/if-loop.rs
@@ -1,10 +1,8 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
+
// This used to ICE because the "if" being unreachable was not handled correctly
fn err() {
if loop {} {}
}
-
fn main() {}
diff --git a/src/test/ui/imports/import-crate-var.rs b/src/test/ui/imports/import-crate-var.rs
index ab26050..b9d146d 100644
--- a/src/test/ui/imports/import-crate-var.rs
+++ b/src/test/ui/imports/import-crate-var.rs
@@ -1,10 +1,8 @@
+// check-pass
// aux-build:import_crate_var.rs
-// compile-pass
-// skip-codegen
#[macro_use] extern crate import_crate_var;
-
fn main() {
m!();
//~^ WARN `$crate` may not be imported
diff --git a/src/test/ui/imports/import-crate-var.stderr b/src/test/ui/imports/import-crate-var.stderr
index 4c358a8..2f8c845 100644
--- a/src/test/ui/imports/import-crate-var.stderr
+++ b/src/test/ui/imports/import-crate-var.stderr
@@ -1,5 +1,5 @@
warning: `$crate` may not be imported
- --> $DIR/import-crate-var.rs:9:5
+ --> $DIR/import-crate-var.rs:7:5
|
LL | m!();
| ^^^^^
diff --git a/src/test/ui/issues/issue-11740.rs b/src/test/ui/issues/issue-11740.rs
index 47bdf08..dc10a20 100644
--- a/src/test/ui/issues/issue-11740.rs
+++ b/src/test/ui/issues/issue-11740.rs
@@ -1,6 +1,5 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
+
struct Attr {
name: String,
value: String,
@@ -21,7 +20,6 @@
}
}
-
fn main() {
let element = Element { attrs: Vec::new() };
let _ = unsafe { element.get_attr("foo") };
diff --git a/src/test/ui/issues/issue-16994.rs b/src/test/ui/issues/issue-16994.rs
index d5f1b13..8d3074b 100644
--- a/src/test/ui/issues/issue-16994.rs
+++ b/src/test/ui/issues/issue-16994.rs
@@ -1,10 +1,9 @@
-// compile-pass
-// skip-codegen
+// check-pass
+
fn cb<'a,T>(_x: Box<dyn Fn((&'a i32, &'a (Vec<&'static i32>, bool))) -> T>) -> T {
panic!()
}
-
fn main() {
cb(Box::new(|(k, &(ref v, b))| (*k, v.clone(), b)));
}
diff --git a/src/test/ui/issues/issue-19601.rs b/src/test/ui/issues/issue-19601.rs
index faaa2db..176e6ba 100644
--- a/src/test/ui/issues/issue-19601.rs
+++ b/src/test/ui/issues/issue-19601.rs
@@ -1,9 +1,6 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
+
trait A<T> {}
struct B<T> where B<T>: A<B<T>> { t: T }
-
-fn main() {
-}
+fn main() {}
diff --git a/src/test/ui/issues/issue-22603.rs b/src/test/ui/issues/issue-22603.rs
index e298316..a83e291 100644
--- a/src/test/ui/issues/issue-22603.rs
+++ b/src/test/ui/issues/issue-22603.rs
@@ -1,6 +1,7 @@
-// skip-codegen
-// compile-pass
+// check-pass
+
#![feature(unboxed_closures, fn_traits)]
+
struct Foo;
impl<A> FnOnce<(A,)> for Foo {
diff --git a/src/test/ui/issues/issue-22789.rs b/src/test/ui/issues/issue-22789.rs
index e668012..cef4075 100644
--- a/src/test/ui/issues/issue-22789.rs
+++ b/src/test/ui/issues/issue-22789.rs
@@ -1,6 +1,7 @@
-// compile-pass
-// skip-codegen
+// check-pass
+
#![feature(unboxed_closures, fn_traits)]
+
fn main() {
let k = |x: i32| { x + 1 };
Fn::call(&k, (0,));
diff --git a/src/test/ui/issues/issue-22814.rs b/src/test/ui/issues/issue-22814.rs
index b008c75..bcc7a8a 100644
--- a/src/test/ui/issues/issue-22814.rs
+++ b/src/test/ui/issues/issue-22814.rs
@@ -3,7 +3,7 @@
macro_rules! test {
( $($name:ident)+) => (
- impl<$($name: Test),*> Test for ($($name,)*) {
+ impl<$($name: Test),+> Test for ($($name,)+) {
}
)
}
diff --git a/src/test/ui/issues/issue-22933-1.rs b/src/test/ui/issues/issue-22933-1.rs
index 1bf8cb0..3c9aa26 100644
--- a/src/test/ui/issues/issue-22933-1.rs
+++ b/src/test/ui/issues/issue-22933-1.rs
@@ -1,6 +1,5 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
+
struct CNFParser {
token: char,
}
@@ -14,12 +13,11 @@
self.consume_while(&(CNFParser::is_whitespace))
}
- fn consume_while(&mut self, p: &Fn(char) -> bool) {
+ fn consume_while(&mut self, p: &dyn Fn(char) -> bool) {
while p(self.token) {
return
}
}
}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-24883.rs b/src/test/ui/issues/issue-24883.rs
index 1aa62d3..819a20d 100644
--- a/src/test/ui/issues/issue-24883.rs
+++ b/src/test/ui/issues/issue-24883.rs
@@ -1,5 +1,5 @@
-// compile-pass
-// skip-codegen
+// check-pass
+
mod a {
pub mod b { pub struct Foo; }
@@ -11,7 +11,6 @@
pub use self::c::*;
}
-
fn main() {
let _ = a::c::Bar(a::b::Foo);
let _ = a::Bar(a::b::Foo);
diff --git a/src/test/ui/issues/issue-26614.rs b/src/test/ui/issues/issue-26614.rs
index 11c2202..b8ebbdc 100644
--- a/src/test/ui/issues/issue-26614.rs
+++ b/src/test/ui/issues/issue-26614.rs
@@ -1,6 +1,5 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
+
trait Mirror {
type It;
}
@@ -9,8 +8,6 @@
type It = Self;
}
-
-
fn main() {
let c: <u32 as Mirror>::It = 5;
const CCCC: <u32 as Mirror>::It = 5;
diff --git a/src/test/ui/issues/issue-26930.rs b/src/test/ui/issues/issue-26930.rs
index abf6b93..707e71b 100644
--- a/src/test/ui/issues/issue-26930.rs
+++ b/src/test/ui/issues/issue-26930.rs
@@ -1,10 +1,8 @@
-// compile-pass
-// skip-codegen
-#![allow(unused)]
+// check-pass
+
extern crate core;
use core as core_export;
use self::x::*;
mod x {}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-27697.rs b/src/test/ui/issues/issue-27697.rs
new file mode 100644
index 0000000..8307001
--- /dev/null
+++ b/src/test/ui/issues/issue-27697.rs
@@ -0,0 +1,21 @@
+// run-pass
+
+use std::ops::Deref;
+
+trait MyTrait {
+ fn do_something(&self);
+ fn as_str(&self) -> &str;
+}
+
+impl Deref for dyn MyTrait {
+ type Target = str;
+ fn deref(&self) -> &Self::Target {
+ self.as_str()
+ }
+}
+
+fn trait_object_does_something(t: &dyn MyTrait) {
+ t.do_something()
+}
+
+fn main() {}
diff --git a/src/test/ui/issues/issue-29857.rs b/src/test/ui/issues/issue-29857.rs
index 5aff968..6f4c5f4 100644
--- a/src/test/ui/issues/issue-29857.rs
+++ b/src/test/ui/issues/issue-29857.rs
@@ -1,5 +1,4 @@
-// compile-pass
-// skip-codegen
+// check-pass
use std::marker::PhantomData;
@@ -17,5 +16,4 @@
impl<T: 'static, W: Bar<Output = T>> Foo<*mut T> for W {}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-31924-non-snake-ffi.rs b/src/test/ui/issues/issue-31924-non-snake-ffi.rs
index 5e2336c..63e42b48 100644
--- a/src/test/ui/issues/issue-31924-non-snake-ffi.rs
+++ b/src/test/ui/issues/issue-31924-non-snake-ffi.rs
@@ -1,8 +1,8 @@
-// compile-pass
-// skip-codegen
-#![deny(non_snake_case)]
-#[no_mangle]
-pub extern "C" fn SparklingGenerationForeignFunctionInterface() {}
+// check-pass
+#![deny(non_snake_case)]
+
+#[no_mangle]
+pub extern "C" fn SparklingGenerationForeignFunctionInterface() {} // OK
fn main() {}
diff --git a/src/test/ui/issues/issue-32119.rs b/src/test/ui/issues/issue-32119.rs
index ea8824b..36adb52 100644
--- a/src/test/ui/issues/issue-32119.rs
+++ b/src/test/ui/issues/issue-32119.rs
@@ -1,6 +1,5 @@
-// compile-pass
-// skip-codegen
-#![allow(dead_code)]
+// check-pass
+
pub type T = ();
mod foo { pub use super::T; }
mod bar { pub use super::T; }
@@ -15,5 +14,4 @@
pub use self::bar::*;
}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-32222.rs b/src/test/ui/issues/issue-32222.rs
index 91f53ab..4ed06bf 100644
--- a/src/test/ui/issues/issue-32222.rs
+++ b/src/test/ui/issues/issue-32222.rs
@@ -1,6 +1,4 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
mod foo {
pub fn bar() {}
@@ -21,5 +19,4 @@
pub use a::bar;
}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-32797.rs b/src/test/ui/issues/issue-32797.rs
index 5ceb7f4..b12b929 100644
--- a/src/test/ui/issues/issue-32797.rs
+++ b/src/test/ui/issues/issue-32797.rs
@@ -1,5 +1,4 @@
-// compile-pass
-// skip-codegen
+// check-pass
pub use bar::*;
mod bar {
@@ -11,5 +10,4 @@
pub use main as f;
}
-
pub fn main() {}
diff --git a/src/test/ui/issues/issue-32922.rs b/src/test/ui/issues/issue-32922.rs
index b06b63c..54ec44a 100644
--- a/src/test/ui/issues/issue-32922.rs
+++ b/src/test/ui/issues/issue-32922.rs
@@ -1,6 +1,4 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
macro_rules! foo { () => {
let x = 1;
@@ -22,7 +20,6 @@
}
}
-
fn main() {
foo! {};
bar! {};
diff --git a/src/test/ui/issues/issue-33241.rs b/src/test/ui/issues/issue-33241.rs
index 4d6204c..5f9f1e4 100644
--- a/src/test/ui/issues/issue-33241.rs
+++ b/src/test/ui/issues/issue-33241.rs
@@ -1,5 +1,4 @@
-// compile-pass
-// skip-codegen
+// check-pass
use std::fmt;
@@ -7,7 +6,6 @@
// an unsized tuple by transmuting a trait object.
fn any<T>() -> T { unreachable!() }
-
fn main() {
let t: &(u8, dyn fmt::Debug) = any();
println!("{:?}", &t.1);
diff --git a/src/test/ui/issues/issue-33571.rs b/src/test/ui/issues/issue-33571.rs
index 223bbc3..147fb3f 100644
--- a/src/test/ui/issues/issue-33571.rs
+++ b/src/test/ui/issues/issue-33571.rs
@@ -1,5 +1,5 @@
#[derive(Clone,
- Sync, //~ ERROR this unsafe trait should be implemented explicitly
+ Sync, //~ ERROR cannot find derive macro `Sync` in this scope
Copy)]
enum Foo {}
diff --git a/src/test/ui/issues/issue-33571.stderr b/src/test/ui/issues/issue-33571.stderr
index 5d83a08..78e7202 100644
--- a/src/test/ui/issues/issue-33571.stderr
+++ b/src/test/ui/issues/issue-33571.stderr
@@ -1,4 +1,10 @@
-error: this unsafe trait should be implemented explicitly
+error: cannot find derive macro `Sync` in this scope
+ --> $DIR/issue-33571.rs:2:10
+ |
+LL | Sync,
+ | ^^^^
+ |
+note: unsafe traits like `Sync` should be implemented explicitly
--> $DIR/issue-33571.rs:2:10
|
LL | Sync,
diff --git a/src/test/ui/issues/issue-34028.rs b/src/test/ui/issues/issue-34028.rs
index 8ebc730..d761c0c 100644
--- a/src/test/ui/issues/issue-34028.rs
+++ b/src/test/ui/issues/issue-34028.rs
@@ -1,5 +1,4 @@
-// compile-pass
-// skip-codegen
+// check-pass
macro_rules! m {
() => { #[cfg(any())] fn f() {} }
@@ -8,5 +7,4 @@
trait T {}
impl T for () { m!(); }
-
fn main() {}
diff --git a/src/test/ui/issues/issue-34171.rs b/src/test/ui/issues/issue-34171.rs
index 25a5f72..157c58c 100644
--- a/src/test/ui/issues/issue-34171.rs
+++ b/src/test/ui/issues/issue-34171.rs
@@ -1,12 +1,10 @@
-// compile-pass
-// skip-codegen
+// check-pass
macro_rules! null { ($i:tt) => {} }
macro_rules! apply_null {
($i:item) => { null! { $i } }
}
-
fn main() {
apply_null!(#[cfg(all())] fn f() {});
}
diff --git a/src/test/ui/issues/issue-34418.rs b/src/test/ui/issues/issue-34418.rs
index 6a86c27..6132f74 100644
--- a/src/test/ui/issues/issue-34418.rs
+++ b/src/test/ui/issues/issue-34418.rs
@@ -1,6 +1,4 @@
-// compile-pass
-// skip-codegen
-#![allow(unused)]
+// check-pass
macro_rules! make_item {
() => { fn f() {} }
@@ -18,5 +16,4 @@
make_stmt! {}
}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-34839.rs b/src/test/ui/issues/issue-34839.rs
index 01669f0..8ffed82 100644
--- a/src/test/ui/issues/issue-34839.rs
+++ b/src/test/ui/issues/issue-34839.rs
@@ -1,6 +1,4 @@
-// compile-pass
-// skip-codegen
-#![allow(dead_code)]
+// check-pass
trait RegularExpression: Sized {
type Text;
@@ -18,5 +16,4 @@
Dynamic(FindCaptures<'t, ExecNoSyncStr<'r>>),
}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-35570.rs b/src/test/ui/issues/issue-35570.rs
index 9bb9db6..fafef79 100644
--- a/src/test/ui/issues/issue-35570.rs
+++ b/src/test/ui/issues/issue-35570.rs
@@ -1,5 +1,4 @@
-// compile-pass
-// skip-codegen
+// check-pass
use std::mem;
@@ -25,7 +24,6 @@
fn takes_lifetime(_f: for<'a> fn(&'a ()) -> <() as Lifetime<'a>>::Out) {
}
-
fn main() {
takes_lifetime(foo);
}
diff --git a/src/test/ui/issues/issue-36116.rs b/src/test/ui/issues/issue-36116.rs
index b4bfba4..c7c70c7 100644
--- a/src/test/ui/issues/issue-36116.rs
+++ b/src/test/ui/issues/issue-36116.rs
@@ -1,8 +1,7 @@
// Unnecessary path disambiguator is ok
-// compile-pass
-// skip-codegen
-#![allow(unused)]
+// check-pass
+
macro_rules! m {
($p: path) => {
let _ = $p(0);
@@ -23,5 +22,4 @@
m!(S::<u8>);
}
-
fn main() {}
diff --git a/src/test/ui/issues/issue-36379.rs b/src/test/ui/issues/issue-36379.rs
index b2da651..3a3e6f4 100644
--- a/src/test/ui/issues/issue-36379.rs
+++ b/src/test/ui/issues/issue-36379.rs
@@ -1,7 +1,5 @@
-// compile-pass
-// skip-codegen
+// check-pass
fn _test() -> impl Default { }
-
-fn main() { }
+fn main() {}
diff --git a/src/test/ui/issues/issue-36839.rs b/src/test/ui/issues/issue-36839.rs
index a660368..ca3d66b 100644
--- a/src/test/ui/issues/issue-36839.rs
+++ b/src/test/ui/issues/issue-36839.rs
@@ -1,5 +1,4 @@
-// compile-pass
-// skip-codegen
+// check-pass
pub trait Foo {
type Bar;
@@ -17,7 +16,6 @@
}
}
-
fn main() {
let _m: &dyn Broken<Assoc=()> = &();
}
diff --git a/src/test/ui/issues/issue-37051.rs b/src/test/ui/issues/issue-37051.rs
index 1ccf5b9..9cae6cf 100644
--- a/src/test/ui/issues/issue-37051.rs
+++ b/src/test/ui/issues/issue-37051.rs
@@ -1,7 +1,7 @@
-// compile-pass
-// skip-codegen
+// check-pass
+
#![feature(associated_type_defaults)]
-#![allow(warnings)]
+
trait State: Sized {
type NextState: State = StateMachineEnded;
fn execute(self) -> Option<Self::NextState>;
@@ -15,6 +15,4 @@
}
}
-
-fn main() {
-}
+fn main() {}
diff --git a/src/test/ui/issues/issue-37366.rs b/src/test/ui/issues/issue-37366.rs
index 1c27960..6bf3a27 100644
--- a/src/test/ui/issues/issue-37366.rs
+++ b/src/test/ui/issues/issue-37366.rs
@@ -1,6 +1,6 @@
+// check-pass
// ignore-emscripten
-// compile-pass
-// skip-codegen
+
#![feature(asm)]
macro_rules! interrupt_handler {
@@ -12,6 +12,4 @@
}
interrupt_handler!{}
-
-fn main() {
-}
+fn main() {}
diff --git a/src/test/ui/issues/issue-37510.rs b/src/test/ui/issues/issue-37510.rs
index 465e680..2081c9f 100644
--- a/src/test/ui/issues/issue-37510.rs
+++ b/src/test/ui/issues/issue-37510.rs
@@ -1,9 +1,7 @@
-// compile-pass
-// skip-codegen
+// check-pass
fn foo(_: &mut i32) -> bool { true }
-
fn main() {
let opt = Some(92);
let mut x = 62;
diff --git a/src/test/ui/issues/issue-37515.rs b/src/test/ui/issues/issue-37515.rs
index cc07bd1..caff507 100644
--- a/src/test/ui/issues/issue-37515.rs
+++ b/src/test/ui/issues/issue-37515.rs
@@ -1,10 +1,8 @@
-// skip-codegen
-// compile-pass
+// check-pass
+
#![warn(unused)]
type Z = dyn for<'x> Send;
//~^ WARN type alias is never used
-
-fn main() {
-}
+fn main() {}
diff --git a/src/test/ui/issues/issue-38160.rs b/src/test/ui/issues/issue-38160.rs
index a454211..0da8b79 100644
--- a/src/test/ui/issues/issue-38160.rs
+++ b/src/test/ui/issues/issue-38160.rs
@@ -1,7 +1,5 @@
-// compile-pass
-// skip-codegen
-#![feature(associated_consts)]
-#![allow(warnings)]
+// check-pass
+
trait MyTrait {
const MY_CONST: &'static str;
}
@@ -18,5 +16,4 @@
my_macro!();
-
fn main() {}
diff --git a/src/test/ui/issues/issue-38381.rs b/src/test/ui/issues/issue-38381.rs
index 1351376..82d4a4e 100644
--- a/src/test/ui/issues/issue-38381.rs
+++ b/src/test/ui/issues/issue-38381.rs
@@ -1,9 +1,7 @@
-// compile-pass
-// skip-codegen
+// check-pass
use std::ops::Deref;
-
fn main() {
let _x: fn(&i32) -> <&i32 as Deref>::Target = unimplemented!();
}
diff --git a/src/test/ui/issues/issue-38591.rs b/src/test/ui/issues/issue-38591.rs
new file mode 100644
index 0000000..7aa71f8
--- /dev/null
+++ b/src/test/ui/issues/issue-38591.rs
@@ -0,0 +1,10 @@
+// run-pass
+
+struct S<T> {
+ t : T,
+ s : Box<S<fn(u : T)>>
+}
+
+fn f(x : S<u32>) {}
+
+fn main () {}
diff --git a/src/test/ui/issues/issue-40350.rs b/src/test/ui/issues/issue-40350.rs
index b2cc004..a39a851 100644
--- a/src/test/ui/issues/issue-40350.rs
+++ b/src/test/ui/issues/issue-40350.rs
@@ -1,6 +1,4 @@
-// compile-pass
-// skip-codegen
-#![allow(warnings)]
+// check-pass
enum E {
A = {
@@ -9,5 +7,4 @@
}
}
-
fn main() {}
diff --git a/src/test/ui/lint/lint-unnecessary-parens.rs b/src/test/ui/lint/lint-unnecessary-parens.rs
index dc74d69..c361010 100644
--- a/src/test/ui/lint/lint-unnecessary-parens.rs
+++ b/src/test/ui/lint/lint-unnecessary-parens.rs
@@ -22,8 +22,8 @@
match (true) { //~ ERROR unnecessary parentheses around `match` head expression
_ => {}
}
- if let 1 = (1) {} //~ ERROR unnecessary parentheses around `if let` head expression
- while let 1 = (2) {} //~ ERROR unnecessary parentheses around `while let` head expression
+ if let 1 = (1) {} //~ ERROR unnecessary parentheses around `let` head expression
+ while let 1 = (2) {} //~ ERROR unnecessary parentheses around `let` head expression
let v = X { y: false };
// struct lits needs parens, so these shouldn't warn.
if (v == X { y: true }) {}
diff --git a/src/test/ui/lint/lint-unnecessary-parens.stderr b/src/test/ui/lint/lint-unnecessary-parens.stderr
index fe2ee38..dfbefd7 100644
--- a/src/test/ui/lint/lint-unnecessary-parens.stderr
+++ b/src/test/ui/lint/lint-unnecessary-parens.stderr
@@ -40,13 +40,13 @@
LL | match (true) {
| ^^^^^^ help: remove these parentheses
-error: unnecessary parentheses around `if let` head expression
+error: unnecessary parentheses around `let` head expression
--> $DIR/lint-unnecessary-parens.rs:25:16
|
LL | if let 1 = (1) {}
| ^^^ help: remove these parentheses
-error: unnecessary parentheses around `while let` head expression
+error: unnecessary parentheses around `let` head expression
--> $DIR/lint-unnecessary-parens.rs:26:19
|
LL | while let 1 = (2) {}
diff --git a/src/test/ui/malformed/malformed-derive-entry.rs b/src/test/ui/malformed/malformed-derive-entry.rs
index 3e53e15..a6d8863 100644
--- a/src/test/ui/malformed/malformed-derive-entry.rs
+++ b/src/test/ui/malformed/malformed-derive-entry.rs
@@ -4,9 +4,6 @@
#[derive(Copy="bad")] //~ ERROR expected one of `)`, `,`, or `::`, found `=`
struct Test2;
-#[derive()] //~ WARNING empty trait list
-struct Test3;
-
#[derive] //~ ERROR malformed `derive` attribute input
struct Test4;
diff --git a/src/test/ui/malformed/malformed-derive-entry.stderr b/src/test/ui/malformed/malformed-derive-entry.stderr
index dfbc5fa..f7500fe 100644
--- a/src/test/ui/malformed/malformed-derive-entry.stderr
+++ b/src/test/ui/malformed/malformed-derive-entry.stderr
@@ -10,14 +10,8 @@
LL | #[derive(Copy="bad")]
| ^ expected one of `)`, `,`, or `::` here
-warning: empty trait list in `derive`
- --> $DIR/malformed-derive-entry.rs:7:1
- |
-LL | #[derive()]
- | ^^^^^^^^^^^
-
error: malformed `derive` attribute input
- --> $DIR/malformed-derive-entry.rs:10:1
+ --> $DIR/malformed-derive-entry.rs:7:1
|
LL | #[derive]
| ^^^^^^^^^ help: missing traits to be derived: `#[derive(Trait1, Trait2, ...)]`
diff --git a/src/test/ui/nll/closure-requirements/region-lbr1-does-outlive-lbr2-because-implied-bound.rs b/src/test/ui/nll/closure-requirements/region-lbr1-does-outlive-lbr2-because-implied-bound.rs
index 5a008ad..a558e8a 100644
--- a/src/test/ui/nll/closure-requirements/region-lbr1-does-outlive-lbr2-because-implied-bound.rs
+++ b/src/test/ui/nll/closure-requirements/region-lbr1-does-outlive-lbr2-because-implied-bound.rs
@@ -1,12 +1,11 @@
// Basic test for free regions in the NLL code. This test does not
// report an error because of the (implied) bound that `'b: 'a`.
+// check-pass
// compile-flags:-Zborrowck=mir -Zverbose
-// compile-pass
-// skip-codegen
fn foo<'a, 'b>(x: &'a &'b u32) -> &'a u32 {
&**x
}
-fn main() { }
+fn main() {}
diff --git a/src/test/ui/nll/issue-62007-assign-const-index.rs b/src/test/ui/nll/issue-62007-assign-const-index.rs
new file mode 100644
index 0000000..3ea5d3a
--- /dev/null
+++ b/src/test/ui/nll/issue-62007-assign-const-index.rs
@@ -0,0 +1,32 @@
+// Issue #62007: assigning over a const-index projection of an array
+// (in this case, `list[I] = n;`) should in theory be able to kill all borrows
+// of `list[0]`, so that `list[0]` could be borrowed on the next
+// iteration through the loop.
+//
+// Currently the compiler does not allow this. We may want to consider
+// loosening that restriction in the future. (However, doing so would
+// at *least* require T-lang team approval, and probably an RFC; e.g.
+// such loosening might make complicate the user's mental mode; it
+// also would make code more brittle in the face of refactorings that
+// replace constants with variables.
+
+#![allow(dead_code)]
+
+struct List<T> {
+ value: T,
+ next: Option<Box<List<T>>>,
+}
+
+fn to_refs<T>(mut list: [&mut List<T>; 2]) -> Vec<&mut T> {
+ let mut result = vec![];
+ loop {
+ result.push(&mut list[0].value); //~ ERROR cannot borrow `list[_].value` as mutable
+ if let Some(n) = list[0].next.as_mut() { //~ ERROR cannot borrow `list[_].next` as mutable
+ list[0] = n;
+ } else {
+ return result;
+ }
+ }
+}
+
+fn main() {}
diff --git a/src/test/ui/nll/issue-62007-assign-const-index.stderr b/src/test/ui/nll/issue-62007-assign-const-index.stderr
new file mode 100644
index 0000000..758a14d
--- /dev/null
+++ b/src/test/ui/nll/issue-62007-assign-const-index.stderr
@@ -0,0 +1,27 @@
+error[E0499]: cannot borrow `list[_].value` as mutable more than once at a time
+ --> $DIR/issue-62007-assign-const-index.rs:23:21
+ |
+LL | fn to_refs<T>(mut list: [&mut List<T>; 2]) -> Vec<&mut T> {
+ | - let's call the lifetime of this reference `'1`
+...
+LL | result.push(&mut list[0].value);
+ | ^^^^^^^^^^^^^^^^^^ mutable borrow starts here in previous iteration of loop
+...
+LL | return result;
+ | ------ returning this value requires that `list[_].value` is borrowed for `'1`
+
+error[E0499]: cannot borrow `list[_].next` as mutable more than once at a time
+ --> $DIR/issue-62007-assign-const-index.rs:24:26
+ |
+LL | fn to_refs<T>(mut list: [&mut List<T>; 2]) -> Vec<&mut T> {
+ | - let's call the lifetime of this reference `'1`
+...
+LL | if let Some(n) = list[0].next.as_mut() {
+ | ^^^^^^^^^^^^---------
+ | |
+ | mutable borrow starts here in previous iteration of loop
+ | argument requires that `list[_].next` is borrowed for `'1`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0499`.
diff --git a/src/test/ui/nll/issue-62007-assign-differing-fields.rs b/src/test/ui/nll/issue-62007-assign-differing-fields.rs
new file mode 100644
index 0000000..29d92b7
--- /dev/null
+++ b/src/test/ui/nll/issue-62007-assign-differing-fields.rs
@@ -0,0 +1,25 @@
+// Double-check we didn't go too far with our resolution to issue
+// #62007: assigning over a field projection (`list.1 = n;` in this
+// case) should kill only borrows of `list.1`; `list.0` can *not*
+// necessarily be borrowed on the next iteration through the loop.
+
+#![allow(dead_code)]
+
+struct List<T> {
+ value: T,
+ next: Option<Box<List<T>>>,
+}
+
+fn to_refs<'a, T>(mut list: (&'a mut List<T>, &'a mut List<T>)) -> Vec<&'a mut T> {
+ let mut result = vec![];
+ loop {
+ result.push(&mut (list.0).value); //~ ERROR cannot borrow `list.0.value` as mutable
+ if let Some(n) = (list.0).next.as_mut() { //~ ERROR cannot borrow `list.0.next` as mutable
+ list.1 = n;
+ } else {
+ return result;
+ }
+ }
+}
+
+fn main() {}
diff --git a/src/test/ui/nll/issue-62007-assign-differing-fields.stderr b/src/test/ui/nll/issue-62007-assign-differing-fields.stderr
new file mode 100644
index 0000000..f942d76
--- /dev/null
+++ b/src/test/ui/nll/issue-62007-assign-differing-fields.stderr
@@ -0,0 +1,27 @@
+error[E0499]: cannot borrow `list.0.value` as mutable more than once at a time
+ --> $DIR/issue-62007-assign-differing-fields.rs:16:21
+ |
+LL | fn to_refs<'a, T>(mut list: (&'a mut List<T>, &'a mut List<T>)) -> Vec<&'a mut T> {
+ | -- lifetime `'a` defined here
+...
+LL | result.push(&mut (list.0).value);
+ | ^^^^^^^^^^^^^^^^^^^ mutable borrow starts here in previous iteration of loop
+...
+LL | return result;
+ | ------ returning this value requires that `list.0.value` is borrowed for `'a`
+
+error[E0499]: cannot borrow `list.0.next` as mutable more than once at a time
+ --> $DIR/issue-62007-assign-differing-fields.rs:17:26
+ |
+LL | fn to_refs<'a, T>(mut list: (&'a mut List<T>, &'a mut List<T>)) -> Vec<&'a mut T> {
+ | -- lifetime `'a` defined here
+...
+LL | if let Some(n) = (list.0).next.as_mut() {
+ | ^^^^^^^^^^^^^---------
+ | |
+ | mutable borrow starts here in previous iteration of loop
+ | argument requires that `list.0.next` is borrowed for `'a`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0499`.
diff --git a/src/test/ui/parser/issue-17383.rs b/src/test/ui/parser/issue-17383.rs
index f95005c..7bf0e64 100644
--- a/src/test/ui/parser/issue-17383.rs
+++ b/src/test/ui/parser/issue-17383.rs
@@ -1,6 +1,6 @@
enum X {
A = 3,
- //~^ ERROR custom discriminant values are not allowed in enums with fields
+ //~^ ERROR custom discriminant values are not allowed in enums with tuple or struct variants
B(usize)
}
diff --git a/src/test/ui/parser/issue-17383.stderr b/src/test/ui/parser/issue-17383.stderr
index 37abd0f..486c405 100644
--- a/src/test/ui/parser/issue-17383.stderr
+++ b/src/test/ui/parser/issue-17383.stderr
@@ -1,11 +1,15 @@
-error: custom discriminant values are not allowed in enums with fields
+error[E0658]: custom discriminant values are not allowed in enums with tuple or struct variants
--> $DIR/issue-17383.rs:2:9
|
LL | A = 3,
- | ^ invalid custom discriminant
+ | ^ disallowed custom discriminant
LL |
LL | B(usize)
- | -------- variant with a field defined here
+ | -------- tuple variant defined here
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/60553
+ = help: add #![feature(arbitrary_enum_discriminant)] to the crate attributes to enable
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/parser/tag-variant-disr-non-nullary.rs b/src/test/ui/parser/tag-variant-disr-non-nullary.rs
index 305edc4..a9cfdd5 100644
--- a/src/test/ui/parser/tag-variant-disr-non-nullary.rs
+++ b/src/test/ui/parser/tag-variant-disr-non-nullary.rs
@@ -1,6 +1,6 @@
enum Color {
Red = 0xff0000,
- //~^ ERROR custom discriminant values are not allowed in enums with fields
+ //~^ ERROR custom discriminant values are not allowed in enums with tuple or struct variants
Green = 0x00ff00,
Blue = 0x0000ff,
Black = 0x000000,
diff --git a/src/test/ui/parser/tag-variant-disr-non-nullary.stderr b/src/test/ui/parser/tag-variant-disr-non-nullary.stderr
index 2d3b283..13b46c6 100644
--- a/src/test/ui/parser/tag-variant-disr-non-nullary.stderr
+++ b/src/test/ui/parser/tag-variant-disr-non-nullary.stderr
@@ -1,21 +1,25 @@
-error: custom discriminant values are not allowed in enums with fields
+error[E0658]: custom discriminant values are not allowed in enums with tuple or struct variants
--> $DIR/tag-variant-disr-non-nullary.rs:2:11
|
LL | Red = 0xff0000,
- | ^^^^^^^^ invalid custom discriminant
+ | ^^^^^^^^ disallowed custom discriminant
LL |
LL | Green = 0x00ff00,
- | ^^^^^^^^ invalid custom discriminant
+ | ^^^^^^^^ disallowed custom discriminant
LL | Blue = 0x0000ff,
- | ^^^^^^^^ invalid custom discriminant
+ | ^^^^^^^^ disallowed custom discriminant
LL | Black = 0x000000,
- | ^^^^^^^^ invalid custom discriminant
+ | ^^^^^^^^ disallowed custom discriminant
LL | White = 0xffffff,
- | ^^^^^^^^ invalid custom discriminant
+ | ^^^^^^^^ disallowed custom discriminant
LL | Other(usize),
- | ------------ variant with a field defined here
+ | ------------ tuple variant defined here
LL | Other2(usize, usize),
- | -------------------- variant with fields defined here
+ | -------------------- tuple variant defined here
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/60553
+ = help: add #![feature(arbitrary_enum_discriminant)] to the crate attributes to enable
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs
index 5dbd38e..d1e7c3b 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs
@@ -1,5 +1,5 @@
-// compile-pass
-// skip-codegen
+// check-pass
+
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(never_type)]
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs
index 74922d4..8973d21 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs
@@ -1,5 +1,5 @@
-// compile-pass
-// skip-codegen
+// check-pass
+
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(never_type)]
diff --git a/src/test/ui/rfc-2497-if-let-chains/ast-pretty-check.rs b/src/test/ui/rfc-2497-if-let-chains/ast-pretty-check.rs
new file mode 100644
index 0000000..e66d465
--- /dev/null
+++ b/src/test/ui/rfc-2497-if-let-chains/ast-pretty-check.rs
@@ -0,0 +1,6 @@
+// compile-pass
+// compile-flags: -Z unpretty=expanded
+
+fn main() {
+ if let 0 = 1 {}
+}
diff --git a/src/test/ui/rfc-2497-if-let-chains/ast-pretty-check.stdout b/src/test/ui/rfc-2497-if-let-chains/ast-pretty-check.stdout
new file mode 100644
index 0000000..a6b15f9
--- /dev/null
+++ b/src/test/ui/rfc-2497-if-let-chains/ast-pretty-check.stdout
@@ -0,0 +1,10 @@
+#![feature(prelude_import)]
+#![no_std]
+#[prelude_import]
+use ::std::prelude::v1::*;
+#[macro_use]
+extern crate std;
+// compile-pass
+// compile-flags: -Z unpretty=expanded
+
+fn main() { if let 0 = 1 { } }
diff --git a/src/test/ui/rfc-2497-if-let-chains/disallowed-positions.rs b/src/test/ui/rfc-2497-if-let-chains/disallowed-positions.rs
new file mode 100644
index 0000000..7d1e5c3
--- /dev/null
+++ b/src/test/ui/rfc-2497-if-let-chains/disallowed-positions.rs
@@ -0,0 +1,244 @@
+// Here we test that `lowering` behaves correctly wrt. `let $pats = $expr` expressions.
+//
+// We want to make sure that `let` is banned in situations other than:
+//
+// expr =
+// | ...
+// | "if" expr_with_let block {"else" block}?
+// | {label ":"}? while" expr_with_let block
+// ;
+//
+// expr_with_let =
+// | "let" top_pats "=" expr
+// | expr_with_let "&&" expr_with_let
+// | "(" expr_with_let ")"
+// | expr
+// ;
+//
+// To that end, we check some positions which is not part of the language above.
+
+#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete
+#![feature(let_chains)] // Avoid inflating `.stderr` with overzealous gates in this test.
+//~^ WARN the feature `let_chains` is incomplete
+
+#![allow(irrefutable_let_patterns)]
+
+use std::ops::Range;
+
+fn main() {}
+
+fn nested_within_if_expr() {
+ if &let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+
+ if !let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ if *let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR type `bool` cannot be dereferenced
+ if -let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR cannot apply unary operator `-` to type `bool`
+
+ fn _check_try_binds_tighter() -> Result<(), ()> {
+ if let 0 = 0? {}
+ //~^ ERROR the `?` operator can only be applied to values that implement `std::ops::Try`
+ Ok(())
+ }
+ if (let 0 = 0)? {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR the `?` operator can only be applied to values that implement `std::ops::Try`
+ //~| ERROR the `?` operator can only be used in a function that returns `Result`
+
+ if true || let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ if (true || let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ if true && (true || let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ if true || (true && let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+
+ let mut x = true;
+ if x = let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+
+ if true..(let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+ if ..(let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+ if (let 0 = 0).. {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+
+ // Binds as `(let ... = true)..true &&/|| false`.
+ if let Range { start: _, end: _ } = true..true && false {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+ if let Range { start: _, end: _ } = true..true || false {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+
+ // Binds as `(let Range { start: F, end } = F)..(|| true)`.
+ const F: fn() -> bool = || true;
+ if let Range { start: F, end } = F..|| true {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+
+ // Binds as `(let Range { start: true, end } = t)..(&&false)`.
+ let t = &&true;
+ if let Range { start: true, end } = t..&&false {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+
+ if let true = let true = true {} //~ ERROR `let` expressions are not supported here
+}
+
+fn nested_within_while_expr() {
+ while &let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+
+ while !let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ while *let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR type `bool` cannot be dereferenced
+ while -let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR cannot apply unary operator `-` to type `bool`
+
+ fn _check_try_binds_tighter() -> Result<(), ()> {
+ while let 0 = 0? {}
+ //~^ ERROR the `?` operator can only be applied to values that implement `std::ops::Try`
+ Ok(())
+ }
+ while (let 0 = 0)? {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR the `?` operator can only be applied to values that implement `std::ops::Try`
+ //~| ERROR the `?` operator can only be used in a function that returns `Result`
+
+ while true || let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ while (true || let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ while true && (true || let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ while true || (true && let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+
+ let mut x = true;
+ while x = let 0 = 0 {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+
+ while true..(let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+ while ..(let 0 = 0) {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+ while (let 0 = 0).. {} //~ ERROR `let` expressions are not supported here
+ //~^ ERROR mismatched types
+
+ // Binds as `(let ... = true)..true &&/|| false`.
+ while let Range { start: _, end: _ } = true..true && false {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+ while let Range { start: _, end: _ } = true..true || false {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+
+ // Binds as `(let Range { start: F, end } = F)..(|| true)`.
+ const F: fn() -> bool = || true;
+ while let Range { start: F, end } = F..|| true {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+
+ // Binds as `(let Range { start: true, end } = t)..(&&false)`.
+ let t = &&true;
+ while let Range { start: true, end } = t..&&false {}
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+ //~| ERROR mismatched types
+
+ while let true = let true = true {} //~ ERROR `let` expressions are not supported here
+}
+
+fn not_error_because_clarified_intent() {
+ if let Range { start: _, end: _ } = (true..true || false) { }
+
+ if let Range { start: _, end: _ } = (true..true && false) { }
+
+ while let Range { start: _, end: _ } = (true..true || false) { }
+
+ while let Range { start: _, end: _ } = (true..true && false) { }
+}
+
+fn outside_if_and_while_expr() {
+ &let 0 = 0; //~ ERROR `let` expressions are not supported here
+
+ !let 0 = 0; //~ ERROR `let` expressions are not supported here
+ *let 0 = 0; //~ ERROR `let` expressions are not supported here
+ //~^ ERROR type `bool` cannot be dereferenced
+ -let 0 = 0; //~ ERROR `let` expressions are not supported here
+ //~^ ERROR cannot apply unary operator `-` to type `bool`
+
+ fn _check_try_binds_tighter() -> Result<(), ()> {
+ let 0 = 0?;
+ //~^ ERROR the `?` operator can only be applied to values that implement `std::ops::Try`
+ Ok(())
+ }
+ (let 0 = 0)?; //~ ERROR `let` expressions are not supported here
+ //~^ ERROR the `?` operator can only be used in a function that returns `Result`
+ //~| ERROR the `?` operator can only be applied to values that implement `std::ops::Try`
+
+ true || let 0 = 0; //~ ERROR `let` expressions are not supported here
+ (true || let 0 = 0); //~ ERROR `let` expressions are not supported here
+ true && (true || let 0 = 0); //~ ERROR `let` expressions are not supported here
+
+ let mut x = true;
+ x = let 0 = 0; //~ ERROR `let` expressions are not supported here
+
+ true..(let 0 = 0); //~ ERROR `let` expressions are not supported here
+ ..(let 0 = 0); //~ ERROR `let` expressions are not supported here
+ (let 0 = 0)..; //~ ERROR `let` expressions are not supported here
+
+ (let Range { start: _, end: _ } = true..true || false);
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+
+ (let true = let true = true);
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+
+ // Check function tail position.
+ &let 0 = 0
+ //~^ ERROR `let` expressions are not supported here
+ //~| ERROR mismatched types
+}
+
+// Let's make sure that `let` inside const generic arguments are considered.
+fn inside_const_generic_arguments() {
+ struct A<const B: bool>;
+ impl<const B: bool> A<{B}> { const O: u32 = 5; }
+
+ if let A::<{
+ true && let 1 = 1 //~ ERROR `let` expressions are not supported here
+ //~^ ERROR constant contains unimplemented expression type
+ //~| ERROR constant contains unimplemented expression type
+ }>::O = 5 {}
+
+ while let A::<{
+ true && let 1 = 1 //~ ERROR `let` expressions are not supported here
+ //~^ ERROR constant contains unimplemented expression type
+ //~| ERROR constant contains unimplemented expression type
+ }>::O = 5 {}
+
+ if A::<{
+ true && let 1 = 1 //~ ERROR `let` expressions are not supported here
+ //~^ ERROR constant contains unimplemented expression type
+ //~| ERROR constant contains unimplemented expression type
+ }>::O == 5 {}
+
+ // In the cases above we have `ExprKind::Block` to help us out.
+ // Below however, we would not have a block and so an implementation might go
+ // from visiting expressions to types without banning `let` expressions down the tree.
+ // This tests ensures that we are not caught by surprise should the parser
+ // admit non-IDENT expressions in const generic arguments.
+
+ if A::<
+ true && let 1 = 1 //~ ERROR expected one of `,` or `>`, found `&&`
+ >::O == 5 {}
+}
diff --git a/src/test/ui/rfc-2497-if-let-chains/disallowed-positions.stderr b/src/test/ui/rfc-2497-if-let-chains/disallowed-positions.stderr
new file mode 100644
index 0000000..207d0d6
--- /dev/null
+++ b/src/test/ui/rfc-2497-if-let-chains/disallowed-positions.stderr
@@ -0,0 +1,987 @@
+error: expected one of `,` or `>`, found `&&`
+ --> $DIR/disallowed-positions.rs:242:14
+ |
+LL | true && let 1 = 1
+ | ^^ expected one of `,` or `>` here
+
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+ --> $DIR/disallowed-positions.rs:20:12
+ |
+LL | #![feature(const_generics)]
+ | ^^^^^^^^^^^^^^
+
+warning: the feature `let_chains` is incomplete and may cause the compiler to crash
+ --> $DIR/disallowed-positions.rs:22:12
+ |
+LL | #![feature(let_chains)] // Avoid inflating `.stderr` with overzealous gates in this test.
+ | ^^^^^^^^^^
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:32:9
+ |
+LL | if &let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:35:9
+ |
+LL | if !let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:36:9
+ |
+LL | if *let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:38:9
+ |
+LL | if -let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:46:9
+ |
+LL | if (let 0 = 0)? {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:50:16
+ |
+LL | if true || let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:51:17
+ |
+LL | if (true || let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:52:25
+ |
+LL | if true && (true || let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:53:25
+ |
+LL | if true || (true && let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:56:12
+ |
+LL | if x = let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:59:15
+ |
+LL | if true..(let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:61:11
+ |
+LL | if ..(let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:63:9
+ |
+LL | if (let 0 = 0).. {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:67:8
+ |
+LL | if let Range { start: _, end: _ } = true..true && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:71:8
+ |
+LL | if let Range { start: _, end: _ } = true..true || false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:78:8
+ |
+LL | if let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:86:8
+ |
+LL | if let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:92:19
+ |
+LL | if let true = let true = true {}
+ | ^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:96:12
+ |
+LL | while &let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:99:12
+ |
+LL | while !let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:100:12
+ |
+LL | while *let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:102:12
+ |
+LL | while -let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:110:12
+ |
+LL | while (let 0 = 0)? {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:114:19
+ |
+LL | while true || let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:115:20
+ |
+LL | while (true || let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:116:28
+ |
+LL | while true && (true || let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:117:28
+ |
+LL | while true || (true && let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:120:15
+ |
+LL | while x = let 0 = 0 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:123:18
+ |
+LL | while true..(let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:125:14
+ |
+LL | while ..(let 0 = 0) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:127:12
+ |
+LL | while (let 0 = 0).. {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:131:11
+ |
+LL | while let Range { start: _, end: _ } = true..true && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:135:11
+ |
+LL | while let Range { start: _, end: _ } = true..true || false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:142:11
+ |
+LL | while let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:150:11
+ |
+LL | while let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:156:22
+ |
+LL | while let true = let true = true {}
+ | ^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:170:6
+ |
+LL | &let 0 = 0;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:172:6
+ |
+LL | !let 0 = 0;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:173:6
+ |
+LL | *let 0 = 0;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:175:6
+ |
+LL | -let 0 = 0;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:183:6
+ |
+LL | (let 0 = 0)?;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:187:13
+ |
+LL | true || let 0 = 0;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:188:14
+ |
+LL | (true || let 0 = 0);
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:189:22
+ |
+LL | true && (true || let 0 = 0);
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:192:9
+ |
+LL | x = let 0 = 0;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:194:12
+ |
+LL | true..(let 0 = 0);
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:195:8
+ |
+LL | ..(let 0 = 0);
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:196:6
+ |
+LL | (let 0 = 0)..;
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:198:6
+ |
+LL | (let Range { start: _, end: _ } = true..true || false);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:202:6
+ |
+LL | (let true = let true = true);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:202:17
+ |
+LL | (let true = let true = true);
+ | ^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:207:6
+ |
+LL | &let 0 = 0
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:218:17
+ |
+LL | true && let 1 = 1
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:224:17
+ |
+LL | true && let 1 = 1
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/disallowed-positions.rs:230:17
+ |
+LL | true && let 1 = 1
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:32:8
+ |
+LL | if &let 0 = 0 {}
+ | ^^^^^^^^^^ expected bool, found &bool
+ |
+ = note: expected type `bool`
+ found type `&bool`
+
+error[E0614]: type `bool` cannot be dereferenced
+ --> $DIR/disallowed-positions.rs:36:8
+ |
+LL | if *let 0 = 0 {}
+ | ^^^^^^^^^^
+
+error[E0600]: cannot apply unary operator `-` to type `bool`
+ --> $DIR/disallowed-positions.rs:38:8
+ |
+LL | if -let 0 = 0 {}
+ | ^^^^^^^^^^ cannot apply unary operator `-`
+ |
+ = note: an implementation of `std::ops::Neg` might be missing for `bool`
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/disallowed-positions.rs:46:8
+ |
+LL | if (let 0 = 0)? {}
+ | ^^^^^^^^^^^^ the `?` operator cannot be applied to type `bool`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `bool`
+ = note: required by `std::ops::Try::into_result`
+
+error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
+ --> $DIR/disallowed-positions.rs:46:8
+ |
+LL | if (let 0 = 0)? {}
+ | ^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `()`
+ = note: required by `std::ops::Try::from_error`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:56:8
+ |
+LL | if x = let 0 = 0 {}
+ | ^^^^^^^^^^^^^
+ | |
+ | expected bool, found ()
+ | help: try comparing for equality: `x == let 0 = 0`
+ |
+ = note: expected type `bool`
+ found type `()`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:59:8
+ |
+LL | if true..(let 0 = 0) {}
+ | ^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:61:8
+ |
+LL | if ..(let 0 = 0) {}
+ | ^^^^^^^^^^^^^ expected bool, found struct `std::ops::RangeTo`
+ |
+ = note: expected type `bool`
+ found type `std::ops::RangeTo<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:63:8
+ |
+LL | if (let 0 = 0).. {}
+ | ^^^^^^^^^^^^^ expected bool, found struct `std::ops::RangeFrom`
+ |
+ = note: expected type `bool`
+ found type `std::ops::RangeFrom<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:67:12
+ |
+LL | if let Range { start: _, end: _ } = true..true && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ---- this match expression has type `bool`
+ | |
+ | expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:67:8
+ |
+LL | if let Range { start: _, end: _ } = true..true && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:71:12
+ |
+LL | if let Range { start: _, end: _ } = true..true || false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ---- this match expression has type `bool`
+ | |
+ | expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:71:8
+ |
+LL | if let Range { start: _, end: _ } = true..true || false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:78:12
+ |
+LL | if let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^ expected fn pointer, found struct `std::ops::Range`
+ |
+ = note: expected type `fn() -> bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:78:41
+ |
+LL | if let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^ expected bool, found closure
+ |
+ = note: expected type `bool`
+ found type `[closure@$DIR/disallowed-positions.rs:78:41: 78:48]`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:78:8
+ |
+LL | if let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:86:12
+ |
+LL | if let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ - this match expression has type `bool`
+ | |
+ | expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:86:44
+ |
+LL | if let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^ expected bool, found &&bool
+ |
+ = note: expected type `bool`
+ found type `&&bool`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:86:8
+ |
+LL | if let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/disallowed-positions.rs:42:20
+ |
+LL | if let 0 = 0? {}
+ | ^^ the `?` operator cannot be applied to type `{integer}`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `{integer}`
+ = note: required by `std::ops::Try::into_result`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:96:11
+ |
+LL | while &let 0 = 0 {}
+ | ^^^^^^^^^^ expected bool, found &bool
+ |
+ = note: expected type `bool`
+ found type `&bool`
+
+error[E0614]: type `bool` cannot be dereferenced
+ --> $DIR/disallowed-positions.rs:100:11
+ |
+LL | while *let 0 = 0 {}
+ | ^^^^^^^^^^
+
+error[E0600]: cannot apply unary operator `-` to type `bool`
+ --> $DIR/disallowed-positions.rs:102:11
+ |
+LL | while -let 0 = 0 {}
+ | ^^^^^^^^^^ cannot apply unary operator `-`
+ |
+ = note: an implementation of `std::ops::Neg` might be missing for `bool`
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/disallowed-positions.rs:110:11
+ |
+LL | while (let 0 = 0)? {}
+ | ^^^^^^^^^^^^ the `?` operator cannot be applied to type `bool`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `bool`
+ = note: required by `std::ops::Try::into_result`
+
+error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
+ --> $DIR/disallowed-positions.rs:110:11
+ |
+LL | while (let 0 = 0)? {}
+ | ^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `()`
+ = note: required by `std::ops::Try::from_error`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:120:11
+ |
+LL | while x = let 0 = 0 {}
+ | ^^^^^^^^^^^^^
+ | |
+ | expected bool, found ()
+ | help: try comparing for equality: `x == let 0 = 0`
+ |
+ = note: expected type `bool`
+ found type `()`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:123:11
+ |
+LL | while true..(let 0 = 0) {}
+ | ^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:125:11
+ |
+LL | while ..(let 0 = 0) {}
+ | ^^^^^^^^^^^^^ expected bool, found struct `std::ops::RangeTo`
+ |
+ = note: expected type `bool`
+ found type `std::ops::RangeTo<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:127:11
+ |
+LL | while (let 0 = 0).. {}
+ | ^^^^^^^^^^^^^ expected bool, found struct `std::ops::RangeFrom`
+ |
+ = note: expected type `bool`
+ found type `std::ops::RangeFrom<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:131:15
+ |
+LL | while let Range { start: _, end: _ } = true..true && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ---- this match expression has type `bool`
+ | |
+ | expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:131:11
+ |
+LL | while let Range { start: _, end: _ } = true..true && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:135:15
+ |
+LL | while let Range { start: _, end: _ } = true..true || false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ---- this match expression has type `bool`
+ | |
+ | expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:135:11
+ |
+LL | while let Range { start: _, end: _ } = true..true || false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:142:15
+ |
+LL | while let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^ expected fn pointer, found struct `std::ops::Range`
+ |
+ = note: expected type `fn() -> bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:142:44
+ |
+LL | while let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^ expected bool, found closure
+ |
+ = note: expected type `bool`
+ found type `[closure@$DIR/disallowed-positions.rs:142:44: 142:51]`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:142:11
+ |
+LL | while let Range { start: F, end } = F..|| true {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:150:15
+ |
+LL | while let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ - this match expression has type `bool`
+ | |
+ | expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:150:47
+ |
+LL | while let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^ expected bool, found &&bool
+ |
+ = note: expected type `bool`
+ found type `&&bool`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:150:11
+ |
+LL | while let Range { start: true, end } = t..&&false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<bool>`
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/disallowed-positions.rs:106:23
+ |
+LL | while let 0 = 0? {}
+ | ^^ the `?` operator cannot be applied to type `{integer}`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `{integer}`
+ = note: required by `std::ops::Try::into_result`
+
+error[E0614]: type `bool` cannot be dereferenced
+ --> $DIR/disallowed-positions.rs:173:5
+ |
+LL | *let 0 = 0;
+ | ^^^^^^^^^^
+
+error[E0600]: cannot apply unary operator `-` to type `bool`
+ --> $DIR/disallowed-positions.rs:175:5
+ |
+LL | -let 0 = 0;
+ | ^^^^^^^^^^ cannot apply unary operator `-`
+ |
+ = note: an implementation of `std::ops::Neg` might be missing for `bool`
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/disallowed-positions.rs:183:5
+ |
+LL | (let 0 = 0)?;
+ | ^^^^^^^^^^^^ the `?` operator cannot be applied to type `bool`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `bool`
+ = note: required by `std::ops::Try::into_result`
+
+error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
+ --> $DIR/disallowed-positions.rs:183:5
+ |
+LL | (let 0 = 0)?;
+ | ^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `()`
+ = note: required by `std::ops::Try::from_error`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:198:10
+ |
+LL | (let Range { start: _, end: _ } = true..true || false);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ---- this match expression has type `bool`
+ | |
+ | expected bool, found struct `std::ops::Range`
+ |
+ = note: expected type `bool`
+ found type `std::ops::Range<_>`
+
+error[E0308]: mismatched types
+ --> $DIR/disallowed-positions.rs:207:5
+ |
+LL | fn outside_if_and_while_expr() {
+ | - help: try adding a return type: `-> &bool`
+...
+LL | &let 0 = 0
+ | ^^^^^^^^^^ expected (), found &bool
+ |
+ = note: expected type `()`
+ found type `&bool`
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/disallowed-positions.rs:179:17
+ |
+LL | let 0 = 0?;
+ | ^^ the `?` operator cannot be applied to type `{integer}`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `{integer}`
+ = note: required by `std::ops::Try::into_result`
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/disallowed-positions.rs:218:25
+ |
+LL | true && let 1 = 1
+ | ^
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/disallowed-positions.rs:218:21
+ |
+LL | true && let 1 = 1
+ | ^
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/disallowed-positions.rs:224:25
+ |
+LL | true && let 1 = 1
+ | ^
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/disallowed-positions.rs:224:21
+ |
+LL | true && let 1 = 1
+ | ^
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/disallowed-positions.rs:230:25
+ |
+LL | true && let 1 = 1
+ | ^
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/disallowed-positions.rs:230:21
+ |
+LL | true && let 1 = 1
+ | ^
+
+error: aborting due to 109 previous errors
+
+Some errors have detailed explanations: E0019, E0277, E0308, E0600, E0614.
+For more information about an error, try `rustc --explain E0019`.
diff --git a/src/test/ui/rfc-2497-if-let-chains/feature-gate.rs b/src/test/ui/rfc-2497-if-let-chains/feature-gate.rs
new file mode 100644
index 0000000..6498766
--- /dev/null
+++ b/src/test/ui/rfc-2497-if-let-chains/feature-gate.rs
@@ -0,0 +1,136 @@
+// gate-test-let_chains
+
+// Here we test feature gating for ´let_chains`.
+// See `disallowed-positions.rs` for the grammar
+// defining the language for gated allowed positions.
+
+#![allow(irrefutable_let_patterns)]
+
+use std::ops::Range;
+
+fn _if() {
+ if let 0 = 1 {} // Stable!
+
+ if (let 0 = 1) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ if (((let 0 = 1))) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ if true && let 0 = 1 {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ if let 0 = 1 && true {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ if (let 0 = 1) && true {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ if true && (let 0 = 1) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ if (let 0 = 1) && (let 0 = 1) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+
+ if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+
+ if let Range { start: _, end: _ } = (true..true) && false {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+}
+
+fn _while() {
+ while let 0 = 1 {} // Stable!
+
+ while (let 0 = 1) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ while (((let 0 = 1))) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ while true && let 0 = 1 {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ while let 0 = 1 && true {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ while (let 0 = 1) && true {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ while true && (let 0 = 1) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+
+ while (let 0 = 1) && (let 0 = 1) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+
+ while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+ //~| ERROR `let` expressions are not supported here
+
+ while let Range { start: _, end: _ } = (true..true) && false {}
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+}
+
+fn _macros() {
+ macro_rules! noop_expr { ($e:expr) => {}; }
+
+ noop_expr!((let 0 = 1));
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+
+ macro_rules! use_expr {
+ ($e:expr) => {
+ if $e {}
+ while $e {}
+ }
+ }
+ use_expr!((let 0 = 1 && 0 == 0));
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+ use_expr!((let 0 = 1));
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ //~| ERROR `let` expressions are not supported here
+ #[cfg(FALSE)] (let 0 = 1);
+ //~^ ERROR `let` expressions in this position are experimental [E0658]
+ use_expr!(let 0 = 1);
+ //~^ ERROR no rules expected the token `let`
+ // ^--- FIXME(53667): Consider whether `Let` can be added to `ident_can_begin_expr`.
+}
+
+fn main() {}
diff --git a/src/test/ui/rfc-2497-if-let-chains/feature-gate.stderr b/src/test/ui/rfc-2497-if-let-chains/feature-gate.stderr
new file mode 100644
index 0000000..6167427
--- /dev/null
+++ b/src/test/ui/rfc-2497-if-let-chains/feature-gate.stderr
@@ -0,0 +1,570 @@
+error: no rules expected the token `let`
+ --> $DIR/feature-gate.rs:131:15
+ |
+LL | macro_rules! use_expr {
+ | --------------------- when calling this macro
+...
+LL | use_expr!(let 0 = 1);
+ | ^^^ no rules expected this token in macro call
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:14:9
+ |
+LL | if (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:18:11
+ |
+LL | if (((let 0 = 1))) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:22:16
+ |
+LL | if true && let 0 = 1 {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:26:8
+ |
+LL | if let 0 = 1 && true {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:30:9
+ |
+LL | if (let 0 = 1) && true {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:34:17
+ |
+LL | if true && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:38:9
+ |
+LL | if (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:38:24
+ |
+LL | if (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:44:8
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:44:21
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:44:35
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:44:48
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:44:61
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:56:8
+ |
+LL | if let Range { start: _, end: _ } = (true..true) && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:64:12
+ |
+LL | while (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:68:14
+ |
+LL | while (((let 0 = 1))) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:72:19
+ |
+LL | while true && let 0 = 1 {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:76:11
+ |
+LL | while let 0 = 1 && true {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:80:12
+ |
+LL | while (let 0 = 1) && true {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:84:20
+ |
+LL | while true && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:88:12
+ |
+LL | while (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:88:27
+ |
+LL | while (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:94:11
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:94:24
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:94:38
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:94:51
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:94:64
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:106:11
+ |
+LL | while let Range { start: _, end: _ } = (true..true) && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:129:20
+ |
+LL | #[cfg(FALSE)] (let 0 = 1);
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:114:17
+ |
+LL | noop_expr!((let 0 = 1));
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:123:16
+ |
+LL | use_expr!((let 0 = 1 && 0 == 0));
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error[E0658]: `let` expressions in this position are experimental
+ --> $DIR/feature-gate.rs:126:16
+ |
+LL | use_expr!((let 0 = 1));
+ | ^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/53667
+ = help: add #![feature(let_chains)] to the crate attributes to enable
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:14:9
+ |
+LL | if (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:18:11
+ |
+LL | if (((let 0 = 1))) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:22:16
+ |
+LL | if true && let 0 = 1 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:26:8
+ |
+LL | if let 0 = 1 && true {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:30:9
+ |
+LL | if (let 0 = 1) && true {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:34:17
+ |
+LL | if true && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:38:9
+ |
+LL | if (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:38:24
+ |
+LL | if (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:44:8
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:44:21
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:44:35
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:44:48
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:44:61
+ |
+LL | if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:56:8
+ |
+LL | if let Range { start: _, end: _ } = (true..true) && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:64:12
+ |
+LL | while (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:68:14
+ |
+LL | while (((let 0 = 1))) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:72:19
+ |
+LL | while true && let 0 = 1 {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:76:11
+ |
+LL | while let 0 = 1 && true {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:80:12
+ |
+LL | while (let 0 = 1) && true {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:84:20
+ |
+LL | while true && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:88:12
+ |
+LL | while (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:88:27
+ |
+LL | while (let 0 = 1) && (let 0 = 1) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:94:11
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:94:24
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:94:38
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:94:51
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:94:64
+ |
+LL | while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:106:11
+ |
+LL | while let Range { start: _, end: _ } = (true..true) && false {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:123:16
+ |
+LL | use_expr!((let 0 = 1 && 0 == 0));
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: `let` expressions are not supported here
+ --> $DIR/feature-gate.rs:126:16
+ |
+LL | use_expr!((let 0 = 1));
+ | ^^^^^^^^^
+ |
+ = note: only supported directly in conditions of `if`- and `while`-expressions
+ = note: as well as when nested within `&&` and parenthesis in those conditions
+
+error: aborting due to 63 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/rfc-2497-if-let-chains/protect-precedences.rs b/src/test/ui/rfc-2497-if-let-chains/protect-precedences.rs
new file mode 100644
index 0000000..1de4e5b
--- /dev/null
+++ b/src/test/ui/rfc-2497-if-let-chains/protect-precedences.rs
@@ -0,0 +1,18 @@
+// run-pass
+
+#![allow(irrefutable_let_patterns)]
+
+use std::ops::Range;
+
+fn main() {
+ let x: bool;
+ // This should associate as: `(x = (true && false));`.
+ x = true && false;
+ assert!(!x);
+
+ fn _f1() -> bool {
+ // Should associate as `(let _ = (return (true && false)))`.
+ if let _ = return true && false {};
+ }
+ assert!(!_f1());
+}
diff --git a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2015.rs b/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2015.rs
deleted file mode 100644
index d79798d..0000000
--- a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2015.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// edition:2015
-
-// Enabling `ireffutable_let_patterns` isn't necessary for what this tests, but it makes coming up
-// with examples easier.
-
-#[allow(irrefutable_let_patterns)]
-fn main() {
- use std::ops::Range;
-
- if let Range { start: _, end: _ } = true..true && false { }
- //~^ ERROR ambiguous use of `&&`
-
- if let Range { start: _, end: _ } = true..true || false { }
- //~^ ERROR ambiguous use of `||`
-
- while let Range { start: _, end: _ } = true..true && false { }
- //~^ ERROR ambiguous use of `&&`
-
- while let Range { start: _, end: _ } = true..true || false { }
- //~^ ERROR ambiguous use of `||`
-
- if let true = false && false { }
- //~^ ERROR ambiguous use of `&&`
-
- while let true = (1 == 2) && false { }
- //~^ ERROR ambiguous use of `&&`
-
- // The following cases are not an error as parenthesis are used to
- // clarify intent:
-
- if let Range { start: _, end: _ } = true..(true || false) { }
-
- if let Range { start: _, end: _ } = true..(true && false) { }
-
- while let Range { start: _, end: _ } = true..(true || false) { }
-
- while let Range { start: _, end: _ } = true..(true && false) { }
-}
diff --git a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2015.stderr b/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2015.stderr
deleted file mode 100644
index 2cd59fe..0000000
--- a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2015.stderr
+++ /dev/null
@@ -1,56 +0,0 @@
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2015.rs:10:47
- |
-LL | if let Range { start: _, end: _ } = true..true && false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `||`
- --> $DIR/syntax-ambiguity-2015.rs:13:47
- |
-LL | if let Range { start: _, end: _ } = true..true || false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true || false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2015.rs:16:50
- |
-LL | while let Range { start: _, end: _ } = true..true && false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `||`
- --> $DIR/syntax-ambiguity-2015.rs:19:50
- |
-LL | while let Range { start: _, end: _ } = true..true || false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true || false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2015.rs:22:19
- |
-LL | if let true = false && false { }
- | ^^^^^^^^^^^^^^ help: consider adding parentheses: `(false && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2015.rs:25:22
- |
-LL | while let true = (1 == 2) && false { }
- | ^^^^^^^^^^^^^^^^^ help: consider adding parentheses: `((1 == 2) && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: aborting due to 6 previous errors
-
diff --git a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2018.rs b/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2018.rs
deleted file mode 100644
index 687bf65..0000000
--- a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2018.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// edition:2018
-
-// Enabling `ireffutable_let_patterns` isn't necessary for what this tests, but it makes coming up
-// with examples easier.
-
-#[allow(irrefutable_let_patterns)]
-fn main() {
- use std::ops::Range;
-
- if let Range { start: _, end: _ } = true..true && false { }
- //~^ ERROR ambiguous use of `&&`
-
- if let Range { start: _, end: _ } = true..true || false { }
- //~^ ERROR ambiguous use of `||`
-
- while let Range { start: _, end: _ } = true..true && false { }
- //~^ ERROR ambiguous use of `&&`
-
- while let Range { start: _, end: _ } = true..true || false { }
- //~^ ERROR ambiguous use of `||`
-
- if let true = false && false { }
- //~^ ERROR ambiguous use of `&&`
-
- while let true = (1 == 2) && false { }
- //~^ ERROR ambiguous use of `&&`
-
- // The following cases are not an error as parenthesis are used to
- // clarify intent:
-
- if let Range { start: _, end: _ } = true..(true || false) { }
-
- if let Range { start: _, end: _ } = true..(true && false) { }
-
- while let Range { start: _, end: _ } = true..(true || false) { }
-
- while let Range { start: _, end: _ } = true..(true && false) { }
-}
diff --git a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2018.stderr b/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2018.stderr
deleted file mode 100644
index cbba2d7..0000000
--- a/src/test/ui/rfc-2497-if-let-chains/syntax-ambiguity-2018.stderr
+++ /dev/null
@@ -1,56 +0,0 @@
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2018.rs:10:47
- |
-LL | if let Range { start: _, end: _ } = true..true && false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `||`
- --> $DIR/syntax-ambiguity-2018.rs:13:47
- |
-LL | if let Range { start: _, end: _ } = true..true || false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true || false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2018.rs:16:50
- |
-LL | while let Range { start: _, end: _ } = true..true && false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `||`
- --> $DIR/syntax-ambiguity-2018.rs:19:50
- |
-LL | while let Range { start: _, end: _ } = true..true || false { }
- | ^^^^^^^^^^^^^ help: consider adding parentheses: `(true || false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2018.rs:22:19
- |
-LL | if let true = false && false { }
- | ^^^^^^^^^^^^^^ help: consider adding parentheses: `(false && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: ambiguous use of `&&`
- --> $DIR/syntax-ambiguity-2018.rs:25:22
- |
-LL | while let true = (1 == 2) && false { }
- | ^^^^^^^^^^^^^^^^^ help: consider adding parentheses: `((1 == 2) && false)`
- |
- = note: this will be a error until the `let_chains` feature is stabilized
- = note: see rust-lang/rust#53668 for more information
-
-error: aborting due to 6 previous errors
-
diff --git a/src/test/ui/single-use-lifetime/one-use-in-fn-return.rs b/src/test/ui/single-use-lifetime/one-use-in-fn-return.rs
index 876a0a5..92b25cb 100644
--- a/src/test/ui/single-use-lifetime/one-use-in-fn-return.rs
+++ b/src/test/ui/single-use-lifetime/one-use-in-fn-return.rs
@@ -1,20 +1,16 @@
-// compile-pass
-
-#![deny(single_use_lifetimes)]
-#![allow(dead_code)]
-#![allow(unused_variables)]
-
// Test that we DO NOT warn when lifetime name is used only
// once in a fn return type -- using `'_` is not legal there,
// as it must refer back to an argument.
//
// (Normally, using `'static` would be preferred, but there are
// times when that is not what you want.)
-//
-// run-pass
+
+// compile-pass
+
+#![deny(single_use_lifetimes)]
fn b<'a>() -> &'a u32 { // OK: used only in return type
&22
}
-fn main() { }
+fn main() {}
diff --git a/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.rs b/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.rs
index d6c611d..e4abf31 100644
--- a/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.rs
+++ b/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.rs
@@ -11,12 +11,12 @@
// Straight list expansion:
type _T0 = dyn _1;
-//~^ ERROR at least one non-builtin trait is required for an object type [E0224]
+//~^ ERROR at least one trait is required for an object type [E0224]
// Twice:
trait _2 = _1 + _1;
type _T1 = dyn _2;
-//~^ ERROR at least one non-builtin trait is required for an object type [E0224]
+//~^ ERROR at least one trait is required for an object type [E0224]
fn main() {}
diff --git a/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.stderr b/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.stderr
index d4f77200..6de79fa 100644
--- a/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.stderr
+++ b/src/test/ui/traits/trait-alias/trait-alias-only-maybe-bound.stderr
@@ -1,10 +1,10 @@
-error[E0224]: at least one non-builtin trait is required for an object type
+error[E0224]: at least one trait is required for an object type
--> $DIR/trait-alias-only-maybe-bound.rs:13:12
|
LL | type _T0 = dyn _1;
| ^^^^^^
-error[E0224]: at least one non-builtin trait is required for an object type
+error[E0224]: at least one trait is required for an object type
--> $DIR/trait-alias-only-maybe-bound.rs:19:12
|
LL | type _T1 = dyn _2;
diff --git a/src/test/ui/traits/trait-object-macro-matcher.rs b/src/test/ui/traits/trait-object-macro-matcher.rs
index 5ec1572..a685256 100644
--- a/src/test/ui/traits/trait-object-macro-matcher.rs
+++ b/src/test/ui/traits/trait-object-macro-matcher.rs
@@ -8,5 +8,5 @@
m!(dyn Copy + Send + 'static);
//~^ ERROR the trait `std::marker::Copy` cannot be made into an object
m!(dyn 'static + Send);
- m!(dyn 'static +); //~ ERROR at least one non-builtin trait is required for an object type
+ m!(dyn 'static +); //~ ERROR at least one trait is required for an object type
}
diff --git a/src/test/ui/traits/trait-object-macro-matcher.stderr b/src/test/ui/traits/trait-object-macro-matcher.stderr
index 0b84c3d..6b5effa 100644
--- a/src/test/ui/traits/trait-object-macro-matcher.stderr
+++ b/src/test/ui/traits/trait-object-macro-matcher.stderr
@@ -1,4 +1,4 @@
-error[E0224]: at least one non-builtin trait is required for an object type
+error[E0224]: at least one trait is required for an object type
--> $DIR/trait-object-macro-matcher.rs:11:8
|
LL | m!(dyn 'static +);
diff --git a/src/test/ui/traits/trait-object-vs-lifetime-2.rs b/src/test/ui/traits/trait-object-vs-lifetime-2.rs
index 8a9b8e7..0b33dc7 100644
--- a/src/test/ui/traits/trait-object-vs-lifetime-2.rs
+++ b/src/test/ui/traits/trait-object-vs-lifetime-2.rs
@@ -5,7 +5,7 @@
fn g() where
'static: 'static,
dyn 'static +: 'static + Copy,
- //~^ ERROR at least one non-builtin trait is required for an object type
+ //~^ ERROR at least one trait is required for an object type
{}
fn main() {}
diff --git a/src/test/ui/traits/trait-object-vs-lifetime-2.stderr b/src/test/ui/traits/trait-object-vs-lifetime-2.stderr
index ef5e240..014d380 100644
--- a/src/test/ui/traits/trait-object-vs-lifetime-2.stderr
+++ b/src/test/ui/traits/trait-object-vs-lifetime-2.stderr
@@ -1,4 +1,4 @@
-error[E0224]: at least one non-builtin trait is required for an object type
+error[E0224]: at least one trait is required for an object type
--> $DIR/trait-object-vs-lifetime-2.rs:7:5
|
LL | dyn 'static +: 'static + Copy,
diff --git a/src/test/ui/traits/trait-object-vs-lifetime.rs b/src/test/ui/traits/trait-object-vs-lifetime.rs
index 803b293..e0ff734 100644
--- a/src/test/ui/traits/trait-object-vs-lifetime.rs
+++ b/src/test/ui/traits/trait-object-vs-lifetime.rs
@@ -7,11 +7,11 @@
// `'static` is a lifetime argument, `'static +` is a type argument
let _: S<'static, u8>;
let _: S<'static, dyn 'static +>;
- //~^ at least one non-builtin trait is required for an object type
+ //~^ at least one trait is required for an object type
let _: S<'static, 'static>;
//~^ ERROR wrong number of lifetime arguments: expected 1, found 2
//~| ERROR wrong number of type arguments: expected 1, found 0
let _: S<dyn 'static +, 'static>;
//~^ ERROR lifetime arguments must be declared prior to type arguments
- //~| ERROR at least one non-builtin trait is required for an object type
+ //~| ERROR at least one trait is required for an object type
}
diff --git a/src/test/ui/traits/trait-object-vs-lifetime.stderr b/src/test/ui/traits/trait-object-vs-lifetime.stderr
index be1af59..be19587 100644
--- a/src/test/ui/traits/trait-object-vs-lifetime.stderr
+++ b/src/test/ui/traits/trait-object-vs-lifetime.stderr
@@ -4,7 +4,7 @@
LL | let _: S<dyn 'static +, 'static>;
| ^^^^^^^
-error[E0224]: at least one non-builtin trait is required for an object type
+error[E0224]: at least one trait is required for an object type
--> $DIR/trait-object-vs-lifetime.rs:9:23
|
LL | let _: S<'static, dyn 'static +>;
@@ -22,7 +22,7 @@
LL | let _: S<'static, 'static>;
| ^^^^^^^^^^^^^^^^^^^ expected 1 type argument
-error[E0224]: at least one non-builtin trait is required for an object type
+error[E0224]: at least one trait is required for an object type
--> $DIR/trait-object-vs-lifetime.rs:14:14
|
LL | let _: S<dyn 'static +, 'static>;
diff --git a/src/test/ui/traits/wf-trait-object-only-maybe-bound.rs b/src/test/ui/traits/wf-trait-object-only-maybe-bound.rs
index 1b83d24..3e6db3e 100644
--- a/src/test/ui/traits/wf-trait-object-only-maybe-bound.rs
+++ b/src/test/ui/traits/wf-trait-object-only-maybe-bound.rs
@@ -1,7 +1,7 @@
// Test that `dyn ?Sized` (i.e., a trait object with only a maybe buond) is not allowed.
type _0 = dyn ?Sized;
-//~^ ERROR at least one non-builtin trait is required for an object type [E0224]
+//~^ ERROR at least one trait is required for an object type [E0224]
//~| ERROR ?Trait` is not permitted in trait object types
fn main() {}
diff --git a/src/test/ui/traits/wf-trait-object-only-maybe-bound.stderr b/src/test/ui/traits/wf-trait-object-only-maybe-bound.stderr
index 0cfb389..8cc97ad 100644
--- a/src/test/ui/traits/wf-trait-object-only-maybe-bound.stderr
+++ b/src/test/ui/traits/wf-trait-object-only-maybe-bound.stderr
@@ -4,7 +4,7 @@
LL | type _0 = dyn ?Sized;
| ^^^^^^
-error[E0224]: at least one non-builtin trait is required for an object type
+error[E0224]: at least one trait is required for an object type
--> $DIR/wf-trait-object-only-maybe-bound.rs:3:11
|
LL | type _0 = dyn ?Sized;
diff --git a/src/tools/cargo b/src/tools/cargo
index 807429e..4c1fa54 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 807429e1b6da4e2ec52488ef2f59e77068c31e1f
+Subproject commit 4c1fa54d10f58d69ac9ff55be68e1b1c25ecb816
diff --git a/src/tools/clippy b/src/tools/clippy
index 149a988..8c80b65 160000
--- a/src/tools/clippy
+++ b/src/tools/clippy
@@ -1 +1 @@
-Subproject commit 149a988146e1e23849338cefe8df7823e1ca3853
+Subproject commit 8c80b65f10213c6e5f4c6d8113e8f8c9477af568
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index ab5594f..6ce7461 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -290,6 +290,13 @@
}
}
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum PassMode {
+ Check,
+ Build,
+ Run,
+}
+
#[derive(Clone, Debug)]
pub struct TestProps {
// Lines that should be expected, in order, on standard out
@@ -349,14 +356,10 @@
// testing harness and used when generating compilation
// arguments. (In particular, it propagates to the aux-builds.)
pub incremental_dir: Option<PathBuf>,
- // Specifies that a test must actually compile without errors.
- pub compile_pass: bool,
+ // How far should the test proceed while still passing.
+ pub pass_mode: Option<PassMode>,
// rustdoc will test the output of the `--test` option
pub check_test_line_numbers_match: bool,
- // The test must be compiled and run successfully. Only used in UI tests for now.
- pub run_pass: bool,
- // Skip any codegen step and running the executable. Only for run-pass.
- pub skip_codegen: bool,
// Do not pass `-Z ui-testing` to UI tests
pub disable_ui_testing_normalization: bool,
// customized normalization rules
@@ -396,10 +399,8 @@
pretty_compare_only: false,
forbid_output: vec![],
incremental_dir: None,
- compile_pass: false,
+ pass_mode: None,
check_test_line_numbers_match: false,
- run_pass: false,
- skip_codegen: false,
disable_ui_testing_normalization: false,
normalize_stdout: vec![],
normalize_stderr: vec![],
@@ -525,18 +526,7 @@
self.check_test_line_numbers_match = config.parse_check_test_line_numbers_match(ln);
}
- if !self.run_pass {
- self.run_pass = config.parse_run_pass(ln);
- }
-
- if !self.compile_pass {
- // run-pass implies compile_pass
- self.compile_pass = config.parse_compile_pass(ln) || self.run_pass;
- }
-
- if !self.skip_codegen {
- self.skip_codegen = config.parse_skip_codegen(ln);
- }
+ self.update_pass_mode(ln, cfg, config);
if !self.disable_ui_testing_normalization {
self.disable_ui_testing_normalization =
@@ -583,6 +573,41 @@
}
}
}
+
+ fn update_pass_mode(&mut self, ln: &str, revision: Option<&str>, config: &Config) {
+ let check_no_run = |s| {
+ if config.mode != Mode::Ui && config.mode != Mode::Incremental {
+ panic!("`{}` header is only supported in UI and incremental tests", s);
+ }
+ if config.mode == Mode::Incremental &&
+ !revision.map_or(false, |r| r.starts_with("cfail")) &&
+ !self.revisions.iter().all(|r| r.starts_with("cfail")) {
+ panic!("`{}` header is only supported in `cfail` incremental tests", s);
+ }
+ };
+ let pass_mode = if config.parse_name_directive(ln, "check-pass") {
+ check_no_run("check-pass");
+ Some(PassMode::Check)
+ } else if config.parse_name_directive(ln, "build-pass") {
+ check_no_run("build-pass");
+ Some(PassMode::Build)
+ } else if config.parse_name_directive(ln, "compile-pass") /* compatibility */ {
+ check_no_run("compile-pass");
+ Some(PassMode::Build)
+ } else if config.parse_name_directive(ln, "run-pass") {
+ if config.mode != Mode::Ui && config.mode != Mode::RunPass /* compatibility */ {
+ panic!("`run-pass` header is only supported in UI tests")
+ }
+ Some(PassMode::Run)
+ } else {
+ None
+ };
+ match (self.pass_mode, pass_mode) {
+ (None, Some(_)) => self.pass_mode = pass_mode,
+ (Some(_), Some(_)) => panic!("multiple `*-pass` headers in a single test"),
+ (_, None) => {}
+ }
+ }
}
fn iter_header(testfile: &Path, cfg: Option<&str>, it: &mut dyn FnMut(&str)) {
@@ -710,10 +735,6 @@
}
}
- fn parse_compile_pass(&self, line: &str) -> bool {
- self.parse_name_directive(line, "compile-pass")
- }
-
fn parse_disable_ui_testing_normalization(&self, line: &str) -> bool {
self.parse_name_directive(line, "disable-ui-testing-normalization")
}
@@ -722,14 +743,6 @@
self.parse_name_directive(line, "check-test-line-numbers-match")
}
- fn parse_run_pass(&self, line: &str) -> bool {
- self.parse_name_directive(line, "run-pass")
- }
-
- fn parse_skip_codegen(&self, line: &str) -> bool {
- self.parse_name_directive(line, "skip-codegen")
- }
-
fn parse_assembly_output(&self, line: &str) -> Option<String> {
self.parse_name_value_directive(line, "assembly-output")
.map(|r| r.trim().to_string())
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index d87bd66..8b52a52 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -10,7 +10,7 @@
use crate::common::{Incremental, MirOpt, RunMake, Ui, JsDocTest, Assembly};
use diff;
use crate::errors::{self, Error, ErrorKind};
-use crate::header::TestProps;
+use crate::header::{TestProps, PassMode};
use crate::json;
use regex::{Captures, Regex};
use rustfix::{apply_suggestions, get_suggestions_from_json, Filter};
@@ -310,20 +310,19 @@
}
fn should_run_successfully(&self) -> bool {
- let run_pass = match self.config.mode {
+ match self.config.mode {
RunPass => true,
- Ui => self.props.run_pass,
- _ => unimplemented!(),
- };
- return run_pass && !self.props.skip_codegen;
+ Ui => self.props.pass_mode == Some(PassMode::Run),
+ mode => panic!("unimplemented for mode {:?}", mode),
+ }
}
fn should_compile_successfully(&self) -> bool {
match self.config.mode {
- CompileFail => self.props.compile_pass,
+ CompileFail => false,
RunPass => true,
JsDocTest => true,
- Ui => self.props.compile_pass,
+ Ui => self.props.pass_mode.is_some(),
Incremental => {
let revision = self.revision
.expect("incremental tests require a list of revisions");
@@ -331,7 +330,7 @@
true
} else if revision.starts_with("cfail") {
// FIXME: would be nice if incremental revs could start with "cpass"
- self.props.compile_pass
+ self.props.pass_mode.is_some()
} else {
panic!("revision name must begin with rpass, rfail, or cfail");
}
@@ -433,11 +432,9 @@
"run-pass tests with expected warnings should be moved to ui/"
);
- if !self.props.skip_codegen {
- let proc_res = self.exec_compiled_test();
- if !proc_res.status.success() {
- self.fatal_proc_rec("test run failed!", &proc_res);
- }
+ let proc_res = self.exec_compiled_test();
+ if !proc_res.status.success() {
+ self.fatal_proc_rec("test run failed!", &proc_res);
}
}
@@ -1344,7 +1341,7 @@
fn check_error_patterns(&self, output_to_check: &str, proc_res: &ProcRes) {
debug!("check_error_patterns");
if self.props.error_patterns.is_empty() {
- if self.props.compile_pass {
+ if self.props.pass_mode.is_some() {
return;
} else {
self.fatal(&format!(
@@ -1971,7 +1968,7 @@
}
}
- if self.props.skip_codegen {
+ if self.props.pass_mode == Some(PassMode::Check) {
assert!(
!self
.props
diff --git a/src/tools/miri b/src/tools/miri
index e4b298b..c65fbc4 160000
--- a/src/tools/miri
+++ b/src/tools/miri
@@ -1 +1 @@
-Subproject commit e4b298bc4f5a7e86eb78404e25de08f179091e03
+Subproject commit c65fbc49d7b9269b277b7207f1044ee851f16b16
diff --git a/src/tools/tidy/Cargo.toml b/src/tools/tidy/Cargo.toml
index eeac6cf..43cae31 100644
--- a/src/tools/tidy/Cargo.toml
+++ b/src/tools/tidy/Cargo.toml
@@ -8,3 +8,5 @@
regex = "1"
serde = { version = "1.0.8", features = ["derive"] }
serde_json = "1.0.2"
+lazy_static = "1"
+walkdir = "2"
diff --git a/src/tools/tidy/src/bins.rs b/src/tools/tidy/src/bins.rs
index 610d1d8..680585a 100644
--- a/src/tools/tidy/src/bins.rs
+++ b/src/tools/tidy/src/bins.rs
@@ -25,16 +25,17 @@
}
}
- super::walk(path,
+ super::walk_no_read(path,
&mut |path| super::filter_dirs(path) || path.ends_with("src/etc"),
- &mut |file| {
+ &mut |entry| {
+ let file = entry.path();
let filename = file.file_name().unwrap().to_string_lossy();
let extensions = [".py", ".sh"];
if extensions.iter().any(|e| filename.ends_with(e)) {
return;
}
- let metadata = t!(fs::symlink_metadata(&file), &file);
+ let metadata = t!(entry.metadata(), file);
if metadata.mode() & 0o111 != 0 {
let rel_path = file.strip_prefix(path).unwrap();
let git_friendly_path = rel_path.to_str().unwrap().replace("\\", "/");
diff --git a/src/tools/tidy/src/errors.rs b/src/tools/tidy/src/errors.rs
index ef1000e..1bc2774 100644
--- a/src/tools/tidy/src/errors.rs
+++ b/src/tools/tidy/src/errors.rs
@@ -4,24 +4,19 @@
//! statistics about the error codes.
use std::collections::HashMap;
-use std::fs::File;
-use std::io::prelude::*;
use std::path::Path;
pub fn check(path: &Path, bad: &mut bool) {
- let mut contents = String::new();
let mut map: HashMap<_, Vec<_>> = HashMap::new();
super::walk(path,
&mut |path| super::filter_dirs(path) || path.ends_with("src/test"),
- &mut |file| {
+ &mut |entry, contents| {
+ let file = entry.path();
let filename = file.file_name().unwrap().to_string_lossy();
if filename != "error_codes.rs" {
return
}
- contents.truncate(0);
- t!(t!(File::open(file)).read_to_string(&mut contents));
-
// In the `register_long_diagnostics!` macro, entries look like this:
//
// ```
diff --git a/src/tools/tidy/src/features.rs b/src/tools/tidy/src/features.rs
index 637f10c..1841beb 100644
--- a/src/tools/tidy/src/features.rs
+++ b/src/tools/tidy/src/features.rs
@@ -11,11 +11,10 @@
use std::collections::HashMap;
use std::fmt;
-use std::fs::{self, File};
-use std::io::prelude::*;
+use std::fs;
use std::path::Path;
-use regex::{Regex, escape};
+use regex::Regex;
mod version;
use version::Version;
@@ -51,20 +50,48 @@
pub type Features = HashMap<String, Feature>;
-pub fn check(path: &Path, bad: &mut bool, quiet: bool) {
+pub struct CollectedFeatures {
+ pub lib: Features,
+ pub lang: Features,
+}
+
+// Currently only used for unstable book generation
+pub fn collect_lib_features(base_src_path: &Path) -> Features {
+ let mut lib_features = Features::new();
+
+ // This library feature is defined in the `compiler_builtins` crate, which
+ // has been moved out-of-tree. Now it can no longer be auto-discovered by
+ // `tidy`, because we need to filter out its (submodule) directory. Manually
+ // add it to the set of known library features so we can still generate docs.
+ lib_features.insert("compiler_builtins_lib".to_owned(), Feature {
+ level: Status::Unstable,
+ since: None,
+ has_gate_test: false,
+ tracking_issue: None,
+ });
+
+ map_lib_features(base_src_path,
+ &mut |res, _, _| {
+ if let Ok((name, feature)) = res {
+ lib_features.insert(name.to_owned(), feature);
+ }
+ });
+ lib_features
+}
+
+pub fn check(path: &Path, bad: &mut bool, verbose: bool) -> CollectedFeatures {
let mut features = collect_lang_features(path, bad);
assert!(!features.is_empty());
let lib_features = get_and_check_lib_features(path, bad, &features);
assert!(!lib_features.is_empty());
- let mut contents = String::new();
-
super::walk_many(&[&path.join("test/ui"),
&path.join("test/ui-fulldeps"),
&path.join("test/compile-fail")],
&mut |path| super::filter_dirs(path),
- &mut |file| {
+ &mut |entry, contents| {
+ let file = entry.path();
let filename = file.file_name().unwrap().to_string_lossy();
if !filename.ends_with(".rs") || filename == "features.rs" ||
filename == "diagnostic_list.rs" {
@@ -74,9 +101,6 @@
let filen_underscore = filename.replace('-',"_").replace(".rs","");
let filename_is_gate_test = test_filen_gate(&filen_underscore, &mut features);
- contents.truncate(0);
- t!(t!(File::open(&file), &file).read_to_string(&mut contents));
-
for (i, line) in contents.lines().enumerate() {
let mut err = |msg: &str| {
tidy_error!(bad, "{}:{}: {}", file.display(), i + 1, msg);
@@ -130,21 +154,23 @@
}
if *bad {
- return;
+ return CollectedFeatures { lib: lib_features, lang: features };
}
- if quiet {
+
+ if verbose {
+ let mut lines = Vec::new();
+ lines.extend(format_features(&features, "lang"));
+ lines.extend(format_features(&lib_features, "lib"));
+
+ lines.sort();
+ for line in lines {
+ println!("* {}", line);
+ }
+ } else {
println!("* {} features", features.len());
- return;
}
- let mut lines = Vec::new();
- lines.extend(format_features(&features, "lang"));
- lines.extend(format_features(&lib_features, "lib"));
-
- lines.sort();
- for line in lines {
- println!("* {}", line);
- }
+ CollectedFeatures { lib: lib_features, lang: features }
}
fn format_features<'a>(features: &'a Features, family: &'a str) -> impl Iterator<Item = String> + 'a {
@@ -159,8 +185,19 @@
}
fn find_attr_val<'a>(line: &'a str, attr: &str) -> Option<&'a str> {
- let r = Regex::new(&format!(r#"{}\s*=\s*"([^"]*)""#, escape(attr)))
- .expect("malformed regex for find_attr_val");
+ lazy_static::lazy_static! {
+ static ref ISSUE: Regex = Regex::new(r#"issue\s*=\s*"([^"]*)""#).unwrap();
+ static ref FEATURE: Regex = Regex::new(r#"feature\s*=\s*"([^"]*)""#).unwrap();
+ static ref SINCE: Regex = Regex::new(r#"since\s*=\s*"([^"]*)""#).unwrap();
+ }
+
+ let r = match attr {
+ "issue" => &*ISSUE,
+ "feature" => &*FEATURE,
+ "since" => &*SINCE,
+ _ => unimplemented!("{} not handled", attr),
+ };
+
r.captures(line)
.and_then(|c| c.get(1))
.map(|m| m.as_str())
@@ -175,9 +212,11 @@
}
fn test_filen_gate(filen_underscore: &str, features: &mut Features) -> bool {
- if filen_underscore.starts_with("feature_gate") {
+ let prefix = "feature_gate_";
+ if filen_underscore.starts_with(prefix) {
for (n, f) in features.iter_mut() {
- if filen_underscore == format!("feature_gate_{}", n) {
+ // Equivalent to filen_underscore == format!("feature_gate_{}", n)
+ if &filen_underscore[prefix.len()..] == n {
f.has_gate_test = true;
return true;
}
@@ -295,32 +334,6 @@
.collect()
}
-pub fn collect_lib_features(base_src_path: &Path) -> Features {
- let mut lib_features = Features::new();
-
- // This library feature is defined in the `compiler_builtins` crate, which
- // has been moved out-of-tree. Now it can no longer be auto-discovered by
- // `tidy`, because we need to filter out its (submodule) directory. Manually
- // add it to the set of known library features so we can still generate docs.
- lib_features.insert("compiler_builtins_lib".to_owned(), Feature {
- level: Status::Unstable,
- since: None,
- has_gate_test: false,
- tracking_issue: None,
- });
-
- map_lib_features(base_src_path,
- &mut |res, _, _| {
- if let Ok((name, feature)) = res {
- if lib_features.contains_key(name) {
- return;
- }
- lib_features.insert(name.to_owned(), feature);
- }
- });
- lib_features
-}
-
fn get_and_check_lib_features(base_src_path: &Path,
bad: &mut bool,
lang_features: &Features) -> Features {
@@ -355,20 +368,25 @@
fn map_lib_features(base_src_path: &Path,
mf: &mut dyn FnMut(Result<(&str, Feature), &str>, &Path, usize)) {
- let mut contents = String::new();
super::walk(base_src_path,
&mut |path| super::filter_dirs(path) || path.ends_with("src/test"),
- &mut |file| {
+ &mut |entry, contents| {
+ let file = entry.path();
let filename = file.file_name().unwrap().to_string_lossy();
if !filename.ends_with(".rs") || filename == "features.rs" ||
filename == "diagnostic_list.rs" {
return;
}
- contents.truncate(0);
- t!(t!(File::open(&file), &file).read_to_string(&mut contents));
+ // This is an early exit -- all the attributes we're concerned with must contain this:
+ // * rustc_const_unstable(
+ // * unstable(
+ // * stable(
+ if !contents.contains("stable(") {
+ return;
+ }
- let mut becoming_feature: Option<(String, Feature)> = None;
+ let mut becoming_feature: Option<(&str, Feature)> = None;
for (i, line) in contents.lines().enumerate() {
macro_rules! err {
($msg:expr) => {{
@@ -447,7 +465,7 @@
if line.contains(']') {
mf(Ok((feature_name, feature)), file, i + 1);
} else {
- becoming_feature = Some((feature_name.to_owned(), feature));
+ becoming_feature = Some((feature_name, feature));
}
}
});
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index d06c997..a0bf0b0 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -3,7 +3,9 @@
//! This library contains the tidy lints and exposes it
//! to be used by tools.
-use std::fs;
+use walkdir::{DirEntry, WalkDir};
+use std::fs::File;
+use std::io::Read;
use std::path::Path;
@@ -65,25 +67,35 @@
skip.iter().any(|p| path.ends_with(p))
}
-fn walk_many(paths: &[&Path], skip: &mut dyn FnMut(&Path) -> bool, f: &mut dyn FnMut(&Path)) {
+
+fn walk_many(
+ paths: &[&Path], skip: &mut dyn FnMut(&Path) -> bool, f: &mut dyn FnMut(&DirEntry, &str)
+) {
for path in paths {
walk(path, skip, f);
}
}
-fn walk(path: &Path, skip: &mut dyn FnMut(&Path) -> bool, f: &mut dyn FnMut(&Path)) {
- if let Ok(dir) = fs::read_dir(path) {
- for entry in dir {
- let entry = t!(entry);
- let kind = t!(entry.file_type());
- let path = entry.path();
- if kind.is_dir() {
- if !skip(&path) {
- walk(&path, skip, f);
- }
- } else {
- f(&path);
+fn walk(path: &Path, skip: &mut dyn FnMut(&Path) -> bool, f: &mut dyn FnMut(&DirEntry, &str)) {
+ let mut contents = String::new();
+ walk_no_read(path, skip, &mut |entry| {
+ contents.clear();
+ if t!(File::open(entry.path()), entry.path()).read_to_string(&mut contents).is_err() {
+ contents.clear();
+ }
+ f(&entry, &contents);
+ });
+}
+
+fn walk_no_read(path: &Path, skip: &mut dyn FnMut(&Path) -> bool, f: &mut dyn FnMut(&DirEntry)) {
+ let walker = WalkDir::new(path).into_iter()
+ .filter_entry(|e| !skip(e.path()));
+ for entry in walker {
+ if let Ok(entry) = entry {
+ if entry.file_type().is_dir() {
+ continue;
}
+ f(&entry);
}
}
}
diff --git a/src/tools/tidy/src/libcoretest.rs b/src/tools/tidy/src/libcoretest.rs
index b15b9c3..ea92f98 100644
--- a/src/tools/tidy/src/libcoretest.rs
+++ b/src/tools/tidy/src/libcoretest.rs
@@ -4,29 +4,22 @@
//! item. All tests must be written externally in `libcore/tests`.
use std::path::Path;
-use std::fs::read_to_string;
pub fn check(path: &Path, bad: &mut bool) {
let libcore_path = path.join("libcore");
super::walk(
&libcore_path,
&mut |subpath| t!(subpath.strip_prefix(&libcore_path)).starts_with("tests"),
- &mut |subpath| {
+ &mut |entry, contents| {
+ let subpath = entry.path();
if let Some("rs") = subpath.extension().and_then(|e| e.to_str()) {
- match read_to_string(subpath) {
- Ok(contents) => {
- if contents.contains("#[test]") {
- tidy_error!(
- bad,
- "{} contains #[test]; libcore tests must be placed inside \
- `src/libcore/tests/`",
- subpath.display()
- );
- }
- }
- Err(err) => {
- panic!("failed to read file {:?}: {}", subpath, err);
- }
+ if contents.contains("#[test]") {
+ tidy_error!(
+ bad,
+ "{} contains #[test]; libcore tests must be placed inside \
+ `src/libcore/tests/`",
+ subpath.display()
+ );
}
}
},
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index eef3719..918762e 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -19,14 +19,14 @@
let args: Vec<String> = env::args().skip(1).collect();
let mut bad = false;
- let quiet = args.iter().any(|s| *s == "--quiet");
+ let verbose = args.iter().any(|s| *s == "--verbose");
bins::check(&path, &mut bad);
style::check(&path, &mut bad);
errors::check(&path, &mut bad);
cargo::check(&path, &mut bad);
- features::check(&path, &mut bad, quiet);
+ let collected = features::check(&path, &mut bad, verbose);
pal::check(&path, &mut bad);
- unstable_book::check(&path, &mut bad);
+ unstable_book::check(&path, collected, &mut bad);
libcoretest::check(&path, &mut bad);
if !args.iter().any(|s| *s == "--no-vendor") {
deps::check(&path, &mut bad);
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index d4a6cf7..c6bb163 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -31,8 +31,6 @@
//! platform-specific cfgs are allowed. Not sure yet how to deal with
//! this in the long term.
-use std::fs::File;
-use std::io::Read;
use std::path::Path;
use std::iter::Iterator;
@@ -87,29 +85,26 @@
];
pub fn check(path: &Path, bad: &mut bool) {
- let mut contents = String::new();
// Sanity check that the complex parsing here works.
let mut saw_target_arch = false;
let mut saw_cfg_bang = false;
- super::walk(path, &mut super::filter_dirs, &mut |file| {
+ super::walk(path, &mut super::filter_dirs, &mut |entry, contents| {
+ let file = entry.path();
let filestr = file.to_string_lossy().replace("\\", "/");
if !filestr.ends_with(".rs") { return }
let is_exception_path = EXCEPTION_PATHS.iter().any(|s| filestr.contains(&**s));
if is_exception_path { return }
- check_cfgs(&mut contents, &file, bad, &mut saw_target_arch, &mut saw_cfg_bang);
+ check_cfgs(contents, &file, bad, &mut saw_target_arch, &mut saw_cfg_bang);
});
assert!(saw_target_arch);
assert!(saw_cfg_bang);
}
-fn check_cfgs(contents: &mut String, file: &Path,
+fn check_cfgs(contents: &str, file: &Path,
bad: &mut bool, saw_target_arch: &mut bool, saw_cfg_bang: &mut bool) {
- contents.truncate(0);
- t!(t!(File::open(file), file).read_to_string(contents));
-
// For now it's ok to have platform-specific code after 'mod tests'.
let mod_tests_idx = find_test_mod(contents);
let contents = &contents[..mod_tests_idx];
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index e860f2e..4a159d9 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -13,8 +13,6 @@
//! A number of these checks can be opted-out of with various directives of the form:
//! `// ignore-tidy-CHECK-NAME`.
-use std::fs::File;
-use std::io::prelude::*;
use std::path::Path;
const COLS: usize = 100;
@@ -109,7 +107,11 @@
Ignore(bool),
}
-fn contains_ignore_directive(contents: &String, check: &str) -> Directive {
+fn contains_ignore_directive(can_contain: bool, contents: &str, check: &str) -> Directive {
+ if !can_contain {
+ return Directive::Deny;
+ }
+ // Update `can_contain` when changing this
if contents.contains(&format!("// ignore-tidy-{}", check)) ||
contents.contains(&format!("# ignore-tidy-{}", check)) {
Directive::Ignore(false)
@@ -129,8 +131,8 @@
}
pub fn check(path: &Path, bad: &mut bool) {
- let mut contents = String::new();
- super::walk(path, &mut super::filter_dirs, &mut |file| {
+ super::walk(path, &mut super::filter_dirs, &mut |entry, contents| {
+ let file = entry.path();
let filename = file.file_name().unwrap().to_string_lossy();
let extensions = [".rs", ".py", ".js", ".sh", ".c", ".cpp", ".h"];
if extensions.iter().all(|e| !filename.ends_with(e)) ||
@@ -138,19 +140,19 @@
return
}
- contents.truncate(0);
- t!(t!(File::open(file), file).read_to_string(&mut contents));
-
if contents.is_empty() {
tidy_error!(bad, "{}: empty file", file.display());
}
- let mut skip_cr = contains_ignore_directive(&contents, "cr");
- let mut skip_tab = contains_ignore_directive(&contents, "tab");
- let mut skip_line_length = contains_ignore_directive(&contents, "linelength");
- let mut skip_file_length = contains_ignore_directive(&contents, "filelength");
- let mut skip_end_whitespace = contains_ignore_directive(&contents, "end-whitespace");
- let mut skip_copyright = contains_ignore_directive(&contents, "copyright");
+ let can_contain = contents.contains("// ignore-tidy-") ||
+ contents.contains("# ignore-tidy-");
+ let mut skip_cr = contains_ignore_directive(can_contain, &contents, "cr");
+ let mut skip_tab = contains_ignore_directive(can_contain, &contents, "tab");
+ let mut skip_line_length = contains_ignore_directive(can_contain, &contents, "linelength");
+ let mut skip_file_length = contains_ignore_directive(can_contain, &contents, "filelength");
+ let mut skip_end_whitespace =
+ contains_ignore_directive(can_contain, &contents, "end-whitespace");
+ let mut skip_copyright = contains_ignore_directive(can_contain, &contents, "copyright");
let mut leading_new_lines = false;
let mut trailing_new_lines = 0;
let mut lines = 0;
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index b572b52..2c52cec 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -4,10 +4,9 @@
use std::path::Path;
pub fn check(path: &Path, bad: &mut bool) {
- super::walk_many(
- &[&path.join("test/ui"), &path.join("test/ui-fulldeps")],
- &mut |_| false,
- &mut |file_path| {
+ for path in &[&path.join("test/ui"), &path.join("test/ui-fulldeps")] {
+ super::walk_no_read(path, &mut |_| false, &mut |entry| {
+ let file_path = entry.path();
if let Some(ext) = file_path.extension() {
if ext == "stderr" || ext == "stdout" {
// Test output filenames have one of the formats:
@@ -45,6 +44,6 @@
}
}
}
- },
- );
+ });
+ }
}
diff --git a/src/tools/tidy/src/unstable_book.rs b/src/tools/tidy/src/unstable_book.rs
index f7e40ce..fb63520 100644
--- a/src/tools/tidy/src/unstable_book.rs
+++ b/src/tools/tidy/src/unstable_book.rs
@@ -1,7 +1,7 @@
use std::collections::BTreeSet;
use std::fs;
-use std::path;
-use crate::features::{collect_lang_features, collect_lib_features, Features, Status};
+use std::path::{PathBuf, Path};
+use crate::features::{CollectedFeatures, Features, Feature, Status};
pub const PATH_STR: &str = "doc/unstable-book";
@@ -12,19 +12,19 @@
pub const LIB_FEATURES_DIR: &str = "src/library-features";
/// Builds the path to the Unstable Book source directory from the Rust 'src' directory.
-pub fn unstable_book_path(base_src_path: &path::Path) -> path::PathBuf {
+pub fn unstable_book_path(base_src_path: &Path) -> PathBuf {
base_src_path.join(PATH_STR)
}
/// Builds the path to the directory where the features are documented within the Unstable Book
/// source directory.
-pub fn unstable_book_lang_features_path(base_src_path: &path::Path) -> path::PathBuf {
+pub fn unstable_book_lang_features_path(base_src_path: &Path) -> PathBuf {
unstable_book_path(base_src_path).join(LANG_FEATURES_DIR)
}
/// Builds the path to the directory where the features are documented within the Unstable Book
/// source directory.
-pub fn unstable_book_lib_features_path(base_src_path: &path::Path) -> path::PathBuf {
+pub fn unstable_book_lib_features_path(base_src_path: &Path) -> PathBuf {
unstable_book_path(base_src_path).join(LIB_FEATURES_DIR)
}
@@ -45,7 +45,7 @@
.collect()
}
-pub fn collect_unstable_book_section_file_names(dir: &path::Path) -> BTreeSet<String> {
+pub fn collect_unstable_book_section_file_names(dir: &Path) -> BTreeSet<String> {
fs::read_dir(dir)
.expect("could not read directory")
.map(|entry| entry.expect("could not read directory entry"))
@@ -60,7 +60,7 @@
///
/// * hyphens replaced by underscores,
/// * the markdown suffix ('.md') removed.
-fn collect_unstable_book_lang_features_section_file_names(base_src_path: &path::Path)
+fn collect_unstable_book_lang_features_section_file_names(base_src_path: &Path)
-> BTreeSet<String> {
collect_unstable_book_section_file_names(&unstable_book_lang_features_path(base_src_path))
}
@@ -69,18 +69,26 @@
///
/// * hyphens replaced by underscores,
/// * the markdown suffix ('.md') removed.
-fn collect_unstable_book_lib_features_section_file_names(base_src_path: &path::Path)
- -> BTreeSet<String> {
+fn collect_unstable_book_lib_features_section_file_names(base_src_path: &Path) -> BTreeSet<String> {
collect_unstable_book_section_file_names(&unstable_book_lib_features_path(base_src_path))
}
-pub fn check(path: &path::Path, bad: &mut bool) {
- // Library features
-
- let lang_features = collect_lang_features(path, bad);
- let lib_features = collect_lib_features(path).into_iter().filter(|&(ref name, _)| {
+pub fn check(path: &Path, features: CollectedFeatures, bad: &mut bool) {
+ let lang_features = features.lang;
+ let mut lib_features = features.lib.into_iter().filter(|&(ref name, _)| {
!lang_features.contains_key(name)
- }).collect();
+ }).collect::<Features>();
+
+ // This library feature is defined in the `compiler_builtins` crate, which
+ // has been moved out-of-tree. Now it can no longer be auto-discovered by
+ // `tidy`, because we need to filter out its (submodule) directory. Manually
+ // add it to the set of known library features so we can still generate docs.
+ lib_features.insert("compiler_builtins_lib".to_owned(), Feature {
+ level: Status::Unstable,
+ since: None,
+ has_gate_test: false,
+ tracking_issue: None,
+ });
// Library features
let unstable_lib_feature_names = collect_unstable_feature_names(&lib_features);
