diff --git a/Cargo.lock b/Cargo.lock index 98dd10955d57d..8d0e2e31d3459 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -327,18 +327,6 @@ dependencies = [ "syn 0.15.35 (registry+https://github.com/rust-lang/crates.io-index)", ] -[[package]] -name = "cargo_metadata" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -dependencies = [ - "error-chain 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)", - "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)", -] - [[package]] name = "cargo_metadata" version = "0.8.0" @@ -794,12 +782,11 @@ dependencies = [ [[package]] name = "dirs" -version = "1.0.5" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.54 (registry+https://github.com/rust-lang/crates.io-index)", - "redox_users 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", + "cfg-if 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)", + "dirs-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1517,8 +1504,8 @@ name = "markup5ever" version = "0.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", - "phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", + "phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)", "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)", "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1533,8 +1520,8 @@ version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", - "phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", - "phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", + "phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)", "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)", "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1990,33 +1977,33 @@ dependencies = [ [[package]] name = "phf" -version = "0.7.22" +version = "0.7.24" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "phf_codegen" -version = "0.7.22" +version = "0.7.24" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", - "phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "phf_generator" -version = "0.7.22" +version = "0.7.24" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", - "rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", + "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "phf_shared" -version = "0.7.22" +version = "0.7.24" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "siphasher 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", @@ -2146,18 +2133,6 @@ dependencies = [ "rustc-ap-syntax 491.0.0 (registry+https://github.com/rust-lang/crates.io-index)", ] -[[package]] -name = "rand" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -dependencies = [ - "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.54 (registry+https://github.com/rust-lang/crates.io-index)", - "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", - "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", -] - [[package]] name = "rand" version = "0.6.1" @@ -2384,7 +2359,7 @@ dependencies = [ "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-workspace-hack 1.0.0", "rustc_tools_util 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", - "rustfmt-nightly 1.3.0", + "rustfmt-nightly 1.3.1", "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)", "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)", "serde_ignored 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3210,7 +3185,7 @@ dependencies = [ [[package]] name = "rustfmt-config_proc_macro" -version = "0.1.0" +version = "0.1.2" 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)", @@ -3220,15 +3195,15 @@ dependencies = [ [[package]] name = "rustfmt-nightly" -version = "1.3.0" +version = "1.3.1" dependencies = [ "annotate-snippets 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)", "atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", "bytecount 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", - "cargo_metadata 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)", + "cargo_metadata 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "derive-new 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", "diff 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)", - "dirs 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)", + "dirs 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)", "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)", "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "getopts 0.2.19 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3241,10 +3216,10 @@ dependencies = [ "rustc-ap-syntax 491.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-ap-syntax_pos 491.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-workspace-hack 1.0.0", - "rustfmt-config_proc_macro 0.1.0", + "rustfmt-config_proc_macro 0.1.2", "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)", - "structopt 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)", + "structopt 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", "term 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", "toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", "unicode-segmentation 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3448,7 +3423,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)", - "phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)", "string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3460,8 +3435,8 @@ name = "string_cache_codegen" version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", - "phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", + "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "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)", "string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3487,16 +3462,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "structopt" -version = "0.2.16" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)", - "structopt-derive 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)", + "structopt-derive 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "structopt-derive" -version = "0.2.16" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "heck 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -4235,7 +4210,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d" "checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa" "checksum bytesize 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "716960a18f978640f25101b5cbf1c6f6b0d3192fab36a2d98ca96f0ecbe41010" -"checksum cargo_metadata 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "585784cac9b05c93a53b17a0b24a5cdd1dfdda5256f030e089b549d2390cc720" "checksum cargo_metadata 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "929766d993a2fde7a0ae962ee82429069cd7b68839cd9375b98efd719df65d3a" "checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83" "checksum cfg-if 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "89431bba4e6b7092fb5fcd00a6f6ca596c55cc26b2f1e6dcdd08a1f4933f66b2" @@ -4275,7 +4249,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198" "checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90" "checksum directories 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2ccc83e029c3cebb4c8155c644d34e3a070ccdb4ff90d369c74cd73f7cb3c984" -"checksum dirs 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "3fd78930633bd1c6e35c4b42b1df7b0cbc6bc191146e512bb3bedf243fcc3901" +"checksum dirs 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1c4ef5a8b902d393339e2a2c7fe573af92ce7e0ee5a3ff827b4c9ad7e07e4fa1" "checksum dirs-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "937756392ec77d1f2dd9dc3ac9d69867d109a2121479d72c364e42f4cab21e2d" "checksum dlmalloc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f283302e035e61c23f2b86b3093e8c6273a4c3125742d6087e96ade001ca5e63" "checksum either 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3be565ca5c557d7f59e7cfcf1844f9e3033650c929c6566f511e8005f205c1d0" @@ -4398,10 +4372,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum pest_generator 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "63120576c4efd69615b5537d3d052257328a4ca82876771d6944424ccfd9f646" "checksum pest_meta 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f5a3492a4ed208ffc247adcdcc7ba2a95be3104f58877d0d02f0df39bf3efb5e" "checksum petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3659d1ee90221741f65dd128d9998311b0e40c5d3c23a62445938214abce4f" -"checksum phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)" = "7d37a244c75a9748e049225155f56dbcb98fe71b192fd25fd23cb914b5ad62f2" -"checksum phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)" = "4e4048fe7dd7a06b8127ecd6d3803149126e9b33c7558879846da3a63f734f2b" -"checksum phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)" = "05a079dd052e7b674d21cb31cbb6c05efd56a2cd2827db7692e2f1a507ebd998" -"checksum phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)" = "c2261d544c2bb6aa3b10022b0be371b9c7c64f762ef28c6f5d4f1ef6d97b5930" +"checksum phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "b3da44b85f8e8dfaec21adae67f95d93244b2ecf6ad2a692320598dcc8e6dd18" +"checksum phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "b03e85129e324ad4166b06b2c7491ae27fe3ec353af72e72cd1654c7225d517e" +"checksum phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "09364cc93c159b8b06b1f4dd8a4398984503483891b0c26b867cf431fb132662" +"checksum phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "234f71a15de2288bcb7e3b6515828d22af7ec8598ee6d24c3b526fa0a80b67a0" "checksum pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "676e8eb2b1b4c9043511a9b7bea0915320d7e502b0a079fb03f9635a5252b18c" "checksum polonius-engine 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8b24942fee141ea45628484a453762bb7e515099c3ec05fbeb76b7bf57b1aeed" "checksum precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" @@ -4416,7 +4390,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a" "checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db" "checksum racer 2.1.23 (registry+https://github.com/rust-lang/crates.io-index)" = "94dbdea3d959d8f76a2e303b3eadf107fd76da886b231291e649168613d432fb" -"checksum rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" "checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a" "checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a" "checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db" @@ -4487,8 +4460,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b1884d1bc09741d466d9b14e6d37ac89d6909cbcac41dd9ae982d4d063bbedfc" "checksum strip-ansi-escapes 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9d63676e2abafa709460982ddc02a3bb586b6d15a49b75c212e06edd3933acee" "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550" -"checksum structopt 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fa19a5a708e22bb5be31c1b6108a2a902f909c4b9ba85cba44c06632386bc0ff" -"checksum structopt-derive 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)" = "c6d59d0ae8ef8de16e49e3ca7afa16024a3e0dfd974a75ef93fdc5464e34523f" +"checksum structopt 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)" = "16c2cdbf9cc375f15d1b4141bc48aeef444806655cd0e904207edc8d68d86ed7" +"checksum structopt-derive 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)" = "53010261a84b37689f9ed7d395165029f9cc7abb9f56bbfe86bee2597ed25107" "checksum strum 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f6c3a2071519ab6a48f465808c4c1ffdd00dfc8e93111d02b4fc5abab177676e" "checksum strum_macros 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8baacebd7b7c9b864d83a6ba7a246232983e277b86fa5cdec77f565715a4b136" "checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad" diff --git a/src/etc/gdb_load_rust_pretty_printers.py b/src/etc/gdb_load_rust_pretty_printers.py index c551346bb00bf..fe38c49d2707d 100644 --- a/src/etc/gdb_load_rust_pretty_printers.py +++ b/src/etc/gdb_load_rust_pretty_printers.py @@ -1,2 +1,3 @@ +import gdb import gdb_rust_pretty_printing gdb_rust_pretty_printing.register_printers(gdb.current_objfile()) diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs index 92fe0834dd029..c0544d7469ca7 100644 --- a/src/liballoc/vec.rs +++ b/src/liballoc/vec.rs @@ -1367,6 +1367,40 @@ impl Vec { self.truncate(new_len); } } + + /// Consumes and leaks the `Vec`, returning a mutable reference to the contents, + /// `&'a mut [T]`. Note that the type `T` must outlive the chosen lifetime + /// `'a`. If the type has only static references, or none at all, then this + /// may be chosen to be `'static`. + /// + /// This function is similar to the `leak` function on `Box`. + /// + /// This function is mainly useful for data that lives for the remainder of + /// the program's life. Dropping the returned reference will cause a memory + /// leak. + /// + /// # Examples + /// + /// Simple usage: + /// + /// ``` + /// #![feature(vec_leak)] + /// + /// fn main() { + /// let x = vec![1, 2, 3]; + /// let static_ref: &'static mut [usize] = Vec::leak(x); + /// static_ref[0] += 1; + /// assert_eq!(static_ref, &[2, 2, 3]); + /// } + /// ``` + #[unstable(feature = "vec_leak", issue = "62195")] + #[inline] + pub fn leak<'a>(vec: Vec) -> &'a mut [T] + where + T: 'a // Technically not needed, but kept to be explicit. + { + Box::leak(vec.into_boxed_slice()) + } } impl Vec { diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs index a697b7bd6e589..c0de8e2ceb3f3 100644 --- a/src/libcore/convert.rs +++ b/src/libcore/convert.rs @@ -251,12 +251,12 @@ pub trait AsMut { /// /// # Examples /// -/// [`String`] implements `Into>`: +/// [`String`] implements [`Into`]`<`[`Vec`]`<`[`u8`]`>>`: /// /// In order to express that we want a generic function to take all arguments that can be /// converted to a specified type `T`, we can use a trait bound of [`Into`]``. /// For example: The function `is_hello` takes all arguments that can be converted into a -/// `Vec`. +/// [`Vec`]`<`[`u8`]`>`. /// /// ``` /// fn is_hello>>(s: T) { @@ -274,6 +274,7 @@ pub trait AsMut { /// [`String`]: ../../std/string/struct.String.html /// [`From`]: trait.From.html /// [`Into`]: trait.Into.html +/// [`Vec`]: ../../std/vec/struct.Vec.html #[stable(feature = "rust1", since = "1.0.0")] pub trait Into: Sized { /// Performs the conversion. @@ -410,12 +411,12 @@ pub trait TryInto: Sized { /// /// This is useful when you are doing a type conversion that may /// trivially succeed but may also need special handling. -/// For example, there is no way to convert an `i64` into an `i32` -/// using the [`From`] trait, because an `i64` may contain a value -/// that an `i32` cannot represent and so the conversion would lose data. -/// This might be handled by truncating the `i64` to an `i32` (essentially -/// giving the `i64`'s value modulo `i32::MAX`) or by simply returning -/// `i32::MAX`, or by some other method. The `From` trait is intended +/// For example, there is no way to convert an [`i64`] into an [`i32`] +/// using the [`From`] trait, because an [`i64`] may contain a value +/// that an [`i32`] cannot represent and so the conversion would lose data. +/// This might be handled by truncating the [`i64`] to an [`i32`] (essentially +/// giving the [`i64`]'s value modulo [`i32::MAX`]) or by simply returning +/// [`i32::MAX`], or by some other method. The [`From`] trait is intended /// for perfect conversions, so the `TryFrom` trait informs the /// programmer when a type conversion could go bad and lets them /// decide how to handle it. @@ -425,8 +426,8 @@ pub trait TryInto: Sized { /// - `TryFrom for U` implies [`TryInto`]` for T` /// - [`try_from`] is reflexive, which means that `TryFrom for T` /// is implemented and cannot fail -- the associated `Error` type for -/// calling `T::try_from()` on a value of type `T` is `Infallible`. -/// When the `!` type is stablized `Infallible` and `!` will be +/// calling `T::try_from()` on a value of type `T` is [`Infallible`]. +/// When the [`!`] type is stablized [`Infallible`] and [`!`] will be /// equivalent. /// /// `TryFrom` can be implemented as follows: @@ -451,7 +452,7 @@ pub trait TryInto: Sized { /// /// # Examples /// -/// As described, [`i32`] implements `TryFrom`: +/// As described, [`i32`] implements `TryFrom<`[`i64`]`>`: /// /// ``` /// use std::convert::TryFrom; @@ -474,6 +475,8 @@ pub trait TryInto: Sized { /// /// [`try_from`]: trait.TryFrom.html#tymethod.try_from /// [`TryInto`]: trait.TryInto.html +/// [`i32::MAX`]: ../../std/i32/constant.MAX.html +/// [`!`]: ../../std/primitive.never.html #[stable(feature = "try_from", since = "1.34.0")] pub trait TryFrom: Sized { /// The type returned in the event of a conversion error. diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index b30eff8baa9c8..d9b68612785e9 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -36,6 +36,8 @@ issue = "0")] #![allow(missing_docs)] +use crate::mem; + #[stable(feature = "drop_in_place", since = "1.8.0")] #[rustc_deprecated(reason = "no longer an intrinsic - use `ptr::drop_in_place` directly", since = "1.18.0")] @@ -1331,6 +1333,26 @@ extern "rust-intrinsic" { // (`transmute` also falls into this category, but it cannot be wrapped due to the // check that `T` and `U` have the same size.) +/// Checks whether `ptr` is properly aligned with respect to +/// `align_of::()`. +pub(crate) fn is_aligned_and_not_null(ptr: *const T) -> bool { + !ptr.is_null() && ptr as usize % mem::align_of::() == 0 +} + +/// Checks whether the regions of memory starting at `src` and `dst` of size +/// `count * size_of::()` overlap. +fn overlaps(src: *const T, dst: *const T, count: usize) -> bool { + let src_usize = src as usize; + let dst_usize = dst as usize; + let size = mem::size_of::().checked_mul(count).unwrap(); + let diff = if src_usize > dst_usize { + src_usize - dst_usize + } else { + dst_usize - src_usize + }; + size > diff +} + /// Copies `count * size_of::()` bytes from `src` to `dst`. The source /// and destination must *not* overlap. /// @@ -1420,7 +1442,11 @@ pub unsafe fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize) { extern "rust-intrinsic" { fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); } - copy_nonoverlapping(src, dst, count); + + debug_assert!(is_aligned_and_not_null(src), "attempt to copy from unaligned or null pointer"); + debug_assert!(is_aligned_and_not_null(dst), "attempt to copy to unaligned or null pointer"); + debug_assert!(!overlaps(src, dst, count), "attempt to copy to overlapping memory"); + copy_nonoverlapping(src, dst, count) } /// Copies `count * size_of::()` bytes from `src` to `dst`. The source @@ -1480,6 +1506,9 @@ pub unsafe fn copy(src: *const T, dst: *mut T, count: usize) { extern "rust-intrinsic" { fn copy(src: *const T, dst: *mut T, count: usize); } + + debug_assert!(is_aligned_and_not_null(src), "attempt to copy from unaligned or null pointer"); + debug_assert!(is_aligned_and_not_null(dst), "attempt to copy to unaligned or null pointer"); copy(src, dst, count) } @@ -1561,6 +1590,8 @@ pub unsafe fn write_bytes(dst: *mut T, val: u8, count: usize) { extern "rust-intrinsic" { fn write_bytes(dst: *mut T, val: u8, count: usize); } + + debug_assert!(is_aligned_and_not_null(dst), "attempt to write to unaligned or null pointer"); write_bytes(dst, val, count) } diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 04c50329de3d0..1f31b65b3603b 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -74,6 +74,7 @@ #![feature(concat_idents)] #![feature(const_fn)] #![feature(const_fn_union)] +#![feature(custom_inner_attributes)] #![feature(doc_cfg)] #![feature(doc_spotlight)] #![feature(extern_types)] diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs index c6d44324ef5ee..dba9a1445e84c 100644 --- a/src/libcore/slice/mod.rs +++ b/src/libcore/slice/mod.rs @@ -25,7 +25,7 @@ use crate::cmp::Ordering::{self, Less, Equal, Greater}; use crate::cmp; use crate::fmt; -use crate::intrinsics::{assume, exact_div, unchecked_sub}; +use crate::intrinsics::{assume, exact_div, unchecked_sub, is_aligned_and_not_null}; use crate::isize; use crate::iter::*; use crate::ops::{FnMut, Try, self}; @@ -5213,7 +5213,7 @@ unsafe impl<'a, T> TrustedRandomAccess for RChunksExactMut<'a, T> { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T] { - debug_assert!(data as usize % mem::align_of::() == 0, "attempt to create unaligned slice"); + debug_assert!(is_aligned_and_not_null(data), "attempt to create unaligned or null slice"); debug_assert!(mem::size_of::().saturating_mul(len) <= isize::MAX as usize, "attempt to create slice covering half the address space"); &*ptr::slice_from_raw_parts(data, len) @@ -5234,7 +5234,7 @@ pub unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T] { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T] { - debug_assert!(data as usize % mem::align_of::() == 0, "attempt to create unaligned slice"); + debug_assert!(is_aligned_and_not_null(data), "attempt to create unaligned or null slice"); debug_assert!(mem::size_of::().saturating_mul(len) <= isize::MAX as usize, "attempt to create slice covering half the address space"); &mut *ptr::slice_from_raw_parts_mut(data, len) diff --git a/src/libproc_macro/bridge/scoped_cell.rs b/src/libproc_macro/bridge/scoped_cell.rs index 6f7965095b638..89fb707001589 100644 --- a/src/libproc_macro/bridge/scoped_cell.rs +++ b/src/libproc_macro/bridge/scoped_cell.rs @@ -74,7 +74,7 @@ impl ScopedCell { } /// Sets the value in `self` to `value` while running `f`. - pub fn set<'a, R>(&self, value: >::Out, f: impl FnOnce() -> R) -> R { + pub fn set(&self, value: >::Out, f: impl FnOnce() -> R) -> R { self.replace(value, |_| f()) } } diff --git a/src/librustc/cfg/construct.rs b/src/librustc/cfg/construct.rs index a7750edbb6f48..a132575b0c673 100644 --- a/src/librustc/cfg/construct.rs +++ b/src/librustc/cfg/construct.rs @@ -1,11 +1,11 @@ use crate::cfg::*; use crate::middle::region; use rustc_data_structures::graph::implementation as graph; -use syntax::ptr::P; use crate::ty::{self, TyCtxt}; use crate::hir::{self, PatKind}; use crate::hir::def_id::DefId; +use crate::hir::ptr::P; struct CFGBuilder<'a, 'tcx> { tcx: TyCtxt<'tcx>, @@ -30,7 +30,7 @@ struct LoopScope { break_index: CFGIndex, // where to go on a `break` } -pub fn construct<'tcx>(tcx: TyCtxt<'tcx>, body: &hir::Body) -> CFG { +pub fn construct(tcx: TyCtxt<'_>, body: &hir::Body) -> CFG { let mut graph = graph::Graph::new(); let entry = graph.add_node(CFGNodeData::Entry); diff --git a/src/librustc/cfg/mod.rs b/src/librustc/cfg/mod.rs index db168d99a0801..88fc7fbfad51f 100644 --- a/src/librustc/cfg/mod.rs +++ b/src/librustc/cfg/mod.rs @@ -49,7 +49,7 @@ pub type CFGNode = graph::Node; pub type CFGEdge = graph::Edge; impl CFG { - pub fn new<'tcx>(tcx: TyCtxt<'tcx>, body: &hir::Body) -> CFG { + pub fn new(tcx: TyCtxt<'_>, body: &hir::Body) -> CFG { construct::construct(tcx, body) } diff --git a/src/librustc/dep_graph/graph.rs b/src/librustc/dep_graph/graph.rs index 93c22c3e713c0..b8c6c1e372382 100644 --- a/src/librustc/dep_graph/graph.rs +++ b/src/librustc/dep_graph/graph.rs @@ -841,7 +841,7 @@ impl DepGraph { // // This method will only load queries that will end up in the disk cache. // Other queries will not be executed. - pub fn exec_cache_promotions<'tcx>(&self, tcx: TyCtxt<'tcx>) { + pub fn exec_cache_promotions(&self, tcx: TyCtxt<'_>) { let data = self.data.as_ref().unwrap(); for prev_index in data.colors.values.indices() { match data.colors.get(prev_index) { diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs index 4b84d56858cca..9160b8024ee45 100644 --- a/src/librustc/hir/check_attr.rs +++ b/src/librustc/hir/check_attr.rs @@ -347,7 +347,7 @@ fn is_c_like_enum(item: &hir::Item) -> bool { } } -fn check_mod_attrs<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module( module_def_id, &mut CheckAttrVisitor { tcx }.as_deep_visitor() diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 9c4a208f0f9fc..49a832948f17c 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -39,6 +39,7 @@ use crate::hir::map::{DefKey, DefPathData, Definitions}; use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX}; use crate::hir::def::{Res, DefKind, PartialRes, PerNS}; use crate::hir::{GenericArg, ConstArg}; +use crate::hir::ptr::P; use crate::lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES, ELIDED_LIFETIMES_IN_PATHS}; use crate::middle::cstore::CrateStore; @@ -61,7 +62,6 @@ use syntax::ast::*; use syntax::errors; use syntax::ext::hygiene::{Mark, SyntaxContext}; use syntax::print::pprust; -use syntax::ptr::P; use syntax::source_map::{self, respan, ExpnInfo, CompilerDesugaringKind, Spanned}; use syntax::source_map::CompilerDesugaringKind::IfTemporary; use syntax::std_inject; @@ -1111,7 +1111,7 @@ impl<'a> LoweringContext<'a> { }, ); - lowered_generics.params = lowered_generics + let mut lowered_params: Vec<_> = lowered_generics .params .into_iter() .chain(in_band_defs) @@ -1121,7 +1121,7 @@ impl<'a> LoweringContext<'a> { // unsorted generic parameters at the moment, so we make sure // that they're ordered correctly here for now. (When we chain // the `in_band_defs`, we might make the order unsorted.) - lowered_generics.params.sort_by_key(|param| { + lowered_params.sort_by_key(|param| { match param.kind { hir::GenericParamKind::Lifetime { .. } => ParamKindOrd::Lifetime, hir::GenericParamKind::Type { .. } => ParamKindOrd::Type, @@ -1129,6 +1129,8 @@ impl<'a> LoweringContext<'a> { } }); + lowered_generics.params = lowered_params.into(); + (lowered_generics, res) } @@ -1155,13 +1157,13 @@ impl<'a> LoweringContext<'a> { &mut self, capture_clause: CaptureBy, closure_node_id: NodeId, - ret_ty: Option<&Ty>, + ret_ty: Option>, span: Span, body: impl FnOnce(&mut LoweringContext<'_>) -> hir::Expr, ) -> hir::ExprKind { let capture_clause = self.lower_capture_clause(capture_clause); let output = match ret_ty { - Some(ty) => FunctionRetTy::Ty(P(ty.clone())), + Some(ty) => FunctionRetTy::Ty(ty), None => FunctionRetTy::Default(span), }; let ast_decl = FnDecl { @@ -2725,7 +2727,7 @@ impl<'a> LoweringContext<'a> { // ::std::future::Future let future_path = - self.std_path(span, &[sym::future, sym::Future], Some(future_params), false); + P(self.std_path(span, &[sym::future, sym::Future], Some(future_params), false)); hir::GenericBound::Trait( hir::PolyTraitRef { @@ -3094,7 +3096,7 @@ impl<'a> LoweringContext<'a> { fn lower_trait_ref(&mut self, p: &TraitRef, itctx: ImplTraitContext<'_>) -> hir::TraitRef { let path = match self.lower_qpath(p.ref_id, &None, &p.path, ParamMode::Explicit, itctx) { - hir::QPath::Resolved(None, path) => path.and_then(|path| path), + hir::QPath::Resolved(None, path) => path, qpath => bug!("lower_trait_ref: unexpected QPath `{:?}`", qpath), }; hir::TraitRef { @@ -3620,7 +3622,7 @@ impl<'a> LoweringContext<'a> { hir::Item { hir_id: new_id, ident, - attrs: attrs.clone(), + attrs: attrs.into_iter().cloned().collect(), node: item, vis, span, @@ -3705,7 +3707,7 @@ impl<'a> LoweringContext<'a> { hir::Item { hir_id: new_hir_id, ident, - attrs: attrs.clone(), + attrs: attrs.into_iter().cloned().collect(), node: item, vis, span: use_tree.span, @@ -4567,7 +4569,7 @@ impl<'a> LoweringContext<'a> { // `|x: u8| future_from_generator(|| -> X { ... })`. let body_id = this.lower_fn_body(&outer_decl, |this| { let async_ret_ty = if let FunctionRetTy::Ty(ty) = &decl.output { - Some(&**ty) + Some(ty.clone()) } else { None }; let async_body = this.make_async_expr( capture_clause, closure_id, async_ret_ty, body.span, @@ -5577,7 +5579,7 @@ impl<'a> LoweringContext<'a> { let principal = hir::PolyTraitRef { bound_generic_params: hir::HirVec::new(), trait_ref: hir::TraitRef { - path: path.and_then(|path| path), + path, hir_ref_id: hir_id, }, span, diff --git a/src/librustc/hir/map/hir_id_validator.rs b/src/librustc/hir/map/hir_id_validator.rs index 60465c04ec62f..891a1956bc971 100644 --- a/src/librustc/hir/map/hir_id_validator.rs +++ b/src/librustc/hir/map/hir_id_validator.rs @@ -4,7 +4,7 @@ use crate::hir::itemlikevisit::ItemLikeVisitor; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::{Lock, ParallelIterator, par_iter}; -pub fn check_crate<'hir>(hir_map: &hir::map::Map<'hir>) { +pub fn check_crate(hir_map: &hir::map::Map<'_>) { hir_map.dep_graph.assert_ignored(); let errors = Lock::new(Vec::new()); diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 3d591c9a1c6bd..4da9919c2d6eb 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -25,7 +25,6 @@ use crate::hir::print::Nested; use crate::util::nodemap::FxHashMap; use crate::util::common::time; -use std::io; use std::result::Result::Err; use crate::ty::query::Providers; @@ -147,7 +146,7 @@ impl Forest { } } - pub fn krate<'hir>(&'hir self) -> &'hir Crate { + pub fn krate(&self) -> &Crate { self.dep_graph.read(DepNode::new_no_params(DepKind::Krate)); &self.krate } @@ -155,7 +154,7 @@ impl Forest { /// This is used internally in the dependency tracking system. /// Use the `krate` method to ensure your dependency on the /// crate is tracked. - pub fn untracked_krate<'hir>(&'hir self) -> &'hir Crate { + pub fn untracked_krate(&self) -> &Crate { &self.krate } } @@ -1085,7 +1084,7 @@ impl<'a> NodesMatchingSuffix<'a> { // If `id` itself is a mod named `m` with parent `p`, then // returns `Some(id, m, p)`. If `id` has no mod in its parent // chain, then returns `None`. - fn find_first_mod_parent<'a>(map: &'a Map<'_>, mut id: HirId) -> Option<(HirId, Name)> { + fn find_first_mod_parent(map: &Map<'_>, mut id: HirId) -> Option<(HirId, Name)> { loop { if let Node::Item(item) = map.find(id)? { if item_is_mod(&item) { @@ -1187,7 +1186,7 @@ pub fn map_crate<'hir>(sess: &crate::session::Session, /// Identical to the `PpAnn` implementation for `hir::Crate`, /// except it avoids creating a dependency on the whole crate. impl<'hir> print::PpAnn for Map<'hir> { - fn nested(&self, state: &mut print::State<'_>, nested: print::Nested) -> io::Result<()> { + fn nested(&self, state: &mut print::State<'_>, nested: print::Nested) { match nested { Nested::Item(id) => state.print_item(self.expect_item(id.id)), Nested::TraitItem(id) => state.print_trait_item(self.trait_item(id)), @@ -1199,7 +1198,7 @@ impl<'hir> print::PpAnn for Map<'hir> { } impl<'a> print::State<'a> { - pub fn print_node(&mut self, node: Node<'_>) -> io::Result<()> { + pub fn print_node(&mut self, node: Node<'_>) { match node { Node::Item(a) => self.print_item(&a), Node::ForeignItem(a) => self.print_foreign_item(&a), @@ -1219,9 +1218,9 @@ impl<'a> print::State<'a> { use syntax::print::pprust::PrintState; // containing cbox, will be closed by print-block at } - self.cbox(print::indent_unit)?; + self.cbox(print::indent_unit); // head-ibox, will be closed by print-block after { - self.ibox(0)?; + self.ibox(0); self.print_block(&a) } Node::Lifetime(a) => self.print_lifetime(&a), diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 6df1c2d8c77e5..bfbd8398f99f3 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -12,6 +12,7 @@ pub use self::UnsafeSource::*; use crate::hir::def::{Res, DefKind}; use crate::hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX}; +use crate::hir::ptr::P; use crate::util::nodemap::{NodeMap, FxHashSet}; use crate::mir::mono::Linkage; @@ -23,7 +24,6 @@ use syntax::ast::{self, CrateSugar, Ident, Name, NodeId, AsmDialect}; use syntax::ast::{Attribute, Label, LitKind, StrStyle, FloatTy, IntTy, UintTy}; use syntax::attr::{InlineAttr, OptimizeAttr}; use syntax::ext::hygiene::SyntaxContext; -use syntax::ptr::P; use syntax::symbol::{Symbol, kw}; use syntax::tokenstream::TokenStream; use syntax::util::parser::ExprPrecedence; @@ -63,6 +63,7 @@ pub mod lowering; pub mod map; pub mod pat_util; pub mod print; +pub mod ptr; pub mod upvars; /// Uniquely identifies a node in the HIR of the current crate. It is @@ -1979,13 +1980,15 @@ pub struct InlineAsmOutput { pub span: Span, } +// NOTE(eddyb) This is used within MIR as well, so unlike the rest of the HIR, +// it needs to be `Clone` and use plain `Vec` instead of `HirVec`. #[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)] pub struct InlineAsm { pub asm: Symbol, pub asm_str_style: StrStyle, - pub outputs: HirVec, - pub inputs: HirVec, - pub clobbers: HirVec, + pub outputs: Vec, + pub inputs: Vec, + pub clobbers: Vec, pub volatile: bool, pub alignstack: bool, pub dialect: AsmDialect, @@ -2217,7 +2220,7 @@ pub enum UseKind { /// within the resolution map. #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)] pub struct TraitRef { - pub path: Path, + pub path: P, // Don't hash the ref_id. It is tracked via the thing it is used to access #[stable_hasher(ignore)] pub hir_ref_id: HirId, diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 8b1984e04f55b..573b9add133ea 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -6,7 +6,6 @@ use syntax::parse::lexer::comments; use syntax::print::pp::{self, Breaks}; use syntax::print::pp::Breaks::{Consistent, Inconsistent}; use syntax::print::pprust::{self, PrintState}; -use syntax::ptr::P; use syntax::symbol::kw; use syntax::util::parser::{self, AssocOp, Fixity}; use syntax_pos::{self, BytePos, FileName}; @@ -14,10 +13,11 @@ use syntax_pos::{self, BytePos, FileName}; use crate::hir; use crate::hir::{PatKind, GenericBound, TraitBoundModifier, RangeEnd}; use crate::hir::{GenericParam, GenericParamKind, GenericArg}; +use crate::hir::ptr::P; use std::borrow::Cow; use std::cell::Cell; -use std::io::{self, Write, Read}; +use std::io::Read; use std::vec; pub enum AnnNode<'a> { @@ -38,14 +38,11 @@ pub enum Nested { } pub trait PpAnn { - fn nested(&self, _state: &mut State<'_>, _nested: Nested) -> io::Result<()> { - Ok(()) + fn nested(&self, _state: &mut State<'_>, _nested: Nested) { } - fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) -> io::Result<()> { - Ok(()) + fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { } - fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) -> io::Result<()> { - Ok(()) + fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { } fn try_fetch_item(&self, _: hir::HirId) -> Option<&hir::Item> { None @@ -60,7 +57,7 @@ impl PpAnn for hir::Crate { fn try_fetch_item(&self, item: hir::HirId) -> Option<&hir::Item> { Some(self.item(item)) } - fn nested(&self, state: &mut State<'_>, nested: Nested) -> io::Result<()> { + fn nested(&self, state: &mut State<'_>, nested: Nested) { match nested { Nested::Item(id) => state.print_item(self.item(id.id)), Nested::TraitItem(id) => state.print_trait_item(self.trait_item(id)), @@ -101,10 +98,6 @@ impl<'a> PrintState<'a> for State<'a> { #[allow(non_upper_case_globals)] pub const indent_unit: usize = 4; -#[allow(non_upper_case_globals)] -pub const default_columns: usize = 78; - - /// Requires you to pass an input filename and reader so that /// it can scan the input text for comments to copy forward. pub fn print_crate<'a>(cm: &'a SourceMap, @@ -112,16 +105,16 @@ pub fn print_crate<'a>(cm: &'a SourceMap, krate: &hir::Crate, filename: FileName, input: &mut dyn Read, - out: Box, + out: &'a mut String, ann: &'a dyn PpAnn) - -> io::Result<()> { + { let mut s = State::new_from_input(cm, sess, filename, input, out, ann); // When printing the AST, we sometimes need to inject `#[no_std]` here. // Since you can't compile the HIR, it's not necessary. - s.print_mod(&krate.module, &krate.attrs)?; - s.print_remaining_comments()?; + s.print_mod(&krate.module, &krate.attrs); + s.print_remaining_comments(); s.s.eof() } @@ -130,7 +123,7 @@ impl<'a> State<'a> { sess: &ParseSess, filename: FileName, input: &mut dyn Read, - out: Box, + out: &'a mut String, ann: &'a dyn PpAnn) -> State<'a> { let comments = comments::gather_comments(sess, filename, input); @@ -138,12 +131,12 @@ impl<'a> State<'a> { } pub fn new(cm: &'a SourceMap, - out: Box, + out: &'a mut String, ann: &'a dyn PpAnn, comments: Option>) -> State<'a> { State { - s: pp::mk_printer(out, default_columns), + s: pp::mk_printer(out), cm: Some(cm), comments, cur_cmnt: 0, @@ -154,65 +147,64 @@ impl<'a> State<'a> { } pub fn to_string(ann: &dyn PpAnn, f: F) -> String - where F: FnOnce(&mut State<'_>) -> io::Result<()> + where F: FnOnce(&mut State<'_>) { - let mut wr = Vec::new(); + let mut wr = String::new(); { let mut printer = State { - s: pp::mk_printer(Box::new(&mut wr), default_columns), + s: pp::mk_printer(&mut wr), cm: None, comments: None, cur_cmnt: 0, boxes: Vec::new(), ann, }; - f(&mut printer).unwrap(); - printer.s.eof().unwrap(); + f(&mut printer); + printer.s.eof(); } - String::from_utf8(wr).unwrap() + wr } pub fn visibility_qualified>>(vis: &hir::Visibility, w: S) -> String { to_string(NO_ANN, |s| { - s.print_visibility(vis)?; + s.print_visibility(vis); s.s.word(w) }) } impl<'a> State<'a> { - pub fn cbox(&mut self, u: usize) -> io::Result<()> { + pub fn cbox(&mut self, u: usize) { self.boxes.push(pp::Breaks::Consistent); - self.s.cbox(u) + self.s.cbox(u); } - pub fn nbsp(&mut self) -> io::Result<()> { + pub fn nbsp(&mut self) { self.s.word(" ") } - pub fn word_nbsp>>(&mut self, w: S) -> io::Result<()> { - self.s.word(w)?; + pub fn word_nbsp>>(&mut self, w: S) { + self.s.word(w); self.nbsp() } - pub fn head>>(&mut self, w: S) -> io::Result<()> { + pub fn head>>(&mut self, w: S) { let w = w.into(); // outer-box is consistent - self.cbox(indent_unit)?; + self.cbox(indent_unit); // head-box is inconsistent - self.ibox(w.len() + 1)?; + self.ibox(w.len() + 1); // keyword that starts the head if !w.is_empty() { - self.word_nbsp(w)?; + self.word_nbsp(w); } - Ok(()) } - pub fn bopen(&mut self) -> io::Result<()> { - self.s.word("{")?; - self.end() // close the head-box + pub fn bopen(&mut self) { + self.s.word("{"); + self.end(); // close the head-box } - pub fn bclose_(&mut self, span: syntax_pos::Span, indented: usize) -> io::Result<()> { + pub fn bclose_(&mut self, span: syntax_pos::Span, indented: usize) { self.bclose_maybe_open(span, indented, true) } @@ -220,17 +212,16 @@ impl<'a> State<'a> { span: syntax_pos::Span, indented: usize, close_box: bool) - -> io::Result<()> { - self.maybe_print_comment(span.hi())?; - self.break_offset_if_not_bol(1, -(indented as isize))?; - self.s.word("}")?; + { + self.maybe_print_comment(span.hi()); + self.break_offset_if_not_bol(1, -(indented as isize)); + self.s.word("}"); if close_box { - self.end()?; // close the outer-box + self.end(); // close the outer-box } - Ok(()) } - pub fn bclose(&mut self, span: syntax_pos::Span) -> io::Result<()> { + pub fn bclose(&mut self, span: syntax_pos::Span) { self.bclose_(span, indent_unit) } @@ -241,14 +232,13 @@ impl<'a> State<'a> { } } - pub fn space_if_not_bol(&mut self) -> io::Result<()> { + pub fn space_if_not_bol(&mut self) { if !self.is_bol() { - self.s.space()?; + self.s.space(); } - Ok(()) } - pub fn break_offset_if_not_bol(&mut self, n: usize, off: isize) -> io::Result<()> { + pub fn break_offset_if_not_bol(&mut self, n: usize, off: isize) { if !self.is_bol() { self.s.break_offset(n, off) } else { @@ -258,17 +248,16 @@ impl<'a> State<'a> { // break into the previous hardbreak. self.s.replace_last_token(pp::Printer::hardbreak_tok_offset(off)); } - Ok(()) } } // Synthesizes a comment that was not textually present in the original source // file. - pub fn synth_comment(&mut self, text: String) -> io::Result<()> { - self.s.word("/*")?; - self.s.space()?; - self.s.word(text)?; - self.s.space()?; + pub fn synth_comment(&mut self, text: String) { + self.s.word("/*"); + self.s.space(); + self.s.word(text); + self.s.space(); self.s.word("*/") } @@ -277,97 +266,93 @@ impl<'a> State<'a> { elts: &[T], mut op: F, mut get_span: G) - -> io::Result<()> - where F: FnMut(&mut State<'_>, &T) -> io::Result<()>, + where F: FnMut(&mut State<'_>, &T), G: FnMut(&T) -> syntax_pos::Span { - self.rbox(0, b)?; + self.rbox(0, b); let len = elts.len(); let mut i = 0; for elt in elts { - self.maybe_print_comment(get_span(elt).hi())?; - op(self, elt)?; + self.maybe_print_comment(get_span(elt).hi()); + op(self, elt); i += 1; if i < len { - self.s.word(",")?; - self.maybe_print_trailing_comment(get_span(elt), Some(get_span(&elts[i]).hi()))?; - self.space_if_not_bol()?; + self.s.word(","); + self.maybe_print_trailing_comment(get_span(elt), Some(get_span(&elts[i]).hi())); + self.space_if_not_bol(); } } - self.end() + self.end(); } - pub fn commasep_exprs(&mut self, b: Breaks, exprs: &[hir::Expr]) -> io::Result<()> { + pub fn commasep_exprs(&mut self, b: Breaks, exprs: &[hir::Expr]) { self.commasep_cmnt(b, exprs, |s, e| s.print_expr(&e), |e| e.span) } - pub fn print_mod(&mut self, _mod: &hir::Mod, attrs: &[ast::Attribute]) -> io::Result<()> { - self.print_inner_attributes(attrs)?; + pub fn print_mod(&mut self, _mod: &hir::Mod, attrs: &[ast::Attribute]) { + self.print_inner_attributes(attrs); for &item_id in &_mod.item_ids { - self.ann.nested(self, Nested::Item(item_id))?; + self.ann.nested(self, Nested::Item(item_id)); } - Ok(()) } pub fn print_foreign_mod(&mut self, nmod: &hir::ForeignMod, attrs: &[ast::Attribute]) - -> io::Result<()> { - self.print_inner_attributes(attrs)?; + { + self.print_inner_attributes(attrs); for item in &nmod.items { - self.print_foreign_item(item)?; + self.print_foreign_item(item); } - Ok(()) } - pub fn print_opt_lifetime(&mut self, lifetime: &hir::Lifetime) -> io::Result<()> { + pub fn print_opt_lifetime(&mut self, lifetime: &hir::Lifetime) { if !lifetime.is_elided() { - self.print_lifetime(lifetime)?; - self.nbsp()?; + self.print_lifetime(lifetime); + self.nbsp(); } - Ok(()) } - pub fn print_type(&mut self, ty: &hir::Ty) -> io::Result<()> { - self.maybe_print_comment(ty.span.lo())?; - self.ibox(0)?; + pub fn print_type(&mut self, ty: &hir::Ty) { + self.maybe_print_comment(ty.span.lo()); + self.ibox(0); match ty.node { hir::TyKind::Slice(ref ty) => { - self.s.word("[")?; - self.print_type(&ty)?; - self.s.word("]")?; + self.s.word("["); + self.print_type(&ty); + self.s.word("]"); } hir::TyKind::Ptr(ref mt) => { - self.s.word("*")?; + self.s.word("*"); match mt.mutbl { - hir::MutMutable => self.word_nbsp("mut")?, - hir::MutImmutable => self.word_nbsp("const")?, + hir::MutMutable => self.word_nbsp("mut"), + hir::MutImmutable => self.word_nbsp("const"), } - self.print_type(&mt.ty)?; + self.print_type(&mt.ty); } hir::TyKind::Rptr(ref lifetime, ref mt) => { - self.s.word("&")?; - self.print_opt_lifetime(lifetime)?; - self.print_mt(mt)?; + self.s.word("&"); + self.print_opt_lifetime(lifetime); + self.print_mt(mt); } hir::TyKind::Never => { - self.s.word("!")?; + self.s.word("!"); }, hir::TyKind::Tup(ref elts) => { - self.popen()?; - self.commasep(Inconsistent, &elts[..], |s, ty| s.print_type(&ty))?; + self.popen(); + self.commasep(Inconsistent, &elts[..], |s, ty| s.print_type(&ty)); if elts.len() == 1 { - self.s.word(",")?; + self.s.word(","); } - self.pclose()?; + self.pclose(); } hir::TyKind::BareFn(ref f) => { self.print_ty_fn(f.abi, f.unsafety, &f.decl, None, &f.generic_params, - &f.arg_names[..])?; + &f.arg_names[..]); } hir::TyKind::Def(..) => {}, hir::TyKind::Path(ref qpath) => { - self.print_qpath(qpath, false)? + self.print_qpath(qpath, false) } hir::TyKind::TraitObject(ref bounds, ref lifetime) => { let mut first = true; @@ -375,51 +360,51 @@ impl<'a> State<'a> { if first { first = false; } else { - self.nbsp()?; - self.word_space("+")?; + self.nbsp(); + self.word_space("+"); } - self.print_poly_trait_ref(bound)?; + self.print_poly_trait_ref(bound); } if !lifetime.is_elided() { - self.nbsp()?; - self.word_space("+")?; - self.print_lifetime(lifetime)?; + self.nbsp(); + self.word_space("+"); + self.print_lifetime(lifetime); } } hir::TyKind::Array(ref ty, ref length) => { - self.s.word("[")?; - self.print_type(&ty)?; - self.s.word("; ")?; - self.print_anon_const(length)?; - self.s.word("]")?; + self.s.word("["); + self.print_type(&ty); + self.s.word("; "); + self.print_anon_const(length); + self.s.word("]"); } hir::TyKind::Typeof(ref e) => { - self.s.word("typeof(")?; - self.print_anon_const(e)?; - self.s.word(")")?; + self.s.word("typeof("); + self.print_anon_const(e); + self.s.word(")"); } hir::TyKind::Infer => { - self.s.word("_")?; + self.s.word("_"); } hir::TyKind::Err => { - self.popen()?; - self.s.word("/*ERROR*/")?; - self.pclose()?; + self.popen(); + self.s.word("/*ERROR*/"); + self.pclose(); } hir::TyKind::CVarArgs(_) => { - self.s.word("...")?; + self.s.word("..."); } } self.end() } - pub fn print_foreign_item(&mut self, item: &hir::ForeignItem) -> io::Result<()> { - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(item.span.lo())?; - self.print_outer_attributes(&item.attrs)?; + pub fn print_foreign_item(&mut self, item: &hir::ForeignItem) { + self.hardbreak_if_not_bol(); + self.maybe_print_comment(item.span.lo()); + self.print_outer_attributes(&item.attrs); match item.node { hir::ForeignItemKind::Fn(ref decl, ref arg_names, ref generics) => { - self.head("")?; + self.head(""); self.print_fn(decl, hir::FnHeader { unsafety: hir::Unsafety::Normal, @@ -431,28 +416,28 @@ impl<'a> State<'a> { generics, &item.vis, arg_names, - None)?; - self.end()?; // end head-ibox - self.s.word(";")?; + None); + self.end(); // end head-ibox + self.s.word(";"); self.end() // end the outer fn box } hir::ForeignItemKind::Static(ref t, m) => { - self.head(visibility_qualified(&item.vis, "static"))?; + self.head(visibility_qualified(&item.vis, "static")); if m == hir::MutMutable { - self.word_space("mut")?; + self.word_space("mut"); } - self.print_ident(item.ident)?; - self.word_space(":")?; - self.print_type(&t)?; - self.s.word(";")?; - self.end()?; // end the head-ibox + self.print_ident(item.ident); + self.word_space(":"); + self.print_type(&t); + self.s.word(";"); + self.end(); // end the head-ibox self.end() // end the outer cbox } hir::ForeignItemKind::Type => { - self.head(visibility_qualified(&item.vis, "type"))?; - self.print_ident(item.ident)?; - self.s.word(";")?; - self.end()?; // end the head-ibox + self.head(visibility_qualified(&item.vis, "type")); + self.print_ident(item.ident); + self.s.word(";"); + self.end(); // end the head-ibox self.end() // end the outer cbox } } @@ -463,16 +448,16 @@ impl<'a> State<'a> { ty: &hir::Ty, default: Option, vis: &hir::Visibility) - -> io::Result<()> { - self.s.word(visibility_qualified(vis, ""))?; - self.word_space("const")?; - self.print_ident(ident)?; - self.word_space(":")?; - self.print_type(ty)?; + { + self.s.word(visibility_qualified(vis, "")); + self.word_space("const"); + self.print_ident(ident); + self.word_space(":"); + self.print_type(ty); if let Some(expr) = default { - self.s.space()?; - self.word_space("=")?; - self.ann.nested(self, Nested::Body(expr))?; + self.s.space(); + self.word_space("="); + self.ann.nested(self, Nested::Body(expr)); } self.s.word(";") } @@ -481,168 +466,168 @@ impl<'a> State<'a> { ident: ast::Ident, bounds: Option<&hir::GenericBounds>, ty: Option<&hir::Ty>) - -> io::Result<()> { - self.word_space("type")?; - self.print_ident(ident)?; + { + self.word_space("type"); + self.print_ident(ident); if let Some(bounds) = bounds { - self.print_bounds(":", bounds)?; + self.print_bounds(":", bounds); } if let Some(ty) = ty { - self.s.space()?; - self.word_space("=")?; - self.print_type(ty)?; + self.s.space(); + self.word_space("="); + self.print_type(ty); } self.s.word(";") } /// Pretty-print an item - pub fn print_item(&mut self, item: &hir::Item) -> io::Result<()> { - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(item.span.lo())?; - self.print_outer_attributes(&item.attrs)?; - self.ann.pre(self, AnnNode::Item(item))?; + pub fn print_item(&mut self, item: &hir::Item) { + self.hardbreak_if_not_bol(); + self.maybe_print_comment(item.span.lo()); + self.print_outer_attributes(&item.attrs); + self.ann.pre(self, AnnNode::Item(item)); match item.node { hir::ItemKind::ExternCrate(orig_name) => { - self.head(visibility_qualified(&item.vis, "extern crate"))?; + self.head(visibility_qualified(&item.vis, "extern crate")); if let Some(orig_name) = orig_name { - self.print_name(orig_name)?; - self.s.space()?; - self.s.word("as")?; - self.s.space()?; + self.print_name(orig_name); + self.s.space(); + self.s.word("as"); + self.s.space(); } - self.print_ident(item.ident)?; - self.s.word(";")?; - self.end()?; // end inner head-block - self.end()?; // end outer head-block + self.print_ident(item.ident); + self.s.word(";"); + self.end(); // end inner head-block + self.end(); // end outer head-block } hir::ItemKind::Use(ref path, kind) => { - self.head(visibility_qualified(&item.vis, "use"))?; - self.print_path(path, false)?; + self.head(visibility_qualified(&item.vis, "use")); + self.print_path(path, false); match kind { hir::UseKind::Single => { if path.segments.last().unwrap().ident != item.ident { - self.s.space()?; - self.word_space("as")?; - self.print_ident(item.ident)?; + self.s.space(); + self.word_space("as"); + self.print_ident(item.ident); } - self.s.word(";")?; + self.s.word(";"); } - hir::UseKind::Glob => self.s.word("::*;")?, - hir::UseKind::ListStem => self.s.word("::{};")? + hir::UseKind::Glob => self.s.word("::*;"), + hir::UseKind::ListStem => self.s.word("::{};") } - self.end()?; // end inner head-block - self.end()?; // end outer head-block + self.end(); // end inner head-block + self.end(); // end outer head-block } hir::ItemKind::Static(ref ty, m, expr) => { - self.head(visibility_qualified(&item.vis, "static"))?; + self.head(visibility_qualified(&item.vis, "static")); if m == hir::MutMutable { - self.word_space("mut")?; + self.word_space("mut"); } - self.print_ident(item.ident)?; - self.word_space(":")?; - self.print_type(&ty)?; - self.s.space()?; - self.end()?; // end the head-ibox + self.print_ident(item.ident); + self.word_space(":"); + self.print_type(&ty); + self.s.space(); + self.end(); // end the head-ibox - self.word_space("=")?; - self.ann.nested(self, Nested::Body(expr))?; - self.s.word(";")?; - self.end()?; // end the outer cbox + self.word_space("="); + self.ann.nested(self, Nested::Body(expr)); + self.s.word(";"); + self.end(); // end the outer cbox } hir::ItemKind::Const(ref ty, expr) => { - self.head(visibility_qualified(&item.vis, "const"))?; - self.print_ident(item.ident)?; - self.word_space(":")?; - self.print_type(&ty)?; - self.s.space()?; - self.end()?; // end the head-ibox - - self.word_space("=")?; - self.ann.nested(self, Nested::Body(expr))?; - self.s.word(";")?; - self.end()?; // end the outer cbox + self.head(visibility_qualified(&item.vis, "const")); + self.print_ident(item.ident); + self.word_space(":"); + self.print_type(&ty); + self.s.space(); + self.end(); // end the head-ibox + + self.word_space("="); + self.ann.nested(self, Nested::Body(expr)); + self.s.word(";"); + self.end(); // end the outer cbox } hir::ItemKind::Fn(ref decl, header, ref param_names, body) => { - self.head("")?; + self.head(""); self.print_fn(decl, header, Some(item.ident.name), param_names, &item.vis, &[], - Some(body))?; - self.s.word(" ")?; - self.end()?; // need to close a box - self.end()?; // need to close a box - self.ann.nested(self, Nested::Body(body))?; + Some(body)); + self.s.word(" "); + self.end(); // need to close a box + self.end(); // need to close a box + self.ann.nested(self, Nested::Body(body)); } hir::ItemKind::Mod(ref _mod) => { - self.head(visibility_qualified(&item.vis, "mod"))?; - self.print_ident(item.ident)?; - self.nbsp()?; - self.bopen()?; - self.print_mod(_mod, &item.attrs)?; - self.bclose(item.span)?; + self.head(visibility_qualified(&item.vis, "mod")); + self.print_ident(item.ident); + self.nbsp(); + self.bopen(); + self.print_mod(_mod, &item.attrs); + self.bclose(item.span); } hir::ItemKind::ForeignMod(ref nmod) => { - self.head("extern")?; - self.word_nbsp(nmod.abi.to_string())?; - self.bopen()?; - self.print_foreign_mod(nmod, &item.attrs)?; - self.bclose(item.span)?; + self.head("extern"); + self.word_nbsp(nmod.abi.to_string()); + self.bopen(); + self.print_foreign_mod(nmod, &item.attrs); + self.bclose(item.span); } hir::ItemKind::GlobalAsm(ref ga) => { - self.head(visibility_qualified(&item.vis, "global asm"))?; - self.s.word(ga.asm.as_str().to_string())?; - self.end()? + self.head(visibility_qualified(&item.vis, "global asm")); + self.s.word(ga.asm.as_str().to_string()); + self.end() } hir::ItemKind::Ty(ref ty, ref generics) => { - self.head(visibility_qualified(&item.vis, "type"))?; - self.print_ident(item.ident)?; - self.print_generic_params(&generics.params)?; - self.end()?; // end the inner ibox - - self.print_where_clause(&generics.where_clause)?; - self.s.space()?; - self.word_space("=")?; - self.print_type(&ty)?; - self.s.word(";")?; - self.end()?; // end the outer ibox + self.head(visibility_qualified(&item.vis, "type")); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); + self.end(); // end the inner ibox + + self.print_where_clause(&generics.where_clause); + self.s.space(); + self.word_space("="); + self.print_type(&ty); + self.s.word(";"); + self.end(); // end the outer ibox } hir::ItemKind::Existential(ref exist) => { - self.head(visibility_qualified(&item.vis, "existential type"))?; - self.print_ident(item.ident)?; - self.print_generic_params(&exist.generics.params)?; - self.end()?; // end the inner ibox + self.head(visibility_qualified(&item.vis, "existential type")); + self.print_ident(item.ident); + self.print_generic_params(&exist.generics.params); + self.end(); // end the inner ibox - self.print_where_clause(&exist.generics.where_clause)?; - self.s.space()?; + self.print_where_clause(&exist.generics.where_clause); + self.s.space(); let mut real_bounds = Vec::with_capacity(exist.bounds.len()); for b in exist.bounds.iter() { if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b { - self.s.space()?; - self.word_space("for ?")?; - self.print_trait_ref(&ptr.trait_ref)?; + self.s.space(); + self.word_space("for ?"); + self.print_trait_ref(&ptr.trait_ref); } else { real_bounds.push(b); } } - self.print_bounds(":", real_bounds)?; - self.s.word(";")?; - self.end()?; // end the outer ibox + self.print_bounds(":", real_bounds); + self.s.word(";"); + self.end(); // end the outer ibox } hir::ItemKind::Enum(ref enum_definition, ref params) => { self.print_enum_def(enum_definition, params, item.ident.name, item.span, - &item.vis)?; + &item.vis); } hir::ItemKind::Struct(ref struct_def, ref generics) => { - self.head(visibility_qualified(&item.vis, "struct"))?; - self.print_struct(struct_def, generics, item.ident.name, item.span, true)?; + self.head(visibility_qualified(&item.vis, "struct")); + self.print_struct(struct_def, generics, item.ident.name, item.span, true); } hir::ItemKind::Union(ref struct_def, ref generics) => { - self.head(visibility_qualified(&item.vis, "union"))?; - self.print_struct(struct_def, generics, item.ident.name, item.span, true)?; + self.head(visibility_qualified(&item.vis, "union")); + self.print_struct(struct_def, generics, item.ident.name, item.span, true); } hir::ItemKind::Impl(unsafety, polarity, @@ -651,109 +636,108 @@ impl<'a> State<'a> { ref opt_trait, ref ty, ref impl_items) => { - self.head("")?; - self.print_visibility(&item.vis)?; - self.print_defaultness(defaultness)?; - self.print_unsafety(unsafety)?; - self.word_nbsp("impl")?; + self.head(""); + self.print_visibility(&item.vis); + self.print_defaultness(defaultness); + self.print_unsafety(unsafety); + self.word_nbsp("impl"); if !generics.params.is_empty() { - self.print_generic_params(&generics.params)?; - self.s.space()?; + self.print_generic_params(&generics.params); + self.s.space(); } if let hir::ImplPolarity::Negative = polarity { - self.s.word("!")?; + self.s.word("!"); } if let Some(ref t) = opt_trait { - self.print_trait_ref(t)?; - self.s.space()?; - self.word_space("for")?; + self.print_trait_ref(t); + self.s.space(); + self.word_space("for"); } - self.print_type(&ty)?; - self.print_where_clause(&generics.where_clause)?; + self.print_type(&ty); + self.print_where_clause(&generics.where_clause); - self.s.space()?; - self.bopen()?; - self.print_inner_attributes(&item.attrs)?; + self.s.space(); + self.bopen(); + self.print_inner_attributes(&item.attrs); for impl_item in impl_items { - self.ann.nested(self, Nested::ImplItem(impl_item.id))?; + self.ann.nested(self, Nested::ImplItem(impl_item.id)); } - self.bclose(item.span)?; + self.bclose(item.span); } hir::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref trait_items) => { - self.head("")?; - self.print_visibility(&item.vis)?; - self.print_is_auto(is_auto)?; - self.print_unsafety(unsafety)?; - self.word_nbsp("trait")?; - self.print_ident(item.ident)?; - self.print_generic_params(&generics.params)?; + self.head(""); + self.print_visibility(&item.vis); + self.print_is_auto(is_auto); + self.print_unsafety(unsafety); + self.word_nbsp("trait"); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); let mut real_bounds = Vec::with_capacity(bounds.len()); for b in bounds.iter() { if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b { - self.s.space()?; - self.word_space("for ?")?; - self.print_trait_ref(&ptr.trait_ref)?; + self.s.space(); + self.word_space("for ?"); + self.print_trait_ref(&ptr.trait_ref); } else { real_bounds.push(b); } } - self.print_bounds(":", real_bounds)?; - self.print_where_clause(&generics.where_clause)?; - self.s.word(" ")?; - self.bopen()?; + self.print_bounds(":", real_bounds); + self.print_where_clause(&generics.where_clause); + self.s.word(" "); + self.bopen(); for trait_item in trait_items { - self.ann.nested(self, Nested::TraitItem(trait_item.id))?; + self.ann.nested(self, Nested::TraitItem(trait_item.id)); } - self.bclose(item.span)?; + self.bclose(item.span); } hir::ItemKind::TraitAlias(ref generics, ref bounds) => { - self.head("")?; - self.print_visibility(&item.vis)?; - self.word_nbsp("trait")?; - self.print_ident(item.ident)?; - self.print_generic_params(&generics.params)?; + self.head(""); + self.print_visibility(&item.vis); + self.word_nbsp("trait"); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); let mut real_bounds = Vec::with_capacity(bounds.len()); // FIXME(durka) this seems to be some quite outdated syntax for b in bounds.iter() { if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b { - self.s.space()?; - self.word_space("for ?")?; - self.print_trait_ref(&ptr.trait_ref)?; + self.s.space(); + self.word_space("for ?"); + self.print_trait_ref(&ptr.trait_ref); } else { real_bounds.push(b); } } - self.nbsp()?; - self.print_bounds("=", real_bounds)?; - self.print_where_clause(&generics.where_clause)?; - self.s.word(";")?; + self.nbsp(); + self.print_bounds("=", real_bounds); + self.print_where_clause(&generics.where_clause); + self.s.word(";"); } } self.ann.post(self, AnnNode::Item(item)) } - pub fn print_trait_ref(&mut self, t: &hir::TraitRef) -> io::Result<()> { + pub fn print_trait_ref(&mut self, t: &hir::TraitRef) { self.print_path(&t.path, false) } fn print_formal_generic_params( &mut self, generic_params: &[hir::GenericParam] - ) -> io::Result<()> { + ) { if !generic_params.is_empty() { - self.s.word("for")?; - self.print_generic_params(generic_params)?; - self.nbsp()?; + self.s.word("for"); + self.print_generic_params(generic_params); + self.nbsp(); } - Ok(()) } - fn print_poly_trait_ref(&mut self, t: &hir::PolyTraitRef) -> io::Result<()> { - self.print_formal_generic_params(&t.bound_generic_params)?; + fn print_poly_trait_ref(&mut self, t: &hir::PolyTraitRef) { + self.print_formal_generic_params(&t.bound_generic_params); self.print_trait_ref(&t.trait_ref) } @@ -763,63 +747,60 @@ impl<'a> State<'a> { name: ast::Name, span: syntax_pos::Span, visibility: &hir::Visibility) - -> io::Result<()> { - self.head(visibility_qualified(visibility, "enum"))?; - self.print_name(name)?; - self.print_generic_params(&generics.params)?; - self.print_where_clause(&generics.where_clause)?; - self.s.space()?; + { + self.head(visibility_qualified(visibility, "enum")); + self.print_name(name); + self.print_generic_params(&generics.params); + self.print_where_clause(&generics.where_clause); + self.s.space(); self.print_variants(&enum_definition.variants, span) } pub fn print_variants(&mut self, variants: &[hir::Variant], span: syntax_pos::Span) - -> io::Result<()> { - self.bopen()?; + { + self.bopen(); for v in variants { - self.space_if_not_bol()?; - self.maybe_print_comment(v.span.lo())?; - self.print_outer_attributes(&v.node.attrs)?; - self.ibox(indent_unit)?; - self.print_variant(v)?; - self.s.word(",")?; - self.end()?; - self.maybe_print_trailing_comment(v.span, None)?; + self.space_if_not_bol(); + self.maybe_print_comment(v.span.lo()); + self.print_outer_attributes(&v.node.attrs); + self.ibox(indent_unit); + self.print_variant(v); + self.s.word(","); + self.end(); + self.maybe_print_trailing_comment(v.span, None); } self.bclose(span) } - pub fn print_visibility(&mut self, vis: &hir::Visibility) -> io::Result<()> { + pub fn print_visibility(&mut self, vis: &hir::Visibility) { match vis.node { - hir::VisibilityKind::Public => self.word_nbsp("pub")?, - hir::VisibilityKind::Crate(ast::CrateSugar::JustCrate) => self.word_nbsp("crate")?, - hir::VisibilityKind::Crate(ast::CrateSugar::PubCrate) => self.word_nbsp("pub(crate)")?, + hir::VisibilityKind::Public => self.word_nbsp("pub"), + hir::VisibilityKind::Crate(ast::CrateSugar::JustCrate) => self.word_nbsp("crate"), + hir::VisibilityKind::Crate(ast::CrateSugar::PubCrate) => self.word_nbsp("pub(crate)"), hir::VisibilityKind::Restricted { ref path, .. } => { - self.s.word("pub(")?; + self.s.word("pub("); if path.segments.len() == 1 && path.segments[0].ident.name == kw::Super { // Special case: `super` can print like `pub(super)`. - self.s.word("super")?; + self.s.word("super"); } else { // Everything else requires `in` at present. - self.word_nbsp("in")?; - self.print_path(path, false)?; + self.word_nbsp("in"); + self.print_path(path, false); } - self.word_nbsp(")")?; + self.word_nbsp(")"); } hir::VisibilityKind::Inherited => () } - - Ok(()) } - pub fn print_defaultness(&mut self, defaultness: hir::Defaultness) -> io::Result<()> { + pub fn print_defaultness(&mut self, defaultness: hir::Defaultness) { match defaultness { - hir::Defaultness::Default { .. } => self.word_nbsp("default")?, + hir::Defaultness::Default { .. } => self.word_nbsp("default"), hir::Defaultness::Final => (), } - Ok(()) } pub fn print_struct(&mut self, @@ -828,43 +809,43 @@ impl<'a> State<'a> { name: ast::Name, span: syntax_pos::Span, print_finalizer: bool) - -> io::Result<()> { - self.print_name(name)?; - self.print_generic_params(&generics.params)?; + { + self.print_name(name); + self.print_generic_params(&generics.params); match struct_def { hir::VariantData::Tuple(..) | hir::VariantData::Unit(..) => { if let hir::VariantData::Tuple(..) = struct_def { - self.popen()?; + self.popen(); self.commasep(Inconsistent, struct_def.fields(), |s, field| { - s.maybe_print_comment(field.span.lo())?; - s.print_outer_attributes(&field.attrs)?; - s.print_visibility(&field.vis)?; + s.maybe_print_comment(field.span.lo()); + s.print_outer_attributes(&field.attrs); + s.print_visibility(&field.vis); s.print_type(&field.ty) - })?; - self.pclose()?; + }); + self.pclose(); } - self.print_where_clause(&generics.where_clause)?; + self.print_where_clause(&generics.where_clause); if print_finalizer { - self.s.word(";")?; + self.s.word(";"); } - self.end()?; + self.end(); self.end() // close the outer-box } hir::VariantData::Struct(..) => { - self.print_where_clause(&generics.where_clause)?; - self.nbsp()?; - self.bopen()?; - self.hardbreak_if_not_bol()?; + self.print_where_clause(&generics.where_clause); + self.nbsp(); + self.bopen(); + self.hardbreak_if_not_bol(); for field in struct_def.fields() { - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(field.span.lo())?; - self.print_outer_attributes(&field.attrs)?; - self.print_visibility(&field.vis)?; - self.print_ident(field.ident)?; - self.word_nbsp(":")?; - self.print_type(&field.ty)?; - self.s.word(",")?; + self.hardbreak_if_not_bol(); + self.maybe_print_comment(field.span.lo()); + self.print_outer_attributes(&field.attrs); + self.print_visibility(&field.vis); + self.print_ident(field.ident); + self.word_nbsp(":"); + self.print_type(&field.ty); + self.s.word(","); } self.bclose(span) @@ -872,16 +853,15 @@ impl<'a> State<'a> { } } - pub fn print_variant(&mut self, v: &hir::Variant) -> io::Result<()> { - self.head("")?; + pub fn print_variant(&mut self, v: &hir::Variant) { + self.head(""); let generics = hir::Generics::empty(); - self.print_struct(&v.node.data, &generics, v.node.ident.name, v.span, false)?; + self.print_struct(&v.node.data, &generics, v.node.ident.name, v.span, false); if let Some(ref d) = v.node.disr_expr { - self.s.space()?; - self.word_space("=")?; - self.print_anon_const(d)?; + self.s.space(); + self.word_space("="); + self.print_anon_const(d); } - Ok(()) } pub fn print_method_sig(&mut self, ident: ast::Ident, @@ -890,7 +870,7 @@ impl<'a> State<'a> { vis: &hir::Visibility, arg_names: &[ast::Ident], body_id: Option) - -> io::Result<()> { + { self.print_fn(&m.decl, m.header, Some(ident.name), @@ -900,67 +880,67 @@ impl<'a> State<'a> { body_id) } - pub fn print_trait_item(&mut self, ti: &hir::TraitItem) -> io::Result<()> { - self.ann.pre(self, AnnNode::SubItem(ti.hir_id))?; - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(ti.span.lo())?; - self.print_outer_attributes(&ti.attrs)?; + pub fn print_trait_item(&mut self, ti: &hir::TraitItem) { + self.ann.pre(self, AnnNode::SubItem(ti.hir_id)); + self.hardbreak_if_not_bol(); + self.maybe_print_comment(ti.span.lo()); + self.print_outer_attributes(&ti.attrs); match ti.node { hir::TraitItemKind::Const(ref ty, default) => { let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityKind::Inherited }; - self.print_associated_const(ti.ident, &ty, default, &vis)?; + self.print_associated_const(ti.ident, &ty, default, &vis); } hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Required(ref arg_names)) => { let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityKind::Inherited }; - self.print_method_sig(ti.ident, sig, &ti.generics, &vis, arg_names, None)?; - self.s.word(";")?; + self.print_method_sig(ti.ident, sig, &ti.generics, &vis, arg_names, None); + self.s.word(";"); } hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) => { let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityKind::Inherited }; - self.head("")?; - self.print_method_sig(ti.ident, sig, &ti.generics, &vis, &[], Some(body))?; - self.nbsp()?; - self.end()?; // need to close a box - self.end()?; // need to close a box - self.ann.nested(self, Nested::Body(body))?; + self.head(""); + self.print_method_sig(ti.ident, sig, &ti.generics, &vis, &[], Some(body)); + self.nbsp(); + self.end(); // need to close a box + self.end(); // need to close a box + self.ann.nested(self, Nested::Body(body)); } hir::TraitItemKind::Type(ref bounds, ref default) => { self.print_associated_type(ti.ident, Some(bounds), - default.as_ref().map(|ty| &**ty))?; + default.as_ref().map(|ty| &**ty)); } } self.ann.post(self, AnnNode::SubItem(ti.hir_id)) } - pub fn print_impl_item(&mut self, ii: &hir::ImplItem) -> io::Result<()> { - self.ann.pre(self, AnnNode::SubItem(ii.hir_id))?; - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(ii.span.lo())?; - self.print_outer_attributes(&ii.attrs)?; - self.print_defaultness(ii.defaultness)?; + pub fn print_impl_item(&mut self, ii: &hir::ImplItem) { + self.ann.pre(self, AnnNode::SubItem(ii.hir_id)); + self.hardbreak_if_not_bol(); + self.maybe_print_comment(ii.span.lo()); + self.print_outer_attributes(&ii.attrs); + self.print_defaultness(ii.defaultness); match ii.node { hir::ImplItemKind::Const(ref ty, expr) => { - self.print_associated_const(ii.ident, &ty, Some(expr), &ii.vis)?; + self.print_associated_const(ii.ident, &ty, Some(expr), &ii.vis); } hir::ImplItemKind::Method(ref sig, body) => { - self.head("")?; - self.print_method_sig(ii.ident, sig, &ii.generics, &ii.vis, &[], Some(body))?; - self.nbsp()?; - self.end()?; // need to close a box - self.end()?; // need to close a box - self.ann.nested(self, Nested::Body(body))?; + self.head(""); + self.print_method_sig(ii.ident, sig, &ii.generics, &ii.vis, &[], Some(body)); + self.nbsp(); + self.end(); // need to close a box + self.end(); // need to close a box + self.ann.nested(self, Nested::Body(body)); } hir::ImplItemKind::Type(ref ty) => { - self.print_associated_type(ii.ident, None, Some(ty))?; + self.print_associated_type(ii.ident, None, Some(ty)); } hir::ImplItemKind::Existential(ref bounds) => { - self.word_space("existential")?; - self.print_associated_type(ii.ident, Some(bounds), None)?; + self.word_space("existential"); + self.print_associated_type(ii.ident, Some(bounds), None); } } self.ann.post(self, AnnNode::SubItem(ii.hir_id)) @@ -969,68 +949,68 @@ impl<'a> State<'a> { pub fn print_local( &mut self, init: Option<&hir::Expr>, - decl: impl Fn(&mut Self) -> io::Result<()> - ) -> io::Result<()> { - self.space_if_not_bol()?; - self.ibox(indent_unit)?; - self.word_nbsp("let")?; + decl: impl Fn(&mut Self) + ) { + self.space_if_not_bol(); + self.ibox(indent_unit); + self.word_nbsp("let"); - self.ibox(indent_unit)?; - decl(self)?; - self.end()?; + self.ibox(indent_unit); + decl(self); + self.end(); if let Some(ref init) = init { - self.nbsp()?; - self.word_space("=")?; - self.print_expr(&init)?; + self.nbsp(); + self.word_space("="); + self.print_expr(&init); } self.end() } - pub fn print_stmt(&mut self, st: &hir::Stmt) -> io::Result<()> { - self.maybe_print_comment(st.span.lo())?; + pub fn print_stmt(&mut self, st: &hir::Stmt) { + self.maybe_print_comment(st.span.lo()); match st.node { hir::StmtKind::Local(ref loc) => { - self.print_local(loc.init.deref(), |this| this.print_local_decl(&loc))?; + self.print_local(loc.init.deref(), |this| this.print_local_decl(&loc)); } hir::StmtKind::Item(item) => { - self.ann.nested(self, Nested::Item(item))? + self.ann.nested(self, Nested::Item(item)) } hir::StmtKind::Expr(ref expr) => { - self.space_if_not_bol()?; - self.print_expr(&expr)?; + self.space_if_not_bol(); + self.print_expr(&expr); } hir::StmtKind::Semi(ref expr) => { - self.space_if_not_bol()?; - self.print_expr(&expr)?; - self.s.word(";")?; + self.space_if_not_bol(); + self.print_expr(&expr); + self.s.word(";"); } } if stmt_ends_with_semi(&st.node) { - self.s.word(";")?; + self.s.word(";"); } self.maybe_print_trailing_comment(st.span, None) } - pub fn print_block(&mut self, blk: &hir::Block) -> io::Result<()> { + pub fn print_block(&mut self, blk: &hir::Block) { self.print_block_with_attrs(blk, &[]) } - pub fn print_block_unclosed(&mut self, blk: &hir::Block) -> io::Result<()> { + pub fn print_block_unclosed(&mut self, blk: &hir::Block) { self.print_block_unclosed_indent(blk, indent_unit) } pub fn print_block_unclosed_indent(&mut self, blk: &hir::Block, indented: usize) - -> io::Result<()> { + { self.print_block_maybe_unclosed(blk, indented, &[], false) } pub fn print_block_with_attrs(&mut self, blk: &hir::Block, attrs: &[ast::Attribute]) - -> io::Result<()> { + { self.print_block_maybe_unclosed(blk, indent_unit, attrs, true) } @@ -1039,56 +1019,55 @@ impl<'a> State<'a> { indented: usize, attrs: &[ast::Attribute], close_box: bool) - -> io::Result<()> { + { match blk.rules { - hir::UnsafeBlock(..) => self.word_space("unsafe")?, - hir::PushUnsafeBlock(..) => self.word_space("push_unsafe")?, - hir::PopUnsafeBlock(..) => self.word_space("pop_unsafe")?, + hir::UnsafeBlock(..) => self.word_space("unsafe"), + hir::PushUnsafeBlock(..) => self.word_space("push_unsafe"), + hir::PopUnsafeBlock(..) => self.word_space("pop_unsafe"), hir::DefaultBlock => (), } - self.maybe_print_comment(blk.span.lo())?; - self.ann.pre(self, AnnNode::Block(blk))?; - self.bopen()?; + self.maybe_print_comment(blk.span.lo()); + self.ann.pre(self, AnnNode::Block(blk)); + self.bopen(); - self.print_inner_attributes(attrs)?; + self.print_inner_attributes(attrs); for st in &blk.stmts { - self.print_stmt(st)?; + self.print_stmt(st); } if let Some(ref expr) = blk.expr { - self.space_if_not_bol()?; - self.print_expr(&expr)?; - self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()))?; + self.space_if_not_bol(); + self.print_expr(&expr); + self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi())); } - self.bclose_maybe_open(blk.span, indented, close_box)?; + self.bclose_maybe_open(blk.span, indented, close_box); self.ann.post(self, AnnNode::Block(blk)) } - pub fn print_anon_const(&mut self, constant: &hir::AnonConst) -> io::Result<()> { + pub fn print_anon_const(&mut self, constant: &hir::AnonConst) { self.ann.nested(self, Nested::Body(constant.body)) } - fn print_call_post(&mut self, args: &[hir::Expr]) -> io::Result<()> { - self.popen()?; - self.commasep_exprs(Inconsistent, args)?; + fn print_call_post(&mut self, args: &[hir::Expr]) { + self.popen(); + self.commasep_exprs(Inconsistent, args); self.pclose() } - pub fn print_expr_maybe_paren(&mut self, expr: &hir::Expr, prec: i8) -> io::Result<()> { + pub fn print_expr_maybe_paren(&mut self, expr: &hir::Expr, prec: i8) { let needs_par = expr.precedence().order() < prec; if needs_par { - self.popen()?; + self.popen(); } - self.print_expr(expr)?; + self.print_expr(expr); if needs_par { - self.pclose()?; + self.pclose(); } - Ok(()) } /// 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: &hir::Expr) -> io::Result<()> { + pub fn print_expr_as_cond(&mut self, expr: &hir::Expr) { let needs_par = 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) {}`. @@ -1100,30 +1079,29 @@ impl<'a> State<'a> { }; if needs_par { - self.popen()?; + self.popen(); } - self.print_expr(expr)?; + self.print_expr(expr); if needs_par { - self.pclose()?; + self.pclose(); } - Ok(()) } - fn print_expr_vec(&mut self, exprs: &[hir::Expr]) -> io::Result<()> { - self.ibox(indent_unit)?; - self.s.word("[")?; - self.commasep_exprs(Inconsistent, exprs)?; - self.s.word("]")?; + fn print_expr_vec(&mut self, exprs: &[hir::Expr]) { + self.ibox(indent_unit); + self.s.word("["); + self.commasep_exprs(Inconsistent, exprs); + self.s.word("]"); self.end() } - fn print_expr_repeat(&mut self, element: &hir::Expr, count: &hir::AnonConst) -> io::Result<()> { - self.ibox(indent_unit)?; - self.s.word("[")?; - self.print_expr(element)?; - self.word_space(";")?; - self.print_anon_const(count)?; - self.s.word("]")?; + fn print_expr_repeat(&mut self, element: &hir::Expr, count: &hir::AnonConst) { + self.ibox(indent_unit); + self.s.word("["); + self.print_expr(element); + self.word_space(";"); + self.print_anon_const(count); + self.s.word("]"); self.end() } @@ -1131,72 +1109,71 @@ impl<'a> State<'a> { qpath: &hir::QPath, fields: &[hir::Field], wth: &Option>) - -> io::Result<()> { - self.print_qpath(qpath, true)?; - self.s.word("{")?; + { + self.print_qpath(qpath, true); + self.s.word("{"); self.commasep_cmnt(Consistent, &fields[..], |s, field| { - s.ibox(indent_unit)?; + s.ibox(indent_unit); if !field.is_shorthand { - s.print_ident(field.ident)?; - s.word_space(":")?; + s.print_ident(field.ident); + s.word_space(":"); } - s.print_expr(&field.expr)?; + s.print_expr(&field.expr); s.end() }, - |f| f.span)?; + |f| f.span); match *wth { Some(ref expr) => { - self.ibox(indent_unit)?; + self.ibox(indent_unit); if !fields.is_empty() { - self.s.word(",")?; - self.s.space()?; + self.s.word(","); + self.s.space(); } - self.s.word("..")?; - self.print_expr(&expr)?; - self.end()?; + self.s.word(".."); + self.print_expr(&expr); + self.end(); } _ => if !fields.is_empty() { - self.s.word(",")? + self.s.word(",") }, } - self.s.word("}")?; - Ok(()) + self.s.word("}"); } - fn print_expr_tup(&mut self, exprs: &[hir::Expr]) -> io::Result<()> { - self.popen()?; - self.commasep_exprs(Inconsistent, exprs)?; + fn print_expr_tup(&mut self, exprs: &[hir::Expr]) { + self.popen(); + self.commasep_exprs(Inconsistent, exprs); if exprs.len() == 1 { - self.s.word(",")?; + self.s.word(","); } self.pclose() } - fn print_expr_call(&mut self, func: &hir::Expr, args: &[hir::Expr]) -> io::Result<()> { + fn print_expr_call(&mut self, func: &hir::Expr, args: &[hir::Expr]) { let prec = match func.node { hir::ExprKind::Field(..) => parser::PREC_FORCE_PAREN, _ => parser::PREC_POSTFIX, }; - self.print_expr_maybe_paren(func, prec)?; + self.print_expr_maybe_paren(func, prec); self.print_call_post(args) } fn print_expr_method_call(&mut self, segment: &hir::PathSegment, args: &[hir::Expr]) - -> io::Result<()> { + { let base_args = &args[1..]; - self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX)?; - self.s.word(".")?; - self.print_ident(segment.ident)?; + self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX); + self.s.word("."); + self.print_ident(segment.ident); let generic_args = segment.generic_args(); if !generic_args.args.is_empty() || !generic_args.bindings.is_empty() { - self.print_generic_args(generic_args, segment.infer_args, true)?; + self.print_generic_args(generic_args, segment.infer_args, true); } self.print_call_post(base_args) @@ -1206,7 +1183,7 @@ impl<'a> State<'a> { op: hir::BinOp, lhs: &hir::Expr, rhs: &hir::Expr) - -> io::Result<()> { + { let assoc_op = bin_op_to_assoc_op(op.node); let prec = assoc_op.precedence() as i8; let fixity = assoc_op.fixity(); @@ -1226,220 +1203,220 @@ impl<'a> State<'a> { _ => left_prec, }; - self.print_expr_maybe_paren(lhs, left_prec)?; - self.s.space()?; - self.word_space(op.node.as_str())?; + self.print_expr_maybe_paren(lhs, left_prec); + self.s.space(); + self.word_space(op.node.as_str()); self.print_expr_maybe_paren(rhs, right_prec) } - fn print_expr_unary(&mut self, op: hir::UnOp, expr: &hir::Expr) -> io::Result<()> { - self.s.word(op.as_str())?; + fn print_expr_unary(&mut self, op: hir::UnOp, expr: &hir::Expr) { + self.s.word(op.as_str()); self.print_expr_maybe_paren(expr, parser::PREC_PREFIX) } fn print_expr_addr_of(&mut self, mutability: hir::Mutability, expr: &hir::Expr) - -> io::Result<()> { - self.s.word("&")?; - self.print_mutability(mutability)?; + { + self.s.word("&"); + self.print_mutability(mutability); self.print_expr_maybe_paren(expr, parser::PREC_PREFIX) } - fn print_literal(&mut self, lit: &hir::Lit) -> io::Result<()> { - self.maybe_print_comment(lit.span.lo())?; + fn print_literal(&mut self, lit: &hir::Lit) { + self.maybe_print_comment(lit.span.lo()); self.writer().word(pprust::literal_to_string(lit.node.to_lit_token())) } - pub fn print_expr(&mut self, expr: &hir::Expr) -> io::Result<()> { - self.maybe_print_comment(expr.span.lo())?; - self.print_outer_attributes(&expr.attrs)?; - self.ibox(indent_unit)?; - self.ann.pre(self, AnnNode::Expr(expr))?; + pub fn print_expr(&mut self, expr: &hir::Expr) { + self.maybe_print_comment(expr.span.lo()); + self.print_outer_attributes(&expr.attrs); + self.ibox(indent_unit); + self.ann.pre(self, AnnNode::Expr(expr)); match expr.node { hir::ExprKind::Box(ref expr) => { - self.word_space("box")?; - self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)?; + self.word_space("box"); + self.print_expr_maybe_paren(expr, parser::PREC_PREFIX); } hir::ExprKind::Array(ref exprs) => { - self.print_expr_vec(exprs)?; + self.print_expr_vec(exprs); } hir::ExprKind::Repeat(ref element, ref count) => { - self.print_expr_repeat(&element, count)?; + self.print_expr_repeat(&element, count); } hir::ExprKind::Struct(ref qpath, ref fields, ref wth) => { - self.print_expr_struct(qpath, &fields[..], wth)?; + self.print_expr_struct(qpath, &fields[..], wth); } hir::ExprKind::Tup(ref exprs) => { - self.print_expr_tup(exprs)?; + self.print_expr_tup(exprs); } hir::ExprKind::Call(ref func, ref args) => { - self.print_expr_call(&func, args)?; + self.print_expr_call(&func, args); } hir::ExprKind::MethodCall(ref segment, _, ref args) => { - self.print_expr_method_call(segment, args)?; + self.print_expr_method_call(segment, args); } hir::ExprKind::Binary(op, ref lhs, ref rhs) => { - self.print_expr_binary(op, &lhs, &rhs)?; + self.print_expr_binary(op, &lhs, &rhs); } hir::ExprKind::Unary(op, ref expr) => { - self.print_expr_unary(op, &expr)?; + self.print_expr_unary(op, &expr); } hir::ExprKind::AddrOf(m, ref expr) => { - self.print_expr_addr_of(m, &expr)?; + self.print_expr_addr_of(m, &expr); } hir::ExprKind::Lit(ref lit) => { - self.print_literal(&lit)?; + self.print_literal(&lit); } hir::ExprKind::Cast(ref expr, ref ty) => { let prec = AssocOp::As.precedence() as i8; - self.print_expr_maybe_paren(&expr, prec)?; - self.s.space()?; - self.word_space("as")?; - self.print_type(&ty)?; + self.print_expr_maybe_paren(&expr, prec); + self.s.space(); + self.word_space("as"); + self.print_type(&ty); } hir::ExprKind::Type(ref expr, ref ty) => { let prec = AssocOp::Colon.precedence() as i8; - self.print_expr_maybe_paren(&expr, prec)?; - self.word_space(":")?; - self.print_type(&ty)?; + self.print_expr_maybe_paren(&expr, prec); + self.word_space(":"); + self.print_type(&ty); } hir::ExprKind::DropTemps(ref init) => { // Print `{`: - self.cbox(indent_unit)?; - self.ibox(0)?; - self.bopen()?; + self.cbox(indent_unit); + self.ibox(0); + self.bopen(); // Print `let _t = $init;`: let temp = ast::Ident::from_str("_t"); - self.print_local(Some(init), |this| this.print_ident(temp))?; - self.s.word(";")?; + self.print_local(Some(init), |this| this.print_ident(temp)); + self.s.word(";"); // Print `_t`: - self.space_if_not_bol()?; - self.print_ident(temp)?; + self.space_if_not_bol(); + self.print_ident(temp); // Print `}`: - self.bclose_maybe_open(expr.span, indent_unit, true)?; + self.bclose_maybe_open(expr.span, indent_unit, true); } hir::ExprKind::While(ref test, ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } - self.head("while")?; - self.print_expr_as_cond(&test)?; - self.s.space()?; - self.print_block(&blk)?; + self.head("while"); + self.print_expr_as_cond(&test); + self.s.space(); + self.print_block(&blk); } hir::ExprKind::Loop(ref blk, opt_label, _) => { if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } - self.head("loop")?; - self.s.space()?; - self.print_block(&blk)?; + self.head("loop"); + self.s.space(); + self.print_block(&blk); } hir::ExprKind::Match(ref expr, ref arms, _) => { - self.cbox(indent_unit)?; - self.ibox(4)?; - self.word_nbsp("match")?; - self.print_expr_as_cond(&expr)?; - self.s.space()?; - self.bopen()?; + self.cbox(indent_unit); + self.ibox(4); + self.word_nbsp("match"); + self.print_expr_as_cond(&expr); + self.s.space(); + self.bopen(); for arm in arms { - self.print_arm(arm)?; + self.print_arm(arm); } - self.bclose_(expr.span, indent_unit)?; + self.bclose_(expr.span, indent_unit); } hir::ExprKind::Closure(capture_clause, ref decl, body, _fn_decl_span, _gen) => { - self.print_capture_clause(capture_clause)?; + self.print_capture_clause(capture_clause); - self.print_closure_args(&decl, body)?; - self.s.space()?; + self.print_closure_args(&decl, body); + self.s.space(); // this is a bare expression - self.ann.nested(self, Nested::Body(body))?; - self.end()?; // need to close a box + self.ann.nested(self, Nested::Body(body)); + self.end(); // need to close a box // a box will be closed by print_expr, but we didn't want an overall // wrapper so we closed the corresponding opening. so create an // empty box to satisfy the close. - self.ibox(0)?; + self.ibox(0); } hir::ExprKind::Block(ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } // containing cbox, will be closed by print-block at } - self.cbox(indent_unit)?; + self.cbox(indent_unit); // head-box, will be closed by print-block after { - self.ibox(0)?; - self.print_block(&blk)?; + self.ibox(0); + self.print_block(&blk); } hir::ExprKind::Assign(ref lhs, ref rhs) => { let prec = AssocOp::Assign.precedence() as i8; - self.print_expr_maybe_paren(&lhs, prec + 1)?; - self.s.space()?; - self.word_space("=")?; - self.print_expr_maybe_paren(&rhs, prec)?; + self.print_expr_maybe_paren(&lhs, prec + 1); + self.s.space(); + self.word_space("="); + self.print_expr_maybe_paren(&rhs, prec); } hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => { let prec = AssocOp::Assign.precedence() as i8; - self.print_expr_maybe_paren(&lhs, prec + 1)?; - self.s.space()?; - self.s.word(op.node.as_str())?; - self.word_space("=")?; - self.print_expr_maybe_paren(&rhs, prec)?; + self.print_expr_maybe_paren(&lhs, prec + 1); + self.s.space(); + self.s.word(op.node.as_str()); + self.word_space("="); + self.print_expr_maybe_paren(&rhs, prec); } hir::ExprKind::Field(ref expr, ident) => { - self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?; - self.s.word(".")?; - self.print_ident(ident)?; + self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); + self.s.word("."); + self.print_ident(ident); } hir::ExprKind::Index(ref expr, ref index) => { - self.print_expr_maybe_paren(&expr, parser::PREC_POSTFIX)?; - self.s.word("[")?; - self.print_expr(&index)?; - self.s.word("]")?; + self.print_expr_maybe_paren(&expr, parser::PREC_POSTFIX); + self.s.word("["); + self.print_expr(&index); + self.s.word("]"); } hir::ExprKind::Path(ref qpath) => { - self.print_qpath(qpath, true)? + self.print_qpath(qpath, true) } hir::ExprKind::Break(destination, ref opt_expr) => { - self.s.word("break")?; - self.s.space()?; + self.s.word("break"); + self.s.space(); if let Some(label) = destination.label { - self.print_ident(label.ident)?; - self.s.space()?; + self.print_ident(label.ident); + self.s.space(); } if let Some(ref expr) = *opt_expr { - self.print_expr_maybe_paren(expr, parser::PREC_JUMP)?; - self.s.space()?; + self.print_expr_maybe_paren(expr, parser::PREC_JUMP); + self.s.space(); } } hir::ExprKind::Continue(destination) => { - self.s.word("continue")?; - self.s.space()?; + self.s.word("continue"); + self.s.space(); if let Some(label) = destination.label { - self.print_ident(label.ident)?; - self.s.space()? + self.print_ident(label.ident); + self.s.space() } } hir::ExprKind::Ret(ref result) => { - self.s.word("return")?; + self.s.word("return"); if let Some(ref expr) = *result { - self.s.word(" ")?; - self.print_expr_maybe_paren(&expr, parser::PREC_JUMP)?; + self.s.word(" "); + self.print_expr_maybe_paren(&expr, parser::PREC_JUMP); } } hir::ExprKind::InlineAsm(ref a, ref outputs, ref inputs) => { - self.s.word("asm!")?; - self.popen()?; - self.print_string(&a.asm.as_str(), a.asm_str_style)?; - self.word_space(":")?; + self.s.word("asm!"); + self.popen(); + self.print_string(&a.asm.as_str(), a.asm_str_style); + self.word_space(":"); let mut out_idx = 0; self.commasep(Inconsistent, &a.outputs, |s, out| { @@ -1448,35 +1425,32 @@ impl<'a> State<'a> { match ch.next() { Some('=') if out.is_rw => { s.print_string(&format!("+{}", ch.as_str()), - ast::StrStyle::Cooked)? + ast::StrStyle::Cooked) } - _ => s.print_string(&constraint, ast::StrStyle::Cooked)?, + _ => s.print_string(&constraint, ast::StrStyle::Cooked), } - s.popen()?; - s.print_expr(&outputs[out_idx])?; - s.pclose()?; + s.popen(); + s.print_expr(&outputs[out_idx]); + s.pclose(); out_idx += 1; - Ok(()) - })?; - self.s.space()?; - self.word_space(":")?; + }); + self.s.space(); + self.word_space(":"); let mut in_idx = 0; self.commasep(Inconsistent, &a.inputs, |s, co| { - s.print_string(&co.as_str(), ast::StrStyle::Cooked)?; - s.popen()?; - s.print_expr(&inputs[in_idx])?; - s.pclose()?; + s.print_string(&co.as_str(), ast::StrStyle::Cooked); + s.popen(); + s.print_expr(&inputs[in_idx]); + s.pclose(); in_idx += 1; - Ok(()) - })?; - self.s.space()?; - self.word_space(":")?; + }); + self.s.space(); + self.word_space(":"); self.commasep(Inconsistent, &a.clobbers, |s, co| { - s.print_string(&co.as_str(), ast::StrStyle::Cooked)?; - Ok(()) - })?; + s.print_string(&co.as_str(), ast::StrStyle::Cooked); + }); let mut options = vec![]; if a.volatile { @@ -1490,131 +1464,126 @@ impl<'a> State<'a> { } if !options.is_empty() { - self.s.space()?; - self.word_space(":")?; + self.s.space(); + self.word_space(":"); self.commasep(Inconsistent, &options, |s, &co| { - s.print_string(co, ast::StrStyle::Cooked)?; - Ok(()) - })?; + s.print_string(co, ast::StrStyle::Cooked); + }); } - self.pclose()?; + self.pclose(); } hir::ExprKind::Yield(ref expr, _) => { - self.word_space("yield")?; - self.print_expr_maybe_paren(&expr, parser::PREC_JUMP)?; + self.word_space("yield"); + self.print_expr_maybe_paren(&expr, parser::PREC_JUMP); } hir::ExprKind::Err => { - self.popen()?; - self.s.word("/*ERROR*/")?; - self.pclose()?; + self.popen(); + self.s.word("/*ERROR*/"); + self.pclose(); } } - self.ann.post(self, AnnNode::Expr(expr))?; + self.ann.post(self, AnnNode::Expr(expr)); self.end() } - pub fn print_local_decl(&mut self, loc: &hir::Local) -> io::Result<()> { - self.print_pat(&loc.pat)?; + pub fn print_local_decl(&mut self, loc: &hir::Local) { + self.print_pat(&loc.pat); if let Some(ref ty) = loc.ty { - self.word_space(":")?; - self.print_type(&ty)?; + self.word_space(":"); + self.print_type(&ty); } - Ok(()) } - pub fn print_usize(&mut self, i: usize) -> io::Result<()> { + pub fn print_usize(&mut self, i: usize) { self.s.word(i.to_string()) } - pub fn print_ident(&mut self, ident: ast::Ident) -> io::Result<()> { + pub fn print_ident(&mut self, ident: ast::Ident) { if ident.is_raw_guess() { - self.s.word(format!("r#{}", ident.name))?; + self.s.word(format!("r#{}", ident.name)); } else { - self.s.word(ident.as_str().to_string())?; + self.s.word(ident.as_str().to_string()); } self.ann.post(self, AnnNode::Name(&ident.name)) } - pub fn print_name(&mut self, name: ast::Name) -> io::Result<()> { + pub fn print_name(&mut self, name: ast::Name) { self.print_ident(ast::Ident::with_empty_ctxt(name)) } - pub fn print_for_decl(&mut self, loc: &hir::Local, coll: &hir::Expr) -> io::Result<()> { - self.print_local_decl(loc)?; - self.s.space()?; - self.word_space("in")?; + pub fn print_for_decl(&mut self, loc: &hir::Local, coll: &hir::Expr) { + self.print_local_decl(loc); + self.s.space(); + self.word_space("in"); self.print_expr(coll) } pub fn print_path(&mut self, path: &hir::Path, colons_before_params: bool) - -> io::Result<()> { - self.maybe_print_comment(path.span.lo())?; + { + self.maybe_print_comment(path.span.lo()); for (i, segment) in path.segments.iter().enumerate() { if i > 0 { - self.s.word("::")? + self.s.word("::") } if segment.ident.name != kw::PathRoot { - self.print_ident(segment.ident)?; + self.print_ident(segment.ident); self.print_generic_args(segment.generic_args(), segment.infer_args, - colons_before_params)?; + colons_before_params); } } - - Ok(()) } - pub fn print_path_segment(&mut self, segment: &hir::PathSegment) -> io::Result<()> { + pub fn print_path_segment(&mut self, segment: &hir::PathSegment) { if segment.ident.name != kw::PathRoot { - self.print_ident(segment.ident)?; - self.print_generic_args(segment.generic_args(), segment.infer_args, false)?; + self.print_ident(segment.ident); + self.print_generic_args(segment.generic_args(), segment.infer_args, false); } - Ok(()) } pub fn print_qpath(&mut self, qpath: &hir::QPath, colons_before_params: bool) - -> io::Result<()> { + { match *qpath { hir::QPath::Resolved(None, ref path) => { self.print_path(path, colons_before_params) } hir::QPath::Resolved(Some(ref qself), ref path) => { - self.s.word("<")?; - self.print_type(qself)?; - self.s.space()?; - self.word_space("as")?; + self.s.word("<"); + self.print_type(qself); + self.s.space(); + self.word_space("as"); for (i, segment) in path.segments[..path.segments.len() - 1].iter().enumerate() { if i > 0 { - self.s.word("::")? + self.s.word("::") } if segment.ident.name != kw::PathRoot { - self.print_ident(segment.ident)?; + self.print_ident(segment.ident); self.print_generic_args(segment.generic_args(), segment.infer_args, - colons_before_params)?; + colons_before_params); } } - self.s.word(">")?; - self.s.word("::")?; + self.s.word(">"); + self.s.word("::"); let item_segment = path.segments.last().unwrap(); - self.print_ident(item_segment.ident)?; + self.print_ident(item_segment.ident); self.print_generic_args(item_segment.generic_args(), item_segment.infer_args, colons_before_params) } hir::QPath::TypeRelative(ref qself, ref item_segment) => { - self.s.word("<")?; - self.print_type(qself)?; - self.s.word(">")?; - self.s.word("::")?; - self.print_ident(item_segment.ident)?; + self.s.word("<"); + self.print_type(qself); + self.s.word(">"); + self.s.word("::"); + self.print_ident(item_segment.ident); self.print_generic_args(item_segment.generic_args(), item_segment.infer_args, colons_before_params) @@ -1626,15 +1595,15 @@ impl<'a> State<'a> { generic_args: &hir::GenericArgs, infer_args: bool, colons_before_params: bool) - -> io::Result<()> { + { if generic_args.parenthesized { - self.s.word("(")?; - self.commasep(Inconsistent, generic_args.inputs(), |s, ty| s.print_type(&ty))?; - self.s.word(")")?; + self.s.word("("); + self.commasep(Inconsistent, generic_args.inputs(), |s, ty| s.print_type(&ty)); + self.s.word(")"); - self.space_if_not_bol()?; - self.word_space("->")?; - self.print_type(generic_args.bindings[0].ty())?; + self.space_if_not_bol(); + self.word_space("->"); + self.print_type(generic_args.bindings[0].ty()); } else { let start = if colons_before_params { "::<" } else { "<" }; let empty = Cell::new(true); @@ -1657,153 +1626,151 @@ impl<'a> State<'a> { }); if nonelided_generic_args { - start_or_comma(self)?; + start_or_comma(self); self.commasep(Inconsistent, &generic_args.args, |s, generic_arg| { match generic_arg { GenericArg::Lifetime(lt) if !elide_lifetimes => s.print_lifetime(lt), - GenericArg::Lifetime(_) => Ok(()), + GenericArg::Lifetime(_) => {}, GenericArg::Type(ty) => s.print_type(ty), GenericArg::Const(ct) => s.print_anon_const(&ct.value), } - })?; + }); } // FIXME(eddyb): this would leak into error messages (e.g., // "non-exhaustive patterns: `Some::<..>(_)` not covered"). if infer_args && false { - start_or_comma(self)?; - self.s.word("..")?; + start_or_comma(self); + self.s.word(".."); } for binding in generic_args.bindings.iter() { - start_or_comma(self)?; - self.print_ident(binding.ident)?; - self.s.space()?; + start_or_comma(self); + self.print_ident(binding.ident); + self.s.space(); match generic_args.bindings[0].kind { hir::TypeBindingKind::Equality { ref ty } => { - self.word_space("=")?; - self.print_type(ty)?; + self.word_space("="); + self.print_type(ty); } hir::TypeBindingKind::Constraint { ref bounds } => { - self.print_bounds(":", bounds)?; + self.print_bounds(":", bounds); } } } if !empty.get() { - self.s.word(">")? + self.s.word(">") } } - - Ok(()) } - pub fn print_pat(&mut self, pat: &hir::Pat) -> io::Result<()> { - self.maybe_print_comment(pat.span.lo())?; - self.ann.pre(self, AnnNode::Pat(pat))?; + pub fn print_pat(&mut self, pat: &hir::Pat) { + self.maybe_print_comment(pat.span.lo()); + self.ann.pre(self, AnnNode::Pat(pat)); // Pat isn't normalized, but the beauty of it // is that it doesn't matter match pat.node { - PatKind::Wild => self.s.word("_")?, + PatKind::Wild => self.s.word("_"), PatKind::Binding(binding_mode, _, ident, ref sub) => { match binding_mode { hir::BindingAnnotation::Ref => { - self.word_nbsp("ref")?; - self.print_mutability(hir::MutImmutable)?; + self.word_nbsp("ref"); + self.print_mutability(hir::MutImmutable); } hir::BindingAnnotation::RefMut => { - self.word_nbsp("ref")?; - self.print_mutability(hir::MutMutable)?; + self.word_nbsp("ref"); + self.print_mutability(hir::MutMutable); } hir::BindingAnnotation::Unannotated => {} hir::BindingAnnotation::Mutable => { - self.word_nbsp("mut")?; + self.word_nbsp("mut"); } } - self.print_ident(ident)?; + self.print_ident(ident); if let Some(ref p) = *sub { - self.s.word("@")?; - self.print_pat(&p)?; + self.s.word("@"); + self.print_pat(&p); } } PatKind::TupleStruct(ref qpath, ref elts, ddpos) => { - self.print_qpath(qpath, true)?; - self.popen()?; + self.print_qpath(qpath, true); + self.popen(); if let Some(ddpos) = ddpos { - self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(&p))?; + self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(&p)); if ddpos != 0 { - self.word_space(",")?; + self.word_space(","); } - self.s.word("..")?; + self.s.word(".."); if ddpos != elts.len() { - self.s.word(",")?; - self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(&p))?; + self.s.word(","); + self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(&p)); } } else { - self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(&p))?; + self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(&p)); } - self.pclose()?; + self.pclose(); } PatKind::Path(ref qpath) => { - self.print_qpath(qpath, true)?; + self.print_qpath(qpath, true); } PatKind::Struct(ref qpath, ref fields, etc) => { - self.print_qpath(qpath, true)?; - self.nbsp()?; - self.word_space("{")?; + self.print_qpath(qpath, true); + self.nbsp(); + self.word_space("{"); self.commasep_cmnt(Consistent, &fields[..], |s, f| { - s.cbox(indent_unit)?; + s.cbox(indent_unit); if !f.node.is_shorthand { - s.print_ident(f.node.ident)?; - s.word_nbsp(":")?; + s.print_ident(f.node.ident); + s.word_nbsp(":"); } - s.print_pat(&f.node.pat)?; + s.print_pat(&f.node.pat); s.end() }, - |f| f.node.pat.span)?; + |f| f.node.pat.span); if etc { if !fields.is_empty() { - self.word_space(",")?; + self.word_space(","); } - self.s.word("..")?; + self.s.word(".."); } - self.s.space()?; - self.s.word("}")?; + self.s.space(); + self.s.word("}"); } PatKind::Tuple(ref elts, ddpos) => { - self.popen()?; + self.popen(); if let Some(ddpos) = ddpos { - self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(&p))?; + self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(&p)); if ddpos != 0 { - self.word_space(",")?; + self.word_space(","); } - self.s.word("..")?; + self.s.word(".."); if ddpos != elts.len() { - self.s.word(",")?; - self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(&p))?; + self.s.word(","); + self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(&p)); } } else { - self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(&p))?; + self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(&p)); if elts.len() == 1 { - self.s.word(",")?; + self.s.word(","); } } - self.pclose()?; + self.pclose(); } PatKind::Box(ref inner) => { let is_range_inner = match inner.node { PatKind::Range(..) => true, _ => false, }; - self.s.word("box ")?; + self.s.word("box "); if is_range_inner { - self.popen()?; + self.popen(); } - self.print_pat(&inner)?; + self.print_pat(&inner); if is_range_inner { - self.pclose()?; + self.pclose(); } } PatKind::Ref(ref inner, mutbl) => { @@ -1811,101 +1778,101 @@ impl<'a> State<'a> { PatKind::Range(..) => true, _ => false, }; - self.s.word("&")?; + self.s.word("&"); if mutbl == hir::MutMutable { - self.s.word("mut ")?; + self.s.word("mut "); } if is_range_inner { - self.popen()?; + self.popen(); } - self.print_pat(&inner)?; + self.print_pat(&inner); if is_range_inner { - self.pclose()?; + self.pclose(); } } - PatKind::Lit(ref e) => self.print_expr(&e)?, + PatKind::Lit(ref e) => self.print_expr(&e), PatKind::Range(ref begin, ref end, ref end_kind) => { - self.print_expr(&begin)?; - self.s.space()?; + self.print_expr(&begin); + self.s.space(); match *end_kind { - RangeEnd::Included => self.s.word("...")?, - RangeEnd::Excluded => self.s.word("..")?, + RangeEnd::Included => self.s.word("..."), + RangeEnd::Excluded => self.s.word(".."), } - self.print_expr(&end)?; + self.print_expr(&end); } PatKind::Slice(ref before, ref slice, ref after) => { - self.s.word("[")?; - self.commasep(Inconsistent, &before[..], |s, p| s.print_pat(&p))?; + self.s.word("["); + self.commasep(Inconsistent, &before[..], |s, p| s.print_pat(&p)); if let Some(ref p) = *slice { if !before.is_empty() { - self.word_space(",")?; + self.word_space(","); } if let PatKind::Wild = p.node { // Print nothing } else { - self.print_pat(&p)?; + self.print_pat(&p); } - self.s.word("..")?; + self.s.word(".."); if !after.is_empty() { - self.word_space(",")?; + self.word_space(","); } } - self.commasep(Inconsistent, &after[..], |s, p| s.print_pat(&p))?; - self.s.word("]")?; + self.commasep(Inconsistent, &after[..], |s, p| s.print_pat(&p)); + self.s.word("]"); } } self.ann.post(self, AnnNode::Pat(pat)) } - pub fn print_arm(&mut self, arm: &hir::Arm) -> io::Result<()> { + pub fn print_arm(&mut self, arm: &hir::Arm) { // I have no idea why this check is necessary, but here it // is :( if arm.attrs.is_empty() { - self.s.space()?; + self.s.space(); } - self.cbox(indent_unit)?; - self.ibox(0)?; - self.print_outer_attributes(&arm.attrs)?; + self.cbox(indent_unit); + self.ibox(0); + self.print_outer_attributes(&arm.attrs); let mut first = true; for p in &arm.pats { if first { first = false; } else { - self.s.space()?; - self.word_space("|")?; + self.s.space(); + self.word_space("|"); } - self.print_pat(&p)?; + self.print_pat(&p); } - self.s.space()?; + self.s.space(); if let Some(ref g) = arm.guard { match g { hir::Guard::If(e) => { - self.word_space("if")?; - self.print_expr(&e)?; - self.s.space()?; + self.word_space("if"); + self.print_expr(&e); + self.s.space(); } } } - self.word_space("=>")?; + self.word_space("=>"); match arm.body.node { hir::ExprKind::Block(ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } // the block will close the pattern's ibox - self.print_block_unclosed_indent(&blk, indent_unit)?; + self.print_block_unclosed_indent(&blk, indent_unit); // If it is a user-provided unsafe block, print a comma after it if let hir::UnsafeBlock(hir::UserProvided) = blk.rules { - self.s.word(",")?; + self.s.word(","); } } _ => { - self.end()?; // close the ibox for the pattern - self.print_expr(&arm.body)?; - self.s.word(",")?; + self.end(); // close the ibox for the pattern + self.print_expr(&arm.body); + self.s.word(","); } } self.end() // close enclosing cbox @@ -1919,82 +1886,82 @@ impl<'a> State<'a> { vis: &hir::Visibility, arg_names: &[ast::Ident], body_id: Option) - -> io::Result<()> { - self.print_fn_header_info(header, vis)?; + { + self.print_fn_header_info(header, vis); if let Some(name) = name { - self.nbsp()?; - self.print_name(name)?; + self.nbsp(); + self.print_name(name); } - self.print_generic_params(&generics.params)?; + self.print_generic_params(&generics.params); - self.popen()?; + self.popen(); let mut i = 0; // Make sure we aren't supplied *both* `arg_names` and `body_id`. assert!(arg_names.is_empty() || body_id.is_none()); self.commasep(Inconsistent, &decl.inputs, |s, ty| { - s.ibox(indent_unit)?; + s.ibox(indent_unit); if let Some(arg_name) = arg_names.get(i) { - s.s.word(arg_name.as_str().to_string())?; - s.s.word(":")?; - s.s.space()?; + s.s.word(arg_name.as_str().to_string()); + s.s.word(":"); + s.s.space(); } else if let Some(body_id) = body_id { - s.ann.nested(s, Nested::BodyArgPat(body_id, i))?; - s.s.word(":")?; - s.s.space()?; + s.ann.nested(s, Nested::BodyArgPat(body_id, i)); + s.s.word(":"); + s.s.space(); } i += 1; - s.print_type(ty)?; + s.print_type(ty); s.end() - })?; + }); if decl.c_variadic { - self.s.word(", ...")?; + self.s.word(", ..."); } - self.pclose()?; + self.pclose(); - self.print_fn_output(decl)?; + self.print_fn_output(decl); self.print_where_clause(&generics.where_clause) } - fn print_closure_args(&mut self, decl: &hir::FnDecl, body_id: hir::BodyId) -> io::Result<()> { - self.s.word("|")?; + fn print_closure_args(&mut self, decl: &hir::FnDecl, body_id: hir::BodyId) { + self.s.word("|"); let mut i = 0; self.commasep(Inconsistent, &decl.inputs, |s, ty| { - s.ibox(indent_unit)?; + s.ibox(indent_unit); - s.ann.nested(s, Nested::BodyArgPat(body_id, i))?; + s.ann.nested(s, Nested::BodyArgPat(body_id, i)); i += 1; if let hir::TyKind::Infer = ty.node { // Print nothing } else { - s.s.word(":")?; - s.s.space()?; - s.print_type(ty)?; + s.s.word(":"); + s.s.space(); + s.print_type(ty); } - s.end() - })?; - self.s.word("|")?; + s.end(); + }); + self.s.word("|"); if let hir::DefaultReturn(..) = decl.output { - return Ok(()); + return; } - self.space_if_not_bol()?; - self.word_space("->")?; + self.space_if_not_bol(); + self.word_space("->"); match decl.output { hir::Return(ref ty) => { - self.print_type(&ty)?; + self.print_type(&ty); self.maybe_print_comment(ty.span.lo()) } hir::DefaultReturn(..) => unreachable!(), } } - pub fn print_capture_clause(&mut self, capture_clause: hir::CaptureClause) -> io::Result<()> { + pub fn print_capture_clause(&mut self, capture_clause: hir::CaptureClause) { match capture_clause { hir::CaptureByValue => self.word_space("move"), - hir::CaptureByRef => Ok(()), + hir::CaptureByRef => {}, } } @@ -2002,55 +1969,53 @@ impl<'a> State<'a> { &mut self, prefix: &'static str, bounds: impl IntoIterator, - ) -> io::Result<()> { + ) { let mut first = true; for bound in bounds { if first { - self.s.word(prefix)?; + self.s.word(prefix); } if !(first && prefix.is_empty()) { - self.nbsp()?; + self.nbsp(); } if first { first = false; } else { - self.word_space("+")?; + self.word_space("+"); } match bound { GenericBound::Trait(tref, modifier) => { if modifier == &TraitBoundModifier::Maybe { - self.s.word("?")?; + self.s.word("?"); } - self.print_poly_trait_ref(tref)?; + self.print_poly_trait_ref(tref); } GenericBound::Outlives(lt) => { - self.print_lifetime(lt)?; + self.print_lifetime(lt); } } } - Ok(()) } - pub fn print_generic_params(&mut self, generic_params: &[GenericParam]) -> io::Result<()> { + pub fn print_generic_params(&mut self, generic_params: &[GenericParam]) { if !generic_params.is_empty() { - self.s.word("<")?; + self.s.word("<"); self.commasep(Inconsistent, generic_params, |s, param| { s.print_generic_param(param) - })?; + }); - self.s.word(">")?; + self.s.word(">"); } - Ok(()) } - pub fn print_generic_param(&mut self, param: &GenericParam) -> io::Result<()> { + pub fn print_generic_param(&mut self, param: &GenericParam) { if let GenericParamKind::Const { .. } = param.kind { - self.word_space("const")?; + self.word_space("const"); } - self.print_ident(param.name.ident())?; + self.print_ident(param.name.ident()); match param.kind { GenericParamKind::Lifetime { .. } => { @@ -2058,48 +2023,47 @@ impl<'a> State<'a> { for bound in ¶m.bounds { match bound { GenericBound::Outlives(lt) => { - self.s.word(sep)?; - self.print_lifetime(lt)?; + self.s.word(sep); + self.print_lifetime(lt); sep = "+"; } _ => bug!(), } } - Ok(()) } GenericParamKind::Type { ref default, .. } => { - self.print_bounds(":", ¶m.bounds)?; + self.print_bounds(":", ¶m.bounds); match default { Some(default) => { - self.s.space()?; - self.word_space("=")?; + self.s.space(); + self.word_space("="); self.print_type(&default) } - _ => Ok(()), + _ => {} } } GenericParamKind::Const { ref ty } => { - self.word_space(":")?; + self.word_space(":"); self.print_type(ty) } } } - pub fn print_lifetime(&mut self, lifetime: &hir::Lifetime) -> io::Result<()> { + pub fn print_lifetime(&mut self, lifetime: &hir::Lifetime) { self.print_ident(lifetime.name.ident()) } - pub fn print_where_clause(&mut self, where_clause: &hir::WhereClause) -> io::Result<()> { + pub fn print_where_clause(&mut self, where_clause: &hir::WhereClause) { if where_clause.predicates.is_empty() { - return Ok(()); + return; } - self.s.space()?; - self.word_space("where")?; + self.s.space(); + self.word_space("where"); for (i, predicate) in where_clause.predicates.iter().enumerate() { if i != 0 { - self.word_space(",")?; + self.word_space(","); } match predicate { @@ -2109,72 +2073,70 @@ impl<'a> State<'a> { ref bounds, .. }) => { - self.print_formal_generic_params(bound_generic_params)?; - self.print_type(&bounded_ty)?; - self.print_bounds(":", bounds)?; + self.print_formal_generic_params(bound_generic_params); + self.print_type(&bounded_ty); + self.print_bounds(":", bounds); } &hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate{ref lifetime, ref bounds, ..}) => { - self.print_lifetime(lifetime)?; - self.s.word(":")?; + self.print_lifetime(lifetime); + self.s.word(":"); for (i, bound) in bounds.iter().enumerate() { match bound { GenericBound::Outlives(lt) => { - self.print_lifetime(lt)?; + self.print_lifetime(lt); } _ => bug!(), } if i != 0 { - self.s.word(":")?; + self.s.word(":"); } } } &hir::WherePredicate::EqPredicate(hir::WhereEqPredicate{ref lhs_ty, ref rhs_ty, ..}) => { - self.print_type(lhs_ty)?; - self.s.space()?; - self.word_space("=")?; - self.print_type(rhs_ty)?; + self.print_type(lhs_ty); + self.s.space(); + self.word_space("="); + self.print_type(rhs_ty); } } } - - Ok(()) } - pub fn print_mutability(&mut self, mutbl: hir::Mutability) -> io::Result<()> { + pub fn print_mutability(&mut self, mutbl: hir::Mutability) { match mutbl { hir::MutMutable => self.word_nbsp("mut"), - hir::MutImmutable => Ok(()), + hir::MutImmutable => {}, } } - pub fn print_mt(&mut self, mt: &hir::MutTy) -> io::Result<()> { - self.print_mutability(mt.mutbl)?; + pub fn print_mt(&mut self, mt: &hir::MutTy) { + self.print_mutability(mt.mutbl); self.print_type(&mt.ty) } - pub fn print_fn_output(&mut self, decl: &hir::FnDecl) -> io::Result<()> { + pub fn print_fn_output(&mut self, decl: &hir::FnDecl) { if let hir::DefaultReturn(..) = decl.output { - return Ok(()); + return; } - self.space_if_not_bol()?; - self.ibox(indent_unit)?; - self.word_space("->")?; + self.space_if_not_bol(); + self.ibox(indent_unit); + self.word_space("->"); match decl.output { hir::DefaultReturn(..) => unreachable!(), - hir::Return(ref ty) => self.print_type(&ty)?, + hir::Return(ref ty) => self.print_type(&ty), } - self.end()?; + self.end(); match decl.output { hir::Return(ref output) => self.maybe_print_comment(output.span.lo()), - _ => Ok(()), + _ => {}, } } @@ -2185,11 +2147,11 @@ impl<'a> State<'a> { name: Option, generic_params: &[hir::GenericParam], arg_names: &[ast::Ident]) - -> io::Result<()> { - self.ibox(indent_unit)?; + { + self.ibox(indent_unit); if !generic_params.is_empty() { - self.s.word("for")?; - self.print_generic_params(generic_params)?; + self.s.word("for"); + self.print_generic_params(generic_params); } let generics = hir::Generics { params: hir::HirVec::new(), @@ -2211,21 +2173,21 @@ impl<'a> State<'a> { &Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityKind::Inherited }, arg_names, - None)?; - self.end() + None); + self.end(); } pub fn maybe_print_trailing_comment(&mut self, span: syntax_pos::Span, next_pos: Option) - -> io::Result<()> { + { let cm = match self.cm { Some(cm) => cm, - _ => return Ok(()), + _ => return, }; if let Some(ref cmnt) = self.next_comment() { if (*cmnt).style != comments::Trailing { - return Ok(()); + return; } let span_line = cm.lookup_char_pos(span.hi()); let comment_line = cm.lookup_char_pos((*cmnt).pos); @@ -2235,84 +2197,82 @@ impl<'a> State<'a> { } if span.hi() < (*cmnt).pos && (*cmnt).pos < next && span_line.line == comment_line.line { - self.print_comment(cmnt)?; + self.print_comment(cmnt); } } - Ok(()) } - pub fn print_remaining_comments(&mut self) -> io::Result<()> { + pub fn print_remaining_comments(&mut self) { // If there aren't any remaining comments, then we need to manually // make sure there is a line break at the end. if self.next_comment().is_none() { - self.s.hardbreak()?; + self.s.hardbreak(); } while let Some(ref cmnt) = self.next_comment() { - self.print_comment(cmnt)? + self.print_comment(cmnt) } - Ok(()) } pub fn print_opt_abi_and_extern_if_nondefault(&mut self, opt_abi: Option) - -> io::Result<()> { + { match opt_abi { - Some(Abi::Rust) => Ok(()), + Some(Abi::Rust) => {}, Some(abi) => { - self.word_nbsp("extern")?; + self.word_nbsp("extern"); self.word_nbsp(abi.to_string()) } - None => Ok(()), + None => {}, } } - pub fn print_extern_opt_abi(&mut self, opt_abi: Option) -> io::Result<()> { + pub fn print_extern_opt_abi(&mut self, opt_abi: Option) { match opt_abi { Some(abi) => { - self.word_nbsp("extern")?; + self.word_nbsp("extern"); self.word_nbsp(abi.to_string()) } - None => Ok(()), + None => {}, } } pub fn print_fn_header_info(&mut self, header: hir::FnHeader, vis: &hir::Visibility) - -> io::Result<()> { - self.s.word(visibility_qualified(vis, ""))?; + { + self.s.word(visibility_qualified(vis, "")); match header.constness { hir::Constness::NotConst => {} - hir::Constness::Const => self.word_nbsp("const")?, + hir::Constness::Const => self.word_nbsp("const"), } match header.asyncness { hir::IsAsync::NotAsync => {} - hir::IsAsync::Async => self.word_nbsp("async")?, + hir::IsAsync::Async => self.word_nbsp("async"), } - self.print_unsafety(header.unsafety)?; + self.print_unsafety(header.unsafety); if header.abi != Abi::Rust { - self.word_nbsp("extern")?; - self.word_nbsp(header.abi.to_string())?; + self.word_nbsp("extern"); + self.word_nbsp(header.abi.to_string()); } self.s.word("fn") } - pub fn print_unsafety(&mut self, s: hir::Unsafety) -> io::Result<()> { + pub fn print_unsafety(&mut self, s: hir::Unsafety) { match s { - hir::Unsafety::Normal => Ok(()), + hir::Unsafety::Normal => {} hir::Unsafety::Unsafe => self.word_nbsp("unsafe"), } } - pub fn print_is_auto(&mut self, s: hir::IsAuto) -> io::Result<()> { + pub fn print_is_auto(&mut self, s: hir::IsAuto) { match s { hir::IsAuto::Yes => self.word_nbsp("auto"), - hir::IsAuto::No => Ok(()), + hir::IsAuto::No => {}, } } } diff --git a/src/librustc/hir/ptr.rs b/src/librustc/hir/ptr.rs new file mode 100644 index 0000000000000..3a87b36a1b434 --- /dev/null +++ b/src/librustc/hir/ptr.rs @@ -0,0 +1,141 @@ +// HACK(eddyb) this is a copy of `syntax::ptr`, minus the mutation (the HIR is +// frozen anyway). The only reason for doing this instead of replacing `P` +// with `Box` in HIR, is that `&Box<[T]>` doesn't implement `IntoIterator`. + +use std::fmt::{self, Display, Debug}; +use std::iter::FromIterator; +use std::ops::Deref; +use std::{slice, vec}; + +use serialize::{Encodable, Decodable, Encoder, Decoder}; + +use rustc_data_structures::stable_hasher::{StableHasher, StableHasherResult, + HashStable}; +/// An owned smart pointer. +#[derive(Hash, PartialEq, Eq)] +pub struct P { + ptr: Box +} + +/// Construct a `P` from a `T` value. +#[allow(non_snake_case)] +pub fn P(value: T) -> P { + P { + ptr: box value + } +} + +impl P { + // HACK(eddyb) used by HIR lowering in a few places still. + // NOTE: do not make this more public than `pub(super)`. + pub(super) fn into_inner(self) -> T { + *self.ptr + } +} + +impl Deref for P { + type Target = T; + + fn deref(&self) -> &T { + &self.ptr + } +} + +impl Debug for P { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + Debug::fmt(&self.ptr, f) + } +} + +impl Display for P { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + Display::fmt(&**self, f) + } +} + +impl Decodable for P { + fn decode(d: &mut D) -> Result, D::Error> { + Decodable::decode(d).map(P) + } +} + +impl Encodable for P { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + (**self).encode(s) + } +} + +impl P<[T]> { + pub const fn new() -> P<[T]> { + // HACK(eddyb) bypass the lack of a `const fn` to create an empty `Box<[T]>` + // (as trait methods, `default` in this case, can't be `const fn` yet). + P { + ptr: unsafe { + use std::ptr::NonNull; + std::mem::transmute(NonNull::<[T; 0]>::dangling() as NonNull<[T]>) + }, + } + } + + #[inline(never)] + pub fn from_vec(v: Vec) -> P<[T]> { + P { ptr: v.into_boxed_slice() } + } + + // HACK(eddyb) used by HIR lowering in a few places still. + // NOTE: do not make this more public than `pub(super)`, + // and do not make this into an `IntoIterator` impl. + pub(super) fn into_iter(self) -> vec::IntoIter { + self.ptr.into_vec().into_iter() + } +} + + +impl Default for P<[T]> { + /// Creates an empty `P<[T]>`. + fn default() -> P<[T]> { + P::new() + } +} + +impl From> for P<[T]> { + fn from(v: Vec) -> Self { + P::from_vec(v) + } +} + +impl FromIterator for P<[T]> { + fn from_iter>(iter: I) -> P<[T]> { + P::from_vec(iter.into_iter().collect()) + } +} + +impl<'a, T> IntoIterator for &'a P<[T]> { + type Item = &'a T; + type IntoIter = slice::Iter<'a, T>; + fn into_iter(self) -> Self::IntoIter { + self.ptr.into_iter() + } +} + +impl Encodable for P<[T]> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + Encodable::encode(&**self, s) + } +} + +impl Decodable for P<[T]> { + fn decode(d: &mut D) -> Result, D::Error> { + Ok(P::from_vec(Decodable::decode(d)?)) + } +} + +impl HashStable for P + where T: ?Sized + HashStable +{ + fn hash_stable(&self, + hcx: &mut CTX, + hasher: &mut StableHasher) { + (**self).hash_stable(hcx, hasher); + } +} diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index 9a5c726901fe8..eca1ada851814 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -1456,7 +1456,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { // Even if the type may have no inference variables, during // type-checking closure types are in local tables only. if !self.in_progress_tables.is_some() || !ty.has_closure_types() { - if let Some((param_env, ty)) = self.tcx.lift_to_global(&(param_env, ty)) { + if !(param_env, ty).has_local_value() { return ty.is_copy_modulo_regions(self.tcx.global_tcx(), param_env, span); } } diff --git a/src/librustc/infer/outlives/free_region_map.rs b/src/librustc/infer/outlives/free_region_map.rs index 1250995a59c10..c085df6a6e7ab 100644 --- a/src/librustc/infer/outlives/free_region_map.rs +++ b/src/librustc/infer/outlives/free_region_map.rs @@ -11,6 +11,10 @@ pub struct FreeRegionMap<'tcx> { } impl<'tcx> FreeRegionMap<'tcx> { + pub fn elements(&self) -> impl Iterator> { + self.relation.elements() + } + pub fn is_empty(&self) -> bool { self.relation.is_empty() } diff --git a/src/librustc/infer/type_variable.rs b/src/librustc/infer/type_variable.rs index dcafb0f3976ff..e30e86998a8c6 100644 --- a/src/librustc/infer/type_variable.rs +++ b/src/librustc/infer/type_variable.rs @@ -115,7 +115,7 @@ impl<'tcx> TypeVariableTable<'tcx> { /// /// Note that this function does not return care whether /// `vid` has been unified with something else or not. - pub fn var_diverges<'a>(&'a self, vid: ty::TyVid) -> bool { + pub fn var_diverges(&self, vid: ty::TyVid) -> bool { self.values.get(vid.index as usize).diverging } diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 257d5159f1131..21c1a8d28d4c5 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -35,6 +35,8 @@ #![feature(arbitrary_self_types)] #![feature(box_patterns)] #![feature(box_syntax)] +#![feature(const_fn)] +#![feature(const_transmute)] #![feature(core_intrinsics)] #![feature(drain_filter)] #![feature(inner_deref)] diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 309af4b72c127..59b08b832d272 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -765,7 +765,7 @@ pub fn maybe_lint_level_root(tcx: TyCtxt<'_>, id: hir::HirId) -> bool { attrs.iter().any(|attr| Level::from_symbol(attr.name_or_empty()).is_some()) } -fn lint_levels<'tcx>(tcx: TyCtxt<'tcx>, cnum: CrateNum) -> &'tcx LintLevelMap { +fn lint_levels(tcx: TyCtxt<'_>, cnum: CrateNum) -> &LintLevelMap { assert_eq!(cnum, LOCAL_CRATE); let mut builder = LintLevelMapBuilder { levels: LintLevelSets::builder(tcx.sess), diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs index 2e9e1ac582f81..5a580dfa420b3 100644 --- a/src/librustc/middle/cstore.rs +++ b/src/librustc/middle/cstore.rs @@ -211,7 +211,7 @@ pub trait CrateStore { fn crates_untracked(&self) -> Vec; // utility functions - fn encode_metadata<'tcx>(&self, tcx: TyCtxt<'tcx>) -> EncodedMetadata; + fn encode_metadata(&self, tcx: TyCtxt<'_>) -> EncodedMetadata; fn metadata_encoding_version(&self) -> &[u8]; } diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index e02ee8943603a..e1889aa555f86 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -26,7 +26,7 @@ use syntax_pos; // explored. For example, if it's a live Node::Item that is a // 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 { +fn should_explore(tcx: TyCtxt<'_>, hir_id: hir::HirId) -> bool { match tcx.hir().find(hir_id) { Some(Node::Item(..)) | Some(Node::ImplItem(..)) | @@ -662,7 +662,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { } } -pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check_crate(tcx: TyCtxt<'_>) { let access_levels = &tcx.privacy_access_levels(LOCAL_CRATE); let krate = tcx.hir().krate(); let live_symbols = find_live(tcx, access_levels, krate); diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 879da6413e28a..96b99fe4cdce2 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -81,7 +81,7 @@ pub enum Linkage { Dynamic, } -pub fn calculate<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn calculate(tcx: TyCtxt<'_>) { let sess = &tcx.sess; let fmts = sess.crate_types.borrow().iter().map(|&ty| { let linkage = calculate_type(tcx, ty); @@ -92,7 +92,7 @@ pub fn calculate<'tcx>(tcx: TyCtxt<'tcx>) { sess.dependency_formats.set(fmts); } -fn calculate_type<'tcx>(tcx: TyCtxt<'tcx>, ty: config::CrateType) -> DependencyList { +fn calculate_type(tcx: TyCtxt<'_>, ty: config::CrateType) -> DependencyList { let sess = &tcx.sess; if !sess.opts.output_types.should_codegen() { @@ -267,7 +267,7 @@ fn add_library( } } -fn attempt_static<'tcx>(tcx: TyCtxt<'tcx>) -> Option { +fn attempt_static(tcx: TyCtxt<'_>) -> Option { let sess = &tcx.sess; let crates = cstore::used_crates(tcx, RequireStatic); if !crates.iter().by_ref().all(|&(_, ref p)| p.is_some()) { @@ -324,7 +324,7 @@ fn activate_injected_dep(injected: Option, // After the linkage for a crate has been determined we need to verify that // there's only going to be one allocator in the output. -fn verify_ok<'tcx>(tcx: TyCtxt<'tcx>, list: &[Linkage]) { +fn verify_ok(tcx: TyCtxt<'_>, list: &[Linkage]) { let sess = &tcx.sess; if list.len() == 0 { return diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 086ddfd7e33bf..c93cc847adff2 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -11,6 +11,7 @@ use self::OverloadedCallType::*; use crate::hir::def::{CtorOf, Res, DefKind}; use crate::hir::def_id::DefId; +use crate::hir::ptr::P; use crate::infer::InferCtxt; use crate::middle::mem_categorization as mc; use crate::middle::region; @@ -18,7 +19,6 @@ use crate::ty::{self, DefIdTree, TyCtxt, adjustment}; use crate::hir::{self, PatKind}; use std::rc::Rc; -use syntax::ptr::P; use syntax_pos::Span; use crate::util::nodemap::ItemLocalSet; diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index e8d68e0b7a7aa..1cc96c549e724 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -10,7 +10,7 @@ use syntax_pos::{Span, sym}; use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; use crate::hir; -fn check_mod_intrinsics<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn check_mod_intrinsics(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module( module_def_id, &mut ItemVisitor { tcx }.as_deep_visitor() diff --git a/src/librustc/middle/lib_features.rs b/src/librustc/middle/lib_features.rs index 9c131ce63428b..694b0a9862960 100644 --- a/src/librustc/middle/lib_features.rs +++ b/src/librustc/middle/lib_features.rs @@ -142,7 +142,7 @@ impl Visitor<'tcx> for LibFeatureCollector<'tcx> { } } -pub fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> LibFeatures { +pub fn collect(tcx: TyCtxt<'_>) -> LibFeatures { let mut collector = LibFeatureCollector::new(tcx); intravisit::walk_crate(&mut collector, tcx.hir().krate()); collector.lib_features diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 7b69fe394fb2c..30ff835bdcc43 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -99,6 +99,7 @@ use self::VarKind::*; use crate::hir::def::*; use crate::hir::Node; +use crate::hir::ptr::P; use crate::ty::{self, TyCtxt}; use crate::ty::query::Providers; use crate::lint; @@ -111,7 +112,6 @@ use std::io::prelude::*; use std::io; use std::rc::Rc; use syntax::ast; -use syntax::ptr::P; use syntax::symbol::{kw, sym}; use syntax_pos::Span; @@ -181,7 +181,7 @@ impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> { fn visit_arm(&mut self, a: &'tcx hir::Arm) { visit_arm(self, a); } } -fn check_mod_liveness<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn check_mod_liveness(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module( module_def_id, &mut IrMaps::new(tcx, module_def_id).as_deep_visitor(), diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index e7253a73bd418..088c862dcb879 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -465,9 +465,11 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> { ) -> bool { self.infcx.map(|infcx| infcx.type_is_copy_modulo_regions(param_env, ty, span)) .or_else(|| { - self.tcx.lift_to_global(&(param_env, ty)).map(|(param_env, ty)| { - ty.is_copy_modulo_regions(self.tcx.global_tcx(), param_env, span) - }) + if (param_env, ty).has_local_value() { + None + } else { + Some(ty.is_copy_modulo_regions(self.tcx, param_env, span)) + } }) .unwrap_or(true) } diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index d607c35f8762b..6b26be34d7520 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -42,8 +42,8 @@ fn item_might_be_inlined(tcx: TyCtxt<'tcx>, item: &hir::Item, attrs: CodegenFnAt } } -fn method_might_be_inlined<'tcx>( - tcx: TyCtxt<'tcx>, +fn method_might_be_inlined( + tcx: TyCtxt<'_>, impl_item: &hir::ImplItem, impl_src: DefId, ) -> bool { @@ -391,7 +391,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a, 'tcx #[derive(Clone, HashStable)] pub struct ReachableSet(pub Lrc); -fn reachable_set<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> ReachableSet { +fn reachable_set(tcx: TyCtxt<'_>, crate_num: CrateNum) -> ReachableSet { debug_assert!(crate_num == LOCAL_CRATE); let access_levels = &tcx.privacy_access_levels(LOCAL_CRATE); diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 114684b152402..67a4c2981a705 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -1446,7 +1446,7 @@ impl<'tcx> Visitor<'tcx> for RegionResolutionVisitor<'tcx> { } } -fn region_scope_tree<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ScopeTree { +fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree { let closure_base_def_id = tcx.closure_base_def_id(def_id); if closure_base_def_id != def_id { return tcx.region_scope_tree(closure_base_def_id); diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 412346bab257e..7776f38f53820 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -8,6 +8,7 @@ use crate::hir::def::{Res, DefKind}; use crate::hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; use crate::hir::map::Map; +use crate::hir::ptr::P; use crate::hir::{GenericArg, GenericParam, ItemLocalId, LifetimeName, Node, ParamName}; use crate::ty::{self, DefIdTree, GenericParamDefKind, TyCtxt}; @@ -21,7 +22,6 @@ use std::cell::Cell; use std::mem::replace; use syntax::ast; use syntax::attr; -use syntax::ptr::P; use syntax::symbol::{kw, sym}; use syntax_pos::Span; @@ -368,7 +368,7 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) { /// entire crate. You should not read the result of this query /// directly, but rather use `named_region_map`, `is_late_bound_map`, /// etc. -fn resolve_lifetimes<'tcx>(tcx: TyCtxt<'tcx>, for_krate: CrateNum) -> &'tcx ResolveLifetimes { +fn resolve_lifetimes(tcx: TyCtxt<'_>, for_krate: CrateNum) -> &ResolveLifetimes { assert_eq!(for_krate, LOCAL_CRATE); let named_region_map = krate(tcx); @@ -395,7 +395,7 @@ fn resolve_lifetimes<'tcx>(tcx: TyCtxt<'tcx>, for_krate: CrateNum) -> &'tcx Reso tcx.arena.alloc(rl) } -fn krate<'tcx>(tcx: TyCtxt<'tcx>) -> NamedRegionMap { +fn krate(tcx: TyCtxt<'_>) -> NamedRegionMap { let krate = tcx.hir().krate(); let mut map = NamedRegionMap { defs: Default::default(), diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 38df4060652b7..101563d2d99ef 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -466,7 +466,7 @@ impl<'tcx> Index<'tcx> { /// Cross-references the feature names of unstable APIs with enabled /// features and possibly prints errors. -fn check_mod_unstable_api_usage<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn check_mod_unstable_api_usage(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module(module_def_id, &mut Checker { tcx }.as_deep_visitor()); } @@ -836,7 +836,7 @@ impl<'tcx> TyCtxt<'tcx> { /// Given the list of enabled features that were not language features (i.e., that /// were expected to be library features), and the list of features used from /// libraries, identify activated features that don't exist and error about them. -pub fn check_unused_or_stable_features<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) { let access_levels = &tcx.privacy_access_levels(LOCAL_CRATE); if tcx.stability().staged_api[&LOCAL_CRATE] { @@ -920,8 +920,8 @@ pub fn check_unused_or_stable_features<'tcx>(tcx: TyCtxt<'tcx>) { // don't lint about unused features. We should reenable this one day! } -fn unnecessary_stable_feature_lint<'tcx>( - tcx: TyCtxt<'tcx>, +fn unnecessary_stable_feature_lint( + tcx: TyCtxt<'_>, span: Span, feature: Symbol, since: Symbol, diff --git a/src/librustc/mir/interpret/error.rs b/src/librustc/mir/interpret/error.rs index 256b3f1015093..7be4a2206f5b8 100644 --- a/src/librustc/mir/interpret/error.rs +++ b/src/librustc/mir/interpret/error.rs @@ -37,6 +37,10 @@ impl ErrorHandled { } } +CloneTypeFoldableImpls! { + ErrorHandled, +} + pub type ConstEvalRawResult<'tcx> = Result, ErrorHandled>; pub type ConstEvalResult<'tcx> = Result<&'tcx ty::Const<'tcx>, ErrorHandled>; diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs index 9b1808c585ce7..59a032d53cfd6 100644 --- a/src/librustc/mir/mod.rs +++ b/src/librustc/mir/mod.rs @@ -2867,19 +2867,19 @@ impl<'tcx> graph::WithStartNode for Body<'tcx> { } impl<'tcx> graph::WithPredecessors for Body<'tcx> { - fn predecessors<'graph>( - &'graph self, + fn predecessors( + &self, node: Self::Node, - ) -> >::Iter { + ) -> >::Iter { self.predecessors_for(node).clone().into_iter() } } impl<'tcx> graph::WithSuccessors for Body<'tcx> { - fn successors<'graph>( - &'graph self, + fn successors( + &self, node: Self::Node, - ) -> >::Iter { + ) -> >::Iter { self.basic_blocks[node].terminator().successors().cloned() } } diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 895f9c6d8fb85..d79215db94e97 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -269,11 +269,11 @@ impl OutputTypes { self.0.contains_key(key) } - pub fn keys<'a>(&'a self) -> BTreeMapKeysIter<'a, OutputType, Option> { + pub fn keys(&self) -> BTreeMapKeysIter<'_, OutputType, Option> { self.0.keys() } - pub fn values<'a>(&'a self) -> BTreeMapValuesIter<'a, OutputType, Option> { + pub fn values(&self) -> BTreeMapValuesIter<'_, OutputType, Option> { self.0.values() } @@ -316,7 +316,7 @@ impl Externs { self.0.get(key) } - pub fn iter<'a>(&'a self) -> BTreeMapIter<'a, String, ExternEntry> { + pub fn iter(&self) -> BTreeMapIter<'_, String, ExternEntry> { self.0.iter() } } diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index bb4ef2d7bd426..6b54035942a78 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -215,66 +215,66 @@ impl Session { *self.crate_disambiguator.get() } - pub fn struct_span_warn<'a, S: Into>( - &'a self, + pub fn struct_span_warn>( + &self, sp: S, msg: &str, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_warn(sp, msg) } - pub fn struct_span_warn_with_code<'a, S: Into>( - &'a self, + pub fn struct_span_warn_with_code>( + &self, sp: S, msg: &str, code: DiagnosticId, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_warn_with_code(sp, msg, code) } - pub fn struct_warn<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> { + pub fn struct_warn(&self, msg: &str) -> DiagnosticBuilder<'_> { self.diagnostic().struct_warn(msg) } - pub fn struct_span_err<'a, S: Into>( - &'a self, + pub fn struct_span_err>( + &self, sp: S, msg: &str, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_err(sp, msg) } - pub fn struct_span_err_with_code<'a, S: Into>( - &'a self, + pub fn struct_span_err_with_code>( + &self, sp: S, msg: &str, code: DiagnosticId, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_err_with_code(sp, msg, code) } // FIXME: This method should be removed (every error should have an associated error code). - pub fn struct_err<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> { + pub fn struct_err(&self, msg: &str) -> DiagnosticBuilder<'_> { self.diagnostic().struct_err(msg) } - pub fn struct_err_with_code<'a>( - &'a self, + pub fn struct_err_with_code( + &self, msg: &str, code: DiagnosticId, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { self.diagnostic().struct_err_with_code(msg, code) } - pub fn struct_span_fatal<'a, S: Into>( - &'a self, + pub fn struct_span_fatal>( + &self, sp: S, msg: &str, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_fatal(sp, msg) } - pub fn struct_span_fatal_with_code<'a, S: Into>( - &'a self, + pub fn struct_span_fatal_with_code>( + &self, sp: S, msg: &str, code: DiagnosticId, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_fatal_with_code(sp, msg, code) } - pub fn struct_fatal<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> { + pub fn struct_fatal(&self, msg: &str) -> DiagnosticBuilder<'_> { self.diagnostic().struct_fatal(msg) } @@ -416,7 +416,7 @@ impl Session { pub fn next_node_id(&self) -> NodeId { self.reserve_node_ids(1) } - pub fn diagnostic<'a>(&'a self) -> &'a errors::Handler { + pub fn diagnostic(&self) -> &errors::Handler { &self.parse_sess.span_diagnostic } @@ -504,7 +504,7 @@ impl Session { ); } - pub fn source_map<'a>(&'a self) -> &'a source_map::SourceMap { + pub fn source_map(&self) -> &source_map::SourceMap { self.parse_sess.source_map() } pub fn verbose(&self) -> bool { diff --git a/src/librustc/traits/coherence.rs b/src/librustc/traits/coherence.rs index d8087af60acdf..b6f0addd77107 100644 --- a/src/librustc/traits/coherence.rs +++ b/src/librustc/traits/coherence.rs @@ -48,8 +48,8 @@ pub fn add_placeholder_note(err: &mut errors::DiagnosticBuilder<'_>) { /// If there are types that satisfy both impls, invokes `on_overlap` /// with a suitably-freshened `ImplHeader` with those types /// substituted. Otherwise, invokes `no_overlap`. -pub fn overlapping_impls<'tcx, F1, F2, R>( - tcx: TyCtxt<'tcx>, +pub fn overlapping_impls( + tcx: TyCtxt<'_>, impl1_def_id: DefId, impl2_def_id: DefId, intercrate_mode: IntercrateMode, @@ -247,10 +247,10 @@ pub enum OrphanCheckErr<'tcx> { /// /// 1. All type parameters in `Self` must be "covered" by some local type constructor. /// 2. Some local type must appear in `Self`. -pub fn orphan_check<'tcx>( - tcx: TyCtxt<'tcx>, +pub fn orphan_check( + tcx: TyCtxt<'_>, impl_def_id: DefId, -) -> Result<(), OrphanCheckErr<'tcx>> { +) -> Result<(), OrphanCheckErr<'_>> { debug!("orphan_check({:?})", impl_def_id); // We only except this routine to be invoked on implementations diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index f54575ff8fc1d..d6cc68bcdab46 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -247,7 +247,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { fn fuzzy_match_tys(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> bool { /// returns the fuzzy category of a given type, or None /// if the type can be equated to any type. - fn type_category<'tcx>(t: Ty<'tcx>) -> Option { + fn type_category(t: Ty<'_>) -> Option { match t.sty { ty::Bool => Some(0), ty::Char => Some(1), diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs index f106458c7676a..99b5ef3894b9c 100644 --- a/src/librustc/traits/fulfill.rs +++ b/src/librustc/traits/fulfill.rs @@ -461,41 +461,35 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> { } ty::Predicate::ConstEvaluatable(def_id, substs) => { - match self.selcx.tcx().lift_to_global(&obligation.param_env) { - None => { + if obligation.param_env.has_local_value() { ProcessResult::Unchanged - } - Some(param_env) => { - match self.selcx.tcx().lift_to_global(&substs) { - Some(substs) => { - let instance = ty::Instance::resolve( - self.selcx.tcx().global_tcx(), - param_env, - def_id, - substs, - ); - if let Some(instance) = instance { - let cid = GlobalId { - instance, - promoted: None, - }; - match self.selcx.tcx().at(obligation.cause.span) - .const_eval(param_env.and(cid)) { - Ok(_) => ProcessResult::Changed(vec![]), - Err(err) => ProcessResult::Error( - CodeSelectionError(ConstEvalFailure(err))) - } - } else { - ProcessResult::Error(CodeSelectionError( - ConstEvalFailure(ErrorHandled::TooGeneric) - )) - } - }, - None => { - pending_obligation.stalled_on = substs.types().collect(); - ProcessResult::Unchanged + } else { + if !substs.has_local_value() { + let instance = ty::Instance::resolve( + self.selcx.tcx().global_tcx(), + obligation.param_env, + def_id, + substs, + ); + if let Some(instance) = instance { + let cid = GlobalId { + instance, + promoted: None, + }; + match self.selcx.tcx().at(obligation.cause.span) + .const_eval(obligation.param_env.and(cid)) { + Ok(_) => ProcessResult::Changed(vec![]), + Err(err) => ProcessResult::Error( + CodeSelectionError(ConstEvalFailure(err))) } + } else { + ProcessResult::Error(CodeSelectionError( + ConstEvalFailure(ErrorHandled::TooGeneric) + )) } + } else { + pending_obligation.stalled_on = substs.types().collect(); + ProcessResult::Unchanged } } } diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index 8d17df1e61055..1ca92d79fa5f6 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -457,6 +457,16 @@ pub enum SelectionError<'tcx> { Overflow, } +EnumTypeFoldableImpl! { + impl<'tcx> TypeFoldable<'tcx> for SelectionError<'tcx> { + (SelectionError::Unimplemented), + (SelectionError::OutputTypeParameterMismatch)(a, b, c), + (SelectionError::TraitNotObjectSafe)(a), + (SelectionError::ConstEvalFailure)(a), + (SelectionError::Overflow), + } +} + pub struct FulfillmentError<'tcx> { pub obligation: PredicateObligation<'tcx>, pub code: FulfillmentErrorCode<'tcx> @@ -782,13 +792,11 @@ fn do_normalize_predicates<'tcx>( return Err(ErrorReported) } }; - - match tcx.lift_to_global(&predicates) { - Some(predicates) => Ok(predicates), - None => { - // FIXME: shouldn't we, you know, actually report an error here? or an ICE? - Err(ErrorReported) - } + if predicates.has_local_value() { + // FIXME: shouldn't we, you know, actually report an error here? or an ICE? + Err(ErrorReported) + } else { + Ok(predicates) } }) } diff --git a/src/librustc/traits/object_safety.rs b/src/librustc/traits/object_safety.rs index cfd5cfa897daf..37eff852abd01 100644 --- a/src/librustc/traits/object_safety.rs +++ b/src/librustc/traits/object_safety.rs @@ -702,6 +702,6 @@ impl<'tcx> TyCtxt<'tcx> { } } -pub(super) fn is_object_safe_provider<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId) -> bool { +pub(super) fn is_object_safe_provider(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool { tcx.object_safety_violations(trait_def_id).is_empty() } diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs index 0f4b7aff82bce..20acf44340690 100644 --- a/src/librustc/traits/project.rs +++ b/src/librustc/traits/project.rs @@ -399,7 +399,8 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> { fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> { if let ConstValue::Unevaluated(def_id, substs) = constant.val { let tcx = self.selcx.tcx().global_tcx(); - if let Some(param_env) = self.tcx().lift_to_global(&self.param_env) { + let param_env = self.param_env; + if !param_env.has_local_value() { if substs.needs_infer() || substs.has_placeholders() { let identity_substs = InternalSubsts::identity_for_item(tcx, def_id); let instance = ty::Instance::resolve(tcx, param_env, def_id, identity_substs); @@ -414,7 +415,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> { } } } else { - if let Some(substs) = self.tcx().lift_to_global(&substs) { + if !substs.has_local_value() { let instance = ty::Instance::resolve(tcx, param_env, def_id, substs); if let Some(instance) = instance { let cid = GlobalId { @@ -1508,8 +1509,8 @@ fn confirm_impl_candidate<'cx, 'tcx>( /// /// Based on the "projection mode", this lookup may in fact only examine the /// topmost impl. See the comments for `Reveal` for more details. -fn assoc_ty_def<'cx, 'tcx>( - selcx: &SelectionContext<'cx, 'tcx>, +fn assoc_ty_def( + selcx: &SelectionContext<'_, '_>, impl_def_id: DefId, assoc_ty_def_id: DefId, ) -> specialization_graph::NodeItem { diff --git a/src/librustc/traits/query/normalize.rs b/src/librustc/traits/query/normalize.rs index 5dd1b9e3d53f3..55e622e46b966 100644 --- a/src/librustc/traits/query/normalize.rs +++ b/src/librustc/traits/query/normalize.rs @@ -193,7 +193,8 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> { fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> { if let ConstValue::Unevaluated(def_id, substs) = constant.val { let tcx = self.infcx.tcx.global_tcx(); - if let Some(param_env) = self.tcx().lift_to_global(&self.param_env) { + let param_env = self.param_env; + if !param_env.has_local_value() { if substs.needs_infer() || substs.has_placeholders() { let identity_substs = InternalSubsts::identity_for_item(tcx, def_id); let instance = ty::Instance::resolve(tcx, param_env, def_id, identity_substs); @@ -208,7 +209,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> { } } } else { - if let Some(substs) = self.tcx().lift_to_global(&substs) { + if !substs.has_local_value() { let instance = ty::Instance::resolve(tcx, param_env, def_id, substs); if let Some(instance) = instance { let cid = GlobalId { diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs index 7c4742259ac16..798a25fe7b1bc 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -328,6 +328,23 @@ impl<'a, 'tcx> ty::Lift<'tcx> for SelectionCandidate<'a> { } } +EnumTypeFoldableImpl! { + impl<'tcx> TypeFoldable<'tcx> for SelectionCandidate<'tcx> { + (SelectionCandidate::BuiltinCandidate) { has_nested }, + (SelectionCandidate::ParamCandidate)(poly_trait_ref), + (SelectionCandidate::ImplCandidate)(def_id), + (SelectionCandidate::AutoImplCandidate)(def_id), + (SelectionCandidate::ProjectionCandidate), + (SelectionCandidate::ClosureCandidate), + (SelectionCandidate::GeneratorCandidate), + (SelectionCandidate::FnPointerCandidate), + (SelectionCandidate::TraitAliasCandidate)(def_id), + (SelectionCandidate::ObjectCandidate), + (SelectionCandidate::BuiltinObjectCandidate), + (SelectionCandidate::BuiltinUnsizeCandidate), + } +} + struct SelectionCandidateSet<'tcx> { // a list of candidates that definitely apply to the current // obligation (meaning: types unify). @@ -818,27 +835,25 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::Predicate::ConstEvaluatable(def_id, substs) => { let tcx = self.tcx(); - match tcx.lift_to_global(&(obligation.param_env, substs)) { - Some((param_env, substs)) => { - let instance = - ty::Instance::resolve(tcx.global_tcx(), param_env, def_id, substs); - if let Some(instance) = instance { - let cid = GlobalId { - instance, - promoted: None, - }; - match self.tcx().const_eval(param_env.and(cid)) { - Ok(_) => Ok(EvaluatedToOk), - Err(_) => Ok(EvaluatedToErr), - } - } else { - Ok(EvaluatedToErr) + if !(obligation.param_env, substs).has_local_value() { + let param_env = obligation.param_env; + let instance = + ty::Instance::resolve(tcx, param_env, def_id, substs); + if let Some(instance) = instance { + let cid = GlobalId { + instance, + promoted: None, + }; + match self.tcx().const_eval(param_env.and(cid)) { + Ok(_) => Ok(EvaluatedToOk), + Err(_) => Ok(EvaluatedToErr), } + } else { + Ok(EvaluatedToErr) } - None => { - // Inference variables still left in param_env or substs. - Ok(EvaluatedToAmbig) - } + } else { + // Inference variables still left in param_env or substs. + Ok(EvaluatedToAmbig) } } } @@ -1172,7 +1187,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } if self.can_use_global_caches(param_env) { - if let Some(trait_ref) = self.tcx().lift_to_global(&trait_ref) { + if !trait_ref.has_local_value() { debug!( "insert_evaluation_cache(trait_ref={:?}, candidate={:?}) global", trait_ref, result, @@ -1645,8 +1660,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { if let Err(Overflow) = candidate { // Don't cache overflow globally; we only produce this // in certain modes. - } else if let Some(trait_ref) = tcx.lift_to_global(&trait_ref) { - if let Some(candidate) = tcx.lift_to_global(&candidate) { + } else if !trait_ref.has_local_value() { + if !candidate.has_local_value() { debug!( "insert_candidate_cache(trait_ref={:?}, candidate={:?}) global", trait_ref, candidate, diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs index 43bb4edd9b27d..f0389bb037ac5 100644 --- a/src/librustc/traits/specialize/mod.rs +++ b/src/librustc/traits/specialize/mod.rs @@ -145,8 +145,8 @@ pub fn find_associated_item<'tcx>( /// Specialization is determined by the sets of types to which the impls apply; /// `impl1` specializes `impl2` if it applies to a subset of the types `impl2` applies /// to. -pub(super) fn specializes<'tcx>( - tcx: TyCtxt<'tcx>, +pub(super) fn specializes( + tcx: TyCtxt<'_>, (impl1_def_id, impl2_def_id): (DefId, DefId), ) -> bool { debug!("specializes({:?}, {:?})", impl1_def_id, impl2_def_id); @@ -282,10 +282,10 @@ fn fulfill_implication<'a, 'tcx>( } // Query provider for `specialization_graph_of`. -pub(super) fn specialization_graph_provider<'tcx>( - tcx: TyCtxt<'tcx>, +pub(super) fn specialization_graph_provider( + tcx: TyCtxt<'_>, trait_id: DefId, -) -> &'tcx specialization_graph::Graph { +) -> &specialization_graph::Graph { let mut sg = specialization_graph::Graph::new(); let mut trait_impls = tcx.all_impls(trait_id); diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs index 2d295679be324..07d6f633143a2 100644 --- a/src/librustc/traits/util.rs +++ b/src/librustc/traits/util.rs @@ -417,7 +417,7 @@ pub struct SupertraitDefIds<'tcx> { visited: FxHashSet, } -pub fn supertrait_def_ids<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId) -> SupertraitDefIds<'tcx> { +pub fn supertrait_def_ids(tcx: TyCtxt<'_>, trait_def_id: DefId) -> SupertraitDefIds<'_> { SupertraitDefIds { tcx, stack: vec![trait_def_id], diff --git a/src/librustc/ty/erase_regions.rs b/src/librustc/ty/erase_regions.rs index 999b4eff85697..3dd1fd100f2a4 100644 --- a/src/librustc/ty/erase_regions.rs +++ b/src/librustc/ty/erase_regions.rs @@ -42,10 +42,10 @@ impl TypeFolder<'tcx> for RegionEraserVisitor<'tcx> { } fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { - if let Some(ty_lifted) = self.tcx.lift_to_global(&ty) { - self.tcx.erase_regions_ty(ty_lifted) - } else { + if ty.has_local_value() { ty.super_fold_with(self) + } else { + self.tcx.erase_regions_ty(ty) } } diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs index 8b98a2916a766..ab7df8e4e845b 100644 --- a/src/librustc/ty/fold.rs +++ b/src/librustc/ty/fold.rs @@ -91,6 +91,9 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone { fn has_infer_types(&self) -> bool { self.has_type_flags(TypeFlags::HAS_TY_INFER) } + fn has_local_value(&self) -> bool { + self.has_type_flags(TypeFlags::KEEP_IN_LOCAL_TCX) + } fn needs_infer(&self) -> bool { self.has_type_flags( TypeFlags::HAS_TY_INFER | TypeFlags::HAS_RE_INFER | TypeFlags::HAS_CT_INFER @@ -922,6 +925,7 @@ impl<'tcx> TypeVisitor<'tcx> for HasEscapingVarsVisitor { } } +// FIXME: Optimize for checking for infer flags struct HasTypeFlagsVisitor { flags: ty::TypeFlags, } diff --git a/src/librustc/ty/query/on_disk_cache.rs b/src/librustc/ty/query/on_disk_cache.rs index 8b2183c42efd4..85153f99b1917 100644 --- a/src/librustc/ty/query/on_disk_cache.rs +++ b/src/librustc/ty/query/on_disk_cache.rs @@ -306,9 +306,9 @@ impl<'sess> OnDiskCache<'sess> { } /// Loads a diagnostic emitted during the previous compilation session. - pub fn load_diagnostics<'tcx>( + pub fn load_diagnostics( &self, - tcx: TyCtxt<'tcx>, + tcx: TyCtxt<'_>, dep_node_index: SerializedDepNodeIndex, ) -> Vec { let diagnostics: Option = self.load_indexed( @@ -335,9 +335,9 @@ impl<'sess> OnDiskCache<'sess> { /// Returns the cached query result if there is something in the cache for /// the given `SerializedDepNodeIndex`; otherwise returns `None`. - pub fn try_load_query_result<'tcx, T>( + pub fn try_load_query_result( &self, - tcx: TyCtxt<'tcx>, + tcx: TyCtxt<'_>, dep_node_index: SerializedDepNodeIndex, ) -> Option where diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs index 5a7d106700af2..0c9e31e1ff28e 100644 --- a/src/librustc/ty/query/plumbing.rs +++ b/src/librustc/ty/query/plumbing.rs @@ -1166,7 +1166,7 @@ macro_rules! define_provider_struct { /// then `force_from_dep_node()` should not fail for it. Otherwise, you can just /// add it to the "We don't have enough information to reconstruct..." group in /// the match below. -pub fn force_from_dep_node<'tcx>(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> bool { +pub fn force_from_dep_node(tcx: TyCtxt<'_>, dep_node: &DepNode) -> bool { use crate::dep_graph::RecoverKey; // We must avoid ever having to call force_from_dep_node() for a diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs index 46adb7eb2a476..a6bfc2dee613b 100644 --- a/src/librustc/ty/relate.rs +++ b/src/librustc/ty/relate.rs @@ -550,7 +550,7 @@ pub fn super_relate_consts>( if let ConstValue::Unevaluated(def_id, substs) = x.val { // FIXME(eddyb) get the right param_env. let param_env = ty::ParamEnv::empty(); - if let Some(substs) = tcx.lift_to_global(&substs) { + if !substs.has_local_value() { let instance = ty::Instance::resolve( tcx.global_tcx(), param_env, diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index 3d8170586c47f..27cd745c20fcb 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -821,6 +821,13 @@ EnumTypeFoldableImpl! { } where T: TypeFoldable<'tcx> } +EnumTypeFoldableImpl! { + impl<'tcx, T, E> TypeFoldable<'tcx> for Result { + (Ok)(a), + (Err)(a), + } where T: TypeFoldable<'tcx>, E: TypeFoldable<'tcx>, +} + impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Rc { fn super_fold_with>(&self, folder: &mut F) -> Self { Rc::new((**self).fold_with(folder)) diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index 714b7c27200e3..a098cd1761236 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -354,7 +354,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { cmt: &mc::cmt_<'tcx>, loan_region: ty::Region<'tcx>, borrow_span: Span) { - pub fn borrow_of_local_data<'tcx>(cmt: &mc::cmt_<'tcx>) -> bool { + pub fn borrow_of_local_data(cmt: &mc::cmt_<'_>) -> bool { match cmt.cat { // Borrows of static items is allowed Categorization::StaticItem => false, diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 3c7f19f7fbf4f..8763a6bc066b3 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -53,7 +53,7 @@ pub struct LoanDataFlowOperator; pub type LoanDataFlow<'tcx> = DataFlowContext<'tcx, LoanDataFlowOperator>; -pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check_crate(tcx: TyCtxt<'_>) { tcx.par_body_owners(|body_owner_def_id| { tcx.ensure().borrowck(body_owner_def_id); }); @@ -73,7 +73,7 @@ pub struct AnalysisData<'tcx> { pub move_data: move_data::FlowedMoveData<'tcx>, } -fn borrowck<'tcx>(tcx: TyCtxt<'tcx>, owner_def_id: DefId) -> &'tcx BorrowCheckResult { +fn borrowck(tcx: TyCtxt<'_>, owner_def_id: DefId) -> &BorrowCheckResult { assert!(tcx.use_ast_borrowck() || tcx.migrate_borrowck()); debug!("borrowck(body_owner_def_id={:?})", owner_def_id); diff --git a/src/librustc_borrowck/dataflow.rs b/src/librustc_borrowck/dataflow.rs index f5d311b35d738..95580952ffb95 100644 --- a/src/librustc_borrowck/dataflow.rs +++ b/src/librustc_borrowck/dataflow.rs @@ -6,7 +6,6 @@ use rustc::cfg; use rustc::cfg::CFGIndex; use rustc::ty::TyCtxt; -use std::io; use std::mem; use std::usize; use syntax::print::pprust::PrintState; @@ -84,9 +83,9 @@ struct PropagationContext<'a, 'tcx, O> { changed: bool, } -fn get_cfg_indices<'a>(id: hir::ItemLocalId, - index: &'a FxHashMap>) - -> &'a [CFGIndex] { +fn get_cfg_indices(id: hir::ItemLocalId, + index: &FxHashMap>) + -> &[CFGIndex] { index.get(&id).map_or(&[], |v| &v[..]) } @@ -98,23 +97,23 @@ impl<'tcx, O: DataFlowOperator> DataFlowContext<'tcx, O> { } impl<'tcx, O: DataFlowOperator> pprust::PpAnn for DataFlowContext<'tcx, O> { - fn nested(&self, state: &mut pprust::State<'_>, nested: pprust::Nested) -> io::Result<()> { + fn nested(&self, state: &mut pprust::State<'_>, nested: pprust::Nested) { pprust::PpAnn::nested(self.tcx.hir(), state, nested) } fn pre(&self, ps: &mut pprust::State<'_>, - node: pprust::AnnNode<'_>) -> io::Result<()> { + node: pprust::AnnNode<'_>) { let id = match node { - pprust::AnnNode::Name(_) => return Ok(()), + pprust::AnnNode::Name(_) => return, pprust::AnnNode::Expr(expr) => expr.hir_id.local_id, pprust::AnnNode::Block(blk) => blk.hir_id.local_id, pprust::AnnNode::Item(_) | - pprust::AnnNode::SubItem(_) => return Ok(()), + pprust::AnnNode::SubItem(_) => return, pprust::AnnNode::Pat(pat) => pat.hir_id.local_id }; if !self.has_bitset_for_local_id(id) { - return Ok(()); + return; } assert!(self.bits_per_id > 0); @@ -147,10 +146,9 @@ impl<'tcx, O: DataFlowOperator> pprust::PpAnn for DataFlowContext<'tcx, O> { ps.synth_comment( format!("id {}: {}{}{}{}", id.as_usize(), entry_str, - gens_str, action_kills_str, scope_kills_str))?; - ps.s.space()?; + gens_str, action_kills_str, scope_kills_str)); + ps.s.space(); } - Ok(()) } } @@ -531,8 +529,8 @@ impl<'tcx, O: DataFlowOperator + Clone + 'static> DataFlowContext<'tcx, O> { debug!("Dataflow result for {}:", self.analysis_name); debug!("{}", pprust::to_string(self, |s| { - s.cbox(pprust::indent_unit)?; - s.ibox(0)?; + s.cbox(pprust::indent_unit); + s.ibox(0); s.print_expr(&body.value) })); } diff --git a/src/librustc_codegen_llvm/back/write.rs b/src/librustc_codegen_llvm/back/write.rs index 3638730707f3f..b135605cf02d7 100644 --- a/src/librustc_codegen_llvm/back/write.rs +++ b/src/librustc_codegen_llvm/back/write.rs @@ -239,9 +239,9 @@ impl<'a> Drop for DiagnosticHandlers<'a> { } } -unsafe extern "C" fn report_inline_asm<'a, 'b>(cgcx: &'a CodegenContext, - msg: &'b str, - cookie: c_uint) { +unsafe extern "C" fn report_inline_asm(cgcx: &CodegenContext, + msg: &str, + cookie: c_uint) { cgcx.diag_emitter.inline_asm_error(cookie as u32, msg.to_owned()); } diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs index 04645dacfec58..21c19e167cfbe 100644 --- a/src/librustc_codegen_llvm/base.rs +++ b/src/librustc_codegen_llvm/base.rs @@ -123,8 +123,8 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'tcx>, cgu_name: InternedString) { submit_codegened_module_to_llvm(&LlvmCodegenBackend(()), tcx, module, cost); - fn module_codegen<'tcx>( - tcx: TyCtxt<'tcx>, + fn module_codegen( + tcx: TyCtxt<'_>, cgu_name: InternedString, ) -> ModuleCodegen { let cgu = tcx.codegen_unit(cgu_name); diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs index 0709368ad860e..f67c740b77748 100644 --- a/src/librustc_codegen_llvm/builder.rs +++ b/src/librustc_codegen_llvm/builder.rs @@ -144,7 +144,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn build_sibling_block<'b>(&self, name: &'b str) -> Self { + fn build_sibling_block(&self, name: &str) -> Self { Builder::new_block(self.cx, self.llfn(), name) } diff --git a/src/librustc_codegen_llvm/lib.rs b/src/librustc_codegen_llvm/lib.rs index 7283aa95b3027..e6630e1816570 100644 --- a/src/librustc_codegen_llvm/lib.rs +++ b/src/librustc_codegen_llvm/lib.rs @@ -124,7 +124,7 @@ impl ExtraBackendMethods for LlvmCodegenBackend { ) { unsafe { allocator::codegen(tcx, mods, kind) } } - fn compile_codegen_unit<'tcx>(&self, tcx: TyCtxt<'tcx>, cgu_name: InternedString) { + fn compile_codegen_unit(&self, tcx: TyCtxt<'_>, cgu_name: InternedString) { base::compile_codegen_unit(tcx, cgu_name); } fn target_machine_factory( diff --git a/src/librustc_codegen_llvm/llvm/ffi.rs b/src/librustc_codegen_llvm/llvm/ffi.rs index a5c295cd4525c..708ba79ec3ab2 100644 --- a/src/librustc_codegen_llvm/llvm/ffi.rs +++ b/src/librustc_codegen_llvm/llvm/ffi.rs @@ -1736,7 +1736,9 @@ extern "C" { pub fn LLVMRustArchiveIteratorFree(AIR: &'a mut ArchiveIterator<'a>); pub fn LLVMRustDestroyArchive(AR: &'static mut Archive); - pub fn LLVMRustGetSectionName(SI: &SectionIterator<'_>, data: &mut *const c_char) -> size_t; + #[allow(improper_ctypes)] + pub fn LLVMRustGetSectionName(SI: &SectionIterator<'_>, + data: &mut Option>) -> size_t; #[allow(improper_ctypes)] pub fn LLVMRustWriteTwineToString(T: &Twine, s: &RustString); diff --git a/src/librustc_codegen_llvm/metadata.rs b/src/librustc_codegen_llvm/metadata.rs index 7cf497cb5d036..cd7255888118c 100644 --- a/src/librustc_codegen_llvm/metadata.rs +++ b/src/librustc_codegen_llvm/metadata.rs @@ -8,7 +8,6 @@ use rustc_data_structures::owning_ref::OwningRef; use rustc_codegen_ssa::METADATA_FILENAME; use std::path::Path; -use std::ptr; use std::slice; use rustc_fs_util::path_to_c_string; @@ -67,10 +66,16 @@ fn search_meta_section<'a>(of: &'a ObjectFile, unsafe { let si = mk_section_iter(of.llof); while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False { - let mut name_buf = ptr::null(); + let mut name_buf = None; let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf); - let name = slice::from_raw_parts(name_buf as *const u8, name_len as usize).to_vec(); - let name = String::from_utf8(name).unwrap(); + let name = name_buf.map_or( + String::new(), // We got a NULL ptr, ignore `name_len`. + |buf| String::from_utf8( + slice::from_raw_parts(buf.as_ptr() as *const u8, + name_len as usize) + .to_vec() + ).unwrap() + ); debug!("get_metadata_section: name {}", name); if read_metadata_section_name(target) == name { let cbuf = llvm::LLVMGetSectionContents(si.llsi); diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs index b9ee82f108ae3..b65e4d24f1b4b 100644 --- a/src/librustc_codegen_ssa/back/symbol_export.rs +++ b/src/librustc_codegen_ssa/back/symbol_export.rs @@ -46,10 +46,10 @@ pub fn crates_export_threshold(crate_types: &[config::CrateType]) -> SymbolExpor } } -fn reachable_non_generics_provider<'tcx>( - tcx: TyCtxt<'tcx>, +fn reachable_non_generics_provider( + tcx: TyCtxt<'_>, cnum: CrateNum, -) -> &'tcx DefIdMap { +) -> &DefIdMap { assert_eq!(cnum, LOCAL_CRATE); if !tcx.sess.opts.output_types.should_codegen() { @@ -157,7 +157,7 @@ fn reachable_non_generics_provider<'tcx>( tcx.arena.alloc(reachable_non_generics) } -fn is_reachable_non_generic_provider_local<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { +fn is_reachable_non_generic_provider_local(tcx: TyCtxt<'_>, def_id: DefId) -> bool { let export_threshold = threshold(tcx); if let Some(&level) = tcx.reachable_non_generics(def_id.krate).get(&def_id) { @@ -167,14 +167,14 @@ fn is_reachable_non_generic_provider_local<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefI } } -fn is_reachable_non_generic_provider_extern<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { +fn is_reachable_non_generic_provider_extern(tcx: TyCtxt<'_>, def_id: DefId) -> bool { tcx.reachable_non_generics(def_id.krate).contains_key(&def_id) } -fn exported_symbols_provider_local<'tcx>( - tcx: TyCtxt<'tcx>, +fn exported_symbols_provider_local( + tcx: TyCtxt<'_>, cnum: CrateNum, -) -> Arc, SymbolExportLevel)>> { +) -> Arc, SymbolExportLevel)>> { assert_eq!(cnum, LOCAL_CRATE); if !tcx.sess.opts.output_types.should_codegen() { @@ -273,10 +273,10 @@ fn exported_symbols_provider_local<'tcx>( Arc::new(symbols) } -fn upstream_monomorphizations_provider<'tcx>( - tcx: TyCtxt<'tcx>, +fn upstream_monomorphizations_provider( + tcx: TyCtxt<'_>, cnum: CrateNum, -) -> &'tcx DefIdMap, CrateNum>> { +) -> &DefIdMap, CrateNum>> { debug_assert!(cnum == LOCAL_CRATE); let cnums = tcx.all_crate_nums(LOCAL_CRATE); @@ -322,10 +322,10 @@ fn upstream_monomorphizations_provider<'tcx>( tcx.arena.alloc(instances) } -fn upstream_monomorphizations_for_provider<'tcx>( - tcx: TyCtxt<'tcx>, +fn upstream_monomorphizations_for_provider( + tcx: TyCtxt<'_>, def_id: DefId, -) -> Option<&'tcx FxHashMap, CrateNum>> { +) -> Option<&FxHashMap, CrateNum>> { debug_assert!(!def_id.is_local()); tcx.upstream_monomorphizations(LOCAL_CRATE).get(&def_id) } diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs index 47b383fddbc31..d06460fc85696 100644 --- a/src/librustc_codegen_ssa/base.rs +++ b/src/librustc_codegen_ssa/base.rs @@ -700,7 +700,7 @@ impl Drop for AbortCodegenOnDrop { } } -fn assert_and_save_dep_graph<'tcx>(tcx: TyCtxt<'tcx>) { +fn assert_and_save_dep_graph(tcx: TyCtxt<'_>) { time(tcx.sess, "assert dep graph", || ::rustc_incremental::assert_dep_graph(tcx)); diff --git a/src/librustc_codegen_ssa/debuginfo/mod.rs b/src/librustc_codegen_ssa/debuginfo/mod.rs index d60a2e0cb1358..c9b1c0260e8c3 100644 --- a/src/librustc_codegen_ssa/debuginfo/mod.rs +++ b/src/librustc_codegen_ssa/debuginfo/mod.rs @@ -10,7 +10,7 @@ pub enum FunctionDebugContext { } impl FunctionDebugContext { - pub fn get_ref<'a>(&'a self, span: Span) -> &'a FunctionDebugContextData { + pub fn get_ref(&self, span: Span) -> &FunctionDebugContextData { match *self { FunctionDebugContext::RegularContext(ref data) => data, FunctionDebugContext::DebugInfoDisabled => { diff --git a/src/librustc_codegen_ssa/mir/analyze.rs b/src/librustc_codegen_ssa/mir/analyze.rs index 0289150a5e42a..2af9b448ef1eb 100644 --- a/src/librustc_codegen_ssa/mir/analyze.rs +++ b/src/librustc_codegen_ssa/mir/analyze.rs @@ -273,7 +273,7 @@ impl CleanupKind { } } -pub fn cleanup_kinds<'tcx>(mir: &mir::Body<'tcx>) -> IndexVec { +pub fn cleanup_kinds(mir: &mir::Body<'_>) -> IndexVec { fn discover_masters<'tcx>(result: &mut IndexVec, mir: &mir::Body<'tcx>) { for (bb, data) in mir.basic_blocks().iter_enumerated() { diff --git a/src/librustc_codegen_ssa/traits/backend.rs b/src/librustc_codegen_ssa/traits/backend.rs index 414871be6116e..9d5aaa7655db8 100644 --- a/src/librustc_codegen_ssa/traits/backend.rs +++ b/src/librustc_codegen_ssa/traits/backend.rs @@ -44,7 +44,7 @@ pub trait ExtraBackendMethods: CodegenBackend + WriteBackendMethods + Sized + Se mods: &mut Self::Module, kind: AllocatorKind, ); - fn compile_codegen_unit<'tcx>(&self, tcx: TyCtxt<'tcx>, cgu_name: InternedString); + fn compile_codegen_unit(&self, tcx: TyCtxt<'_>, cgu_name: InternedString); // If find_features is true this won't access `sess.crate_types` by assuming // that `is_pie_binary` is false. When we discover LLVM target features // `sess.crate_types` is uninitialized so we cannot access it. diff --git a/src/librustc_codegen_ssa/traits/builder.rs b/src/librustc_codegen_ssa/traits/builder.rs index 1c80e614db8d5..3a144f0b0e0aa 100644 --- a/src/librustc_codegen_ssa/traits/builder.rs +++ b/src/librustc_codegen_ssa/traits/builder.rs @@ -36,7 +36,7 @@ pub trait BuilderMethods<'a, 'tcx>: { fn new_block<'b>(cx: &'a Self::CodegenCx, llfn: Self::Value, name: &'b str) -> Self; fn with_cx(cx: &'a Self::CodegenCx) -> Self; - fn build_sibling_block<'b>(&self, name: &'b str) -> Self; + fn build_sibling_block(&self, name: &str) -> Self; fn cx(&self) -> &Self::CodegenCx; fn llbb(&self) -> Self::BasicBlock; diff --git a/src/librustc_codegen_utils/symbol_names_test.rs b/src/librustc_codegen_utils/symbol_names_test.rs index f48d1f2853c52..7ab29c5c4c3d0 100644 --- a/src/librustc_codegen_utils/symbol_names_test.rs +++ b/src/librustc_codegen_utils/symbol_names_test.rs @@ -11,7 +11,7 @@ use syntax::symbol::{Symbol, sym}; const SYMBOL_NAME: Symbol = sym::rustc_symbol_name; const DEF_PATH: Symbol = sym::rustc_def_path; -pub fn report_symbol_names<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn report_symbol_names(tcx: TyCtxt<'_>) { // if the `rustc_attrs` feature is not enabled, then the // attributes we are interested in cannot be present anyway, so // skip the walk. diff --git a/src/librustc_data_structures/bit_set.rs b/src/librustc_data_structures/bit_set.rs index 5d8388d89f5b3..1eb28bccbe382 100644 --- a/src/librustc_data_structures/bit_set.rs +++ b/src/librustc_data_structures/bit_set.rs @@ -168,7 +168,7 @@ impl BitSet { /// Iterates over the indices of set bits in a sorted order. #[inline] - pub fn iter<'a>(&'a self) -> BitIter<'a, T> { + pub fn iter(&self) -> BitIter<'_, T> { BitIter { cur: None, iter: self.words.iter().enumerate(), @@ -849,7 +849,7 @@ impl BitMatrix { /// Iterates through all the columns set to true in a given row of /// the matrix. - pub fn iter<'a>(&'a self, row: R) -> BitIter<'a, C> { + pub fn iter(&self, row: R) -> BitIter<'_, C> { assert!(row.index() < self.num_rows); let (start, end) = self.range(row); BitIter { diff --git a/src/librustc_data_structures/fingerprint.rs b/src/librustc_data_structures/fingerprint.rs index 7975c62b90fb6..3bea965ef3041 100644 --- a/src/librustc_data_structures/fingerprint.rs +++ b/src/librustc_data_structures/fingerprint.rs @@ -58,7 +58,7 @@ impl Fingerprint { Ok(()) } - pub fn decode_opaque<'a>(decoder: &mut Decoder<'a>) -> Result { + pub fn decode_opaque(decoder: &mut Decoder<'_>) -> Result { let mut bytes = [0; 16]; decoder.read_raw_bytes(&mut bytes)?; diff --git a/src/librustc_data_structures/graph/implementation/mod.rs b/src/librustc_data_structures/graph/implementation/mod.rs index de4b1bcd0c2a1..d2699004c81d8 100644 --- a/src/librustc_data_structures/graph/implementation/mod.rs +++ b/src/librustc_data_structures/graph/implementation/mod.rs @@ -247,11 +247,11 @@ impl Graph { self.incoming_edges(target).sources() } - pub fn depth_traverse<'a>( - &'a self, + pub fn depth_traverse( + &self, start: NodeIndex, direction: Direction, - ) -> DepthFirstTraversal<'a, N, E> { + ) -> DepthFirstTraversal<'_, N, E> { DepthFirstTraversal::with_start_node(self, start, direction) } diff --git a/src/librustc_data_structures/graph/mod.rs b/src/librustc_data_structures/graph/mod.rs index 3d47b7d49fb96..3158aafc09134 100644 --- a/src/librustc_data_structures/graph/mod.rs +++ b/src/librustc_data_structures/graph/mod.rs @@ -21,10 +21,10 @@ pub trait WithSuccessors: DirectedGraph where Self: for<'graph> GraphSuccessors<'graph, Item = ::Node>, { - fn successors<'graph>( - &'graph self, + fn successors( + &self, node: Self::Node, - ) -> >::Iter; + ) -> >::Iter; } pub trait GraphSuccessors<'graph> { @@ -36,10 +36,10 @@ pub trait WithPredecessors: DirectedGraph where Self: for<'graph> GraphPredecessors<'graph, Item = ::Node>, { - fn predecessors<'graph>( - &'graph self, + fn predecessors( + &self, node: Self::Node, - ) -> >::Iter; + ) -> >::Iter; } pub trait GraphPredecessors<'graph> { diff --git a/src/librustc_data_structures/graph/reference.rs b/src/librustc_data_structures/graph/reference.rs index 5ad2a71e1d732..9442bb3cdec3b 100644 --- a/src/librustc_data_structures/graph/reference.rs +++ b/src/librustc_data_structures/graph/reference.rs @@ -17,15 +17,15 @@ impl<'graph, G: WithStartNode> WithStartNode for &'graph G { } impl<'graph, G: WithSuccessors> WithSuccessors for &'graph G { - fn successors<'iter>(&'iter self, node: Self::Node) -> >::Iter { + fn successors(&self, node: Self::Node) -> >::Iter { (**self).successors(node) } } impl<'graph, G: WithPredecessors> WithPredecessors for &'graph G { - fn predecessors<'iter>(&'iter self, - node: Self::Node) - -> >::Iter { + fn predecessors(&self, + node: Self::Node) + -> >::Iter { (**self).predecessors(node) } } diff --git a/src/librustc_data_structures/graph/test.rs b/src/librustc_data_structures/graph/test.rs index b390c41957294..bc142144e930f 100644 --- a/src/librustc_data_structures/graph/test.rs +++ b/src/librustc_data_structures/graph/test.rs @@ -51,15 +51,15 @@ impl WithNumNodes for TestGraph { } impl WithPredecessors for TestGraph { - fn predecessors<'graph>(&'graph self, - node: usize) - -> >::Iter { + fn predecessors(&self, + node: usize) + -> >::Iter { self.predecessors[&node].iter().cloned() } } impl WithSuccessors for TestGraph { - fn successors<'graph>(&'graph self, node: usize) -> >::Iter { + fn successors(&self, node: usize) -> >::Iter { self.successors[&node].iter().cloned() } } diff --git a/src/librustc_data_structures/transitive_relation.rs b/src/librustc_data_structures/transitive_relation.rs index 0974607fabea8..d7cbd1e2e4b47 100644 --- a/src/librustc_data_structures/transitive_relation.rs +++ b/src/librustc_data_structures/transitive_relation.rs @@ -58,6 +58,10 @@ impl TransitiveRelation { self.edges.is_empty() } + pub fn elements(&self) -> impl Iterator { + self.elements.iter() + } + fn index(&self, a: &T) -> Option { self.map.get(a).cloned() } diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index d92f3aafa1c7e..9f0e90e5214fe 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -188,7 +188,7 @@ impl PpSourceMode { _ => panic!("Should use call_with_pp_support_hir"), } } - fn call_with_pp_support_hir<'tcx, A, F>(&self, tcx: TyCtxt<'tcx>, f: F) -> A + fn call_with_pp_support_hir(&self, tcx: TyCtxt<'_>, f: F) -> A where F: FnOnce(&dyn HirPrinterSupport<'_>, &hir::Crate) -> A, { @@ -228,7 +228,7 @@ impl PpSourceMode { trait PrinterSupport: pprust::PpAnn { /// Provides a uniform interface for re-extracting a reference to a /// `Session` from a value that now owns it. - fn sess<'a>(&'a self) -> &'a Session; + fn sess(&self) -> &Session; /// Produces the pretty-print annotation object. /// @@ -240,7 +240,7 @@ trait PrinterSupport: pprust::PpAnn { trait HirPrinterSupport<'hir>: pprust_hir::PpAnn { /// Provides a uniform interface for re-extracting a reference to a /// `Session` from a value that now owns it. - fn sess<'a>(&'a self) -> &'a Session; + fn sess(&self) -> &Session; /// Provides a uniform interface for re-extracting a reference to an /// `hir_map::Map` from a value that now owns it. @@ -272,7 +272,7 @@ struct NoAnn<'hir> { } impl<'hir> PrinterSupport for NoAnn<'hir> { - fn sess<'a>(&'a self) -> &'a Session { + fn sess(&self) -> &Session { self.sess } @@ -282,7 +282,7 @@ impl<'hir> PrinterSupport for NoAnn<'hir> { } impl<'hir> HirPrinterSupport<'hir> for NoAnn<'hir> { - fn sess<'a>(&'a self) -> &'a Session { + fn sess(&self) -> &Session { self.sess } @@ -297,12 +297,9 @@ impl<'hir> HirPrinterSupport<'hir> for NoAnn<'hir> { impl<'hir> pprust::PpAnn for NoAnn<'hir> {} impl<'hir> pprust_hir::PpAnn for NoAnn<'hir> { - fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) - -> io::Result<()> { + fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) { if let Some(tcx) = self.tcx { pprust_hir::PpAnn::nested(tcx.hir(), state, nested) - } else { - Ok(()) } } } @@ -313,7 +310,7 @@ struct IdentifiedAnnotation<'hir> { } impl<'hir> PrinterSupport for IdentifiedAnnotation<'hir> { - fn sess<'a>(&'a self) -> &'a Session { + fn sess(&self) -> &Session { self.sess } @@ -323,44 +320,44 @@ impl<'hir> PrinterSupport for IdentifiedAnnotation<'hir> { } impl<'hir> pprust::PpAnn for IdentifiedAnnotation<'hir> { - fn pre(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) -> io::Result<()> { + fn pre(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) { match node { pprust::AnnNode::Expr(_) => s.popen(), - _ => Ok(()), + _ => {} } } - fn post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) -> io::Result<()> { + fn post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) { match node { pprust::AnnNode::Ident(_) | - pprust::AnnNode::Name(_) => Ok(()), + pprust::AnnNode::Name(_) => {}, pprust::AnnNode::Item(item) => { - s.s.space()?; + s.s.space(); s.synth_comment(item.id.to_string()) } pprust::AnnNode::SubItem(id) => { - s.s.space()?; + s.s.space(); s.synth_comment(id.to_string()) } pprust::AnnNode::Block(blk) => { - s.s.space()?; + s.s.space(); s.synth_comment(format!("block {}", blk.id)) } pprust::AnnNode::Expr(expr) => { - s.s.space()?; - s.synth_comment(expr.id.to_string())?; + s.s.space(); + s.synth_comment(expr.id.to_string()); s.pclose() } pprust::AnnNode::Pat(pat) => { - s.s.space()?; - s.synth_comment(format!("pat {}", pat.id)) + s.s.space(); + s.synth_comment(format!("pat {}", pat.id)); } } } } impl<'hir> HirPrinterSupport<'hir> for IdentifiedAnnotation<'hir> { - fn sess<'a>(&'a self) -> &'a Session { + fn sess(&self) -> &Session { self.sess } @@ -374,45 +371,42 @@ impl<'hir> HirPrinterSupport<'hir> for IdentifiedAnnotation<'hir> { } impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> { - fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) - -> io::Result<()> { + fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) { if let Some(ref tcx) = self.tcx { pprust_hir::PpAnn::nested(tcx.hir(), state, nested) - } else { - Ok(()) } } - fn pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) -> io::Result<()> { + fn pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) { match node { pprust_hir::AnnNode::Expr(_) => s.popen(), - _ => Ok(()), + _ => {} } } - fn post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) -> io::Result<()> { + fn post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) { match node { - pprust_hir::AnnNode::Name(_) => Ok(()), + pprust_hir::AnnNode::Name(_) => {}, pprust_hir::AnnNode::Item(item) => { - s.s.space()?; + s.s.space(); s.synth_comment(format!("hir_id: {} hir local_id: {}", item.hir_id, item.hir_id.local_id.as_u32())) } pprust_hir::AnnNode::SubItem(id) => { - s.s.space()?; + s.s.space(); s.synth_comment(id.to_string()) } pprust_hir::AnnNode::Block(blk) => { - s.s.space()?; + s.s.space(); s.synth_comment(format!("block hir_id: {} hir local_id: {}", blk.hir_id, blk.hir_id.local_id.as_u32())) } pprust_hir::AnnNode::Expr(expr) => { - s.s.space()?; + s.s.space(); s.synth_comment(format!("expr hir_id: {} hir local_id: {}", - expr.hir_id, expr.hir_id.local_id.as_u32()))?; + expr.hir_id, expr.hir_id.local_id.as_u32())); s.pclose() } pprust_hir::AnnNode::Pat(pat) => { - s.s.space()?; + s.s.space(); s.synth_comment(format!("pat hir_id: {} hir local_id: {}", pat.hir_id, pat.hir_id.local_id.as_u32())) } @@ -435,19 +429,19 @@ impl<'a> PrinterSupport for HygieneAnnotation<'a> { } impl<'a> pprust::PpAnn for HygieneAnnotation<'a> { - fn post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) -> io::Result<()> { + fn post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) { match node { pprust::AnnNode::Ident(&ast::Ident { name, span }) => { - s.s.space()?; + s.s.space(); // FIXME #16420: this doesn't display the connections // between syntax contexts s.synth_comment(format!("{}{:?}", name.as_u32(), span.ctxt())) } pprust::AnnNode::Name(&name) => { - s.s.space()?; + s.s.space(); s.synth_comment(name.as_u32().to_string()) } - _ => Ok(()), + _ => {} } } } @@ -458,7 +452,7 @@ struct TypedAnnotation<'a, 'tcx> { } impl<'b, 'tcx> HirPrinterSupport<'tcx> for TypedAnnotation<'b, 'tcx> { - fn sess<'a>(&'a self) -> &'a Session { + fn sess(&self) -> &Session { &self.tcx.sess } @@ -476,32 +470,30 @@ impl<'b, 'tcx> HirPrinterSupport<'tcx> for TypedAnnotation<'b, 'tcx> { } impl<'a, 'tcx> pprust_hir::PpAnn for TypedAnnotation<'a, 'tcx> { - fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) - -> io::Result<()> { + fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) { let old_tables = self.tables.get(); if let pprust_hir::Nested::Body(id) = nested { self.tables.set(self.tcx.body_tables(id)); } - pprust_hir::PpAnn::nested(self.tcx.hir(), state, nested)?; + pprust_hir::PpAnn::nested(self.tcx.hir(), state, nested); self.tables.set(old_tables); - Ok(()) } - fn pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) -> io::Result<()> { + fn pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) { match node { pprust_hir::AnnNode::Expr(_) => s.popen(), - _ => Ok(()), + _ => {} } } - fn post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) -> io::Result<()> { + fn post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) { match node { pprust_hir::AnnNode::Expr(expr) => { - s.s.space()?; - s.s.word("as")?; - s.s.space()?; - s.s.word(self.tables.get().expr_ty(expr).to_string())?; - s.pclose() + s.s.space(); + s.s.word("as"); + s.s.space(); + s.s.word(self.tables.get().expr_ty(expr).to_string()); + s.pclose(); } - _ => Ok(()), + _ => {}, } } } @@ -728,11 +720,11 @@ pub fn print_after_parsing(sess: &Session, let (src, src_name) = get_source(input, sess); let mut rdr = &*src; - let mut out = Vec::new(); + let mut out = String::new(); if let PpmSource(s) = ppm { // Silently ignores an identified node. - let out: &mut dyn Write = &mut out; + let out = &mut out; s.call_with_pp_support(sess, None, move |annotation| { debug!("pretty printing source code {:?}", s); let sess = annotation.sess(); @@ -741,15 +733,15 @@ pub fn print_after_parsing(sess: &Session, krate, src_name, &mut rdr, - box out, + out, annotation.pp_ann(), false) - }).unwrap() + }) } else { unreachable!(); }; - write_output(out, ofile); + write_output(out.into_bytes(), ofile); } pub fn print_after_hir_lowering<'tcx>( @@ -773,12 +765,12 @@ pub fn print_after_hir_lowering<'tcx>( let (src, src_name) = get_source(input, tcx.sess); let mut rdr = &src[..]; - let mut out = Vec::new(); + let mut out = String::new(); match (ppm, opt_uii) { (PpmSource(s), _) => { // Silently ignores an identified node. - let out: &mut dyn Write = &mut out; + let out = &mut out; s.call_with_pp_support(tcx.sess, Some(tcx), move |annotation| { debug!("pretty printing source code {:?}", s); let sess = annotation.sess(); @@ -787,14 +779,14 @@ pub fn print_after_hir_lowering<'tcx>( krate, src_name, &mut rdr, - box out, + out, annotation.pp_ann(), true) }) } (PpmHir(s), None) => { - let out: &mut dyn Write = &mut out; + let out = &mut out; s.call_with_pp_support_hir(tcx, move |annotation, krate| { debug!("pretty printing source code {:?}", s); let sess = annotation.sess(); @@ -803,21 +795,21 @@ pub fn print_after_hir_lowering<'tcx>( krate, src_name, &mut rdr, - box out, + out, annotation.pp_ann()) }) } (PpmHirTree(s), None) => { - let out: &mut dyn Write = &mut out; + let out = &mut out; s.call_with_pp_support_hir(tcx, move |_annotation, krate| { debug!("pretty printing source code {:?}", s); - write!(out, "{:#?}", krate) - }) + *out = format!("{:#?}", krate); + }); } (PpmHir(s), Some(uii)) => { - let out: &mut dyn Write = &mut out; + let out = &mut out; s.call_with_pp_support_hir(tcx, move |annotation, _| { debug!("pretty printing source code {:?}", s); let sess = annotation.sess(); @@ -826,48 +818,46 @@ pub fn print_after_hir_lowering<'tcx>( &sess.parse_sess, src_name, &mut rdr, - box out, + out, annotation.pp_ann()); for node_id in uii.all_matching_node_ids(hir_map) { 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()?; + pp_state.print_node(node); + pp_state.s.space(); let path = annotation.node_path(hir_id) .expect("-Z unpretty missing node paths"); - pp_state.synth_comment(path)?; - pp_state.s.hardbreak()?; + pp_state.synth_comment(path); + pp_state.s.hardbreak(); } - pp_state.s.eof() + pp_state.s.eof(); }) } (PpmHirTree(s), Some(uii)) => { - let out: &mut dyn Write = &mut out; + let out = &mut out; 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 hir_id = tcx.hir().node_to_hir_id(node_id); let node = tcx.hir().get(hir_id); - write!(out, "{:#?}", node)?; + out.push_str(&format!("{:#?}", node)); } - Ok(()) }) } _ => unreachable!(), } - .unwrap(); - write_output(out, ofile); + write_output(out.into_bytes(), ofile); } // In an ideal world, this would be a public function called by the driver after // analysis is performed. However, we want to call `phase_3_run_analysis_passes` // with a different callback than the standard driver, so that isn't easy. // Instead, we call that function ourselves. -fn print_with_analysis<'tcx>( - tcx: TyCtxt<'tcx>, +fn print_with_analysis( + tcx: TyCtxt<'_>, ppm: PpMode, uii: Option, ofile: Option<&Path>, diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs index a2717ab7ad8a9..83a0fb486fd9a 100644 --- a/src/librustc_errors/emitter.rs +++ b/src/librustc_errors/emitter.rs @@ -1635,7 +1635,7 @@ impl Destination { } } - fn writable<'a>(&'a mut self) -> WritableDst<'a> { + fn writable(&mut self) -> WritableDst<'_> { match *self { Destination::Terminal(ref mut t) => WritableDst::Terminal(t), Destination::Buffered(ref mut t) => { diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs index 70bd25a9d5772..1ffee1cdf691f 100644 --- a/src/librustc_errors/lib.rs +++ b/src/librustc_errors/lib.rs @@ -438,14 +438,14 @@ impl Handler { self.err_count.store(0, SeqCst); } - pub fn struct_dummy<'a>(&'a self) -> DiagnosticBuilder<'a> { + pub fn struct_dummy(&self) -> DiagnosticBuilder<'_> { DiagnosticBuilder::new(self, Level::Cancelled, "") } - pub fn struct_span_warn<'a, S: Into>(&'a self, - sp: S, - msg: &str) - -> DiagnosticBuilder<'a> { + pub fn struct_span_warn>(&self, + sp: S, + msg: &str) + -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Warning, msg); result.set_span(sp); if !self.flags.can_emit_warnings { @@ -453,11 +453,11 @@ impl Handler { } result } - pub fn struct_span_warn_with_code<'a, S: Into>(&'a self, - sp: S, - msg: &str, - code: DiagnosticId) - -> DiagnosticBuilder<'a> { + pub fn struct_span_warn_with_code>(&self, + sp: S, + msg: &str, + code: DiagnosticId) + -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Warning, msg); result.set_span(sp); result.code(code); @@ -466,63 +466,63 @@ impl Handler { } result } - pub fn struct_warn<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> { + pub fn struct_warn(&self, msg: &str) -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Warning, msg); if !self.flags.can_emit_warnings { result.cancel(); } result } - pub fn struct_span_err<'a, S: Into>(&'a self, - sp: S, - msg: &str) - -> DiagnosticBuilder<'a> { + pub fn struct_span_err>(&self, + sp: S, + msg: &str) + -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Error, msg); result.set_span(sp); result } - pub fn struct_span_err_with_code<'a, S: Into>(&'a self, - sp: S, - msg: &str, - code: DiagnosticId) - -> DiagnosticBuilder<'a> { + pub fn struct_span_err_with_code>(&self, + sp: S, + msg: &str, + code: DiagnosticId) + -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Error, msg); result.set_span(sp); result.code(code); result } // FIXME: This method should be removed (every error should have an associated error code). - pub fn struct_err<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> { + pub fn struct_err(&self, msg: &str) -> DiagnosticBuilder<'_> { DiagnosticBuilder::new(self, Level::Error, msg) } - pub fn struct_err_with_code<'a>( - &'a self, + pub fn struct_err_with_code( + &self, msg: &str, code: DiagnosticId, - ) -> DiagnosticBuilder<'a> { + ) -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Error, msg); result.code(code); result } - pub fn struct_span_fatal<'a, S: Into>(&'a self, - sp: S, - msg: &str) - -> DiagnosticBuilder<'a> { + pub fn struct_span_fatal>(&self, + sp: S, + msg: &str) + -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Fatal, msg); result.set_span(sp); result } - pub fn struct_span_fatal_with_code<'a, S: Into>(&'a self, - sp: S, - msg: &str, - code: DiagnosticId) - -> DiagnosticBuilder<'a> { + pub fn struct_span_fatal_with_code>(&self, + sp: S, + msg: &str, + code: DiagnosticId) + -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Fatal, msg); result.set_span(sp); result.code(code); result } - pub fn struct_fatal<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> { + pub fn struct_fatal(&self, msg: &str) -> DiagnosticBuilder<'_> { DiagnosticBuilder::new(self, Level::Fatal, msg) } @@ -563,10 +563,10 @@ impl Handler { pub fn span_err>(&self, sp: S, msg: &str) { self.emit(&sp.into(), msg, Error); } - pub fn mut_span_err<'a, S: Into>(&'a self, - sp: S, - msg: &str) - -> DiagnosticBuilder<'a> { + pub fn mut_span_err>(&self, + sp: S, + msg: &str) + -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Error, msg); result.set_span(sp); result @@ -605,10 +605,10 @@ impl Handler { pub fn span_note_without_error>(&self, sp: S, msg: &str) { self.emit(&sp.into(), msg, Note); } - pub fn span_note_diag<'a>(&'a self, - sp: Span, - msg: &str) - -> DiagnosticBuilder<'a> { + pub fn span_note_diag(&self, + sp: Span, + msg: &str) + -> DiagnosticBuilder<'_> { let mut db = DiagnosticBuilder::new(self, Note, msg); db.set_span(sp); db diff --git a/src/librustc_incremental/assert_dep_graph.rs b/src/librustc_incremental/assert_dep_graph.rs index a43347a2197c3..38dc6edaf6325 100644 --- a/src/librustc_incremental/assert_dep_graph.rs +++ b/src/librustc_incremental/assert_dep_graph.rs @@ -51,7 +51,7 @@ use std::io::Write; use syntax::ast; use syntax_pos::Span; -pub fn assert_dep_graph<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn assert_dep_graph(tcx: TyCtxt<'_>) { tcx.dep_graph.with_ignore(|| { if tcx.sess.opts.debugging_opts.dump_dep_graph { dump_graph(tcx); diff --git a/src/librustc_incremental/assert_module_sources.rs b/src/librustc_incremental/assert_module_sources.rs index f502d0475460e..046fdc72270db 100644 --- a/src/librustc_incremental/assert_module_sources.rs +++ b/src/librustc_incremental/assert_module_sources.rs @@ -35,7 +35,7 @@ const MODULE: Symbol = sym::module; const CFG: Symbol = sym::cfg; const KIND: Symbol = sym::kind; -pub fn assert_module_sources<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn assert_module_sources(tcx: TyCtxt<'_>) { tcx.dep_graph.with_ignore(|| { if tcx.sess.opts.incremental.is_none() { return; diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 5296ed0ffd0b8..1d83aa112a837 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -206,7 +206,7 @@ impl Assertion { } } -pub fn check_dirty_clean_annotations<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) { // can't add `#[rustc_dirty]` etc without opting in to this feature if !tcx.features().rustc_attrs { return; diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs index d9bcc0b2a83c7..90aefb0f32416 100644 --- a/src/librustc_incremental/persist/load.rs +++ b/src/librustc_incremental/persist/load.rs @@ -15,7 +15,7 @@ use super::fs::*; use super::file_format; use super::work_product; -pub fn dep_graph_tcx_init<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn dep_graph_tcx_init(tcx: TyCtxt<'_>) { if !tcx.dep_graph.is_fully_enabled() { return } @@ -192,7 +192,7 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture { })) } -pub fn load_query_result_cache<'sess>(sess: &'sess Session) -> OnDiskCache<'sess> { +pub fn load_query_result_cache(sess: &Session) -> OnDiskCache<'_> { if sess.opts.incremental.is_none() || !sess.opts.debugging_opts.incremental_queries { return OnDiskCache::new_empty(sess.source_map()); diff --git a/src/librustc_incremental/persist/save.rs b/src/librustc_incremental/persist/save.rs index 49c79ec09f5e2..13e2c5d1c574d 100644 --- a/src/librustc_incremental/persist/save.rs +++ b/src/librustc_incremental/persist/save.rs @@ -15,7 +15,7 @@ use super::dirty_clean; use super::file_format; use super::work_product; -pub fn save_dep_graph<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn save_dep_graph(tcx: TyCtxt<'_>) { debug!("save_dep_graph()"); tcx.dep_graph.with_ignore(|| { let sess = tcx.sess; diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs index c1b6e3409c915..d698728198130 100644 --- a/src/librustc_interface/passes.rs +++ b/src/librustc_interface/passes.rs @@ -878,7 +878,7 @@ pub fn create_global_ctxt( /// Runs the resolution, type-checking, region checking and other /// miscellaneous analysis passes on the crate. -fn analysis<'tcx>(tcx: TyCtxt<'tcx>, cnum: CrateNum) -> Result<()> { +fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> { assert_eq!(cnum, LOCAL_CRATE); let sess = tcx.sess; @@ -995,8 +995,8 @@ fn analysis<'tcx>(tcx: TyCtxt<'tcx>, cnum: CrateNum) -> Result<()> { Ok(()) } -fn encode_and_write_metadata<'tcx>( - tcx: TyCtxt<'tcx>, +fn encode_and_write_metadata( + tcx: TyCtxt<'_>, outputs: &OutputFilenames, ) -> (middle::cstore::EncodedMetadata, bool) { #[derive(PartialEq, Eq, PartialOrd, Ord)] diff --git a/src/librustc_interface/proc_macro_decls.rs b/src/librustc_interface/proc_macro_decls.rs index 9e1ef6b022d9b..d888c9e57d326 100644 --- a/src/librustc_interface/proc_macro_decls.rs +++ b/src/librustc_interface/proc_macro_decls.rs @@ -6,11 +6,11 @@ use rustc::ty::query::Providers; use syntax::attr; use syntax::symbol::sym; -pub fn find<'tcx>(tcx: TyCtxt<'tcx>) -> Option { +pub fn find(tcx: TyCtxt<'_>) -> Option { tcx.proc_macro_decls_static(LOCAL_CRATE) } -fn proc_macro_decls_static<'tcx>(tcx: TyCtxt<'tcx>, cnum: CrateNum) -> Option { +fn proc_macro_decls_static(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option { assert_eq!(cnum, LOCAL_CRATE); let mut finder = Finder { decls: None }; diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index d808a15982e37..951c7b6d7213e 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -31,6 +31,7 @@ mod nonstandard_style; pub mod builtin; mod types; mod unused; +mod non_ascii_idents; use rustc::lint; use rustc::lint::{EarlyContext, LateContext, LateLintPass, EarlyLintPass, LintPass, LintArray}; @@ -62,6 +63,7 @@ use nonstandard_style::*; use builtin::*; use types::*; use unused::*; +use non_ascii_idents::*; use rustc::lint::internal::*; /// Useful for other parts of the compiler. @@ -74,7 +76,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn lint_mod<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn lint_mod(tcx: TyCtxt<'_>, module_def_id: DefId) { lint::late_lint_mod(tcx, module_def_id, BuiltinCombinedModuleLateLintPass::new()); } @@ -97,6 +99,7 @@ macro_rules! early_lint_passes { EllipsisInclusiveRangePatterns: EllipsisInclusiveRangePatterns::default(), NonCamelCaseTypes: NonCamelCaseTypes, DeprecatedAttr: DeprecatedAttr::new(), + NonAsciiIdents: NonAsciiIdents, ]); ) } diff --git a/src/librustc_lint/non_ascii_idents.rs b/src/librustc_lint/non_ascii_idents.rs new file mode 100644 index 0000000000000..dd876505d3e44 --- /dev/null +++ b/src/librustc_lint/non_ascii_idents.rs @@ -0,0 +1,23 @@ +use crate::lint::{EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; +use syntax::ast; + +declare_lint! { + pub NON_ASCII_IDENTS, + Allow, + "detects non-ASCII identifiers" +} + +declare_lint_pass!(NonAsciiIdents => [NON_ASCII_IDENTS]); + +impl EarlyLintPass for NonAsciiIdents { + fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: ast::Ident) { + if !ident.name.as_str().is_ascii() { + let mut err = cx.struct_span_lint( + NON_ASCII_IDENTS, + ident.span, + "identifier contains non-ASCII characters", + ); + err.emit(); + } + } +} diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index 04a9c4e9a1a11..914084d7e9ece 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -250,7 +250,7 @@ provide! { <'tcx> tcx, def_id, other, cdata, exported_symbols => { Arc::new(cdata.exported_symbols(tcx)) } } -pub fn provide<'tcx>(providers: &mut Providers<'tcx>) { +pub fn provide(providers: &mut Providers<'_>) { // FIXME(#44234) - almost all of these queries have no sub-queries and // therefore no actual inputs, they're just reading tables calculated in // resolve! Does this work? Unsure! That's what the issue is about @@ -550,7 +550,7 @@ impl CrateStore for cstore::CStore { self.do_postorder_cnums_untracked() } - fn encode_metadata<'tcx>(&self, tcx: TyCtxt<'tcx>) -> EncodedMetadata { + fn encode_metadata(&self, tcx: TyCtxt<'_>) -> EncodedMetadata { encoder::encode_metadata(tcx) } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index b52b6dfbb5e12..73c20ccad5abf 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -1863,7 +1863,7 @@ impl<'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'tcx> { // will allow us to slice the metadata to the precise length that we just // generated regardless of trailing bytes that end up in it. -pub fn encode_metadata<'tcx>(tcx: TyCtxt<'tcx>) -> EncodedMetadata { +pub fn encode_metadata(tcx: TyCtxt<'_>) -> EncodedMetadata { let mut encoder = opaque::Encoder::new(vec![]); encoder.emit_raw_bytes(METADATA_HEADER); @@ -1905,7 +1905,7 @@ pub fn encode_metadata<'tcx>(tcx: TyCtxt<'tcx>) -> EncodedMetadata { EncodedMetadata { raw_data: result } } -pub fn get_repr_options<'tcx>(tcx: TyCtxt<'tcx>, did: DefId) -> ReprOptions { +pub fn get_repr_options(tcx: TyCtxt<'_>, did: DefId) -> ReprOptions { let ty = tcx.type_of(did); match ty.sty { ty::Adt(ref def, _) => return def.repr, diff --git a/src/librustc_metadata/foreign_modules.rs b/src/librustc_metadata/foreign_modules.rs index 0ce103cfa40dc..b1f4dfffc7898 100644 --- a/src/librustc_metadata/foreign_modules.rs +++ b/src/librustc_metadata/foreign_modules.rs @@ -3,7 +3,7 @@ use rustc::hir; use rustc::middle::cstore::ForeignModule; use rustc::ty::TyCtxt; -pub fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> Vec { +pub fn collect(tcx: TyCtxt<'_>) -> Vec { let mut collector = Collector { tcx, modules: Vec::new(), diff --git a/src/librustc_metadata/link_args.rs b/src/librustc_metadata/link_args.rs index cd6270046faab..728fd004fcb69 100644 --- a/src/librustc_metadata/link_args.rs +++ b/src/librustc_metadata/link_args.rs @@ -4,7 +4,7 @@ use rustc::ty::TyCtxt; use rustc_target::spec::abi::Abi; use syntax::symbol::sym; -pub fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> Vec { +pub fn collect(tcx: TyCtxt<'_>) -> Vec { let mut collector = Collector { args: Vec::new(), }; diff --git a/src/librustc_metadata/native_libs.rs b/src/librustc_metadata/native_libs.rs index 7b335b3b4832d..4a01d0e559af4 100644 --- a/src/librustc_metadata/native_libs.rs +++ b/src/librustc_metadata/native_libs.rs @@ -11,7 +11,7 @@ use syntax::feature_gate::{self, GateIssue}; use syntax::symbol::{Symbol, sym}; use syntax::{span_err, struct_span_err}; -pub fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> Vec { +pub fn collect(tcx: TyCtxt<'_>) -> Vec { let mut collector = Collector { tcx, libs: Vec::new(), diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs index 4872440f5bd4a..0072fcb22f13e 100644 --- a/src/librustc_mir/borrow_check/mod.rs +++ b/src/librustc_mir/borrow_check/mod.rs @@ -87,7 +87,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn mir_borrowck<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> BorrowCheckResult<'tcx> { +fn mir_borrowck(tcx: TyCtxt<'_>, def_id: DefId) -> BorrowCheckResult<'_> { let input_body = tcx.mir_validated(def_id); debug!("run query mir_borrowck: {}", tcx.def_path_str(def_id)); diff --git a/src/librustc_mir/borrow_check/nll/constraints/graph.rs b/src/librustc_mir/borrow_check/nll/constraints/graph.rs index c4b2a5daef89a..081dc8c7e7188 100644 --- a/src/librustc_mir/borrow_check/nll/constraints/graph.rs +++ b/src/librustc_mir/borrow_check/nll/constraints/graph.rs @@ -234,10 +234,10 @@ impl<'s, D: ConstraintGraphDirecton> graph::WithNumNodes for RegionGraph<'s, D> } impl<'s, D: ConstraintGraphDirecton> graph::WithSuccessors for RegionGraph<'s, D> { - fn successors<'graph>( - &'graph self, + fn successors( + &self, node: Self::Node, - ) -> >::Iter { + ) -> >::Iter { self.outgoing_regions(node) } } diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs index 41ed564d0f0e1..a4fa1d98255ba 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs @@ -809,7 +809,6 @@ impl<'tcx> RegionInferenceContext<'tcx> { ty: Ty<'tcx>, ) -> Option> { let tcx = infcx.tcx; - let gcx = tcx.global_tcx(); debug!("try_promote_type_test_subject(ty = {:?})", ty); @@ -863,8 +862,10 @@ impl<'tcx> RegionInferenceContext<'tcx> { }); debug!("try_promote_type_test_subject: folded ty = {:?}", ty); - // `lift_to_global` will only fail if we failed to promote some region. - gcx.lift_to_global(&ty)?; + // `has_local_value` will only be true if we failed to promote some region. + if ty.has_local_value() { + return None; + } Some(ClosureOutlivesSubject::Ty(ty)) } diff --git a/src/librustc_mir/borrow_check/nll/region_infer/values.rs b/src/librustc_mir/borrow_check/nll/region_infer/values.rs index cfd80cecca510..6f9f5707935ba 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/values.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/values.rs @@ -162,7 +162,7 @@ impl LivenessValues { } /// Iterate through each region that has a value in this set. - crate fn rows<'a>(&'a self) -> impl Iterator { + crate fn rows(&self) -> impl Iterator { self.points.rows() } diff --git a/src/librustc_mir/borrow_check/path_utils.rs b/src/librustc_mir/borrow_check/path_utils.rs index aa2b177e54ed8..538ac6881d90a 100644 --- a/src/librustc_mir/borrow_check/path_utils.rs +++ b/src/librustc_mir/borrow_check/path_utils.rs @@ -130,7 +130,7 @@ pub(super) fn is_active<'tcx>( /// Determines if a given borrow is borrowing local data /// This is called for all Yield statements on movable generators -pub(super) fn borrow_of_local_data<'tcx>(place: &Place<'tcx>) -> bool { +pub(super) fn borrow_of_local_data(place: &Place<'_>) -> bool { place.iterate(|place_base, place_projection| { match place_base { PlaceBase::Static(..) => return false, diff --git a/src/librustc_mir/build/expr/category.rs b/src/librustc_mir/build/expr/category.rs index 222ce6d1c968e..f679a00035d76 100644 --- a/src/librustc_mir/build/expr/category.rs +++ b/src/librustc_mir/build/expr/category.rs @@ -31,7 +31,7 @@ pub enum RvalueFunc { /// Determines the category for a given expression. Note that scope /// and paren expressions have no category. impl Category { - pub fn of<'tcx>(ek: &ExprKind<'tcx>) -> Option { + pub fn of(ek: &ExprKind<'_>) -> Option { match *ek { ExprKind::Scope { .. } => None, diff --git a/src/librustc_mir/build/matches/test.rs b/src/librustc_mir/build/matches/test.rs index 95e2e52092a91..528dfbef6946a 100644 --- a/src/librustc_mir/build/matches/test.rs +++ b/src/librustc_mir/build/matches/test.rs @@ -826,6 +826,6 @@ impl Test<'_> { } } -fn is_switch_ty<'tcx>(ty: Ty<'tcx>) -> bool { +fn is_switch_ty(ty: Ty<'_>) -> bool { ty.is_integral() || ty.is_char() || ty.is_bool() } diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs index ad970de466cfd..80a035d8287f4 100644 --- a/src/librustc_mir/build/mod.rs +++ b/src/librustc_mir/build/mod.rs @@ -22,7 +22,7 @@ use syntax_pos::Span; use super::lints; /// Construct the MIR for a given `DefId`. -pub fn mir_build<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Body<'tcx> { +pub fn mir_build(tcx: TyCtxt<'_>, def_id: DefId) -> Body<'_> { let id = tcx.hir().as_local_hir_id(def_id).unwrap(); // Figure out what primary body this item has. @@ -171,11 +171,11 @@ pub fn mir_build<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Body<'tcx> { /////////////////////////////////////////////////////////////////////////// // BuildMir -- walks a crate, looking for fn items and methods to build MIR from -fn liberated_closure_env_ty<'tcx>( - tcx: TyCtxt<'tcx>, +fn liberated_closure_env_ty( + tcx: TyCtxt<'_>, closure_expr_id: hir::HirId, body_id: hir::BodyId, -) -> Ty<'tcx> { +) -> Ty<'_> { let closure_ty = tcx.body_tables(body_id).node_type(closure_expr_id); let (closure_def_id, closure_substs) = match closure_ty.sty { @@ -485,7 +485,7 @@ macro_rules! unpack { }; } -fn should_abort_on_panic<'tcx>(tcx: TyCtxt<'tcx>, fn_def_id: DefId, abi: Abi) -> bool { +fn should_abort_on_panic(tcx: TyCtxt<'_>, fn_def_id: DefId, abi: Abi) -> bool { // Not callable from C, so we can safely unwind through these if abi == Abi::Rust || abi == Abi::RustCall { return false; } diff --git a/src/librustc_mir/dataflow/at_location.rs b/src/librustc_mir/dataflow/at_location.rs index 7735528d8f8e0..f0014602e2d6b 100644 --- a/src/librustc_mir/dataflow/at_location.rs +++ b/src/librustc_mir/dataflow/at_location.rs @@ -8,6 +8,7 @@ use crate::dataflow::{BitDenotation, DataflowResults, GenKillSet}; use crate::dataflow::move_paths::{HasMoveData, MovePathIndex}; use std::iter; +use std::borrow::Borrow; /// A trait for "cartesian products" of multiple FlowAtLocation. /// @@ -60,18 +61,20 @@ pub trait FlowsAtLocation { /// (e.g., via `reconstruct_statement_effect` and /// `reconstruct_terminator_effect`; don't forget to call /// `apply_local_effect`). -pub struct FlowAtLocation<'tcx, BD> +pub struct FlowAtLocation<'tcx, BD, DR = DataflowResults<'tcx, BD>> where BD: BitDenotation<'tcx>, + DR: Borrow>, { - base_results: DataflowResults<'tcx, BD>, + base_results: DR, curr_state: BitSet, stmt_trans: GenKillSet, } -impl<'tcx, BD> FlowAtLocation<'tcx, BD> +impl<'tcx, BD, DR> FlowAtLocation<'tcx, BD, DR> where BD: BitDenotation<'tcx>, + DR: Borrow>, { /// Iterate over each bit set in the current state. pub fn each_state_bit(&self, f: F) @@ -91,8 +94,8 @@ where 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(); + pub fn new(results: DR) -> Self { + let bits_per_block = results.borrow().sets().bits_per_block(); let curr_state = BitSet::new_empty(bits_per_block); let stmt_trans = GenKillSet::from_elem(HybridBitSet::new_empty(bits_per_block)); FlowAtLocation { @@ -104,7 +107,7 @@ where /// Access the underlying operator. pub fn operator(&self) -> &BD { - self.base_results.operator() + self.base_results.borrow().operator() } pub fn contains(&self, x: BD::Idx) -> bool { @@ -134,27 +137,31 @@ where } } -impl<'tcx, BD> FlowsAtLocation for FlowAtLocation<'tcx, BD> - where BD: BitDenotation<'tcx> +impl<'tcx, BD, DR> FlowsAtLocation for FlowAtLocation<'tcx, BD, DR> +where + BD: BitDenotation<'tcx>, + DR: Borrow>, { fn reset_to_entry_of(&mut self, bb: BasicBlock) { - self.curr_state.overwrite(self.base_results.sets().entry_set_for(bb.index())); + self.curr_state.overwrite(self.base_results.borrow().sets().entry_set_for(bb.index())); } fn reset_to_exit_of(&mut self, bb: BasicBlock) { self.reset_to_entry_of(bb); - let trans = self.base_results.sets().trans_for(bb.index()); + let trans = self.base_results.borrow().sets().trans_for(bb.index()); trans.apply(&mut self.curr_state) } fn reconstruct_statement_effect(&mut self, loc: Location) { self.stmt_trans.clear(); self.base_results + .borrow() .operator() .before_statement_effect(&mut self.stmt_trans, loc); self.stmt_trans.apply(&mut self.curr_state); self.base_results + .borrow() .operator() .statement_effect(&mut self.stmt_trans, loc); } @@ -162,11 +169,13 @@ impl<'tcx, BD> FlowsAtLocation for FlowAtLocation<'tcx, BD> fn reconstruct_terminator_effect(&mut self, loc: Location) { self.stmt_trans.clear(); self.base_results + .borrow() .operator() .before_terminator_effect(&mut self.stmt_trans, loc); self.stmt_trans.apply(&mut self.curr_state); self.base_results + .borrow() .operator() .terminator_effect(&mut self.stmt_trans, loc); } @@ -177,9 +186,10 @@ impl<'tcx, BD> FlowsAtLocation for FlowAtLocation<'tcx, BD> } -impl<'tcx, T> FlowAtLocation<'tcx, T> +impl<'tcx, T, DR> FlowAtLocation<'tcx, T, DR> where T: HasMoveData<'tcx> + BitDenotation<'tcx, Idx = MovePathIndex>, + DR: Borrow>, { pub fn has_any_child_of(&self, mpi: T::Idx) -> Option { // We process `mpi` before the loop below, for two reasons: diff --git a/src/librustc_mir/dataflow/impls/borrowed_locals.rs b/src/librustc_mir/dataflow/impls/borrowed_locals.rs index 0f7f37f2db8b4..d94ebdbae24ae 100644 --- a/src/librustc_mir/dataflow/impls/borrowed_locals.rs +++ b/src/librustc_mir/dataflow/impls/borrowed_locals.rs @@ -92,7 +92,7 @@ struct BorrowedLocalsVisitor<'gk> { trans: &'gk mut GenKillSet, } -fn find_local<'tcx>(place: &Place<'tcx>) -> Option { +fn find_local(place: &Place<'_>) -> Option { place.iterate(|place_base, place_projection| { for proj in place_projection { if proj.elem == ProjectionElem::Deref { diff --git a/src/librustc_mir/dataflow/impls/storage_liveness.rs b/src/librustc_mir/dataflow/impls/storage_liveness.rs index d2003993d4506..7fa950cb98d34 100644 --- a/src/librustc_mir/dataflow/impls/storage_liveness.rs +++ b/src/librustc_mir/dataflow/impls/storage_liveness.rs @@ -1,7 +1,13 @@ pub use super::*; use rustc::mir::*; +use rustc::mir::visit::{ + PlaceContext, Visitor, NonMutatingUseContext, +}; +use std::cell::RefCell; use crate::dataflow::BitDenotation; +use crate::dataflow::HaveBeenBorrowedLocals; +use crate::dataflow::{DataflowResults, DataflowResultsCursor, DataflowResultsRefCursor}; #[derive(Copy, Clone)] pub struct MaybeStorageLive<'a, 'tcx> { @@ -27,7 +33,9 @@ impl<'a, 'tcx> BitDenotation<'tcx> for MaybeStorageLive<'a, 'tcx> { } fn start_block_effect(&self, _on_entry: &mut BitSet) { - // Nothing is live on function entry + // Nothing is live on function entry (generators only have a self + // argument, and we don't care about that) + assert_eq!(1, self.body.arg_count); } fn statement_effect(&self, @@ -63,3 +71,123 @@ impl<'a, 'tcx> BottomValue for MaybeStorageLive<'a, 'tcx> { /// bottom = dead const BOTTOM_VALUE: bool = false; } + +/// Dataflow analysis that determines whether each local requires storage at a +/// given location; i.e. whether its storage can go away without being observed. +pub struct RequiresStorage<'mir, 'tcx> { + body: &'mir Body<'tcx>, + borrowed_locals: + RefCell>>, +} + +impl<'mir, 'tcx: 'mir> RequiresStorage<'mir, 'tcx> { + pub fn new( + body: &'mir Body<'tcx>, + borrowed_locals: &'mir DataflowResults<'tcx, HaveBeenBorrowedLocals<'mir, 'tcx>>, + ) -> Self { + RequiresStorage { + body, + borrowed_locals: RefCell::new(DataflowResultsCursor::new(borrowed_locals, body)), + } + } + + pub fn body(&self) -> &Body<'tcx> { + self.body + } +} + +impl<'mir, 'tcx> BitDenotation<'tcx> for RequiresStorage<'mir, 'tcx> { + type Idx = Local; + fn name() -> &'static str { "requires_storage" } + fn bits_per_block(&self) -> usize { + self.body.local_decls.len() + } + + fn start_block_effect(&self, _sets: &mut BitSet) { + // Nothing is live on function entry (generators only have a self + // argument, and we don't care about that) + assert_eq!(1, self.body.arg_count); + } + + fn statement_effect(&self, + sets: &mut GenKillSet, + loc: Location) { + self.check_for_move(sets, loc); + self.check_for_borrow(sets, loc); + + 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::Assign(ref place, _) + | StatementKind::SetDiscriminant { ref place, .. } => { + place.base_local().map(|l| sets.gen(l)); + } + StatementKind::InlineAsm(box InlineAsm { ref outputs, .. }) => { + for p in &**outputs { + p.base_local().map(|l| sets.gen(l)); + } + } + _ => (), + } + } + + fn terminator_effect(&self, + sets: &mut GenKillSet, + loc: Location) { + self.check_for_move(sets, loc); + self.check_for_borrow(sets, loc); + } + + fn propagate_call_return( + &self, + in_out: &mut BitSet, + _call_bb: mir::BasicBlock, + _dest_bb: mir::BasicBlock, + dest_place: &mir::Place<'tcx>, + ) { + dest_place.base_local().map(|l| in_out.insert(l)); + } +} + +impl<'mir, 'tcx> RequiresStorage<'mir, 'tcx> { + /// Kill locals that are fully moved and have not been borrowed. + fn check_for_move(&self, sets: &mut GenKillSet, loc: Location) { + let mut visitor = MoveVisitor { + sets, + borrowed_locals: &self.borrowed_locals, + }; + visitor.visit_location(self.body, loc); + } + + /// Gen locals that are newly borrowed. This includes borrowing any part of + /// a local (we rely on this behavior of `HaveBeenBorrowedLocals`). + fn check_for_borrow(&self, sets: &mut GenKillSet, loc: Location) { + let mut borrowed_locals = self.borrowed_locals.borrow_mut(); + borrowed_locals.seek(loc); + borrowed_locals.each_gen_bit(|l| sets.gen(l)); + } +} + +impl<'mir, 'tcx> BottomValue for RequiresStorage<'mir, 'tcx> { + /// bottom = dead + const BOTTOM_VALUE: bool = false; +} + +struct MoveVisitor<'a, 'mir, 'tcx> { + borrowed_locals: + &'a RefCell>>, + sets: &'a mut GenKillSet, +} + +impl<'a, 'mir: 'a, 'tcx> Visitor<'tcx> for MoveVisitor<'a, 'mir, 'tcx> { + fn visit_local(&mut self, local: &Local, context: PlaceContext, loc: Location) { + if PlaceContext::NonMutatingUse(NonMutatingUseContext::Move) == context { + let mut borrowed_locals = self.borrowed_locals.borrow_mut(); + borrowed_locals.seek(loc); + if !borrowed_locals.contains(*local) { + self.sets.kill(*local); + } + } + } +} diff --git a/src/librustc_mir/dataflow/mod.rs b/src/librustc_mir/dataflow/mod.rs index 6cdd9de8b954d..5433a9013aa85 100644 --- a/src/librustc_mir/dataflow/mod.rs +++ b/src/librustc_mir/dataflow/mod.rs @@ -17,7 +17,7 @@ use std::io; use std::path::PathBuf; use std::usize; -pub use self::impls::{MaybeStorageLive}; +pub use self::impls::{MaybeStorageLive, RequiresStorage}; pub use self::impls::{MaybeInitializedPlaces, MaybeUninitializedPlaces}; pub use self::impls::DefinitelyInitializedPlaces; pub use self::impls::EverInitializedPlaces; @@ -360,6 +360,99 @@ pub(crate) trait DataflowResultsConsumer<'a, 'tcx: 'a> { fn body(&self) -> &'a Body<'tcx>; } +/// Allows iterating dataflow results in a flexible and reasonably fast way. +pub struct DataflowResultsCursor<'mir, 'tcx, BD, DR = DataflowResults<'tcx, BD>> +where + BD: BitDenotation<'tcx>, + DR: Borrow>, +{ + flow_state: FlowAtLocation<'tcx, BD, DR>, + + // The statement (or terminator) whose effect has been reconstructed in + // flow_state. + curr_loc: Option, + + body: &'mir Body<'tcx>, +} + +pub type DataflowResultsRefCursor<'mir, 'tcx, BD> = + DataflowResultsCursor<'mir, 'tcx, BD, &'mir DataflowResults<'tcx, BD>>; + +impl<'mir, 'tcx, BD, DR> DataflowResultsCursor<'mir, 'tcx, BD, DR> +where + BD: BitDenotation<'tcx>, + DR: Borrow>, +{ + pub fn new(result: DR, body: &'mir Body<'tcx>) -> Self { + DataflowResultsCursor { + flow_state: FlowAtLocation::new(result), + curr_loc: None, + body, + } + } + + /// Seek to the given location in MIR. This method is fast if you are + /// traversing your MIR statements in order. + /// + /// After calling `seek`, the current state will reflect all effects up to + /// and including the `before_statement_effect` of the statement at location + /// `loc`. The `statement_effect` of the statement at `loc` will be + /// available as the current effect (see e.g. `each_gen_bit`). + /// + /// If `loc.statement_index` equals the number of statements in the block, + /// we will reconstruct the terminator effect in the same way as described + /// above. + pub fn seek(&mut self, loc: Location) { + if self.curr_loc.map(|cur| loc == cur).unwrap_or(false) { + return; + } + + let start_index; + let should_reset = match self.curr_loc { + None => true, + Some(cur) + if loc.block != cur.block || loc.statement_index < cur.statement_index => true, + _ => false, + }; + if should_reset { + self.flow_state.reset_to_entry_of(loc.block); + start_index = 0; + } else { + let curr_loc = self.curr_loc.unwrap(); + start_index = curr_loc.statement_index; + // Apply the effect from the last seek to the current state. + self.flow_state.apply_local_effect(curr_loc); + } + + for stmt in start_index..loc.statement_index { + let mut stmt_loc = loc; + stmt_loc.statement_index = stmt; + self.flow_state.reconstruct_statement_effect(stmt_loc); + self.flow_state.apply_local_effect(stmt_loc); + } + + if loc.statement_index == self.body[loc.block].statements.len() { + self.flow_state.reconstruct_terminator_effect(loc); + } else { + self.flow_state.reconstruct_statement_effect(loc); + } + self.curr_loc = Some(loc); + } + + /// Return whether the current state contains bit `x`. + pub fn contains(&self, x: BD::Idx) -> bool { + self.flow_state.contains(x) + } + + /// Iterate over each `gen` bit in the current effect (invoke `seek` first). + pub fn each_gen_bit(&self, f: F) + where + F: FnMut(BD::Idx), + { + self.flow_state.each_gen_bit(f) + } +} + pub fn state_for_location<'tcx, T: BitDenotation<'tcx>>(loc: Location, analysis: &T, result: &DataflowResults<'tcx, T>, diff --git a/src/librustc_mir/hair/cx/to_ref.rs b/src/librustc_mir/hair/cx/to_ref.rs index 946d66fc91d7d..c365cc2ad8544 100644 --- a/src/librustc_mir/hair/cx/to_ref.rs +++ b/src/librustc_mir/hair/cx/to_ref.rs @@ -1,7 +1,7 @@ use crate::hair::*; use rustc::hir; -use syntax::ptr::P; +use rustc::hir::ptr::P; pub trait ToRef { type Output; diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs index fc2951895f3fe..d356194c00343 100644 --- a/src/librustc_mir/hair/pattern/_match.rs +++ b/src/librustc_mir/hair/pattern/_match.rs @@ -835,7 +835,7 @@ impl<'tcx> IntRange<'tcx> { fn from_ctor(tcx: TyCtxt<'tcx>, ctor: &Constructor<'tcx>) -> Option> { // Floating-point ranges are permitted and we don't want // to consider them when constructing integer ranges. - fn is_integral<'tcx>(ty: Ty<'tcx>) -> bool { + fn is_integral(ty: Ty<'_>) -> bool { match ty.sty { ty::Char | ty::Int(_) | ty::Uint(_) => true, _ => false, diff --git a/src/librustc_mir/hair/pattern/check_match.rs b/src/librustc_mir/hair/pattern/check_match.rs index ed850379af60b..915ce9f20d07d 100644 --- a/src/librustc_mir/hair/pattern/check_match.rs +++ b/src/librustc_mir/hair/pattern/check_match.rs @@ -18,15 +18,15 @@ use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc::hir::def::*; use rustc::hir::def_id::DefId; use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap}; +use rustc::hir::ptr::P; use rustc::hir::{self, Pat, PatKind}; use smallvec::smallvec; use std::slice; -use syntax::ptr::P; use syntax_pos::{Span, DUMMY_SP, MultiSpan}; -pub(crate) fn check_match<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +pub(crate) fn check_match(tcx: TyCtxt<'_>, def_id: DefId) { let body_id = if let Some(id) = tcx.hir().as_local_hir_id(def_id) { tcx.hir().body_owned_by(id) } else { @@ -43,7 +43,7 @@ pub(crate) fn check_match<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { }.visit_body(tcx.hir().body(body_id)); } -fn create_e0004<'a>(sess: &'a Session, sp: Span, error_message: String) -> DiagnosticBuilder<'a> { +fn create_e0004(sess: &Session, sp: Span, error_message: String) -> DiagnosticBuilder<'_> { struct_span_err!(sess, sp, E0004, "{}", &error_message) } diff --git a/src/librustc_mir/hair/pattern/mod.rs b/src/librustc_mir/hair/pattern/mod.rs index cf597ce0b6319..6ba2f58776849 100644 --- a/src/librustc_mir/hair/pattern/mod.rs +++ b/src/librustc_mir/hair/pattern/mod.rs @@ -20,13 +20,13 @@ use rustc::ty::layout::{VariantIdx, Size}; use rustc::hir::{self, PatKind, RangeEnd}; use rustc::hir::def::{CtorOf, Res, DefKind, CtorKind}; use rustc::hir::pat_util::EnumerateAndAdjustIterator; +use rustc::hir::ptr::P; use rustc_data_structures::indexed_vec::Idx; use std::cmp::Ordering; use std::fmt; use syntax::ast; -use syntax::ptr::P; use syntax::symbol::sym; use syntax_pos::Span; diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index bb2738d5aa4a3..097d76925c8eb 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -281,10 +281,10 @@ impl<'tcx> InliningMap<'tcx> { } } -pub fn collect_crate_mono_items<'tcx>( - tcx: TyCtxt<'tcx>, +pub fn collect_crate_mono_items( + tcx: TyCtxt<'_>, mode: MonoItemCollectionMode, -) -> (FxHashSet>, InliningMap<'tcx>) { +) -> (FxHashSet>, InliningMap<'_>) { let roots = time(tcx.sess, "collecting roots", || { collect_roots(tcx, mode) }); @@ -315,7 +315,7 @@ pub fn collect_crate_mono_items<'tcx>( // Find all non-generic items by walking the HIR. These items serve as roots to // start monomorphizing from. -fn collect_roots<'tcx>(tcx: TyCtxt<'tcx>, mode: MonoItemCollectionMode) -> Vec> { +fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionMode) -> Vec> { debug!("Collecting roots"); let mut roots = Vec::new(); @@ -912,7 +912,7 @@ fn find_vtable_types_for_unsizing<'tcx>( } } -fn create_fn_mono_item<'tcx>(instance: Instance<'tcx>) -> MonoItem<'tcx> { +fn create_fn_mono_item(instance: Instance<'_>) -> MonoItem<'_> { debug!("create_fn_mono_item(instance={})", instance); MonoItem::Fn(instance) } @@ -1114,7 +1114,7 @@ impl RootCollector<'_, 'v> { } } -fn item_requires_monomorphization<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { +fn item_requires_monomorphization(tcx: TyCtxt<'_>, def_id: DefId) -> bool { let generics = tcx.generics_of(def_id); generics.requires_monomorphization(tcx) } @@ -1243,7 +1243,7 @@ fn collect_neighbours<'tcx>( } } -fn def_id_to_string<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> String { +fn def_id_to_string(tcx: TyCtxt<'_>, def_id: DefId) -> String { let mut output = String::new(); let printer = DefPathBasedNames::new(tcx, false, false); printer.push_def_path(def_id, &mut output); diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs index 32e4d4f437a78..a934c921d9257 100644 --- a/src/librustc_mir/monomorphize/partitioning.rs +++ b/src/librustc_mir/monomorphize/partitioning.rs @@ -839,10 +839,10 @@ where } } -fn collect_and_partition_mono_items<'tcx>( - tcx: TyCtxt<'tcx>, +fn collect_and_partition_mono_items( + tcx: TyCtxt<'_>, cnum: CrateNum, -) -> (Arc, Arc>>>) { +) -> (Arc, Arc>>>) { assert_eq!(cnum, LOCAL_CRATE); let collection_mode = match tcx.sess.opts.debugging_opts.print_mono_items { diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs index 7987095a33401..32b964dbadfa9 100644 --- a/src/librustc_mir/shim.rs +++ b/src/librustc_mir/shim.rs @@ -829,7 +829,7 @@ fn build_call_shim<'tcx>( body } -pub fn build_adt_ctor<'tcx>(tcx: TyCtxt<'tcx>, ctor_id: DefId) -> &'tcx Body<'tcx> { +pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> &Body<'_> { debug_assert!(tcx.is_constructor(ctor_id)); let span = tcx.hir().span_if_local(ctor_id) diff --git a/src/librustc_mir/transform/add_retag.rs b/src/librustc_mir/transform/add_retag.rs index e01017d7c9bdb..de5af0a46b534 100644 --- a/src/librustc_mir/transform/add_retag.rs +++ b/src/librustc_mir/transform/add_retag.rs @@ -14,8 +14,8 @@ pub struct AddRetag; /// after the assignment, we can be sure to obtain the same place value. /// (Concurrent accesses by other threads are no problem as these are anyway non-atomic /// copies. Data races are UB.) -fn is_stable<'tcx>( - place: &Place<'tcx>, +fn is_stable( + place: &Place<'_>, ) -> bool { use rustc::mir::Place::*; diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs index 24df3549be481..9898ba897734d 100644 --- a/src/librustc_mir/transform/check_unsafety.rs +++ b/src/librustc_mir/transform/check_unsafety.rs @@ -480,11 +480,11 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UnusedUnsafeVisitor<'a> { } } -fn check_unused_unsafe<'a, 'tcx>( - tcx: TyCtxt<'tcx>, +fn check_unused_unsafe( + tcx: TyCtxt<'_>, def_id: DefId, used_unsafe: &FxHashSet, - unsafe_blocks: &'a mut Vec<(hir::HirId, bool)>, + unsafe_blocks: &mut Vec<(hir::HirId, bool)>, ) { let body_id = tcx.hir().as_local_hir_id(def_id).and_then(|hir_id| { @@ -506,7 +506,7 @@ fn check_unused_unsafe<'a, 'tcx>( hir::intravisit::Visitor::visit_body(&mut visitor, body); } -fn unsafety_check_result<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> UnsafetyCheckResult { +fn unsafety_check_result(tcx: TyCtxt<'_>, def_id: DefId) -> UnsafetyCheckResult { debug!("unsafety_violations({:?})", def_id); // N.B., this borrow is valid because all the consumers of @@ -545,7 +545,7 @@ fn unsafety_check_result<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> UnsafetyChec } } -fn unsafe_derive_on_repr_packed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +fn unsafe_derive_on_repr_packed(tcx: TyCtxt<'_>, def_id: DefId) { let lint_hir_id = tcx.hir().as_local_hir_id(def_id).unwrap_or_else(|| bug!("checking unsafety for non-local def id {:?}", def_id)); @@ -602,7 +602,7 @@ fn report_unused_unsafe(tcx: TyCtxt<'_>, used_unsafe: &FxHashSet, id db.emit(); } -fn builtin_derive_def_id<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option { +fn builtin_derive_def_id(tcx: TyCtxt<'_>, def_id: DefId) -> Option { debug!("builtin_derive_def_id({:?})", def_id); if let Some(impl_def_id) = tcx.impl_of_method(def_id) { if tcx.has_attr(impl_def_id, sym::automatically_derived) { @@ -618,7 +618,7 @@ fn builtin_derive_def_id<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option(tcx: TyCtxt<'tcx>, def_id: DefId) { +pub fn check_unsafety(tcx: TyCtxt<'_>, def_id: DefId) { debug!("check_unsafety({:?})", def_id); // closures are handled by their parent fn. diff --git a/src/librustc_mir/transform/dump_mir.rs b/src/librustc_mir/transform/dump_mir.rs index 243820ba7d027..a6fb555f20bd0 100644 --- a/src/librustc_mir/transform/dump_mir.rs +++ b/src/librustc_mir/transform/dump_mir.rs @@ -14,7 +14,7 @@ use crate::util as mir_util; pub struct Marker(pub &'static str); impl MirPass for Marker { - fn name<'a>(&'a self) -> Cow<'a, str> { + fn name(&self) -> Cow<'_, str> { Cow::Borrowed(self.0) } @@ -52,7 +52,7 @@ pub fn on_mir_pass<'tcx>( } } -pub fn emit_mir<'tcx>(tcx: TyCtxt<'tcx>, outputs: &OutputFilenames) -> io::Result<()> { +pub fn emit_mir(tcx: TyCtxt<'_>, outputs: &OutputFilenames) -> io::Result<()> { let path = outputs.path(OutputType::Mir); let mut f = File::create(&path)?; mir_util::write_mir_pretty(tcx, None, &mut f)?; diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index 7b961e97a10de..2ed3f7d5c26e2 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -68,7 +68,7 @@ use crate::transform::simplify; use crate::transform::no_landing_pads::no_landing_pads; use crate::dataflow::{DataflowResults, DataflowResultsConsumer, FlowAtLocation}; use crate::dataflow::{do_dataflow, DebugFormatted, state_for_location}; -use crate::dataflow::{MaybeStorageLive, HaveBeenBorrowedLocals}; +use crate::dataflow::{MaybeStorageLive, HaveBeenBorrowedLocals, RequiresStorage}; use crate::util::dump_mir; use crate::util::liveness; @@ -437,16 +437,18 @@ fn locals_live_across_suspend_points( // Calculate the MIR locals which have been previously // borrowed (even if they are still active). - // This is only used for immovable generators. - let borrowed_locals = if !movable { - let analysis = HaveBeenBorrowedLocals::new(body); - let result = - do_dataflow(tcx, body, def_id, &[], &dead_unwinds, analysis, - |bd, p| DebugFormatted::new(&bd.body().local_decls[p])); - Some((analysis, result)) - } else { - None - }; + let borrowed_locals_analysis = HaveBeenBorrowedLocals::new(body); + let borrowed_locals_result = + do_dataflow(tcx, body, def_id, &[], &dead_unwinds, borrowed_locals_analysis, + |bd, p| DebugFormatted::new(&bd.body().local_decls[p])); + + // Calculate the MIR locals that we actually need to keep storage around + // for. + let requires_storage_analysis = RequiresStorage::new(body, &borrowed_locals_result); + let requires_storage = + do_dataflow(tcx, body, def_id, &[], &dead_unwinds, requires_storage_analysis, + |bd, p| DebugFormatted::new(&bd.body().local_decls[p])); + let requires_storage_analysis = RequiresStorage::new(body, &borrowed_locals_result); // Calculate the liveness of MIR locals ignoring borrows. let mut live_locals = liveness::LiveVarSet::new_empty(body.local_decls.len()); @@ -471,10 +473,10 @@ fn locals_live_across_suspend_points( statement_index: data.statements.len(), }; - if let Some((ref analysis, ref result)) = borrowed_locals { + if !movable { let borrowed_locals = state_for_location(loc, - analysis, - result, + &borrowed_locals_analysis, + &borrowed_locals_result, body); // The `liveness` variable contains the liveness of MIR locals ignoring borrows. // This is correct for movable generators since borrows cannot live across @@ -489,27 +491,34 @@ fn locals_live_across_suspend_points( liveness.outs[block].union(&borrowed_locals); } - let mut storage_liveness = state_for_location(loc, - &storage_live_analysis, - &storage_live, - body); + let storage_liveness = state_for_location(loc, + &storage_live_analysis, + &storage_live, + body); // Store the storage liveness for later use so we can restore the state // after a suspension point storage_liveness_map.insert(block, storage_liveness.clone()); - // Mark locals without storage statements as always having live storage - storage_liveness.union(&ignored.0); + let mut storage_required = state_for_location(loc, + &requires_storage_analysis, + &requires_storage, + body); + + // Mark locals without storage statements as always requiring storage + storage_required.union(&ignored.0); // Locals live are live at this point only if they are used across // suspension points (the `liveness` variable) - // and their storage is live (the `storage_liveness` variable) - let mut live_locals_here = storage_liveness; + // and their storage is required (the `storage_required` variable) + let mut live_locals_here = storage_required; live_locals_here.intersect(&liveness.outs[block]); // The generator argument is ignored live_locals_here.remove(self_arg()); + debug!("loc = {:?}, live_locals_here = {:?}", loc, live_locals_here); + // Add the locals live at this suspension point to the set of locals which live across // any suspension points live_locals.union(&live_locals_here); @@ -517,6 +526,7 @@ fn locals_live_across_suspend_points( live_locals_at_suspension_points.push(live_locals_here); } } + debug!("live_locals = {:?}", live_locals); // Renumber our liveness_map bitsets to include only the locals we are // saving. @@ -529,8 +539,8 @@ fn locals_live_across_suspend_points( body, &live_locals, &ignored, - storage_live, - storage_live_analysis); + requires_storage, + requires_storage_analysis); LivenessInfo { live_locals, @@ -567,8 +577,8 @@ fn compute_storage_conflicts( body: &'mir Body<'tcx>, stored_locals: &liveness::LiveVarSet, ignored: &StorageIgnored, - storage_live: DataflowResults<'tcx, MaybeStorageLive<'mir, 'tcx>>, - _storage_live_analysis: MaybeStorageLive<'mir, 'tcx>, + requires_storage: DataflowResults<'tcx, RequiresStorage<'mir, 'tcx>>, + _requires_storage_analysis: RequiresStorage<'mir, 'tcx>, ) -> BitMatrix { assert_eq!(body.local_decls.len(), ignored.0.domain_size()); assert_eq!(body.local_decls.len(), stored_locals.domain_size()); @@ -584,9 +594,9 @@ fn compute_storage_conflicts( let mut visitor = StorageConflictVisitor { body, stored_locals: &stored_locals, - local_conflicts: BitMatrix::from_row_n(&ineligible_locals, body.local_decls.len()) + local_conflicts: BitMatrix::from_row_n(&ineligible_locals, body.local_decls.len()), }; - let mut state = FlowAtLocation::new(storage_live); + let mut state = FlowAtLocation::new(requires_storage); visitor.analyze_results(&mut state); let local_conflicts = visitor.local_conflicts; @@ -627,7 +637,7 @@ struct StorageConflictVisitor<'body, 'tcx, 's> { impl<'body, 'tcx, 's> DataflowResultsConsumer<'body, 'tcx> for StorageConflictVisitor<'body, 'tcx, 's> { - type FlowState = FlowAtLocation<'tcx, MaybeStorageLive<'body, 'tcx>>; + type FlowState = FlowAtLocation<'tcx, RequiresStorage<'body, 'tcx>>; fn body(&self) -> &'body Body<'tcx> { self.body @@ -657,7 +667,7 @@ impl<'body, 'tcx, 's> DataflowResultsConsumer<'body, 'tcx> impl<'body, 'tcx, 's> StorageConflictVisitor<'body, 'tcx, 's> { fn apply_state(&mut self, - flow_state: &FlowAtLocation<'tcx, MaybeStorageLive<'body, 'tcx>>, + flow_state: &FlowAtLocation<'tcx, RequiresStorage<'body, 'tcx>>, loc: Location) { // Ignore unreachable blocks. match self.body.basic_blocks()[loc.block].terminator().kind { @@ -1018,14 +1028,14 @@ fn create_generator_resume_function<'tcx>( dump_mir(tcx, None, "generator_resume", &0, source, body, |_, _| Ok(()) ); } -fn source_info<'tcx>(body: &Body<'tcx>) -> SourceInfo { +fn source_info(body: &Body<'_>) -> SourceInfo { SourceInfo { span: body.span, scope: OUTERMOST_SOURCE_SCOPE, } } -fn insert_clean_drop<'tcx>(body: &mut Body<'tcx>) -> BasicBlock { +fn insert_clean_drop(body: &mut Body<'_>) -> BasicBlock { let return_block = insert_term_block(body, TerminatorKind::Return); // Create a block to destroy an unresumed generators. This can only destroy upvars. diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs index 81d91dcd0a95f..7f43c4a3e89a1 100644 --- a/src/librustc_mir/transform/mod.rs +++ b/src/librustc_mir/transform/mod.rs @@ -50,13 +50,13 @@ pub(crate) fn provide(providers: &mut Providers<'_>) { }; } -fn is_mir_available<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { +fn is_mir_available(tcx: TyCtxt<'_>, def_id: DefId) -> bool { tcx.mir_keys(def_id.krate).contains(&def_id) } /// Finds the full set of `DefId`s within the current crate that have /// MIR associated with them. -fn mir_keys<'tcx>(tcx: TyCtxt<'tcx>, krate: CrateNum) -> &'tcx DefIdSet { +fn mir_keys(tcx: TyCtxt<'_>, krate: CrateNum) -> &DefIdSet { assert_eq!(krate, LOCAL_CRATE); let mut set = DefIdSet::default(); @@ -94,7 +94,7 @@ fn mir_keys<'tcx>(tcx: TyCtxt<'tcx>, krate: CrateNum) -> &'tcx DefIdSet { tcx.arena.alloc(set) } -fn mir_built<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx Steal> { +fn mir_built(tcx: TyCtxt<'_>, def_id: DefId) -> &Steal> { let mir = build::mir_build(tcx, def_id); tcx.alloc_steal_mir(mir) } @@ -137,7 +137,7 @@ pub fn default_name() -> Cow<'static, str> { /// pass will be named after the type, and it will consist of a main /// loop that goes over each available MIR and applies `run_pass`. pub trait MirPass { - fn name<'a>(&'a self) -> Cow<'a, str> { + fn name(&self) -> Cow<'_, str> { default_name::() } @@ -192,7 +192,7 @@ pub fn run_passes( } } -fn mir_const<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx Steal> { +fn mir_const(tcx: TyCtxt<'_>, def_id: DefId) -> &Steal> { // Unsafety check uses the raw mir, so make sure it is run let _ = tcx.unsafety_check_result(def_id); @@ -223,7 +223,7 @@ fn mir_validated(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx Steal> { tcx.alloc_steal_mir(body) } -fn optimized_mir<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx Body<'tcx> { +fn optimized_mir(tcx: TyCtxt<'_>, def_id: DefId) -> &Body<'_> { if tcx.is_constructor(def_id) { // There's no reason to run all of the MIR passes on constructors when // we can just output the MIR we want directly. This also saves const diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index f082b5e5a046c..3e52d3ee9bbdf 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -1473,7 +1473,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn mir_const_qualif<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> (u8, &'tcx BitSet) { +fn mir_const_qualif(tcx: TyCtxt<'_>, def_id: DefId) -> (u8, &BitSet) { // N.B., this `borrow()` is guaranteed to be valid (i.e., the value // cannot yet be stolen), because `mir_validated()`, which steals // from `mir_const(), forces this query to execute before diff --git a/src/librustc_mir/transform/simplify.rs b/src/librustc_mir/transform/simplify.rs index f226f15c0096f..2eed9d453f233 100644 --- a/src/librustc_mir/transform/simplify.rs +++ b/src/librustc_mir/transform/simplify.rs @@ -53,7 +53,7 @@ pub fn simplify_cfg(body: &mut Body<'_>) { } impl MirPass for SimplifyCfg { - fn name<'a>(&'a self) -> Cow<'a, str> { + fn name(&self) -> Cow<'_, str> { Cow::Borrowed(&self.label) } diff --git a/src/librustc_mir/transform/simplify_branches.rs b/src/librustc_mir/transform/simplify_branches.rs index 0c63a8d9c96b1..f39c71ef42d71 100644 --- a/src/librustc_mir/transform/simplify_branches.rs +++ b/src/librustc_mir/transform/simplify_branches.rs @@ -15,7 +15,7 @@ impl SimplifyBranches { } impl MirPass for SimplifyBranches { - fn name<'a>(&'a self) -> Cow<'a, str> { + fn name(&self) -> Cow<'_, str> { Cow::Borrowed(&self.label) } diff --git a/src/librustc_mir/util/graphviz.rs b/src/librustc_mir/util/graphviz.rs index 1d876d7bddb53..9d142d9b700b6 100644 --- a/src/librustc_mir/util/graphviz.rs +++ b/src/librustc_mir/util/graphviz.rs @@ -8,8 +8,8 @@ use std::io::{self, Write}; use super::pretty::dump_mir_def_ids; /// Write a graphviz DOT graph of a list of MIRs. -pub fn write_mir_graphviz<'tcx, W>( - tcx: TyCtxt<'tcx>, +pub fn write_mir_graphviz( + tcx: TyCtxt<'_>, single: Option, w: &mut W, ) -> io::Result<()> diff --git a/src/librustc_mir/util/liveness.rs b/src/librustc_mir/util/liveness.rs index 8ead571d9664d..b42eebc7ee3be 100644 --- a/src/librustc_mir/util/liveness.rs +++ b/src/librustc_mir/util/liveness.rs @@ -56,8 +56,8 @@ pub struct LivenessResult { /// Computes which local variables are live within the given function /// `mir`, including drops. -pub fn liveness_of_locals<'tcx>( - body: &Body<'tcx>, +pub fn liveness_of_locals( + body: &Body<'_>, ) -> LivenessResult { let num_live_vars = body.local_decls.len(); @@ -243,8 +243,8 @@ impl<'tcx> Visitor<'tcx> for DefsUsesVisitor } } -fn block<'tcx>( - b: &BasicBlockData<'tcx>, +fn block( + b: &BasicBlockData<'_>, locals: usize, ) -> DefsUses { let mut visitor = DefsUsesVisitor { diff --git a/src/librustc_mir/util/mod.rs b/src/librustc_mir/util/mod.rs index 719029dbaac77..fd2a5e452ce4b 100644 --- a/src/librustc_mir/util/mod.rs +++ b/src/librustc_mir/util/mod.rs @@ -21,7 +21,7 @@ pub use self::graphviz::{graphviz_safe_def_name, write_mir_graphviz}; pub use self::graphviz::write_node_label as write_graphviz_node_label; /// If possible, suggest replacing `ref` with `ref mut`. -pub fn suggest_ref_mut<'tcx>(tcx: TyCtxt<'tcx>, binding_span: Span) -> Option<(String)> { +pub fn suggest_ref_mut(tcx: TyCtxt<'_>, binding_span: Span) -> Option<(String)> { let hi_src = tcx.sess.source_map().span_to_snippet(binding_span).unwrap(); if hi_src.starts_with("ref") && hi_src["ref".len()..].starts_with(Pattern_White_Space) diff --git a/src/librustc_passes/hir_stats.rs b/src/librustc_passes/hir_stats.rs index 6936aedb9de80..e7f6abc410a32 100644 --- a/src/librustc_passes/hir_stats.rs +++ b/src/librustc_passes/hir_stats.rs @@ -38,7 +38,7 @@ pub fn print_hir_stats(krate: &hir::Crate) { collector.print("HIR STATS"); } -pub fn print_ast_stats<'v>(krate: &'v ast::Crate, title: &str) { +pub fn print_ast_stats(krate: &ast::Crate, title: &str) { let mut collector = StatCollector { krate: None, data: FxHashMap::default(), diff --git a/src/librustc_passes/layout_test.rs b/src/librustc_passes/layout_test.rs index 8f790d1328572..6b1ce578240e4 100644 --- a/src/librustc_passes/layout_test.rs +++ b/src/librustc_passes/layout_test.rs @@ -14,7 +14,7 @@ use rustc::ty::TyCtxt; use syntax::ast::Attribute; use syntax::symbol::sym; -pub fn test_layout<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn test_layout(tcx: TyCtxt<'_>) { if tcx.features().rustc_attrs { // if the `rustc_attrs` feature is not enabled, don't bother testing layout tcx.hir() diff --git a/src/librustc_passes/loops.rs b/src/librustc_passes/loops.rs index ed0a78b465276..616e6974110e6 100644 --- a/src/librustc_passes/loops.rs +++ b/src/librustc_passes/loops.rs @@ -45,7 +45,7 @@ struct CheckLoopVisitor<'a, 'hir> { cx: Context, } -fn check_mod_loops<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn check_mod_loops(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckLoopVisitor { sess: &tcx.sess, hir_map: &tcx.hir(), diff --git a/src/librustc_passes/rvalue_promotion.rs b/src/librustc_passes/rvalue_promotion.rs index bc1151974bb70..e14fa07fbbfe4 100644 --- a/src/librustc_passes/rvalue_promotion.rs +++ b/src/librustc_passes/rvalue_promotion.rs @@ -39,7 +39,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn const_is_rvalue_promotable_to_static<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { +fn const_is_rvalue_promotable_to_static(tcx: TyCtxt<'_>, def_id: DefId) -> bool { assert!(def_id.is_local()); let hir_id = tcx.hir().as_local_hir_id(def_id) @@ -48,7 +48,7 @@ fn const_is_rvalue_promotable_to_static<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) tcx.rvalue_promotable_map(def_id).contains(&body_id.hir_id.local_id) } -fn rvalue_promotable_map<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ItemLocalSet { +fn rvalue_promotable_map(tcx: TyCtxt<'_>, def_id: DefId) -> &ItemLocalSet { let outer_def_id = tcx.closure_base_def_id(def_id); if outer_def_id != def_id { return tcx.rvalue_promotable_map(outer_def_id); diff --git a/src/librustc_plugin/build.rs b/src/librustc_plugin/build.rs index d3ac597160fd6..816e283a10460 100644 --- a/src/librustc_plugin/build.rs +++ b/src/librustc_plugin/build.rs @@ -30,11 +30,11 @@ impl<'v> ItemLikeVisitor<'v> for RegistrarFinder { } /// Finds the function marked with `#[plugin_registrar]`, if any. -pub fn find_plugin_registrar<'tcx>(tcx: TyCtxt<'tcx>) -> Option { +pub fn find_plugin_registrar(tcx: TyCtxt<'_>) -> Option { tcx.plugin_registrar_fn(LOCAL_CRATE) } -fn plugin_registrar_fn<'tcx>(tcx: TyCtxt<'tcx>, cnum: CrateNum) -> Option { +fn plugin_registrar_fn(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option { assert_eq!(cnum, LOCAL_CRATE); let mut finder = RegistrarFinder { registrars: Vec::new() }; diff --git a/src/librustc_plugin/registry.rs b/src/librustc_plugin/registry.rs index 16d484e2a98f2..2fb65a6069372 100644 --- a/src/librustc_plugin/registry.rs +++ b/src/librustc_plugin/registry.rs @@ -77,7 +77,7 @@ impl<'a> Registry<'a> { /// /// Returns empty slice in case the plugin was loaded /// with `--extra-plugins` - pub fn args<'b>(&'b self) -> &'b [ast::NestedMetaItem] { + pub fn args(&self) -> &[ast::NestedMetaItem] { self.args_hidden.as_ref().map(|v| &v[..]).unwrap_or(&[]) } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 3e98200e53274..339021f511afd 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -337,7 +337,7 @@ fn item_tables<'a, 'tcx>( if tcx.has_typeck_tables(def_id) { tcx.typeck_tables_of(def_id) } else { empty_tables } } -fn min<'tcx>(vis1: ty::Visibility, vis2: ty::Visibility, tcx: TyCtxt<'tcx>) -> ty::Visibility { +fn min(vis1: ty::Visibility, vis2: ty::Visibility, tcx: TyCtxt<'_>) -> ty::Visibility { if vis1.is_at_least(vis2, tcx) { vis2 } else { vis1 } } @@ -384,14 +384,14 @@ impl<'a, 'tcx, VL: VisibilityLike> DefIdVisitor<'tcx> for FindMin<'a, 'tcx, VL> trait VisibilityLike: Sized { const MAX: Self; const SHALLOW: bool = false; - fn new_min<'a, 'tcx>(find: &FindMin<'a, 'tcx, Self>, def_id: DefId) -> Self; + fn new_min(find: &FindMin<'_, '_, Self>, def_id: DefId) -> Self; // Returns an over-approximation (`skip_assoc_tys` = true) of visibility due to // associated types for which we can't determine visibility precisely. - fn of_impl<'a, 'tcx>( + fn of_impl( hir_id: hir::HirId, - tcx: TyCtxt<'tcx>, - access_levels: &'a AccessLevels, + tcx: TyCtxt<'_>, + access_levels: &AccessLevels, ) -> Self { let mut find = FindMin { tcx, access_levels, min: Self::MAX }; let def_id = tcx.hir().local_def_id_from_hir_id(hir_id); @@ -404,7 +404,7 @@ trait VisibilityLike: Sized { } impl VisibilityLike for ty::Visibility { const MAX: Self = ty::Visibility::Public; - fn new_min<'a, 'tcx>(find: &FindMin<'a, 'tcx, Self>, def_id: DefId) -> Self { + fn new_min(find: &FindMin<'_, '_, Self>, def_id: DefId) -> Self { min(def_id_visibility(find.tcx, def_id).0, find.min, find.tcx) } } @@ -420,7 +420,7 @@ impl VisibilityLike for Option { // both "shallow" version of its self type and "shallow" version of its trait if it exists // (which require reaching the `DefId`s in them). const SHALLOW: bool = true; - fn new_min<'a, 'tcx>(find: &FindMin<'a, 'tcx, Self>, def_id: DefId) -> Self { + fn new_min(find: &FindMin<'_, '_, Self>, def_id: DefId) -> Self { cmp::min(if let Some(hir_id) = find.tcx.hir().as_local_hir_id(def_id) { find.access_levels.map.get(&hir_id).cloned() } else { @@ -1828,7 +1828,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn check_mod_privacy<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn check_mod_privacy(tcx: TyCtxt<'_>, module_def_id: DefId) { let empty_tables = ty::TypeckTables::empty(None); // Check privacy of names not checked in previous compilation stages. @@ -1855,7 +1855,7 @@ fn check_mod_privacy<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { intravisit::walk_mod(&mut visitor, module, hir_id); } -fn privacy_access_levels<'tcx>(tcx: TyCtxt<'tcx>, krate: CrateNum) -> &'tcx AccessLevels { +fn privacy_access_levels(tcx: TyCtxt<'_>, krate: CrateNum) -> &AccessLevels { assert_eq!(krate, LOCAL_CRATE); // Build up a set of all exported items in the AST. This is a set of all @@ -1879,7 +1879,7 @@ fn privacy_access_levels<'tcx>(tcx: TyCtxt<'tcx>, krate: CrateNum) -> &'tcx Acce tcx.arena.alloc(visitor.access_levels) } -fn check_private_in_public<'tcx>(tcx: TyCtxt<'tcx>, krate: CrateNum) { +fn check_private_in_public(tcx: TyCtxt<'_>, krate: CrateNum) { assert_eq!(krate, LOCAL_CRATE); let access_levels = tcx.privacy_access_levels(LOCAL_CRATE); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index f4c23a023b104..77a976a54f434 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -198,9 +198,9 @@ enum ResolutionError<'a> { /// /// This takes the error provided, combines it with the span and any additional spans inside the /// error and emits it. -fn resolve_error<'sess, 'a>(resolver: &'sess Resolver<'_>, - span: Span, - resolution_error: ResolutionError<'a>) { +fn resolve_error(resolver: &Resolver<'_>, + span: Span, + resolution_error: ResolutionError<'_>) { resolve_struct_error(resolver, span, resolution_error).emit(); } diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index 392a46a262f50..522dc1aa9f8de 100644 --- a/src/librustc_resolve/macros.rs +++ b/src/librustc_resolve/macros.rs @@ -19,9 +19,8 @@ use syntax::ext::base::{MacroKind, SyntaxExtension}; use syntax::ext::expand::{AstFragment, Invocation, InvocationKind}; use syntax::ext::hygiene::Mark; use syntax::ext::tt::macro_rules; -use syntax::feature_gate::{ - feature_err, is_builtin_attr_name, AttributeGate, GateIssue, Stability, BUILTIN_ATTRIBUTES, -}; +use syntax::feature_gate::{feature_err, emit_feature_err, is_builtin_attr_name}; +use syntax::feature_gate::{AttributeGate, GateIssue, Stability, BUILTIN_ATTRIBUTES}; use syntax::symbol::{Symbol, kw, sym}; use syntax::visit::Visitor; use syntax::util::lev_distance::find_best_match_for_name; @@ -298,12 +297,25 @@ impl<'a> Resolver<'a> { let res = self.resolve_macro_to_res_inner(path, kind, parent_scope, trace, force); // Report errors and enforce feature gates for the resolved macro. + let features = self.session.features_untracked(); if res != Err(Determinacy::Undetermined) { // Do not report duplicated errors on every undetermined resolution. for segment in &path.segments { if let Some(args) = &segment.args { self.session.span_err(args.span(), "generic arguments in macro path"); } + if kind == MacroKind::Attr && !features.rustc_attrs && + segment.ident.as_str().starts_with("rustc") { + let msg = "attributes starting with `rustc` are \ + reserved for use by the `rustc` compiler"; + emit_feature_err( + &self.session.parse_sess, + sym::rustc_attrs, + segment.ident.span, + GateIssue::Language, + msg, + ); + } } } @@ -320,24 +332,15 @@ impl<'a> Resolver<'a> { } Res::NonMacroAttr(attr_kind) => { if kind == MacroKind::Attr { - let features = self.session.features_untracked(); if attr_kind == NonMacroAttrKind::Custom { assert!(path.segments.len() == 1); - let name = path.segments[0].ident.as_str(); - if name.starts_with("rustc_") { - if !features.rustc_attrs { - let msg = "unless otherwise specified, attributes with the prefix \ - `rustc_` are reserved for internal compiler diagnostics"; - self.report_unknown_attribute(path.span, &name, msg, - sym::rustc_attrs); - } - } else if !features.custom_attribute { + if !features.custom_attribute { let msg = format!("The attribute `{}` is currently unknown to the \ compiler and may have meaning added to it in the \ future", path); self.report_unknown_attribute( path.span, - &name, + &path.segments[0].ident.as_str(), &msg, sym::custom_attribute, ); diff --git a/src/librustc_traits/chalk_context/program_clauses/primitive.rs b/src/librustc_traits/chalk_context/program_clauses/primitive.rs index 8e4b9da6de268..6e8eed0f90725 100644 --- a/src/librustc_traits/chalk_context/program_clauses/primitive.rs +++ b/src/librustc_traits/chalk_context/program_clauses/primitive.rs @@ -15,7 +15,7 @@ use crate::lowering::Lower; use crate::generic_types; use std::iter; -crate fn wf_clause_for_raw_ptr<'tcx>(tcx: TyCtxt<'tcx>, mutbl: hir::Mutability) -> Clauses<'tcx> { +crate fn wf_clause_for_raw_ptr(tcx: TyCtxt<'_>, mutbl: hir::Mutability) -> Clauses<'_> { let ptr_ty = generic_types::raw_ptr(tcx, mutbl); let wf_clause = ProgramClause { @@ -29,13 +29,13 @@ crate fn wf_clause_for_raw_ptr<'tcx>(tcx: TyCtxt<'tcx>, mutbl: hir::Mutability) tcx.mk_clauses(iter::once(wf_clause)) } -crate fn wf_clause_for_fn_ptr<'tcx>( - tcx: TyCtxt<'tcx>, +crate fn wf_clause_for_fn_ptr( + tcx: TyCtxt<'_>, arity_and_output: usize, variadic: bool, unsafety: hir::Unsafety, abi: abi::Abi, -) -> Clauses<'tcx> { +) -> Clauses<'_> { let fn_ptr = generic_types::fn_ptr(tcx, arity_and_output, variadic, unsafety, abi); let wf_clause = ProgramClause { @@ -50,7 +50,7 @@ crate fn wf_clause_for_fn_ptr<'tcx>( tcx.mk_clauses(iter::once(wf_clause)) } -crate fn wf_clause_for_slice<'tcx>(tcx: TyCtxt<'tcx>) -> Clauses<'tcx> { +crate fn wf_clause_for_slice(tcx: TyCtxt<'_>) -> Clauses<'_> { let ty = generic_types::bound(tcx, 0); let slice_ty = tcx.mk_slice(ty); @@ -111,7 +111,7 @@ crate fn wf_clause_for_array<'tcx>( tcx.mk_clauses(iter::once(wf_clause)) } -crate fn wf_clause_for_tuple<'tcx>(tcx: TyCtxt<'tcx>, arity: usize) -> Clauses<'tcx> { +crate fn wf_clause_for_tuple(tcx: TyCtxt<'_>, arity: usize) -> Clauses<'_> { let type_list = generic_types::type_list(tcx, arity); let tuple_ty = tcx.mk_ty(ty::Tuple(type_list)); @@ -152,7 +152,7 @@ crate fn wf_clause_for_tuple<'tcx>(tcx: TyCtxt<'tcx>, arity: usize) -> Clauses<' tcx.mk_clauses(iter::once(wf_clause)) } -crate fn wf_clause_for_ref<'tcx>(tcx: TyCtxt<'tcx>, mutbl: hir::Mutability) -> Clauses<'tcx> { +crate fn wf_clause_for_ref(tcx: TyCtxt<'_>, mutbl: hir::Mutability) -> Clauses<'_> { let region = tcx.mk_region( ty::ReLateBound(ty::INNERMOST, ty::BoundRegion::BrAnon(0)) ); @@ -176,7 +176,7 @@ crate fn wf_clause_for_ref<'tcx>(tcx: TyCtxt<'tcx>, mutbl: hir::Mutability) -> C tcx.mk_clauses(iter::once(wf_clause)) } -crate fn wf_clause_for_fn_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Clauses<'tcx> { +crate fn wf_clause_for_fn_def(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> { let fn_def = generic_types::fn_def(tcx, def_id); let wf_clause = ProgramClause { diff --git a/src/librustc_traits/dropck_outlives.rs b/src/librustc_traits/dropck_outlives.rs index 3abd7e90cf10f..ecd888b606981 100644 --- a/src/librustc_traits/dropck_outlives.rs +++ b/src/librustc_traits/dropck_outlives.rs @@ -279,10 +279,10 @@ fn dtorck_constraint_for_ty<'tcx>( } /// Calculates the dtorck constraint for a type. -crate fn adt_dtorck_constraint<'tcx>( - tcx: TyCtxt<'tcx>, +crate fn adt_dtorck_constraint( + tcx: TyCtxt<'_>, def_id: DefId, -) -> Result, NoSolution> { +) -> Result, NoSolution> { let def = tcx.adt_def(def_id); let span = tcx.def_span(def_id); debug!("dtorck_constraint: {:?}", def); @@ -313,7 +313,7 @@ crate fn adt_dtorck_constraint<'tcx>( Ok(result) } -fn dedup_dtorck_constraint<'tcx>(c: &mut DtorckConstraint<'tcx>) { +fn dedup_dtorck_constraint(c: &mut DtorckConstraint<'_>) { let mut outlives = FxHashSet::default(); let mut dtorck_types = FxHashSet::default(); diff --git a/src/librustc_traits/lowering/environment.rs b/src/librustc_traits/lowering/environment.rs index 0173685583148..9ff685bb4ee8a 100644 --- a/src/librustc_traits/lowering/environment.rs +++ b/src/librustc_traits/lowering/environment.rs @@ -160,7 +160,7 @@ crate fn program_clauses_for_env<'tcx>( ); } -crate fn environment<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Environment<'tcx> { +crate fn environment(tcx: TyCtxt<'_>, def_id: DefId) -> Environment<'_> { use super::{Lower, IntoFromEnvGoal}; use rustc::hir::{Node, TraitItemKind, ImplItemKind, ItemKind, ForeignItemKind}; diff --git a/src/librustc_traits/lowering/mod.rs b/src/librustc_traits/lowering/mod.rs index 2a6613101614d..b0d9134c834d6 100644 --- a/src/librustc_traits/lowering/mod.rs +++ b/src/librustc_traits/lowering/mod.rs @@ -155,7 +155,7 @@ impl<'tcx> IntoWellFormedGoal for DomainGoal<'tcx> { } } -crate fn program_clauses_for<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Clauses<'tcx> { +crate fn program_clauses_for(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> { // FIXME(eddyb) this should only be using `def_kind`. match tcx.def_key(def_id).disambiguated_data.data { DefPathData::TypeNs(..) => match tcx.def_kind(def_id) { @@ -181,7 +181,7 @@ crate fn program_clauses_for<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Clauses< } } -fn program_clauses_for_trait<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Clauses<'tcx> { +fn program_clauses_for_trait(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> { // `trait Trait where WC { .. } // P0 == Self` // Rule Implemented-From-Env (see rustc guide) @@ -337,7 +337,7 @@ fn program_clauses_for_impl(tcx: TyCtxt<'tcx>, def_id: DefId) -> Clauses<'tcx> { tcx.mk_clauses(iter::once(Clause::ForAll(ty::Binder::bind(clause)))) } -pub fn program_clauses_for_type_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Clauses<'tcx> { +pub fn program_clauses_for_type_def(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> { // Rule WellFormed-Type // // `struct Ty where WC1, ..., WCm` @@ -411,10 +411,10 @@ pub fn program_clauses_for_type_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> C tcx.mk_clauses(iter::once(well_formed_clause).chain(from_env_clauses)) } -pub fn program_clauses_for_associated_type_def<'tcx>( - tcx: TyCtxt<'tcx>, +pub fn program_clauses_for_associated_type_def( + tcx: TyCtxt<'_>, item_id: DefId, -) -> Clauses<'tcx> { +) -> Clauses<'_> { // Rule ProjectionEq-Placeholder // // ``` @@ -549,10 +549,10 @@ pub fn program_clauses_for_associated_type_def<'tcx>( tcx.mk_clauses(clauses) } -pub fn program_clauses_for_associated_type_value<'tcx>( - tcx: TyCtxt<'tcx>, +pub fn program_clauses_for_associated_type_value( + tcx: TyCtxt<'_>, item_id: DefId, -) -> Clauses<'tcx> { +) -> Clauses<'_> { // Rule Normalize-From-Impl (see rustc guide) // // ``` @@ -611,7 +611,7 @@ pub fn program_clauses_for_associated_type_value<'tcx>( tcx.mk_clauses(iter::once(normalize_clause)) } -pub fn dump_program_clauses<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn dump_program_clauses(tcx: TyCtxt<'_>) { if !tcx.features().rustc_attrs { return; } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 9b8f6a556bf88..1792716d1fb35 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -7,6 +7,7 @@ use crate::hir::{self, GenericArg, GenericArgs, ExprKind}; use crate::hir::def::{CtorOf, Res, DefKind}; use crate::hir::def_id::DefId; use crate::hir::HirVec; +use crate::hir::ptr::P; use crate::lint; use crate::middle::lang_items::SizedTraitLangItem; use crate::middle::resolve_lifetime as rl; @@ -23,7 +24,6 @@ use crate::require_c_abi_if_c_variadic; use smallvec::SmallVec; use syntax::ast; use syntax::feature_gate::{GateIssue, emit_feature_err}; -use syntax::ptr::P; use syntax::util::lev_distance::find_best_match_for_name; use syntax::symbol::sym; use syntax_pos::{DUMMY_SP, Span, MultiSpan}; diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index b435c99ad01f5..841e73adb0b68 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -5,6 +5,7 @@ use errors::{Applicability, DiagnosticBuilder}; use rustc::hir::{self, PatKind, Pat, ExprKind}; use rustc::hir::def::{Res, DefKind, CtorKind}; use rustc::hir::pat_util::EnumerateAndAdjustIterator; +use rustc::hir::ptr::P; use rustc::infer; use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc::traits::{ObligationCause, ObligationCauseCode}; @@ -12,7 +13,6 @@ use rustc::ty::{self, Ty, TypeFoldable}; use rustc::ty::subst::Kind; use syntax::ast; use syntax::source_map::Spanned; -use syntax::ptr::P; use syntax::util::lev_distance::find_best_match_for_name; use syntax_pos::Span; use syntax_pos::hygiene::CompilerDesugaringKind; diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index 4bd2f216224a5..94c76deade279 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -54,6 +54,7 @@ use crate::check::{FnCtxt, Needs}; use errors::DiagnosticBuilder; use rustc::hir; use rustc::hir::def_id::DefId; +use rustc::hir::ptr::P; use rustc::infer::{Coercion, InferResult, InferOk}; use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc::traits::{self, ObligationCause, ObligationCauseCode}; @@ -67,7 +68,6 @@ use rustc::ty::relate::RelateResult; use smallvec::{smallvec, SmallVec}; use std::ops::Deref; use syntax::feature_gate; -use syntax::ptr::P; use syntax::symbol::sym; use syntax_pos; diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index a2621abf44d8d..c4c4e10a14cc0 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -29,7 +29,7 @@ use syntax_pos::Span; /// struct/enum definition for the nominal type itself (i.e. /// cannot do `struct S; impl Drop for S { ... }`). /// -pub fn check_drop_impl<'tcx>(tcx: TyCtxt<'tcx>, drop_impl_did: DefId) -> Result<(), ErrorReported> { +pub fn check_drop_impl(tcx: TyCtxt<'_>, drop_impl_did: DefId) -> Result<(), ErrorReported> { let dtor_self_type = tcx.type_of(drop_impl_did); let dtor_predicates = tcx.predicates_of(drop_impl_did); match dtor_self_type.sty { diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs index 21fa219a1cab2..ccc20bd9585c9 100644 --- a/src/librustc_typeck/check/expr.rs +++ b/src/librustc_typeck/check/expr.rs @@ -20,13 +20,13 @@ use crate::astconv::AstConv as _; use errors::{Applicability, DiagnosticBuilder}; use syntax::ast; -use syntax::ptr::P; use syntax::symbol::{Symbol, LocalInternedString, kw, sym}; use syntax::source_map::Span; use syntax::util::lev_distance::find_best_match_for_name; use rustc::hir; use rustc::hir::{ExprKind, QPath}; use rustc::hir::def::{CtorKind, Res, DefKind}; +use rustc::hir::ptr::P; use rustc::infer; use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc::mir::interpret::GlobalId; diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs index 8c2b8d1565f2f..9b1a891382209 100644 --- a/src/librustc_typeck/check/intrinsic.rs +++ b/src/librustc_typeck/check/intrinsic.rs @@ -79,7 +79,7 @@ pub fn intrisic_operation_unsafety(intrinsic: &str) -> hir::Unsafety { /// Remember to add all intrinsics here, in librustc_codegen_llvm/intrinsic.rs, /// and in libcore/intrinsics.rs -pub fn check_intrinsic_type<'tcx>(tcx: TyCtxt<'tcx>, it: &hir::ForeignItem) { +pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem) { let param = |n| tcx.mk_ty_param(n, InternedString::intern(&format!("P{}", n))); let name = it.ident.as_str(); @@ -385,7 +385,7 @@ pub fn check_intrinsic_type<'tcx>(tcx: TyCtxt<'tcx>, it: &hir::ForeignItem) { } /// Type-check `extern "platform-intrinsic" { ... }` functions. -pub fn check_platform_intrinsic_type<'tcx>(tcx: TyCtxt<'tcx>, it: &hir::ForeignItem) { +pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem) { let param = |n| { let name = InternedString::intern(&format!("P{}", n)); tcx.mk_ty_param(n, name) diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index fa1b07d2dcfcd..be00a6efe55ed 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -775,12 +775,12 @@ impl Ord for TraitInfo { } /// Retrieves all traits in this crate and any dependent crates. -pub fn all_traits<'tcx>(tcx: TyCtxt<'tcx>) -> Vec { +pub fn all_traits(tcx: TyCtxt<'_>) -> Vec { tcx.all_traits(LOCAL_CRATE).iter().map(|&def_id| TraitInfo { def_id }).collect() } /// Computes all traits in this crate and any dependent crates. -fn compute_all_traits<'tcx>(tcx: TyCtxt<'tcx>) -> Vec { +fn compute_all_traits(tcx: TyCtxt<'_>) -> Vec { use hir::itemlikevisit; let mut traits = vec![]; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 37866bab9009d..6ba65bf182488 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -93,6 +93,7 @@ use rustc::hir::def::{CtorOf, Res, DefKind}; use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap}; use rustc::hir::itemlikevisit::ItemLikeVisitor; +use rustc::hir::ptr::P; use crate::middle::lang_items; use crate::namespace::Namespace; use rustc::infer::{self, InferCtxt, InferOk, InferResult}; @@ -122,7 +123,6 @@ use syntax_pos::hygiene::CompilerDesugaringKind; use syntax::ast; use syntax::attr; use syntax::feature_gate::{GateIssue, emit_feature_err}; -use syntax::ptr::P; use syntax::source_map::{DUMMY_SP, original_sp}; use syntax::symbol::{kw, sym}; @@ -698,31 +698,31 @@ impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> { fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { } } -pub fn check_wf_new<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check_wf_new(tcx: TyCtxt<'_>) { 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) { +fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx }); } -fn typeck_item_bodies<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) { +fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) { debug_assert!(crate_num == LOCAL_CRATE); tcx.par_body_owners(|body_owner_def_id| { tcx.ensure().typeck_tables_of(body_owner_def_id); }); } -fn check_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) { wfcheck::check_item_well_formed(tcx, def_id); } -fn check_trait_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) { wfcheck::check_trait_item(tcx, def_id); } -fn check_impl_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) { wfcheck::check_impl_item(tcx, def_id); } @@ -742,7 +742,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn adt_destructor<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option { +fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option { tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl) } @@ -755,10 +755,10 @@ fn adt_destructor<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option( - tcx: TyCtxt<'tcx>, +fn primary_body_of( + tcx: TyCtxt<'_>, id: hir::HirId, -) -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)> { +) -> Option<(hir::BodyId, Option<&hir::FnDecl>)> { match tcx.hir().get(id) { Node::Item(item) => { match item.node { @@ -796,7 +796,7 @@ fn primary_body_of<'tcx>( } } -fn has_typeck_tables<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { +fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool { // Closures' tables come from their outermost function, // as they are part of the same "inference environment". let outer_def_id = tcx.closure_base_def_id(def_id); @@ -808,11 +808,11 @@ fn has_typeck_tables<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { primary_body_of(tcx, id).is_some() } -fn used_trait_imports<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx DefIdSet { +fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet { &*tcx.typeck_tables_of(def_id).used_trait_imports } -fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::TypeckTables<'tcx> { +fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> { // Closures' tables come from their outermost function, // as they are part of the same "inference environment". let outer_def_id = tcx.closure_base_def_id(def_id); @@ -912,7 +912,7 @@ fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::TypeckT tables } -fn check_abi<'tcx>(tcx: TyCtxt<'tcx>, span: Span, abi: Abi) { +fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) { if !tcx.sess.target.target.is_abi_supported(abi) { struct_span_err!(tcx.sess, span, E0570, "The ABI `{}` is not supported for the current target", abi).emit() @@ -1285,7 +1285,7 @@ fn check_fn<'a, 'tcx>( (fcx, gen_ty) } -fn check_struct<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) { +fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { let def_id = tcx.hir().local_def_id_from_hir_id(id); let def = tcx.adt_def(def_id); def.destructor(tcx); // force the destructor to be evaluated @@ -1299,7 +1299,7 @@ fn check_struct<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) { check_packed(tcx, span, def_id); } -fn check_union<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) { +fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { let def_id = tcx.hir().local_def_id_from_hir_id(id); let def = tcx.adt_def(def_id); def.destructor(tcx); // force the destructor to be evaluated @@ -1461,14 +1461,14 @@ fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) } } -fn check_on_unimplemented<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId, item: &hir::Item) { +fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) { let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id); // an error would be reported if this fails. let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id); } -fn report_forbidden_specialization<'tcx>( - tcx: TyCtxt<'tcx>, +fn report_forbidden_specialization( + tcx: TyCtxt<'_>, impl_item: &hir::ImplItem, parent_impl: DefId, ) { @@ -1684,7 +1684,7 @@ fn check_impl_items_against_trait<'tcx>( /// Checks whether a type can be represented in memory. In particular, it /// identifies types that contain themselves without indirection through a /// pointer, which would mean their size is unbounded. -fn check_representable<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, item_def_id: DefId) -> bool { +fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool { let rty = tcx.type_of(item_def_id); // Check that it is possible to represent this type. This call identifies @@ -1706,7 +1706,7 @@ fn check_representable<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, item_def_id: DefId) -> return true; } -pub fn check_simd<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) { +pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { let t = tcx.type_of(def_id); if let ty::Adt(def, substs) = t.sty { if def.is_struct() { @@ -1735,7 +1735,7 @@ pub fn check_simd<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) { } } -fn check_packed<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) { +fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { let repr = tcx.adt_def(def_id).repr; if repr.packed() { for attr in tcx.get_attrs(def_id).iter() { @@ -1759,7 +1759,7 @@ fn check_packed<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) { } } -fn check_packed_inner<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, stack: &mut Vec) -> bool { +fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec) -> bool { let t = tcx.type_of(def_id); if stack.contains(&def_id) { debug!("check_packed_inner: {:?} is recursive", t); @@ -1833,7 +1833,7 @@ fn bad_non_zero_sized_fields<'tcx>( err.emit(); } -fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) { +fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { let adt = tcx.adt_def(def_id); if !adt.repr.transparent() { return; @@ -1982,7 +1982,7 @@ pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], i check_transparent(tcx, sp, def_id); } -fn report_unexpected_variant_res<'tcx>(tcx: TyCtxt<'tcx>, res: Res, span: Span, qpath: &QPath) { +fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) { span_err!(tcx.sess, span, E0533, "expected unit struct/variant or constant, found {} `{}`", res.descr(), diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 034ff5f834767..2c48bd8b4f026 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -3,7 +3,7 @@ use crate::constrained_generic_params::{identify_constrained_generic_params, Par use crate::hir::def_id::DefId; use rustc::traits::{self, ObligationCauseCode}; -use rustc::ty::{self, Lift, Ty, TyCtxt, GenericParamDefKind, TypeFoldable, ToPredicate}; +use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, TypeFoldable, ToPredicate}; use rustc::ty::subst::{Subst, InternalSubsts}; use rustc::util::nodemap::{FxHashSet, FxHashMap}; use rustc::mir::interpret::ConstValue; @@ -68,7 +68,7 @@ impl<'tcx> CheckWfFcxBuilder<'tcx> { /// We do this check as a pre-pass before checking fn bodies because if these constraints are /// not included it frequently leads to confusing errors in fn bodies. So it's better to check /// the types first. -pub fn check_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +pub fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) { let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); let item = tcx.hir().expect_item(hir_id); @@ -156,7 +156,7 @@ pub fn check_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { } } -pub fn check_trait_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +pub fn check_trait_item(tcx: TyCtxt<'_>, def_id: DefId) { let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); let trait_item = tcx.hir().expect_trait_item(hir_id); @@ -167,7 +167,7 @@ pub fn check_trait_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { check_associated_item(tcx, trait_item.hir_id, trait_item.span, method_sig); } -pub fn check_impl_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +pub fn check_impl_item(tcx: TyCtxt<'_>, def_id: DefId) { let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); let impl_item = tcx.hir().expect_impl_item(hir_id); @@ -178,8 +178,8 @@ pub fn check_impl_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { check_associated_item(tcx, impl_item.hir_id, impl_item.span, method_sig); } -fn check_associated_item<'tcx>( - tcx: TyCtxt<'tcx>, +fn check_associated_item( + tcx: TyCtxt<'_>, item_id: hir::HirId, span: Span, sig_if_method: Option<&hir::MethodSig>, @@ -231,7 +231,7 @@ fn for_item<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item) -> CheckWfFcxBuilder<'tcx for_id(tcx, item.hir_id, item.span) } -fn for_id<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) -> CheckWfFcxBuilder<'tcx> { +fn for_id(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) -> CheckWfFcxBuilder<'_> { let def_id = tcx.hir().local_def_id_from_hir_id(id); CheckWfFcxBuilder { inherited: Inherited::build(tcx, def_id), @@ -261,14 +261,15 @@ fn check_type_defn<'tcx, F>( let needs_drop_copy = || { packed && { let ty = variant.fields.last().unwrap().ty; - fcx.tcx.erase_regions(&ty).lift_to_tcx(fcx_tcx) - .map(|ty| ty.needs_drop(fcx_tcx, fcx_tcx.param_env(def_id))) - .unwrap_or_else(|| { + let ty = fcx.tcx.erase_regions(&ty); + if ty.has_local_value() { fcx_tcx.sess.delay_span_bug( item.span, &format!("inference variables in {:?}", ty)); // Just treat unresolved type expression as if it needs drop. true - }) + } else { + ty.needs_drop(fcx_tcx, fcx_tcx.param_env(def_id)) + } } }; let all_sized = @@ -316,7 +317,7 @@ fn check_type_defn<'tcx, F>( }); } -fn check_trait<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item) { +fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item) { debug!("check_trait: {:?}", item.hir_id); let trait_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id); @@ -339,7 +340,7 @@ fn check_trait<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item) { }); } -fn check_item_fn<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item) { +fn check_item_fn(tcx: TyCtxt<'_>, item: &hir::Item) { for_item(tcx, item).with_fcx(|fcx, tcx| { let def_id = fcx.tcx.hir().local_def_id_from_hir_id(item.hir_id); let sig = fcx.tcx.fn_sig(def_id); @@ -351,8 +352,8 @@ fn check_item_fn<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item) { }) } -fn check_item_type<'tcx>( - tcx: TyCtxt<'tcx>, +fn check_item_type( + tcx: TyCtxt<'_>, item_id: hir::HirId, ty_span: Span, allow_foreign_ty: bool, @@ -979,7 +980,7 @@ fn check_variances_for_type_defn<'tcx>( } } -fn report_bivariance<'tcx>(tcx: TyCtxt<'tcx>, span: Span, param_name: ast::Name) { +fn report_bivariance(tcx: TyCtxt<'_>, span: Span, param_name: ast::Name) { let mut err = error_392(tcx, span, param_name); let suggested_marker_id = tcx.lang_items().phantom_data(); @@ -1022,7 +1023,7 @@ fn reject_shadowing_parameters(tcx: TyCtxt<'_>, def_id: DefId) { /// Feature gates RFC 2056 -- trivial bounds, checking for global bounds that /// aren't true. -fn check_false_global_bounds<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, span: Span, id: hir::HirId) { +fn check_false_global_bounds(fcx: &FnCtxt<'_, '_>, span: Span, id: hir::HirId) { let empty_env = ty::ParamEnv::empty(); let def_id = fcx.tcx.hir().local_def_id_from_hir_id(id); @@ -1134,11 +1135,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } -fn error_392<'tcx>( - tcx: TyCtxt<'tcx>, +fn error_392( + tcx: TyCtxt<'_>, span: Span, param_name: ast::Name, -) -> DiagnosticBuilder<'tcx> { +) -> DiagnosticBuilder<'_> { let mut err = struct_span_err!(tcx.sess, span, E0392, "parameter `{}` is never used", param_name); err.span_label(span, "unused parameter"); diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 6a95dec1c81bc..28711e32a4c51 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -363,10 +363,8 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } fn visit_free_region_map(&mut self) { - let free_region_map = self.tcx() - .lift_to_global(&self.fcx.tables.borrow().free_region_map); - let free_region_map = free_region_map.expect("all regions in free-region-map are global"); - self.tables.free_region_map = free_region_map; + self.tables.free_region_map = self.fcx.tables.borrow().free_region_map.clone(); + debug_assert!(!self.tables.free_region_map.elements().any(|r| r.has_local_value())); } fn visit_user_provided_tys(&mut self) { @@ -381,12 +379,10 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { local_id, }; - let c_ty = if let Some(c_ty) = self.tcx().lift_to_global(c_ty) { - c_ty - } else { + if cfg!(debug_assertions) && c_ty.has_local_value() { span_bug!( hir_id.to_span(self.fcx.tcx), - "writeback: `{:?}` missing from the global type context", + "writeback: `{:?}` is a local value", c_ty ); }; @@ -423,12 +419,10 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); for (&def_id, c_sig) in fcx_tables.user_provided_sigs.iter() { - let c_sig = if let Some(c_sig) = self.tcx().lift_to_global(c_sig) { - c_sig - } else { + if cfg!(debug_assertions) && c_sig.has_local_value() { span_bug!( self.fcx.tcx.hir().span_if_local(def_id).unwrap(), - "writeback: `{:?}` missing from the global type context", + "writeback: `{:?}` is a local value", c_sig ); }; @@ -592,10 +586,10 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } } - if let Some(substs) = self.tcx().lift_to_global(&opaque_defn.substs) { + if !opaque_defn.substs.has_local_value() { let new = ty::ResolvedOpaqueTy { concrete_type: definition_ty, - substs, + substs: opaque_defn.substs, }; let old = self.tables @@ -617,7 +611,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } else { self.tcx().sess.delay_span_bug( span, - "cannot lift `opaque_defn` substs to global type context", + "`opaque_defn` is a local value", ); } } @@ -743,20 +737,19 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } } - fn resolve(&self, x: &T, span: &dyn Locatable) -> T::Lifted + fn resolve(&self, x: &T, span: &dyn Locatable) -> T where - T: TypeFoldable<'tcx> + ty::Lift<'tcx>, + T: TypeFoldable<'tcx>, { let x = x.fold_with(&mut Resolver::new(self.fcx, span, self.body)); - if let Some(lifted) = self.tcx().lift_to_global(&x) { - lifted - } else { + if cfg!(debug_assertions) && x.has_local_value() { span_bug!( span.to_span(self.fcx.tcx), - "writeback: `{:?}` missing from the global type context", + "writeback: `{:?}` is a local value", x ); } + x } } diff --git a/src/librustc_typeck/check_unused.rs b/src/librustc_typeck/check_unused.rs index 7e781eeec56a9..8614de1977085 100644 --- a/src/librustc_typeck/check_unused.rs +++ b/src/librustc_typeck/check_unused.rs @@ -13,7 +13,7 @@ use rustc::util::nodemap::DefIdSet; use rustc_data_structures::fx::FxHashMap; -pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check_crate(tcx: TyCtxt<'_>) { let mut used_trait_imports = DefIdSet::default(); for &body_id in tcx.hir().krate().bodies.keys() { let item_def_id = tcx.hir().body_owner_def_id(body_id); @@ -70,7 +70,7 @@ impl CheckVisitor<'tcx> { } } -fn unused_crates_lint<'tcx>(tcx: TyCtxt<'tcx>) { +fn unused_crates_lint(tcx: TyCtxt<'_>) { let lint = lint::builtin::UNUSED_EXTERN_CRATES; // Collect first the crates that are completely unused. These we diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index 42deeaf31f427..68bdcbfe3fd95 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -17,7 +17,7 @@ use rustc::hir::def_id::DefId; use hir::Node; use rustc::hir::{self, ItemKind}; -pub fn check_trait<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId) { +pub fn check_trait(tcx: TyCtxt<'_>, trait_def_id: DefId) { Checker { tcx, trait_def_id } .check(tcx.lang_items().drop_trait(), visit_implementation_of_drop) .check(tcx.lang_items().copy_trait(), visit_implementation_of_copy) @@ -46,7 +46,7 @@ impl<'tcx> Checker<'tcx> { } } -fn visit_implementation_of_drop<'tcx>(tcx: TyCtxt<'tcx>, impl_did: DefId) { +fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: DefId) { if let ty::Adt(..) = tcx.type_of(impl_did).sty { /* do nothing */ } else { @@ -74,7 +74,7 @@ fn visit_implementation_of_drop<'tcx>(tcx: TyCtxt<'tcx>, impl_did: DefId) { } } -fn visit_implementation_of_copy<'tcx>(tcx: TyCtxt<'tcx>, impl_did: DefId) { +fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: DefId) { debug!("visit_implementation_of_copy: impl_did={:?}", impl_did); let impl_hir_id = if let Some(n) = tcx.hir().as_local_hir_id(impl_did) { @@ -154,7 +154,7 @@ fn visit_implementation_of_coerce_unsized(tcx: TyCtxt<'tcx>, impl_did: DefId) { } } -fn visit_implementation_of_dispatch_from_dyn<'tcx>(tcx: TyCtxt<'tcx>, impl_did: DefId) { +fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: DefId) { debug!("visit_implementation_of_dispatch_from_dyn: impl_did={:?}", impl_did); if impl_did.is_local() { diff --git a/src/librustc_typeck/coherence/inherent_impls.rs b/src/librustc_typeck/coherence/inherent_impls.rs index 6088c03fc0681..f208c6a138d26 100644 --- a/src/librustc_typeck/coherence/inherent_impls.rs +++ b/src/librustc_typeck/coherence/inherent_impls.rs @@ -17,10 +17,10 @@ use syntax::ast; use syntax_pos::Span; /// On-demand query: yields a map containing all types mapped to their inherent impls. -pub fn crate_inherent_impls<'tcx>( - tcx: TyCtxt<'tcx>, +pub fn crate_inherent_impls( + tcx: TyCtxt<'_>, crate_num: CrateNum, -) -> &'tcx CrateInherentImpls { +) -> &CrateInherentImpls { assert_eq!(crate_num, LOCAL_CRATE); let krate = tcx.hir().krate(); @@ -33,7 +33,7 @@ pub fn crate_inherent_impls<'tcx>( } /// On-demand query: yields a vector of the inherent impls for a specific type. -pub fn inherent_impls<'tcx>(tcx: TyCtxt<'tcx>, ty_def_id: DefId) -> &'tcx [DefId] { +pub fn inherent_impls(tcx: TyCtxt<'_>, ty_def_id: DefId) -> &[DefId] { assert!(ty_def_id.is_local()); // NB. Until we adopt the red-green dep-tracking algorithm (see diff --git a/src/librustc_typeck/coherence/inherent_impls_overlap.rs b/src/librustc_typeck/coherence/inherent_impls_overlap.rs index aae1b1777a30f..1785304fb1d48 100644 --- a/src/librustc_typeck/coherence/inherent_impls_overlap.rs +++ b/src/librustc_typeck/coherence/inherent_impls_overlap.rs @@ -5,7 +5,7 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::traits::{self, IntercrateMode}; use rustc::ty::TyCtxt; -pub fn crate_inherent_impls_overlap_check<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) { +pub fn crate_inherent_impls_overlap_check(tcx: TyCtxt<'_>, crate_num: CrateNum) { assert_eq!(crate_num, LOCAL_CRATE); let krate = tcx.hir().krate(); krate.visit_all_item_likes(&mut InherentOverlapChecker { tcx }); diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 4336e861ce216..9b9789139b70f 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -18,7 +18,7 @@ mod inherent_impls_overlap; mod orphan; mod unsafety; -fn check_impl<'tcx>(tcx: TyCtxt<'tcx>, hir_id: HirId) { +fn check_impl(tcx: TyCtxt<'_>, hir_id: HirId) { let impl_def_id = tcx.hir().local_def_id_from_hir_id(hir_id); // If there are no traits, then this implementation must have a @@ -124,7 +124,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn coherent_trait<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { +fn coherent_trait(tcx: TyCtxt<'_>, def_id: DefId) { let impls = tcx.hir().trait_impls(def_id); for &impl_id in impls { check_impl(tcx, impl_id); @@ -135,7 +135,7 @@ fn coherent_trait<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) { builtin::check_trait(tcx, def_id); } -pub fn check_coherence<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check_coherence(tcx: TyCtxt<'_>) { for &trait_def_id in tcx.hir().krate().trait_impls.keys() { tcx.ensure().coherent_trait(trait_def_id); } @@ -151,7 +151,7 @@ pub fn check_coherence<'tcx>(tcx: TyCtxt<'tcx>) { /// Overlap: no two impls for the same trait are implemented for the /// same type. Likewise, no two inherent impls for a given type /// constructor provide a method with the same name. -fn check_impl_overlap<'tcx>(tcx: TyCtxt<'tcx>, hir_id: HirId) { +fn check_impl_overlap(tcx: TyCtxt<'_>, hir_id: HirId) { let impl_def_id = tcx.hir().local_def_id_from_hir_id(hir_id); let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap(); let trait_def_id = trait_ref.def_id; diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index 4e6fcfe0593e2..2d0faecd8ee71 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -6,7 +6,7 @@ use rustc::ty::{self, TyCtxt}; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir; -pub fn check<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check(tcx: TyCtxt<'_>) { let mut orphan = OrphanChecker { tcx }; tcx.hir().krate().visit_all_item_likes(&mut orphan); } diff --git a/src/librustc_typeck/coherence/unsafety.rs b/src/librustc_typeck/coherence/unsafety.rs index c41a0e1514e68..123d7c6123b89 100644 --- a/src/librustc_typeck/coherence/unsafety.rs +++ b/src/librustc_typeck/coherence/unsafety.rs @@ -5,7 +5,7 @@ use rustc::ty::TyCtxt; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::{self, Unsafety}; -pub fn check<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn check(tcx: TyCtxt<'_>) { let mut unsafety = UnsafetyChecker { tcx }; tcx.hir().krate().visit_all_item_likes(&mut unsafety); } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 87e1166b7c041..e5802179ec479 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -56,7 +56,7 @@ struct OnlySelfBounds(bool); /////////////////////////////////////////////////////////////////////////// // Main entry point -fn collect_mod_item_types<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn collect_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module( module_def_id, &mut CollectItemTypesVisitor { tcx }.as_deep_visitor() @@ -253,10 +253,10 @@ impl AstConv<'tcx> for ItemCtxt<'tcx> { } } -fn type_param_predicates<'tcx>( - tcx: TyCtxt<'tcx>, +fn type_param_predicates( + tcx: TyCtxt<'_>, (item_def_id, def_id): (DefId, DefId), -) -> &'tcx ty::GenericPredicates<'tcx> { +) -> &ty::GenericPredicates<'_> { use rustc::hir::*; // In the AST, bounds can derive from two places. Either @@ -381,7 +381,7 @@ impl ItemCtxt<'tcx> { /// parameter with ID `param_id`. We use this so as to avoid running /// `ast_ty_to_ty`, because we want to avoid triggering an all-out /// conversion of the type to avoid inducing unnecessary cycles. -fn is_param<'tcx>(tcx: TyCtxt<'tcx>, ast_ty: &hir::Ty, param_id: hir::HirId) -> bool { +fn is_param(tcx: TyCtxt<'_>, ast_ty: &hir::Ty, param_id: hir::HirId) -> bool { if let hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) = ast_ty.node { match path.res { Res::SelfTy(Some(def_id), None) | Res::Def(DefKind::TyParam, def_id) => { @@ -394,7 +394,7 @@ fn is_param<'tcx>(tcx: TyCtxt<'tcx>, ast_ty: &hir::Ty, param_id: hir::HirId) -> } } -fn convert_item<'tcx>(tcx: TyCtxt<'tcx>, item_id: hir::HirId) { +fn convert_item(tcx: TyCtxt<'_>, item_id: hir::HirId) { let it = tcx.hir().expect_item(item_id); debug!("convert: item {} with id {}", it.ident, it.hir_id); let def_id = tcx.hir().local_def_id_from_hir_id(item_id); @@ -476,7 +476,7 @@ fn convert_item<'tcx>(tcx: TyCtxt<'tcx>, item_id: hir::HirId) { } } -fn convert_trait_item<'tcx>(tcx: TyCtxt<'tcx>, trait_item_id: hir::HirId) { +fn convert_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::HirId) { let trait_item = tcx.hir().expect_trait_item(trait_item_id); let def_id = tcx.hir().local_def_id_from_hir_id(trait_item.hir_id); tcx.generics_of(def_id); @@ -497,7 +497,7 @@ fn convert_trait_item<'tcx>(tcx: TyCtxt<'tcx>, trait_item_id: hir::HirId) { tcx.predicates_of(def_id); } -fn convert_impl_item<'tcx>(tcx: TyCtxt<'tcx>, impl_item_id: hir::HirId) { +fn convert_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::HirId) { let def_id = tcx.hir().local_def_id_from_hir_id(impl_item_id); tcx.generics_of(def_id); tcx.type_of(def_id); @@ -507,7 +507,7 @@ fn convert_impl_item<'tcx>(tcx: TyCtxt<'tcx>, impl_item_id: hir::HirId) { } } -fn convert_variant_ctor<'tcx>(tcx: TyCtxt<'tcx>, ctor_id: hir::HirId) { +fn convert_variant_ctor(tcx: TyCtxt<'_>, ctor_id: hir::HirId) { let def_id = tcx.hir().local_def_id_from_hir_id(ctor_id); tcx.generics_of(def_id); tcx.type_of(def_id); @@ -562,8 +562,8 @@ fn convert_enum_variant_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, variants: } } -fn convert_variant<'tcx>( - tcx: TyCtxt<'tcx>, +fn convert_variant( + tcx: TyCtxt<'_>, variant_did: Option, ctor_did: Option, ident: Ident, @@ -619,7 +619,7 @@ fn convert_variant<'tcx>( ) } -fn adt_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::AdtDef { +fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef { use rustc::hir::*; let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); @@ -686,10 +686,10 @@ fn adt_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::AdtDef { /// Ensures that the super-predicates of the trait with a `DefId` /// of `trait_def_id` are converted and stored. This also ensures that /// the transitive super-predicates are converted. -fn super_predicates_of<'tcx>( - tcx: TyCtxt<'tcx>, +fn super_predicates_of( + tcx: TyCtxt<'_>, trait_def_id: DefId, -) -> &'tcx ty::GenericPredicates<'tcx> { +) -> &ty::GenericPredicates<'_> { debug!("super_predicates(trait_def_id={:?})", trait_def_id); let trait_hir_id = tcx.hir().as_local_hir_id(trait_def_id).unwrap(); @@ -740,7 +740,7 @@ fn super_predicates_of<'tcx>( }) } -fn trait_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::TraitDef { +fn trait_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TraitDef { let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); let item = tcx.hir().expect_item(hir_id); @@ -879,7 +879,7 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::Generics { +fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { use rustc::hir::*; let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); @@ -1122,7 +1122,7 @@ fn generics_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::Generics { }) } -fn report_assoc_ty_on_inherent_impl<'tcx>(tcx: TyCtxt<'tcx>, span: Span) { +fn report_assoc_ty_on_inherent_impl(tcx: TyCtxt<'_>, span: Span) { span_err!( tcx.sess, span, @@ -1131,7 +1131,7 @@ fn report_assoc_ty_on_inherent_impl<'tcx>(tcx: TyCtxt<'tcx>, span: Span) { ); } -fn type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Ty<'tcx> { +fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { checked_type_of(tcx, def_id, true).unwrap() } @@ -1139,7 +1139,7 @@ fn type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Ty<'tcx> { /// /// If you want to fail anyway, you can set the `fail` parameter to true, but in this case, /// you'd better just call [`type_of`] directly. -pub fn checked_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, fail: bool) -> Option> { +pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option> { use rustc::hir::*; let hir_id = match tcx.hir().as_local_hir_id(def_id) { @@ -1353,7 +1353,7 @@ pub fn checked_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, fail: bool) -> Op None } } - Node::TraitRef(&hir::TraitRef { ref path, .. }) => Some(path), + Node::TraitRef(&hir::TraitRef { ref path, .. }) => Some(&**path), _ => None, }; @@ -1464,7 +1464,7 @@ pub fn checked_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, fail: bool) -> Op }) } -fn find_existential_constraints<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Ty<'tcx> { +fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { use rustc::hir::{ImplItem, Item, TraitItem}; debug!("find_existential_constraints({:?})", def_id); @@ -1682,7 +1682,7 @@ fn find_existential_constraints<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Ty<'t } } -fn fn_sig<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::PolyFnSig<'tcx> { +fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> { use rustc::hir::*; use rustc::hir::Node::*; @@ -1758,7 +1758,7 @@ fn fn_sig<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::PolyFnSig<'tcx> { } } -fn impl_trait_ref<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option> { +fn impl_trait_ref(tcx: TyCtxt<'_>, def_id: DefId) -> Option> { let icx = ItemCtxt::new(tcx, def_id); let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); @@ -1773,7 +1773,7 @@ fn impl_trait_ref<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option(tcx: TyCtxt<'tcx>, def_id: DefId) -> hir::ImplPolarity { +fn impl_polarity(tcx: TyCtxt<'_>, def_id: DefId) -> hir::ImplPolarity { let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); match tcx.hir().expect_item(hir_id).node { hir::ItemKind::Impl(_, polarity, ..) => polarity, @@ -1804,10 +1804,10 @@ fn early_bound_lifetimes_from_generics<'a, 'tcx: 'a>( /// Returns a list of type predicates for the definition with ID `def_id`, including inferred /// lifetime constraints. This includes all predicates returned by `explicit_predicates_of`, plus /// inferred constraints concerning which regions outlive other regions. -fn predicates_defined_on<'tcx>( - tcx: TyCtxt<'tcx>, +fn predicates_defined_on( + tcx: TyCtxt<'_>, def_id: DefId, -) -> &'tcx ty::GenericPredicates<'tcx> { +) -> &ty::GenericPredicates<'_> { debug!("predicates_defined_on({:?})", def_id); let mut result = tcx.explicit_predicates_of(def_id); debug!( @@ -1834,7 +1834,7 @@ fn predicates_defined_on<'tcx>( /// Returns a list of all type predicates (explicit and implicit) for the definition with /// ID `def_id`. This includes all predicates returned by `predicates_defined_on`, plus /// `Self: Trait` predicates for traits. -fn predicates_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::GenericPredicates<'tcx> { +fn predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::GenericPredicates<'_> { let mut result = tcx.predicates_defined_on(def_id); if tcx.is_trait(def_id) { @@ -1861,10 +1861,10 @@ fn predicates_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::GenericPre /// Returns a list of user-specified type predicates for the definition with ID `def_id`. /// N.B., this does not include any implied/inferred constraints. -fn explicit_predicates_of<'tcx>( - tcx: TyCtxt<'tcx>, +fn explicit_predicates_of( + tcx: TyCtxt<'_>, def_id: DefId, -) -> &'tcx ty::GenericPredicates<'tcx> { +) -> &ty::GenericPredicates<'_> { use rustc::hir::*; use rustc_data_structures::fx::FxHashSet; @@ -2271,7 +2271,7 @@ fn compute_sig_of_foreign_fn_decl<'tcx>( fty } -fn is_foreign_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { +fn is_foreign_item(tcx: TyCtxt<'_>, def_id: DefId) -> bool { match tcx.hir().get_if_local(def_id) { Some(Node::ForeignItem(..)) => true, Some(_) => false, @@ -2279,7 +2279,7 @@ fn is_foreign_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool { } } -fn static_mutability<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option { +fn static_mutability(tcx: TyCtxt<'_>, def_id: DefId) -> Option { match tcx.hir().get_if_local(def_id) { Some(Node::Item(&hir::Item { node: hir::ItemKind::Static(_, mutbl, _), .. @@ -2387,7 +2387,7 @@ fn from_target_feature( } } -fn linkage_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Linkage { +fn linkage_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Linkage { use rustc::mir::mono::Linkage::*; // Use the names from src/llvm/docs/LangRef.rst here. Most types are only @@ -2422,7 +2422,7 @@ fn linkage_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Linkag } } -fn codegen_fn_attrs<'tcx>(tcx: TyCtxt<'tcx>, id: DefId) -> CodegenFnAttrs { +fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs { let attrs = tcx.get_attrs(id); let mut codegen_fn_attrs = CodegenFnAttrs::new(); diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs index b833d8555ee0a..08c7cbc389a67 100644 --- a/src/librustc_typeck/impl_wf_check.rs +++ b/src/librustc_typeck/impl_wf_check.rs @@ -49,7 +49,7 @@ use syntax_pos::Span; /// impl<'a> Trait for Bar { type X = &'a i32; } /// // ^ 'a is unused and appears in assoc type, error /// ``` -pub fn impl_wf_check<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn impl_wf_check(tcx: TyCtxt<'_>) { // We will tag this as part of the WF check -- logically, it is, // but it's one that we must perform earlier than the rest of // WfCheck. @@ -58,7 +58,7 @@ pub fn impl_wf_check<'tcx>(tcx: TyCtxt<'tcx>) { } } -fn check_mod_impl_wf<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) { +fn check_mod_impl_wf(tcx: TyCtxt<'_>, module_def_id: DefId) { tcx.hir().visit_item_likes_in_module( module_def_id, &mut ImplWfCheck { tcx } @@ -92,8 +92,8 @@ impl ItemLikeVisitor<'tcx> for ImplWfCheck<'tcx> { fn visit_impl_item(&mut self, _impl_item: &'tcx hir::ImplItem) { } } -fn enforce_impl_params_are_constrained<'tcx>( - tcx: TyCtxt<'tcx>, +fn enforce_impl_params_are_constrained( + tcx: TyCtxt<'_>, impl_def_id: DefId, impl_item_refs: &[hir::ImplItemRef], ) { @@ -183,7 +183,7 @@ fn report_unused_parameter(tcx: TyCtxt<'_>, span: Span, kind: &str, name: &str) } /// Enforce that we do not have two items in an impl with the same name. -fn enforce_impl_items_are_distinct<'tcx>(tcx: TyCtxt<'tcx>, impl_item_refs: &[hir::ImplItemRef]) { +fn enforce_impl_items_are_distinct(tcx: TyCtxt<'_>, impl_item_refs: &[hir::ImplItemRef]) { let mut seen_type_items = FxHashMap::default(); let mut seen_value_items = FxHashMap::default(); for impl_item_ref in impl_item_refs { diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 85ae55b2dd946..56c7544eaf57a 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -161,7 +161,7 @@ fn require_same_types<'tcx>( }) } -fn check_main_fn_ty<'tcx>(tcx: TyCtxt<'tcx>, main_def_id: DefId) { +fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: DefId) { let main_id = tcx.hir().as_local_hir_id(main_def_id).unwrap(); let main_span = tcx.def_span(main_def_id); let main_t = tcx.type_of(main_def_id); @@ -226,7 +226,7 @@ fn check_main_fn_ty<'tcx>(tcx: TyCtxt<'tcx>, main_def_id: DefId) { } } -fn check_start_fn_ty<'tcx>(tcx: TyCtxt<'tcx>, start_def_id: DefId) { +fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: DefId) { let start_id = tcx.hir().as_local_hir_id(start_def_id).unwrap(); let start_span = tcx.def_span(start_def_id); let start_t = tcx.type_of(start_def_id); @@ -283,7 +283,7 @@ fn check_start_fn_ty<'tcx>(tcx: TyCtxt<'tcx>, start_def_id: DefId) { } } -fn check_for_entry_fn<'tcx>(tcx: TyCtxt<'tcx>) { +fn check_for_entry_fn(tcx: TyCtxt<'_>) { match tcx.entry_fn(LOCAL_CRATE) { Some((def_id, EntryFnType::Main)) => check_main_fn_ty(tcx, def_id), Some((def_id, EntryFnType::Start)) => check_start_fn_ty(tcx, def_id), @@ -300,7 +300,7 @@ pub fn provide(providers: &mut Providers<'_>) { impl_wf_check::provide(providers); } -pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>) -> Result<(), ErrorReported> { +pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> { tcx.sess.profiler(|p| p.start_activity("type-check crate")); // this ensures that later parts of type checking can assume that items diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs index 63e41e01fbff5..6b8f6fccd40d7 100644 --- a/src/librustc_typeck/outlives/mod.rs +++ b/src/librustc_typeck/outlives/mod.rs @@ -20,10 +20,10 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn inferred_outlives_of<'tcx>( - tcx: TyCtxt<'tcx>, +fn inferred_outlives_of( + tcx: TyCtxt<'_>, item_def_id: DefId, -) -> &'tcx [ty::Predicate<'tcx>] { +) -> &[ty::Predicate<'_>] { let id = tcx .hir() .as_local_hir_id(item_def_id) @@ -70,10 +70,10 @@ fn inferred_outlives_of<'tcx>( } } -fn inferred_outlives_crate<'tcx>( - tcx: TyCtxt<'tcx>, +fn inferred_outlives_crate( + tcx: TyCtxt<'_>, crate_num: CrateNum, -) -> &'tcx CratePredicatesMap<'tcx> { +) -> &CratePredicatesMap<'_> { assert_eq!(crate_num, LOCAL_CRATE); // Compute a map from each struct/enum/union S to the **explicit** diff --git a/src/librustc_typeck/outlives/test.rs b/src/librustc_typeck/outlives/test.rs index 4690cb9eada2e..5ddf95b0f80c2 100644 --- a/src/librustc_typeck/outlives/test.rs +++ b/src/librustc_typeck/outlives/test.rs @@ -3,7 +3,7 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::ty::TyCtxt; use syntax::symbol::sym; -pub fn test_inferred_outlives<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn test_inferred_outlives(tcx: TyCtxt<'_>) { tcx.hir() .krate() .visit_all_item_likes(&mut OutlivesTest { tcx }); diff --git a/src/librustc_typeck/outlives/utils.rs b/src/librustc_typeck/outlives/utils.rs index c6b0da3fe474c..783890da639f4 100644 --- a/src/librustc_typeck/outlives/utils.rs +++ b/src/librustc_typeck/outlives/utils.rs @@ -125,7 +125,7 @@ pub fn insert_outlives_predicate<'tcx>( } } -fn is_free_region<'tcx>(tcx: TyCtxt<'tcx>, region: Region<'_>) -> bool { +fn is_free_region(tcx: TyCtxt<'_>, region: Region<'_>) -> bool { // First, screen for regions that might appear in a type header. match region { // These correspond to `T: 'a` relationships: diff --git a/src/librustc_typeck/variance/mod.rs b/src/librustc_typeck/variance/mod.rs index 1a8871a3da9da..343d7ea656fbb 100644 --- a/src/librustc_typeck/variance/mod.rs +++ b/src/librustc_typeck/variance/mod.rs @@ -34,7 +34,7 @@ pub fn provide(providers: &mut Providers<'_>) { }; } -fn crate_variances<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> &'tcx CrateVariancesMap<'tcx> { +fn crate_variances(tcx: TyCtxt<'_>, crate_num: CrateNum) -> &CrateVariancesMap<'_> { assert_eq!(crate_num, LOCAL_CRATE); let mut arena = arena::TypedArena::default(); let terms_cx = terms::determine_parameters_to_be_inferred(tcx, &mut arena); @@ -42,7 +42,7 @@ fn crate_variances<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> &'tcx CrateV tcx.arena.alloc(solve::solve_constraints(constraints_cx)) } -fn variances_of<'tcx>(tcx: TyCtxt<'tcx>, item_def_id: DefId) -> &'tcx [ty::Variance] { +fn variances_of(tcx: TyCtxt<'_>, item_def_id: DefId) -> &[ty::Variance] { let id = tcx.hir().as_local_hir_id(item_def_id).expect("expected local def-id"); let unsupported = || { // Variance not relevant. diff --git a/src/librustc_typeck/variance/test.rs b/src/librustc_typeck/variance/test.rs index cefc200f5cba8..0c7ebc34e8f6d 100644 --- a/src/librustc_typeck/variance/test.rs +++ b/src/librustc_typeck/variance/test.rs @@ -3,7 +3,7 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::ty::TyCtxt; use syntax::symbol::sym; -pub fn test_variance<'tcx>(tcx: TyCtxt<'tcx>) { +pub fn test_variance(tcx: TyCtxt<'_>) { tcx.hir().krate().visit_all_item_likes(&mut VarianceTest { tcx }); } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 3fe048a6986bb..7353c3ec2e557 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -20,6 +20,7 @@ use rustc::mir::interpret::{GlobalId, ConstValue}; use rustc::hir; use rustc::hir::def::{CtorKind, DefKind, Res}; use rustc::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use rustc::hir::ptr::P; use rustc::ty::subst::{InternalSubsts, SubstsRef, UnpackedKind}; use rustc::ty::{self, DefIdTree, TyCtxt, Region, RegionVid, Ty, AdtKind}; use rustc::ty::fold::TypeFolder; @@ -29,7 +30,6 @@ use syntax::ast::{self, AttrStyle, Ident}; use syntax::attr; use syntax::ext::base::MacroKind; use syntax::source_map::{dummy_spanned, Spanned}; -use syntax::ptr::P; use syntax::symbol::{Symbol, kw, sym}; use syntax::symbol::InternedString; use syntax_pos::{self, Pos, FileName}; diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 2557b8d1627c0..45a3c8a3c2256 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -6,11 +6,11 @@ use syntax::ast; use syntax::ast::{Name, NodeId}; use syntax::attr; use syntax::ext::base::MacroKind; -use syntax::ptr::P; use syntax_pos::{self, Span}; use rustc::hir; use rustc::hir::def_id::CrateNum; +use rustc::hir::ptr::P; pub struct Module<'hir> { pub name: Option, diff --git a/src/libstd/process.rs b/src/libstd/process.rs index a568f46663730..000f80f99e7a9 100644 --- a/src/libstd/process.rs +++ b/src/libstd/process.rs @@ -1765,33 +1765,6 @@ mod tests { assert_eq!(out, "foobar\n"); } - - #[test] - #[cfg_attr(target_os = "android", ignore)] - #[cfg(unix)] - fn uid_works() { - use crate::os::unix::prelude::*; - - let mut p = Command::new("/bin/sh") - .arg("-c").arg("true") - .uid(unsafe { libc::getuid() }) - .gid(unsafe { libc::getgid() }) - .spawn().unwrap(); - assert!(p.wait().unwrap().success()); - } - - #[test] - #[cfg_attr(target_os = "android", ignore)] - #[cfg(unix)] - fn uid_to_root_fails() { - use crate::os::unix::prelude::*; - - // if we're already root, this isn't a valid test. Most of the bots run - // as non-root though (android is an exception). - if unsafe { libc::getuid() == 0 } { return } - assert!(Command::new("/bin/ls").uid(0).gid(0).spawn().is_err()); - } - #[test] #[cfg_attr(target_os = "android", ignore)] fn test_process_status() { diff --git a/src/libsyntax/attr/mod.rs b/src/libsyntax/attr/mod.rs index 436620ae7293b..453b6ebf3c49d 100644 --- a/src/libsyntax/attr/mod.rs +++ b/src/libsyntax/attr/mod.rs @@ -440,12 +440,12 @@ pub fn contains_name(attrs: &[Attribute], name: Symbol) -> bool { }) } -pub fn find_by_name<'a>(attrs: &'a [Attribute], name: Symbol) -> Option<&'a Attribute> { +pub fn find_by_name(attrs: &[Attribute], name: Symbol) -> Option<&Attribute> { attrs.iter().find(|attr| attr.check_name(name)) } -pub fn filter_by_name<'a>(attrs: &'a [Attribute], name: Symbol) - -> impl Iterator { +pub fn filter_by_name(attrs: &[Attribute], name: Symbol) + -> impl Iterator { attrs.iter().filter(move |attr| attr.check_name(name)) } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 5473f55aa3370..3f2bae50325d5 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1525,9 +1525,7 @@ impl<'feat> ExpansionConfig<'feat> { } fn enable_custom_inner_attributes(&self) -> bool { - self.features.map_or(false, |features| { - features.custom_inner_attributes || features.custom_attribute || features.rustc_attrs - }) + self.features.map_or(false, |features| features.custom_inner_attributes) } } diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 92ce3779a3c81..fc8aa4793bc61 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -901,7 +901,7 @@ fn may_begin_with(token: &Token, name: Name) -> bool { /// # Returns /// /// The parsed non-terminal. -fn parse_nt<'a>(p: &mut Parser<'a>, sp: Span, name: Symbol) -> Nonterminal { +fn parse_nt(p: &mut Parser<'_>, sp: Span, name: Symbol) -> Nonterminal { if name == sym::tt { return token::NtTT(p.parse_token_tree()); } diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index f97e9d43854fc..a8e2b997d8acd 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -1289,6 +1289,18 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ attribute is just used for rustc unit \ tests and will never be stable", cfg_fn!(rustc_attrs))), + (sym::rustc_dump_env_program_clauses, Whitelisted, template!(Word), Gated(Stability::Unstable, + sym::rustc_attrs, + "the `#[rustc_dump_env_program_clauses]` \ + attribute is just used for rustc unit \ + tests and will never be stable", + cfg_fn!(rustc_attrs))), + (sym::rustc_object_lifetime_default, Whitelisted, template!(Word), Gated(Stability::Unstable, + sym::rustc_attrs, + "the `#[rustc_object_lifetime_default]` \ + attribute is just used for rustc unit \ + tests and will never be stable", + cfg_fn!(rustc_attrs))), (sym::rustc_test_marker, Normal, template!(Word), Gated(Stability::Unstable, sym::rustc_attrs, "the `#[rustc_test_marker]` attribute \ @@ -1350,6 +1362,26 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ "internal implementation detail", cfg_fn!(rustc_attrs))), + (sym::rustc_allocator_nounwind, Whitelisted, template!(Word), Gated(Stability::Unstable, + sym::rustc_attrs, + "internal implementation detail", + cfg_fn!(rustc_attrs))), + + (sym::rustc_doc_only_macro, Whitelisted, template!(Word), Gated(Stability::Unstable, + sym::rustc_attrs, + "internal implementation detail", + cfg_fn!(rustc_attrs))), + + (sym::rustc_promotable, Whitelisted, template!(Word), Gated(Stability::Unstable, + sym::rustc_attrs, + "internal implementation detail", + cfg_fn!(rustc_attrs))), + + (sym::rustc_allow_const_fn_ptr, Whitelisted, template!(Word), Gated(Stability::Unstable, + sym::rustc_attrs, + "internal implementation detail", + cfg_fn!(rustc_attrs))), + (sym::rustc_dummy, Normal, template!(Word /* doesn't matter*/), Gated(Stability::Unstable, sym::rustc_attrs, "used by the test suite", @@ -1636,6 +1668,14 @@ impl<'a> Context<'a> { } debug!("check_attribute: {:?} is builtin, {:?}, {:?}", attr.path, ty, gateage); return; + } else { + for segment in &attr.path.segments { + if segment.ident.as_str().starts_with("rustc") { + let msg = "attributes starting with `rustc` are \ + reserved for use by the `rustc` compiler"; + gate_feature!(self, rustc_attrs, segment.ident.span, msg); + } + } } for &(n, ty) in self.plugin_attributes { if attr.path == n { @@ -1646,19 +1686,13 @@ impl<'a> Context<'a> { return; } } - if !attr::is_known(attr) { - if attr.name_or_empty().as_str().starts_with("rustc_") { - let msg = "unless otherwise specified, attributes with the prefix `rustc_` \ - are reserved for internal compiler diagnostics"; - gate_feature!(self, rustc_attrs, attr.span, msg); - } else if !is_macro { - // Only run the custom attribute lint during regular feature gate - // checking. Macro gating runs before the plugin attributes are - // registered, so we skip this in that case. - let msg = format!("The attribute `{}` is currently unknown to the compiler and \ - may have meaning added to it in the future", attr.path); - gate_feature!(self, custom_attribute, attr.span, &msg); - } + if !is_macro && !attr::is_known(attr) { + // Only run the custom attribute lint during regular feature gate + // checking. Macro gating runs before the plugin attributes are + // registered, so we skip this in that case. + let msg = format!("The attribute `{}` is currently unknown to the compiler and \ + may have meaning added to it in the future", attr.path); + gate_feature!(self, custom_attribute, attr.span, &msg); } } } diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 337b84247361d..1fe3dfa40ee6e 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -12,6 +12,7 @@ #![deny(unused_lifetimes)] #![feature(bind_by_move_pattern_guards)] +#![feature(box_syntax)] #![feature(const_fn)] #![feature(const_transmute)] #![feature(crate_visibility_modifier)] diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs index e23bc025f6e31..11a1de13fc217 100644 --- a/src/libsyntax/mut_visit.rs +++ b/src/libsyntax/mut_visit.rs @@ -1261,7 +1261,6 @@ pub fn noop_visit_vis(Spanned { node, span }: &mut Visibility, vi #[cfg(test)] mod tests { - use std::io; use crate::ast::{self, Ident}; use crate::util::parser_testing::{string_to_crate, matches_codepattern}; use crate::print::pprust; @@ -1271,7 +1270,7 @@ mod tests { // this version doesn't care about getting comments or docstrings in. fn fake_print_crate(s: &mut pprust::State<'_>, - krate: &ast::Crate) -> io::Result<()> { + krate: &ast::Crate) { s.print_mod(&krate.module, &krate.attrs) } diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs index 0ea0b2a694d7d..edcdb18a037d8 100644 --- a/src/libsyntax/parse/diagnostics.rs +++ b/src/libsyntax/parse/diagnostics.rs @@ -613,12 +613,12 @@ impl<'a> Parser<'a> { let sum_with_parens = pprust::to_string(|s| { use crate::print::pprust::PrintState; - s.s.word("&")?; - s.print_opt_lifetime(lifetime)?; - s.print_mutability(mut_ty.mutbl)?; - s.popen()?; - s.print_type(&mut_ty.ty)?; - s.print_type_bounds(" +", &bounds)?; + s.s.word("&"); + s.print_opt_lifetime(lifetime); + s.print_mutability(mut_ty.mutbl); + s.popen(); + s.print_type(&mut_ty.ty); + s.print_type_bounds(" +", &bounds); s.pclose() }); err.span_suggestion( diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 696b5f48385e7..a08c10e2cff6a 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2572,12 +2572,12 @@ impl<'a> Parser<'a> { }; let sugg = pprust::to_string(|s| { use crate::print::pprust::PrintState; - s.popen()?; - s.print_expr(&e)?; - s.s.word( ".")?; - s.print_usize(float.trunc() as usize)?; - s.pclose()?; - s.s.word(".")?; + s.popen(); + s.print_expr(&e); + s.s.word( "."); + s.print_usize(float.trunc() as usize); + s.pclose(); + s.s.word("."); s.s.word(fstr.splitn(2, ".").last().unwrap().to_string()) }); err.span_suggestion( @@ -4634,9 +4634,9 @@ impl<'a> Parser<'a> { } let sugg = pprust::to_string(|s| { use crate::print::pprust::{PrintState, INDENT_UNIT}; - s.ibox(INDENT_UNIT)?; - s.bopen()?; - s.print_stmt(&stmt)?; + s.ibox(INDENT_UNIT); + s.bopen(); + s.print_stmt(&stmt); s.bclose_maybe_open(stmt.span, INDENT_UNIT, false) }); e.span_suggestion( diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index f5412f3e21602..f64e95aee5bca 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -136,7 +136,6 @@ use std::collections::VecDeque; use std::fmt; -use std::io; use std::borrow::Cow; use log::debug; @@ -172,7 +171,7 @@ pub enum Token { } impl Token { - pub fn is_eof(&self) -> bool { + crate fn is_eof(&self) -> bool { match *self { Token::Eof => true, _ => false, @@ -223,20 +222,21 @@ fn buf_str(buf: &[BufEntry], left: usize, right: usize, lim: usize) -> String { } #[derive(Copy, Clone)] -pub enum PrintStackBreak { +crate enum PrintStackBreak { Fits, Broken(Breaks), } #[derive(Copy, Clone)] -pub struct PrintStackElem { +crate struct PrintStackElem { offset: isize, pbreak: PrintStackBreak } const SIZE_INFINITY: isize = 0xffff; -pub fn mk_printer<'a>(out: Box, linewidth: usize) -> Printer<'a> { +pub fn mk_printer(out: &mut String) -> Printer<'_> { + let linewidth = 78; // Yes 55, it makes the ring buffers big enough to never fall behind. let n: usize = 55 * linewidth; debug!("mk_printer {}", linewidth); @@ -259,7 +259,7 @@ pub fn mk_printer<'a>(out: Box, linewidth: usize) -> Printer<' } pub struct Printer<'a> { - out: Box, + out: &'a mut String, buf_max_len: usize, /// Width of lines we're constrained to margin: isize, @@ -300,8 +300,6 @@ impl Default for BufEntry { } } -const SPACES: [u8; 128] = [b' '; 128]; - impl<'a> Printer<'a> { pub fn last_token(&mut self) -> Token { self.buf[self.right].token.clone() @@ -312,16 +310,15 @@ impl<'a> Printer<'a> { self.buf[self.right].token = t; } - fn pretty_print_eof(&mut self) -> io::Result<()> { + fn pretty_print_eof(&mut self) { if !self.scan_stack.is_empty() { self.check_stack(0); - self.advance_left()?; + self.advance_left(); } self.indent(0); - Ok(()) } - fn pretty_print_begin(&mut self, b: BeginToken) -> io::Result<()> { + fn pretty_print_begin(&mut self, b: BeginToken) { if self.scan_stack.is_empty() { self.left_total = 1; self.right_total = 1; @@ -335,24 +332,22 @@ impl<'a> Printer<'a> { self.buf[self.right] = BufEntry { token: Token::Begin(b), size: -self.right_total }; let right = self.right; self.scan_push(right); - Ok(()) } - fn pretty_print_end(&mut self) -> io::Result<()> { + fn pretty_print_end(&mut self) { if self.scan_stack.is_empty() { debug!("pp End/print Vec<{},{}>", self.left, self.right); - self.print_end() + self.print_end(); } else { debug!("pp End/buffer Vec<{},{}>", self.left, self.right); self.advance_right(); self.buf[self.right] = BufEntry { token: Token::End, size: -1 }; let right = self.right; self.scan_push(right); - Ok(()) } } - fn pretty_print_break(&mut self, b: BreakToken) -> io::Result<()> { + fn pretty_print_break(&mut self, b: BreakToken) { if self.scan_stack.is_empty() { self.left_total = 1; self.right_total = 1; @@ -368,25 +363,24 @@ impl<'a> Printer<'a> { self.scan_push(right); self.buf[self.right] = BufEntry { token: Token::Break(b), size: -self.right_total }; self.right_total += b.blank_space; - Ok(()) } - fn pretty_print_string(&mut self, s: Cow<'static, str>, len: isize) -> io::Result<()> { + fn pretty_print_string(&mut self, s: Cow<'static, str>, len: isize) { if self.scan_stack.is_empty() { debug!("pp String('{}')/print Vec<{},{}>", s, self.left, self.right); - self.print_string(s, len) + self.print_string(s, len); } else { debug!("pp String('{}')/buffer Vec<{},{}>", s, self.left, self.right); self.advance_right(); self.buf[self.right] = BufEntry { token: Token::String(s, len), size: len }; self.right_total += len; - self.check_stream() + self.check_stream(); } } - pub fn check_stream(&mut self) -> io::Result<()> { + crate fn check_stream(&mut self) { debug!("check_stream Vec<{}, {}> with left_total={}, right_total={}", self.left, self.right, self.left_total, self.right_total); if self.right_total - self.left_total > self.space { @@ -397,32 +391,31 @@ impl<'a> Printer<'a> { let scanned = self.scan_pop_bottom(); self.buf[scanned].size = SIZE_INFINITY; } - self.advance_left()?; + self.advance_left(); if self.left != self.right { - self.check_stream()?; + self.check_stream(); } } - Ok(()) } - pub fn scan_push(&mut self, x: usize) { + crate fn scan_push(&mut self, x: usize) { debug!("scan_push {}", x); self.scan_stack.push_front(x); } - pub fn scan_pop(&mut self) -> usize { + crate fn scan_pop(&mut self) -> usize { self.scan_stack.pop_front().unwrap() } - pub fn scan_top(&mut self) -> usize { + crate fn scan_top(&mut self) -> usize { *self.scan_stack.front().unwrap() } - pub fn scan_pop_bottom(&mut self) -> usize { + crate fn scan_pop_bottom(&mut self) -> usize { self.scan_stack.pop_back().unwrap() } - pub fn advance_right(&mut self) { + crate fn advance_right(&mut self) { self.right += 1; self.right %= self.buf_max_len; // Extend the buf if necessary. @@ -432,7 +425,7 @@ impl<'a> Printer<'a> { assert_ne!(self.right, self.left); } - pub fn advance_left(&mut self) -> io::Result<()> { + crate fn advance_left(&mut self) { debug!("advance_left Vec<{},{}>, sizeof({})={}", self.left, self.right, self.left, self.buf[self.left].size); @@ -450,7 +443,7 @@ impl<'a> Printer<'a> { _ => 0 }; - self.print(left, left_size)?; + self.print(left, left_size); self.left_total += len; @@ -463,11 +456,9 @@ impl<'a> Printer<'a> { left_size = self.buf[self.left].size; } - - Ok(()) } - pub fn check_stack(&mut self, k: isize) { + crate fn check_stack(&mut self, k: isize) { if !self.scan_stack.is_empty() { let x = self.scan_top(); match self.buf[x].token { @@ -495,20 +486,19 @@ impl<'a> Printer<'a> { } } - pub fn print_newline(&mut self, amount: isize) -> io::Result<()> { + crate fn print_newline(&mut self, amount: isize) { debug!("NEWLINE {}", amount); - let ret = writeln!(self.out); + self.out.push('\n'); self.pending_indentation = 0; self.indent(amount); - ret } - pub fn indent(&mut self, amount: isize) { + crate fn indent(&mut self, amount: isize) { debug!("INDENT {}", amount); self.pending_indentation += amount; } - pub fn get_top(&mut self) -> PrintStackElem { + crate fn get_top(&mut self) -> PrintStackElem { match self.print_stack.last() { Some(el) => *el, None => PrintStackElem { @@ -518,7 +508,7 @@ impl<'a> Printer<'a> { } } - pub fn print_begin(&mut self, b: BeginToken, l: isize) -> io::Result<()> { + crate fn print_begin(&mut self, b: BeginToken, l: isize) { if l > self.space { let col = self.margin - self.space + b.offset; debug!("print Begin -> push broken block at col {}", col); @@ -533,52 +523,46 @@ impl<'a> Printer<'a> { pbreak: PrintStackBreak::Fits }); } - Ok(()) } - pub fn print_end(&mut self) -> io::Result<()> { + crate fn print_end(&mut self) { debug!("print End -> pop End"); let print_stack = &mut self.print_stack; assert!(!print_stack.is_empty()); print_stack.pop().unwrap(); - Ok(()) } - pub fn print_break(&mut self, b: BreakToken, l: isize) -> io::Result<()> { + crate fn print_break(&mut self, b: BreakToken, l: isize) { let top = self.get_top(); match top.pbreak { PrintStackBreak::Fits => { debug!("print Break({}) in fitting block", b.blank_space); self.space -= b.blank_space; self.indent(b.blank_space); - Ok(()) } PrintStackBreak::Broken(Breaks::Consistent) => { debug!("print Break({}+{}) in consistent block", top.offset, b.offset); - let ret = self.print_newline(top.offset + b.offset); + self.print_newline(top.offset + b.offset); self.space = self.margin - (top.offset + b.offset); - ret } PrintStackBreak::Broken(Breaks::Inconsistent) => { if l > self.space { debug!("print Break({}+{}) w/ newline in inconsistent", top.offset, b.offset); - let ret = self.print_newline(top.offset + b.offset); + self.print_newline(top.offset + b.offset); self.space = self.margin - (top.offset + b.offset); - ret } else { debug!("print Break({}) w/o newline in inconsistent", b.blank_space); self.indent(b.blank_space); self.space -= b.blank_space; - Ok(()) } } } } - pub fn print_string(&mut self, s: Cow<'static, str>, len: isize) -> io::Result<()> { + crate fn print_string(&mut self, s: Cow<'static, str>, len: isize) { debug!("print String({})", s); // assert!(len <= space); self.space -= len; @@ -587,23 +571,15 @@ impl<'a> Printer<'a> { // // write!(self.out, "{: >n$}", "", n = self.pending_indentation as usize)?; // - // But that is significantly slower than using `SPACES`. This code is - // sufficiently hot, and indents can get sufficiently large, that the - // difference is significant on some workloads. - let spaces_len = SPACES.len() as isize; - while self.pending_indentation >= spaces_len { - self.out.write_all(&SPACES)?; - self.pending_indentation -= spaces_len; - } - if self.pending_indentation > 0 { - self.out.write_all(&SPACES[0..self.pending_indentation as usize])?; - self.pending_indentation = 0; - } - - write!(self.out, "{}", s) + // But that is significantly slower. This code is sufficiently hot, and indents can get + // sufficiently large, that the difference is significant on some workloads. + self.out.reserve(self.pending_indentation as usize); + self.out.extend(std::iter::repeat(' ').take(self.pending_indentation as usize)); + self.pending_indentation = 0; + self.out.push_str(&s); } - pub fn print(&mut self, token: Token, l: isize) -> io::Result<()> { + crate fn print(&mut self, token: Token, l: isize) { debug!("print {} {} (remaining line space={})", token, l, self.space); debug!("{}", buf_str(&self.buf, @@ -616,7 +592,7 @@ impl<'a> Printer<'a> { Token::Break(b) => self.print_break(b, l), Token::String(s, len) => { assert_eq!(len, l); - self.print_string(s, len) + self.print_string(s, len); } Token::Eof => panic!(), // Eof should never get here. } @@ -625,7 +601,7 @@ impl<'a> Printer<'a> { // Convenience functions to talk to the printer. /// "raw box" - pub fn rbox(&mut self, indent: usize, b: Breaks) -> io::Result<()> { + crate fn rbox(&mut self, indent: usize, b: Breaks) { self.pretty_print_begin(BeginToken { offset: indent as isize, breaks: b @@ -633,57 +609,53 @@ impl<'a> Printer<'a> { } /// Inconsistent breaking box - pub fn ibox(&mut self, indent: usize) -> io::Result<()> { + crate fn ibox(&mut self, indent: usize) { self.rbox(indent, Breaks::Inconsistent) } /// Consistent breaking box - pub fn cbox(&mut self, indent: usize) -> io::Result<()> { + pub fn cbox(&mut self, indent: usize) { self.rbox(indent, Breaks::Consistent) } - pub fn break_offset(&mut self, n: usize, off: isize) -> io::Result<()> { + pub fn break_offset(&mut self, n: usize, off: isize) { self.pretty_print_break(BreakToken { offset: off, blank_space: n as isize }) } - pub fn end(&mut self) -> io::Result<()> { + crate fn end(&mut self) { self.pretty_print_end() } - pub fn eof(&mut self) -> io::Result<()> { + pub fn eof(&mut self) { self.pretty_print_eof() } - pub fn word>>(&mut self, wrd: S) -> io::Result<()> { + pub fn word>>(&mut self, wrd: S) { let s = wrd.into(); let len = s.len() as isize; self.pretty_print_string(s, len) } - fn spaces(&mut self, n: usize) -> io::Result<()> { + fn spaces(&mut self, n: usize) { self.break_offset(n, 0) } - pub fn zerobreak(&mut self) -> io::Result<()> { + crate fn zerobreak(&mut self) { self.spaces(0) } - pub fn space(&mut self) -> io::Result<()> { + pub fn space(&mut self) { self.spaces(1) } - pub fn hardbreak(&mut self) -> io::Result<()> { + pub fn hardbreak(&mut self) { self.spaces(SIZE_INFINITY as usize) } pub fn hardbreak_tok_offset(off: isize) -> Token { Token::Break(BreakToken {offset: off, blank_space: SIZE_INFINITY}) } - - pub fn hardbreak_tok() -> Token { - Self::hardbreak_tok_offset(0) - } } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 3f059927e57fe..67646cce69b4f 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -21,8 +21,7 @@ use syntax_pos::{self, BytePos}; use syntax_pos::{DUMMY_SP, FileName}; use std::borrow::Cow; -use std::io::{self, Write, Read}; -use std::vec; +use std::io::Read; pub enum AnnNode<'a> { Ident(&'a ast::Ident), @@ -35,8 +34,8 @@ pub enum AnnNode<'a> { } pub trait PpAnn { - fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) -> io::Result<()> { Ok(()) } - fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) -> io::Result<()> { Ok(()) } + fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { } + fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { } } #[derive(Copy, Clone)] @@ -54,21 +53,7 @@ pub struct State<'a> { is_expanded: bool } -fn rust_printer<'a>(writer: Box, ann: &'a dyn PpAnn) -> State<'a> { - State { - s: pp::mk_printer(writer, DEFAULT_COLUMNS), - cm: None, - comments: None, - cur_cmnt: 0, - boxes: Vec::new(), - ann, - is_expanded: false - } -} - -pub const INDENT_UNIT: usize = 4; - -pub const DEFAULT_COLUMNS: usize = 78; +crate const INDENT_UNIT: usize = 4; /// Requires you to pass an input filename and reader so that /// it can scan the input text for comments to copy forward. @@ -77,9 +62,9 @@ pub fn print_crate<'a>(cm: &'a SourceMap, krate: &ast::Crate, filename: FileName, input: &mut dyn Read, - out: Box, + out: &mut String, ann: &'a dyn PpAnn, - is_expanded: bool) -> io::Result<()> { + is_expanded: bool) { let mut s = State::new_from_input(cm, sess, filename, input, out, ann, is_expanded); if is_expanded && std_inject::injected_crate_name().is_some() { @@ -93,16 +78,16 @@ pub fn print_crate<'a>(cm: &'a SourceMap, let list = attr::mk_list_item( DUMMY_SP, ast::Ident::with_empty_ctxt(sym::feature), vec![pi_nested]); let fake_attr = attr::mk_attr_inner(DUMMY_SP, attr::mk_attr_id(), list); - s.print_attribute(&fake_attr)?; + s.print_attribute(&fake_attr); // #![no_std] let no_std_meta = attr::mk_word_item(ast::Ident::with_empty_ctxt(sym::no_std)); let fake_attr = attr::mk_attr_inner(DUMMY_SP, attr::mk_attr_id(), no_std_meta); - s.print_attribute(&fake_attr)?; + s.print_attribute(&fake_attr); } - s.print_mod(&krate.module, &krate.attrs)?; - s.print_remaining_comments()?; + s.print_mod(&krate.module, &krate.attrs); + s.print_remaining_comments(); s.s.eof() } @@ -111,7 +96,7 @@ impl<'a> State<'a> { sess: &ParseSess, filename: FileName, input: &mut dyn Read, - out: Box, + out: &'a mut String, ann: &'a dyn PpAnn, is_expanded: bool) -> State<'a> { let comments = comments::gather_comments(sess, filename, input); @@ -119,12 +104,12 @@ impl<'a> State<'a> { } pub fn new(cm: &'a SourceMap, - out: Box, + out: &'a mut String, ann: &'a dyn PpAnn, comments: Option>, is_expanded: bool) -> State<'a> { State { - s: pp::mk_printer(out, DEFAULT_COLUMNS), + s: pp::mk_printer(out), cm: Some(cm), comments, cur_cmnt: 0, @@ -136,16 +121,23 @@ impl<'a> State<'a> { } pub fn to_string(f: F) -> String where - F: FnOnce(&mut State<'_>) -> io::Result<()>, + F: FnOnce(&mut State<'_>), { - let mut wr = Vec::new(); + let mut wr = String::new(); { - let ann = NoAnn; - let mut printer = rust_printer(Box::new(&mut wr), &ann); - f(&mut printer).unwrap(); - printer.s.eof().unwrap(); + let mut printer = State { + s: pp::mk_printer(&mut wr), + cm: None, + comments: None, + cur_cmnt: 0, + boxes: Vec::new(), + ann: &NoAnn, + is_expanded: false + }; + f(&mut printer); + printer.s.eof(); } - String::from_utf8(wr).unwrap() + wr } fn binop_to_string(op: BinOpToken) -> &'static str { @@ -254,7 +246,7 @@ pub fn token_to_string(token: &Token) -> String { token_kind_to_string(&token.kind) } -pub fn nonterminal_to_string(nt: &Nonterminal) -> String { +crate fn nonterminal_to_string(nt: &Nonterminal) -> String { match *nt { token::NtExpr(ref e) => expr_to_string(e), token::NtMeta(ref e) => meta_item_to_string(e), @@ -366,20 +358,20 @@ pub fn fun_to_string(decl: &ast::FnDecl, generics: &ast::Generics) -> String { to_string(|s| { - s.head("")?; + s.head(""); s.print_fn(decl, header, Some(name), - generics, &source_map::dummy_spanned(ast::VisibilityKind::Inherited))?; - s.end()?; // Close the head box - s.end() // Close the outer box + generics, &source_map::dummy_spanned(ast::VisibilityKind::Inherited)); + s.end(); // Close the head box + s.end(); // Close the outer box }) } pub fn block_to_string(blk: &ast::Block) -> String { to_string(|s| { // containing cbox, will be closed by print-block at } - s.cbox(INDENT_UNIT)?; + s.cbox(INDENT_UNIT); // head-ibox, will be closed by print-block after { - s.ibox(0)?; + s.ibox(0); s.print_block(blk) }) } @@ -426,14 +418,14 @@ pub trait PrintState<'a> { fn comments(&mut self) -> &mut Option>; fn cur_cmnt(&mut self) -> &mut usize; - fn word_space>>(&mut self, w: S) -> io::Result<()> { - self.writer().word(w)?; + fn word_space>>(&mut self, w: S) { + self.writer().word(w); self.writer().space() } - fn popen(&mut self) -> io::Result<()> { self.writer().word("(") } + fn popen(&mut self) { self.writer().word("(") } - fn pclose(&mut self) -> io::Result<()> { self.writer().word(")") } + fn pclose(&mut self) { self.writer().word(")") } fn is_begin(&mut self) -> bool { match self.writer().last_token() { @@ -454,89 +446,86 @@ pub trait PrintState<'a> { self.writer().last_token().is_eof() || self.writer().last_token().is_hardbreak_tok() } - fn hardbreak_if_not_bol(&mut self) -> io::Result<()> { + fn hardbreak_if_not_bol(&mut self) { if !self.is_bol() { - self.writer().hardbreak()? + self.writer().hardbreak() } - Ok(()) } // "raw box" - fn rbox(&mut self, u: usize, b: pp::Breaks) -> io::Result<()> { + fn rbox(&mut self, u: usize, b: pp::Breaks) { self.boxes().push(b); self.writer().rbox(u, b) } - fn ibox(&mut self, u: usize) -> io::Result<()> { + fn ibox(&mut self, u: usize) { self.boxes().push(pp::Breaks::Inconsistent); - self.writer().ibox(u) + self.writer().ibox(u); } - fn end(&mut self) -> io::Result<()> { + fn end(&mut self) { self.boxes().pop().unwrap(); self.writer().end() } - fn commasep(&mut self, b: Breaks, elts: &[T], mut op: F) -> io::Result<()> - where F: FnMut(&mut Self, &T) -> io::Result<()>, + fn commasep(&mut self, b: Breaks, elts: &[T], mut op: F) + where F: FnMut(&mut Self, &T), { - self.rbox(0, b)?; + self.rbox(0, b); let mut first = true; for elt in elts { - if first { first = false; } else { self.word_space(",")?; } - op(self, elt)?; + if first { first = false; } else { self.word_space(","); } + op(self, elt); } - self.end() + self.end(); } - fn maybe_print_comment(&mut self, pos: BytePos) -> io::Result<()> { + fn maybe_print_comment(&mut self, pos: BytePos) { while let Some(ref cmnt) = self.next_comment() { if cmnt.pos < pos { - self.print_comment(cmnt)?; + self.print_comment(cmnt); } else { break } } - Ok(()) } fn print_comment(&mut self, - cmnt: &comments::Comment) -> io::Result<()> { - let r = match cmnt.style { + cmnt: &comments::Comment) { + match cmnt.style { comments::Mixed => { assert_eq!(cmnt.lines.len(), 1); - self.writer().zerobreak()?; - self.writer().word(cmnt.lines[0].clone())?; + self.writer().zerobreak(); + self.writer().word(cmnt.lines[0].clone()); self.writer().zerobreak() } comments::Isolated => { - self.hardbreak_if_not_bol()?; + self.hardbreak_if_not_bol(); for line in &cmnt.lines { // Don't print empty lines because they will end up as trailing // whitespace if !line.is_empty() { - self.writer().word(line.clone())?; + self.writer().word(line.clone()); } - self.writer().hardbreak()?; + self.writer().hardbreak(); } - Ok(()) } comments::Trailing => { if !self.is_bol() { - self.writer().word(" ")?; + self.writer().word(" "); } if cmnt.lines.len() == 1 { - self.writer().word(cmnt.lines[0].clone())?; + self.writer().word(cmnt.lines[0].clone()); self.writer().hardbreak() } else { - self.ibox(0)?; + self.ibox(0); for line in &cmnt.lines { if !line.is_empty() { - self.writer().word(line.clone())?; + self.writer().word(line.clone()); } - self.writer().hardbreak()?; + self.writer().hardbreak(); } - self.end() + self.end(); } } comments::BlankLine => { @@ -546,18 +535,12 @@ pub trait PrintState<'a> { _ => false }; if is_semi || self.is_begin() || self.is_end() { - self.writer().hardbreak()?; + self.writer().hardbreak(); } - self.writer().hardbreak() - } - }; - match r { - Ok(()) => { - *self.cur_cmnt() = *self.cur_cmnt() + 1; - Ok(()) + self.writer().hardbreak(); } - Err(e) => Err(e), } + *self.cur_cmnt() = *self.cur_cmnt() + 1; } fn next_comment(&mut self) -> Option { @@ -574,13 +557,13 @@ pub trait PrintState<'a> { } } - fn print_literal(&mut self, lit: &ast::Lit) -> io::Result<()> { - self.maybe_print_comment(lit.span.lo())?; + fn print_literal(&mut self, lit: &ast::Lit) { + self.maybe_print_comment(lit.span.lo()); self.writer().word(literal_to_string(lit.token)) } fn print_string(&mut self, st: &str, - style: ast::StrStyle) -> io::Result<()> { + style: ast::StrStyle) { let st = match style { ast::StrStyle::Cooked => { (format!("\"{}\"", st.escape_debug())) @@ -595,28 +578,28 @@ pub trait PrintState<'a> { } fn print_inner_attributes(&mut self, - attrs: &[ast::Attribute]) -> io::Result<()> { + attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, true) } fn print_inner_attributes_no_trailing_hardbreak(&mut self, attrs: &[ast::Attribute]) - -> io::Result<()> { + { self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, false) } fn print_outer_attributes(&mut self, - attrs: &[ast::Attribute]) -> io::Result<()> { + attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Outer, false, true) } fn print_inner_attributes_inline(&mut self, - attrs: &[ast::Attribute]) -> io::Result<()> { + attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Inner, true, true) } fn print_outer_attributes_inline(&mut self, - attrs: &[ast::Attribute]) -> io::Result<()> { + attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Outer, true, true) } @@ -624,69 +607,67 @@ pub trait PrintState<'a> { attrs: &[ast::Attribute], kind: ast::AttrStyle, is_inline: bool, - trailing_hardbreak: bool) -> io::Result<()> { + trailing_hardbreak: bool) { let mut count = 0; for attr in attrs { if attr.style == kind { - self.print_attribute_inline(attr, is_inline)?; + self.print_attribute_inline(attr, is_inline); if is_inline { - self.nbsp()?; + self.nbsp(); } count += 1; } } if count > 0 && trailing_hardbreak && !is_inline { - self.hardbreak_if_not_bol()?; + self.hardbreak_if_not_bol(); } - Ok(()) } - fn print_attribute_path(&mut self, path: &ast::Path) -> io::Result<()> { + fn print_attribute_path(&mut self, path: &ast::Path) { for (i, segment) in path.segments.iter().enumerate() { if i > 0 { - self.writer().word("::")? + self.writer().word("::"); } if segment.ident.name != kw::PathRoot { if segment.ident.name == kw::DollarCrate { - self.print_dollar_crate(segment.ident)?; + self.print_dollar_crate(segment.ident); } else { - self.writer().word(segment.ident.as_str().to_string())?; + self.writer().word(segment.ident.as_str().to_string()); } } } - Ok(()) } - fn print_attribute(&mut self, attr: &ast::Attribute) -> io::Result<()> { + fn print_attribute(&mut self, attr: &ast::Attribute) { self.print_attribute_inline(attr, false) } fn print_attribute_inline(&mut self, attr: &ast::Attribute, - is_inline: bool) -> io::Result<()> { + is_inline: bool) { if !is_inline { - self.hardbreak_if_not_bol()?; + self.hardbreak_if_not_bol(); } - self.maybe_print_comment(attr.span.lo())?; + self.maybe_print_comment(attr.span.lo()); if attr.is_sugared_doc { - self.writer().word(attr.value_str().unwrap().as_str().to_string())?; + self.writer().word(attr.value_str().unwrap().as_str().to_string()); self.writer().hardbreak() } else { match attr.style { - ast::AttrStyle::Inner => self.writer().word("#![")?, - ast::AttrStyle::Outer => self.writer().word("#[")?, + ast::AttrStyle::Inner => self.writer().word("#!["), + ast::AttrStyle::Outer => self.writer().word("#["), } if let Some(mi) = attr.meta() { - self.print_meta_item(&mi)? + self.print_meta_item(&mi); } else { - self.print_attribute_path(&attr.path)?; - self.writer().space()?; - self.print_tts(attr.tokens.clone())?; + self.print_attribute_path(&attr.path); + self.writer().space(); + self.print_tts(attr.tokens.clone()); } - self.writer().word("]") + self.writer().word("]"); } } - fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) -> io::Result<()> { + fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) { match item { ast::NestedMetaItem::MetaItem(ref mi) => { self.print_meta_item(mi) @@ -697,26 +678,26 @@ pub trait PrintState<'a> { } } - fn print_meta_item(&mut self, item: &ast::MetaItem) -> io::Result<()> { - self.ibox(INDENT_UNIT)?; + fn print_meta_item(&mut self, item: &ast::MetaItem) { + self.ibox(INDENT_UNIT); match item.node { - ast::MetaItemKind::Word => self.print_attribute_path(&item.path)?, + ast::MetaItemKind::Word => self.print_attribute_path(&item.path), ast::MetaItemKind::NameValue(ref value) => { - self.print_attribute_path(&item.path)?; - self.writer().space()?; - self.word_space("=")?; - self.print_literal(value)?; + self.print_attribute_path(&item.path); + self.writer().space(); + self.word_space("="); + self.print_literal(value); } ast::MetaItemKind::List(ref items) => { - self.print_attribute_path(&item.path)?; - self.popen()?; + self.print_attribute_path(&item.path); + self.popen(); self.commasep(Consistent, &items[..], - |s, i| s.print_meta_list_item(i))?; - self.pclose()?; + |s, i| s.print_meta_list_item(i)); + self.pclose(); } } - self.end() + self.end(); } /// This doesn't deserve to be called "pretty" printing, but it should be @@ -726,44 +707,43 @@ pub trait PrintState<'a> { /// appropriate macro, transcribe back into the grammar we just parsed from, /// and then pretty-print the resulting AST nodes (so, e.g., we print /// expression arguments as expressions). It can be done! I think. - fn print_tt(&mut self, tt: tokenstream::TokenTree) -> io::Result<()> { + fn print_tt(&mut self, tt: tokenstream::TokenTree) { match tt { TokenTree::Token(ref token) => { - self.writer().word(token_to_string(&token))?; + self.writer().word(token_to_string(&token)); match token.kind { token::DocComment(..) => { self.writer().hardbreak() } - _ => Ok(()) + _ => {} } } TokenTree::Delimited(_, delim, tts) => { - self.writer().word(token_kind_to_string(&token::OpenDelim(delim)))?; - self.writer().space()?; - self.print_tts(tts)?; - self.writer().space()?; + self.writer().word(token_kind_to_string(&token::OpenDelim(delim))); + self.writer().space(); + self.print_tts(tts); + self.writer().space(); self.writer().word(token_kind_to_string(&token::CloseDelim(delim))) }, } } - fn print_tts(&mut self, tts: tokenstream::TokenStream) -> io::Result<()> { - self.ibox(0)?; + fn print_tts(&mut self, tts: tokenstream::TokenStream) { + self.ibox(0); for (i, tt) in tts.into_trees().enumerate() { if i != 0 { - self.writer().space()?; + self.writer().space(); } - self.print_tt(tt)?; + self.print_tt(tt); } - self.end() + self.end(); } - fn space_if_not_bol(&mut self) -> io::Result<()> { - if !self.is_bol() { self.writer().space()?; } - Ok(()) + fn space_if_not_bol(&mut self) { + if !self.is_bol() { self.writer().space(); } } - fn nbsp(&mut self) -> io::Result<()> { self.writer().word(" ") } + fn nbsp(&mut self) { self.writer().word(" ") } // AST pretty-printer is used as a fallback for turning AST structures into token streams for // proc macros. Additionally, proc macros may stringify their input and expect it survive the @@ -772,10 +752,10 @@ pub trait PrintState<'a> { // its hygiene data, most importantly name of the crate it refers to. // As a result we print `$crate` as `crate` if it refers to the local crate // and as `::other_crate_name` if it refers to some other crate. - fn print_dollar_crate(&mut self, ident: ast::Ident) -> io::Result<()> { + fn print_dollar_crate(&mut self, ident: ast::Ident) { let name = ident.span.ctxt().dollar_crate_name(); if !ast::Ident::with_empty_ctxt(name).is_path_segment_keyword() { - self.writer().word("::")?; + self.writer().word("::"); } self.writer().word(name.as_str().to_string()) } @@ -800,61 +780,52 @@ impl<'a> PrintState<'a> for State<'a> { } impl<'a> State<'a> { - pub fn cbox(&mut self, u: usize) -> io::Result<()> { + pub fn cbox(&mut self, u: usize) { self.boxes.push(pp::Breaks::Consistent); - self.s.cbox(u) + self.s.cbox(u); } - pub fn word_nbsp>>(&mut self, w: S) -> io::Result<()> { - self.s.word(w)?; + crate fn word_nbsp>>(&mut self, w: S) { + self.s.word(w); self.nbsp() } - pub fn head>>(&mut self, w: S) -> io::Result<()> { + crate fn head>>(&mut self, w: S) { let w = w.into(); // outer-box is consistent - self.cbox(INDENT_UNIT)?; + self.cbox(INDENT_UNIT); // head-box is inconsistent - self.ibox(w.len() + 1)?; + self.ibox(w.len() + 1); // keyword that starts the head if !w.is_empty() { - self.word_nbsp(w)?; + self.word_nbsp(w); } - Ok(()) } - pub fn bopen(&mut self) -> io::Result<()> { - self.s.word("{")?; - self.end() // close the head-box + crate fn bopen(&mut self) { + self.s.word("{"); + self.end(); // close the head-box } - pub fn bclose_(&mut self, span: syntax_pos::Span, - indented: usize) -> io::Result<()> { + crate fn bclose_(&mut self, span: syntax_pos::Span, + indented: usize) { self.bclose_maybe_open(span, indented, true) } - pub fn bclose_maybe_open(&mut self, span: syntax_pos::Span, - indented: usize, close_box: bool) -> io::Result<()> { - self.maybe_print_comment(span.hi())?; - self.break_offset_if_not_bol(1, -(indented as isize))?; - self.s.word("}")?; + crate fn bclose_maybe_open(&mut self, span: syntax_pos::Span, + indented: usize, close_box: bool) { + self.maybe_print_comment(span.hi()); + self.break_offset_if_not_bol(1, -(indented as isize)); + self.s.word("}"); if close_box { - self.end()?; // close the outer-box + self.end(); // close the outer-box } - Ok(()) } - pub fn bclose(&mut self, span: syntax_pos::Span) -> io::Result<()> { + crate fn bclose(&mut self, span: syntax_pos::Span) { self.bclose_(span, INDENT_UNIT) } - pub fn in_cbox(&self) -> bool { - match self.boxes.last() { - Some(&last_box) => last_box == pp::Breaks::Consistent, - None => false - } - } - - pub fn break_offset_if_not_bol(&mut self, n: usize, - off: isize) -> io::Result<()> { + crate fn break_offset_if_not_bol(&mut self, n: usize, + off: isize) { if !self.is_bol() { self.s.break_offset(n, off) } else { @@ -864,79 +835,75 @@ impl<'a> State<'a> { // break into the previous hardbreak. self.s.replace_last_token(pp::Printer::hardbreak_tok_offset(off)); } - Ok(()) } } // Synthesizes a comment that was not textually present in the original source // file. - pub fn synth_comment(&mut self, text: String) -> io::Result<()> { - self.s.word("/*")?; - self.s.space()?; - self.s.word(text)?; - self.s.space()?; + pub fn synth_comment(&mut self, text: String) { + self.s.word("/*"); + self.s.space(); + self.s.word(text); + self.s.space(); self.s.word("*/") } - pub fn commasep_cmnt(&mut self, + crate fn commasep_cmnt(&mut self, b: Breaks, elts: &[T], mut op: F, - mut get_span: G) -> io::Result<()> where - F: FnMut(&mut State<'_>, &T) -> io::Result<()>, + mut get_span: G) where + F: FnMut(&mut State<'_>, &T), G: FnMut(&T) -> syntax_pos::Span, { - self.rbox(0, b)?; + self.rbox(0, b); let len = elts.len(); let mut i = 0; for elt in elts { - self.maybe_print_comment(get_span(elt).hi())?; - op(self, elt)?; + self.maybe_print_comment(get_span(elt).hi()); + op(self, elt); i += 1; if i < len { - self.s.word(",")?; + self.s.word(","); self.maybe_print_trailing_comment(get_span(elt), - Some(get_span(&elts[i]).hi()))?; - self.space_if_not_bol()?; + Some(get_span(&elts[i]).hi())); + self.space_if_not_bol(); } } - self.end() + self.end(); } - pub fn commasep_exprs(&mut self, b: Breaks, - exprs: &[P]) -> io::Result<()> { + crate fn commasep_exprs(&mut self, b: Breaks, + exprs: &[P]) { self.commasep_cmnt(b, exprs, |s, e| s.print_expr(e), |e| e.span) } - pub fn print_mod(&mut self, _mod: &ast::Mod, - attrs: &[ast::Attribute]) -> io::Result<()> { - self.print_inner_attributes(attrs)?; + crate fn print_mod(&mut self, _mod: &ast::Mod, + attrs: &[ast::Attribute]) { + self.print_inner_attributes(attrs); for item in &_mod.items { - self.print_item(item)?; + self.print_item(item); } - Ok(()) } - pub fn print_foreign_mod(&mut self, nmod: &ast::ForeignMod, - attrs: &[ast::Attribute]) -> io::Result<()> { - self.print_inner_attributes(attrs)?; + crate fn print_foreign_mod(&mut self, nmod: &ast::ForeignMod, + attrs: &[ast::Attribute]) { + self.print_inner_attributes(attrs); for item in &nmod.items { - self.print_foreign_item(item)?; + self.print_foreign_item(item); } - Ok(()) } - pub fn print_opt_lifetime(&mut self, lifetime: &Option) -> io::Result<()> { + crate fn print_opt_lifetime(&mut self, lifetime: &Option) { if let Some(lt) = *lifetime { - self.print_lifetime(lt)?; - self.nbsp()?; + self.print_lifetime(lt); + self.nbsp(); } - Ok(()) } - pub fn print_generic_arg(&mut self, generic_arg: &GenericArg) -> io::Result<()> { + crate fn print_generic_arg(&mut self, generic_arg: &GenericArg) { match generic_arg { GenericArg::Lifetime(lt) => self.print_lifetime(*lt), GenericArg::Type(ty) => self.print_type(ty), @@ -944,136 +911,136 @@ impl<'a> State<'a> { } } - pub fn print_type(&mut self, ty: &ast::Ty) -> io::Result<()> { - self.maybe_print_comment(ty.span.lo())?; - self.ibox(0)?; + crate fn print_type(&mut self, ty: &ast::Ty) { + self.maybe_print_comment(ty.span.lo()); + self.ibox(0); match ty.node { ast::TyKind::Slice(ref ty) => { - self.s.word("[")?; - self.print_type(ty)?; - self.s.word("]")?; + self.s.word("["); + self.print_type(ty); + self.s.word("]"); } ast::TyKind::Ptr(ref mt) => { - self.s.word("*")?; + self.s.word("*"); match mt.mutbl { - ast::Mutability::Mutable => self.word_nbsp("mut")?, - ast::Mutability::Immutable => self.word_nbsp("const")?, + ast::Mutability::Mutable => self.word_nbsp("mut"), + ast::Mutability::Immutable => self.word_nbsp("const"), } - self.print_type(&mt.ty)?; + self.print_type(&mt.ty); } ast::TyKind::Rptr(ref lifetime, ref mt) => { - self.s.word("&")?; - self.print_opt_lifetime(lifetime)?; - self.print_mt(mt)?; + self.s.word("&"); + self.print_opt_lifetime(lifetime); + self.print_mt(mt); } ast::TyKind::Never => { - self.s.word("!")?; + self.s.word("!"); }, ast::TyKind::Tup(ref elts) => { - self.popen()?; + self.popen(); self.commasep(Inconsistent, &elts[..], - |s, ty| s.print_type(ty))?; + |s, ty| s.print_type(ty)); if elts.len() == 1 { - self.s.word(",")?; + self.s.word(","); } - self.pclose()?; + self.pclose(); } ast::TyKind::Paren(ref typ) => { - self.popen()?; - self.print_type(typ)?; - self.pclose()?; + self.popen(); + self.print_type(typ); + self.pclose(); } ast::TyKind::BareFn(ref f) => { self.print_ty_fn(f.abi, f.unsafety, &f.decl, None, - &f.generic_params)?; + &f.generic_params); } ast::TyKind::Path(None, ref path) => { - self.print_path(path, false, 0)?; + self.print_path(path, false, 0); } ast::TyKind::Path(Some(ref qself), ref path) => { - self.print_qpath(path, qself, false)? + self.print_qpath(path, qself, false) } ast::TyKind::TraitObject(ref bounds, syntax) => { let prefix = if syntax == ast::TraitObjectSyntax::Dyn { "dyn" } else { "" }; - self.print_type_bounds(prefix, &bounds[..])?; + self.print_type_bounds(prefix, &bounds[..]); } ast::TyKind::ImplTrait(_, ref bounds) => { - self.print_type_bounds("impl", &bounds[..])?; + self.print_type_bounds("impl", &bounds[..]); } ast::TyKind::Array(ref ty, ref length) => { - self.s.word("[")?; - self.print_type(ty)?; - self.s.word("; ")?; - self.print_expr(&length.value)?; - self.s.word("]")?; + self.s.word("["); + self.print_type(ty); + self.s.word("; "); + self.print_expr(&length.value); + self.s.word("]"); } ast::TyKind::Typeof(ref e) => { - self.s.word("typeof(")?; - self.print_expr(&e.value)?; - self.s.word(")")?; + self.s.word("typeof("); + self.print_expr(&e.value); + self.s.word(")"); } ast::TyKind::Infer => { - self.s.word("_")?; + self.s.word("_"); } ast::TyKind::Err => { - self.popen()?; - self.s.word("/*ERROR*/")?; - self.pclose()?; + self.popen(); + self.s.word("/*ERROR*/"); + self.pclose(); } ast::TyKind::ImplicitSelf => { - self.s.word("Self")?; + self.s.word("Self"); } ast::TyKind::Mac(ref m) => { - self.print_mac(m)?; + self.print_mac(m); } ast::TyKind::CVarArgs => { - self.s.word("...")?; + self.s.word("..."); } } - self.end() + self.end(); } - pub fn print_foreign_item(&mut self, - item: &ast::ForeignItem) -> io::Result<()> { - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(item.span.lo())?; - self.print_outer_attributes(&item.attrs)?; + crate fn print_foreign_item(&mut self, + item: &ast::ForeignItem) { + self.hardbreak_if_not_bol(); + self.maybe_print_comment(item.span.lo()); + self.print_outer_attributes(&item.attrs); match item.node { ast::ForeignItemKind::Fn(ref decl, ref generics) => { - self.head("")?; + self.head(""); self.print_fn(decl, ast::FnHeader::default(), Some(item.ident), - generics, &item.vis)?; - self.end()?; // end head-ibox - self.s.word(";")?; - self.end() // end the outer fn box + generics, &item.vis); + self.end(); // end head-ibox + self.s.word(";"); + self.end(); // end the outer fn box } ast::ForeignItemKind::Static(ref t, m) => { - self.head(visibility_qualified(&item.vis, "static"))?; + self.head(visibility_qualified(&item.vis, "static")); if m == ast::Mutability::Mutable { - self.word_space("mut")?; + self.word_space("mut"); } - self.print_ident(item.ident)?; - self.word_space(":")?; - self.print_type(t)?; - self.s.word(";")?; - self.end()?; // end the head-ibox - self.end() // end the outer cbox + self.print_ident(item.ident); + self.word_space(":"); + self.print_type(t); + self.s.word(";"); + self.end(); // end the head-ibox + self.end(); // end the outer cbox } ast::ForeignItemKind::Ty => { - self.head(visibility_qualified(&item.vis, "type"))?; - self.print_ident(item.ident)?; - self.s.word(";")?; - self.end()?; // end the head-ibox - self.end() // end the outer cbox + self.head(visibility_qualified(&item.vis, "type")); + self.print_ident(item.ident); + self.s.word(";"); + self.end(); // end the head-ibox + self.end(); // end the outer cbox } ast::ForeignItemKind::Macro(ref m) => { - self.print_mac(m)?; + self.print_mac(m); match m.node.delim { - MacDelimiter::Brace => Ok(()), + MacDelimiter::Brace => {}, _ => self.s.word(";") } } @@ -1085,17 +1052,16 @@ impl<'a> State<'a> { ty: &ast::Ty, default: Option<&ast::Expr>, vis: &ast::Visibility) - -> io::Result<()> { - self.s.word(visibility_qualified(vis, ""))?; - self.word_space("const")?; - self.print_ident(ident)?; - self.word_space(":")?; - self.print_type(ty)?; + self.s.word(visibility_qualified(vis, "")); + self.word_space("const"); + self.print_ident(ident); + self.word_space(":"); + self.print_type(ty); if let Some(expr) = default { - self.s.space()?; - self.word_space("=")?; - self.print_expr(expr)?; + self.s.space(); + self.word_space("="); + self.print_expr(expr); } self.s.word(";") } @@ -1104,140 +1070,140 @@ impl<'a> State<'a> { ident: ast::Ident, bounds: Option<&ast::GenericBounds>, ty: Option<&ast::Ty>) - -> io::Result<()> { - self.word_space("type")?; - self.print_ident(ident)?; + { + self.word_space("type"); + self.print_ident(ident); if let Some(bounds) = bounds { - self.print_type_bounds(":", bounds)?; + self.print_type_bounds(":", bounds); } if let Some(ty) = ty { - self.s.space()?; - self.word_space("=")?; - self.print_type(ty)?; + self.s.space(); + self.word_space("="); + self.print_type(ty); } self.s.word(";") } /// Pretty-print an item - pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> { - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(item.span.lo())?; - self.print_outer_attributes(&item.attrs)?; - self.ann.pre(self, AnnNode::Item(item))?; + crate fn print_item(&mut self, item: &ast::Item) { + self.hardbreak_if_not_bol(); + self.maybe_print_comment(item.span.lo()); + self.print_outer_attributes(&item.attrs); + self.ann.pre(self, AnnNode::Item(item)); match item.node { ast::ItemKind::ExternCrate(orig_name) => { - self.head(visibility_qualified(&item.vis, "extern crate"))?; + self.head(visibility_qualified(&item.vis, "extern crate")); if let Some(orig_name) = orig_name { - self.print_name(orig_name)?; - self.s.space()?; - self.s.word("as")?; - self.s.space()?; + self.print_name(orig_name); + self.s.space(); + self.s.word("as"); + self.s.space(); } - self.print_ident(item.ident)?; - self.s.word(";")?; - self.end()?; // end inner head-block - self.end()?; // end outer head-block + self.print_ident(item.ident); + self.s.word(";"); + self.end(); // end inner head-block + self.end(); // end outer head-block } ast::ItemKind::Use(ref tree) => { - self.head(visibility_qualified(&item.vis, "use"))?; - self.print_use_tree(tree)?; - self.s.word(";")?; - self.end()?; // end inner head-block - self.end()?; // end outer head-block + self.head(visibility_qualified(&item.vis, "use")); + self.print_use_tree(tree); + self.s.word(";"); + self.end(); // end inner head-block + self.end(); // end outer head-block } ast::ItemKind::Static(ref ty, m, ref expr) => { - self.head(visibility_qualified(&item.vis, "static"))?; + self.head(visibility_qualified(&item.vis, "static")); if m == ast::Mutability::Mutable { - self.word_space("mut")?; + self.word_space("mut"); } - self.print_ident(item.ident)?; - self.word_space(":")?; - self.print_type(ty)?; - self.s.space()?; - self.end()?; // end the head-ibox + self.print_ident(item.ident); + self.word_space(":"); + self.print_type(ty); + self.s.space(); + self.end(); // end the head-ibox - self.word_space("=")?; - self.print_expr(expr)?; - self.s.word(";")?; - self.end()?; // end the outer cbox + self.word_space("="); + self.print_expr(expr); + self.s.word(";"); + self.end(); // end the outer cbox } ast::ItemKind::Const(ref ty, ref expr) => { - self.head(visibility_qualified(&item.vis, "const"))?; - self.print_ident(item.ident)?; - self.word_space(":")?; - self.print_type(ty)?; - self.s.space()?; - self.end()?; // end the head-ibox - - self.word_space("=")?; - self.print_expr(expr)?; - self.s.word(";")?; - self.end()?; // end the outer cbox + self.head(visibility_qualified(&item.vis, "const")); + self.print_ident(item.ident); + self.word_space(":"); + self.print_type(ty); + self.s.space(); + self.end(); // end the head-ibox + + self.word_space("="); + self.print_expr(expr); + self.s.word(";"); + self.end(); // end the outer cbox } ast::ItemKind::Fn(ref decl, header, ref param_names, ref body) => { - self.head("")?; + self.head(""); self.print_fn( decl, header, Some(item.ident), param_names, &item.vis - )?; - self.s.word(" ")?; - self.print_block_with_attrs(body, &item.attrs)?; + ); + self.s.word(" "); + self.print_block_with_attrs(body, &item.attrs); } ast::ItemKind::Mod(ref _mod) => { - self.head(visibility_qualified(&item.vis, "mod"))?; - self.print_ident(item.ident)?; + self.head(visibility_qualified(&item.vis, "mod")); + self.print_ident(item.ident); if _mod.inline || self.is_expanded { - self.nbsp()?; - self.bopen()?; - self.print_mod(_mod, &item.attrs)?; - self.bclose(item.span)?; + self.nbsp(); + self.bopen(); + self.print_mod(_mod, &item.attrs); + self.bclose(item.span); } else { - self.s.word(";")?; - self.end()?; // end inner head-block - self.end()?; // end outer head-block + self.s.word(";"); + self.end(); // end inner head-block + self.end(); // end outer head-block } } ast::ItemKind::ForeignMod(ref nmod) => { - self.head("extern")?; - self.word_nbsp(nmod.abi.to_string())?; - self.bopen()?; - self.print_foreign_mod(nmod, &item.attrs)?; - self.bclose(item.span)?; + self.head("extern"); + self.word_nbsp(nmod.abi.to_string()); + self.bopen(); + self.print_foreign_mod(nmod, &item.attrs); + self.bclose(item.span); } ast::ItemKind::GlobalAsm(ref ga) => { - self.head(visibility_qualified(&item.vis, "global_asm!"))?; - self.s.word(ga.asm.as_str().to_string())?; - self.end()?; + self.head(visibility_qualified(&item.vis, "global_asm!")); + self.s.word(ga.asm.as_str().to_string()); + self.end(); } ast::ItemKind::Ty(ref ty, ref generics) => { - self.head(visibility_qualified(&item.vis, "type"))?; - self.print_ident(item.ident)?; - self.print_generic_params(&generics.params)?; - self.end()?; // end the inner ibox - - self.print_where_clause(&generics.where_clause)?; - self.s.space()?; - self.word_space("=")?; - self.print_type(ty)?; - self.s.word(";")?; - self.end()?; // end the outer ibox + self.head(visibility_qualified(&item.vis, "type")); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); + self.end(); // end the inner ibox + + self.print_where_clause(&generics.where_clause); + self.s.space(); + self.word_space("="); + self.print_type(ty); + self.s.word(";"); + self.end(); // end the outer ibox } ast::ItemKind::Existential(ref bounds, ref generics) => { - self.head(visibility_qualified(&item.vis, "existential type"))?; - self.print_ident(item.ident)?; - self.print_generic_params(&generics.params)?; - self.end()?; // end the inner ibox + self.head(visibility_qualified(&item.vis, "existential type")); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); + self.end(); // end the inner ibox - self.print_where_clause(&generics.where_clause)?; - self.s.space()?; - self.print_type_bounds(":", bounds)?; - self.s.word(";")?; - self.end()?; // end the outer ibox + self.print_where_clause(&generics.where_clause); + self.s.space(); + self.print_type_bounds(":", bounds); + self.s.word(";"); + self.end(); // end the outer ibox } ast::ItemKind::Enum(ref enum_definition, ref params) => { self.print_enum_def( @@ -1246,15 +1212,15 @@ impl<'a> State<'a> { item.ident, item.span, &item.vis - )?; + ); } ast::ItemKind::Struct(ref struct_def, ref generics) => { - self.head(visibility_qualified(&item.vis, "struct"))?; - self.print_struct(struct_def, generics, item.ident, item.span, true)?; + self.head(visibility_qualified(&item.vis, "struct")); + self.print_struct(struct_def, generics, item.ident, item.span, true); } ast::ItemKind::Union(ref struct_def, ref generics) => { - self.head(visibility_qualified(&item.vis, "union"))?; - self.print_struct(struct_def, generics, item.ident, item.span, true)?; + self.head(visibility_qualified(&item.vis, "union")); + self.print_struct(struct_def, generics, item.ident, item.span, true); } ast::ItemKind::Impl(unsafety, polarity, @@ -1263,171 +1229,170 @@ impl<'a> State<'a> { ref opt_trait, ref ty, ref impl_items) => { - self.head("")?; - self.print_visibility(&item.vis)?; - self.print_defaultness(defaultness)?; - self.print_unsafety(unsafety)?; - self.word_nbsp("impl")?; + self.head(""); + self.print_visibility(&item.vis); + self.print_defaultness(defaultness); + self.print_unsafety(unsafety); + self.word_nbsp("impl"); if !generics.params.is_empty() { - self.print_generic_params(&generics.params)?; - self.s.space()?; + self.print_generic_params(&generics.params); + self.s.space(); } if polarity == ast::ImplPolarity::Negative { - self.s.word("!")?; + self.s.word("!"); } if let Some(ref t) = *opt_trait { - self.print_trait_ref(t)?; - self.s.space()?; - self.word_space("for")?; + self.print_trait_ref(t); + self.s.space(); + self.word_space("for"); } - self.print_type(ty)?; - self.print_where_clause(&generics.where_clause)?; + self.print_type(ty); + self.print_where_clause(&generics.where_clause); - self.s.space()?; - self.bopen()?; - self.print_inner_attributes(&item.attrs)?; + self.s.space(); + self.bopen(); + self.print_inner_attributes(&item.attrs); for impl_item in impl_items { - self.print_impl_item(impl_item)?; + self.print_impl_item(impl_item); } - self.bclose(item.span)?; + self.bclose(item.span); } ast::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref trait_items) => { - self.head("")?; - self.print_visibility(&item.vis)?; - self.print_unsafety(unsafety)?; - self.print_is_auto(is_auto)?; - self.word_nbsp("trait")?; - self.print_ident(item.ident)?; - self.print_generic_params(&generics.params)?; + self.head(""); + self.print_visibility(&item.vis); + self.print_unsafety(unsafety); + self.print_is_auto(is_auto); + self.word_nbsp("trait"); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); let mut real_bounds = Vec::with_capacity(bounds.len()); for b in bounds.iter() { if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b { - self.s.space()?; - self.word_space("for ?")?; - self.print_trait_ref(&ptr.trait_ref)?; + self.s.space(); + self.word_space("for ?"); + self.print_trait_ref(&ptr.trait_ref); } else { real_bounds.push(b.clone()); } } - self.print_type_bounds(":", &real_bounds[..])?; - self.print_where_clause(&generics.where_clause)?; - self.s.word(" ")?; - self.bopen()?; + self.print_type_bounds(":", &real_bounds[..]); + self.print_where_clause(&generics.where_clause); + self.s.word(" "); + self.bopen(); for trait_item in trait_items { - self.print_trait_item(trait_item)?; + self.print_trait_item(trait_item); } - self.bclose(item.span)?; + self.bclose(item.span); } ast::ItemKind::TraitAlias(ref generics, ref bounds) => { - self.head("")?; - self.print_visibility(&item.vis)?; - self.word_nbsp("trait")?; - self.print_ident(item.ident)?; - self.print_generic_params(&generics.params)?; + self.head(""); + self.print_visibility(&item.vis); + self.word_nbsp("trait"); + self.print_ident(item.ident); + self.print_generic_params(&generics.params); let mut real_bounds = Vec::with_capacity(bounds.len()); // FIXME(durka) this seems to be some quite outdated syntax for b in bounds.iter() { if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b { - self.s.space()?; - self.word_space("for ?")?; - self.print_trait_ref(&ptr.trait_ref)?; + self.s.space(); + self.word_space("for ?"); + self.print_trait_ref(&ptr.trait_ref); } else { real_bounds.push(b.clone()); } } - self.nbsp()?; - self.print_type_bounds("=", &real_bounds[..])?; - self.print_where_clause(&generics.where_clause)?; - self.s.word(";")?; + self.nbsp(); + self.print_type_bounds("=", &real_bounds[..]); + self.print_where_clause(&generics.where_clause); + self.s.word(";"); } ast::ItemKind::Mac(ref mac) => { if item.ident.name == kw::Invalid { - self.print_mac(mac)?; + self.print_mac(mac); match mac.node.delim { MacDelimiter::Brace => {} - _ => self.s.word(";")?, + _ => self.s.word(";"), } } else { - self.print_path(&mac.node.path, false, 0)?; - self.s.word("! ")?; - self.print_ident(item.ident)?; - self.cbox(INDENT_UNIT)?; - self.popen()?; - self.print_tts(mac.node.stream())?; - self.pclose()?; - self.s.word(";")?; - self.end()?; + self.print_path(&mac.node.path, false, 0); + self.s.word("! "); + self.print_ident(item.ident); + self.cbox(INDENT_UNIT); + self.popen(); + self.print_tts(mac.node.stream()); + self.pclose(); + self.s.word(";"); + self.end(); } } ast::ItemKind::MacroDef(ref tts) => { - self.s.word("macro_rules! ")?; - self.print_ident(item.ident)?; - self.cbox(INDENT_UNIT)?; - self.popen()?; - self.print_tts(tts.stream())?; - self.pclose()?; - self.s.word(";")?; - self.end()?; + self.s.word("macro_rules! "); + self.print_ident(item.ident); + self.cbox(INDENT_UNIT); + self.popen(); + self.print_tts(tts.stream()); + self.pclose(); + self.s.word(";"); + self.end(); } } self.ann.post(self, AnnNode::Item(item)) } - fn print_trait_ref(&mut self, t: &ast::TraitRef) -> io::Result<()> { + fn print_trait_ref(&mut self, t: &ast::TraitRef) { self.print_path(&t.path, false, 0) } fn print_formal_generic_params( &mut self, generic_params: &[ast::GenericParam] - ) -> io::Result<()> { + ) { if !generic_params.is_empty() { - self.s.word("for")?; - self.print_generic_params(generic_params)?; - self.nbsp()?; + self.s.word("for"); + self.print_generic_params(generic_params); + self.nbsp(); } - Ok(()) } - fn print_poly_trait_ref(&mut self, t: &ast::PolyTraitRef) -> io::Result<()> { - self.print_formal_generic_params(&t.bound_generic_params)?; + fn print_poly_trait_ref(&mut self, t: &ast::PolyTraitRef) { + self.print_formal_generic_params(&t.bound_generic_params); self.print_trait_ref(&t.trait_ref) } - pub fn print_enum_def(&mut self, enum_definition: &ast::EnumDef, + crate fn print_enum_def(&mut self, enum_definition: &ast::EnumDef, generics: &ast::Generics, ident: ast::Ident, span: syntax_pos::Span, - visibility: &ast::Visibility) -> io::Result<()> { - self.head(visibility_qualified(visibility, "enum"))?; - self.print_ident(ident)?; - self.print_generic_params(&generics.params)?; - self.print_where_clause(&generics.where_clause)?; - self.s.space()?; + visibility: &ast::Visibility) { + self.head(visibility_qualified(visibility, "enum")); + self.print_ident(ident); + self.print_generic_params(&generics.params); + self.print_where_clause(&generics.where_clause); + self.s.space(); self.print_variants(&enum_definition.variants, span) } - pub fn print_variants(&mut self, + crate fn print_variants(&mut self, variants: &[ast::Variant], - span: syntax_pos::Span) -> io::Result<()> { - self.bopen()?; + span: syntax_pos::Span) { + self.bopen(); for v in variants { - self.space_if_not_bol()?; - self.maybe_print_comment(v.span.lo())?; - self.print_outer_attributes(&v.node.attrs)?; - self.ibox(INDENT_UNIT)?; - self.print_variant(v)?; - self.s.word(",")?; - self.end()?; - self.maybe_print_trailing_comment(v.span, None)?; + self.space_if_not_bol(); + self.maybe_print_comment(v.span.lo()); + self.print_outer_attributes(&v.node.attrs); + self.ibox(INDENT_UNIT); + self.print_variant(v); + self.s.word(","); + self.end(); + self.maybe_print_trailing_comment(v.span, None); } self.bclose(span) } - pub fn print_visibility(&mut self, vis: &ast::Visibility) -> io::Result<()> { + crate fn print_visibility(&mut self, vis: &ast::Visibility) { match vis.node { ast::VisibilityKind::Public => self.word_nbsp("pub"), ast::VisibilityKind::Crate(sugar) => match sugar { @@ -1442,62 +1407,61 @@ impl<'a> State<'a> { self.word_nbsp(format!("pub(in {})", path)) } } - ast::VisibilityKind::Inherited => Ok(()) + ast::VisibilityKind::Inherited => {} } } - pub fn print_defaultness(&mut self, defaultness: ast::Defaultness) -> io::Result<()> { + crate fn print_defaultness(&mut self, defaultness: ast::Defaultness) { if let ast::Defaultness::Default = defaultness { - self.word_nbsp("default")?; + self.word_nbsp("default"); } - Ok(()) } - pub fn print_struct(&mut self, + crate fn print_struct(&mut self, struct_def: &ast::VariantData, generics: &ast::Generics, ident: ast::Ident, span: syntax_pos::Span, - print_finalizer: bool) -> io::Result<()> { - self.print_ident(ident)?; - self.print_generic_params(&generics.params)?; + print_finalizer: bool) { + self.print_ident(ident); + self.print_generic_params(&generics.params); match struct_def { ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => { if let ast::VariantData::Tuple(..) = struct_def { - self.popen()?; + self.popen(); self.commasep( Inconsistent, struct_def.fields(), |s, field| { - s.maybe_print_comment(field.span.lo())?; - s.print_outer_attributes(&field.attrs)?; - s.print_visibility(&field.vis)?; + s.maybe_print_comment(field.span.lo()); + s.print_outer_attributes(&field.attrs); + s.print_visibility(&field.vis); s.print_type(&field.ty) } - )?; - self.pclose()?; + ); + self.pclose(); } - self.print_where_clause(&generics.where_clause)?; + self.print_where_clause(&generics.where_clause); if print_finalizer { - self.s.word(";")?; + self.s.word(";"); } - self.end()?; - self.end() // close the outer-box + self.end(); + self.end(); // close the outer-box } ast::VariantData::Struct(..) => { - self.print_where_clause(&generics.where_clause)?; - self.nbsp()?; - self.bopen()?; - self.hardbreak_if_not_bol()?; + self.print_where_clause(&generics.where_clause); + self.nbsp(); + self.bopen(); + self.hardbreak_if_not_bol(); for field in struct_def.fields() { - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(field.span.lo())?; - self.print_outer_attributes(&field.attrs)?; - self.print_visibility(&field.vis)?; - self.print_ident(field.ident.unwrap())?; - self.word_nbsp(":")?; - self.print_type(&field.ty)?; - self.s.word(",")?; + self.hardbreak_if_not_bol(); + self.maybe_print_comment(field.span.lo()); + self.print_outer_attributes(&field.attrs); + self.print_visibility(&field.vis); + self.print_ident(field.ident.unwrap()); + self.word_nbsp(":"); + self.print_type(&field.ty); + self.s.word(","); } self.bclose(span) @@ -1505,26 +1469,26 @@ impl<'a> State<'a> { } } - pub fn print_variant(&mut self, v: &ast::Variant) -> io::Result<()> { - self.head("")?; + crate fn print_variant(&mut self, v: &ast::Variant) { + self.head(""); let generics = ast::Generics::default(); - self.print_struct(&v.node.data, &generics, v.node.ident, v.span, false)?; + self.print_struct(&v.node.data, &generics, v.node.ident, v.span, false); match v.node.disr_expr { Some(ref d) => { - self.s.space()?; - self.word_space("=")?; + self.s.space(); + self.word_space("="); self.print_expr(&d.value) } - _ => Ok(()) + _ => {} } } - pub fn print_method_sig(&mut self, + crate fn print_method_sig(&mut self, ident: ast::Ident, generics: &ast::Generics, m: &ast::MethodSig, vis: &ast::Visibility) - -> io::Result<()> { + { self.print_fn(&m.decl, m.header, Some(ident), @@ -1532,12 +1496,12 @@ impl<'a> State<'a> { vis) } - pub fn print_trait_item(&mut self, ti: &ast::TraitItem) - -> io::Result<()> { - self.ann.pre(self, AnnNode::SubItem(ti.id))?; - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(ti.span.lo())?; - self.print_outer_attributes(&ti.attrs)?; + crate fn print_trait_item(&mut self, ti: &ast::TraitItem) + { + self.ann.pre(self, AnnNode::SubItem(ti.id)); + self.hardbreak_if_not_bol(); + self.maybe_print_comment(ti.span.lo()); + self.print_outer_attributes(&ti.attrs); match ti.node { ast::TraitItemKind::Const(ref ty, ref default) => { self.print_associated_const( @@ -1545,184 +1509,174 @@ impl<'a> State<'a> { ty, default.as_ref().map(|expr| &**expr), &source_map::respan(ti.span.shrink_to_lo(), ast::VisibilityKind::Inherited), - )?; + ); } ast::TraitItemKind::Method(ref sig, ref body) => { if body.is_some() { - self.head("")?; + self.head(""); } self.print_method_sig( ti.ident, &ti.generics, sig, &source_map::respan(ti.span.shrink_to_lo(), ast::VisibilityKind::Inherited), - )?; + ); if let Some(ref body) = *body { - self.nbsp()?; - self.print_block_with_attrs(body, &ti.attrs)?; + self.nbsp(); + self.print_block_with_attrs(body, &ti.attrs); } else { - self.s.word(";")?; + self.s.word(";"); } } ast::TraitItemKind::Type(ref bounds, ref default) => { self.print_associated_type(ti.ident, Some(bounds), - default.as_ref().map(|ty| &**ty))?; + default.as_ref().map(|ty| &**ty)); } ast::TraitItemKind::Macro(ref mac) => { - self.print_mac(mac)?; + self.print_mac(mac); match mac.node.delim { MacDelimiter::Brace => {} - _ => self.s.word(";")?, + _ => self.s.word(";"), } } } self.ann.post(self, AnnNode::SubItem(ti.id)) } - pub fn print_impl_item(&mut self, ii: &ast::ImplItem) -> io::Result<()> { - self.ann.pre(self, AnnNode::SubItem(ii.id))?; - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(ii.span.lo())?; - self.print_outer_attributes(&ii.attrs)?; - self.print_defaultness(ii.defaultness)?; + crate fn print_impl_item(&mut self, ii: &ast::ImplItem) { + self.ann.pre(self, AnnNode::SubItem(ii.id)); + self.hardbreak_if_not_bol(); + self.maybe_print_comment(ii.span.lo()); + self.print_outer_attributes(&ii.attrs); + self.print_defaultness(ii.defaultness); match ii.node { ast::ImplItemKind::Const(ref ty, ref expr) => { - self.print_associated_const(ii.ident, ty, Some(expr), &ii.vis)?; + self.print_associated_const(ii.ident, ty, Some(expr), &ii.vis); } ast::ImplItemKind::Method(ref sig, ref body) => { - self.head("")?; - self.print_method_sig(ii.ident, &ii.generics, sig, &ii.vis)?; - self.nbsp()?; - self.print_block_with_attrs(body, &ii.attrs)?; + self.head(""); + self.print_method_sig(ii.ident, &ii.generics, sig, &ii.vis); + self.nbsp(); + self.print_block_with_attrs(body, &ii.attrs); } ast::ImplItemKind::Type(ref ty) => { - self.print_associated_type(ii.ident, None, Some(ty))?; + self.print_associated_type(ii.ident, None, Some(ty)); } ast::ImplItemKind::Existential(ref bounds) => { - self.word_space("existential")?; - self.print_associated_type(ii.ident, Some(bounds), None)?; + self.word_space("existential"); + self.print_associated_type(ii.ident, Some(bounds), None); } ast::ImplItemKind::Macro(ref mac) => { - self.print_mac(mac)?; + self.print_mac(mac); match mac.node.delim { MacDelimiter::Brace => {} - _ => self.s.word(";")?, + _ => self.s.word(";"), } } } self.ann.post(self, AnnNode::SubItem(ii.id)) } - pub fn print_stmt(&mut self, st: &ast::Stmt) -> io::Result<()> { - self.maybe_print_comment(st.span.lo())?; + crate fn print_stmt(&mut self, st: &ast::Stmt) { + self.maybe_print_comment(st.span.lo()); match st.node { ast::StmtKind::Local(ref loc) => { - self.print_outer_attributes(&loc.attrs)?; - self.space_if_not_bol()?; - self.ibox(INDENT_UNIT)?; - self.word_nbsp("let")?; - - self.ibox(INDENT_UNIT)?; - self.print_local_decl(loc)?; - self.end()?; + self.print_outer_attributes(&loc.attrs); + self.space_if_not_bol(); + self.ibox(INDENT_UNIT); + self.word_nbsp("let"); + + self.ibox(INDENT_UNIT); + self.print_local_decl(loc); + self.end(); if let Some(ref init) = loc.init { - self.nbsp()?; - self.word_space("=")?; - self.print_expr(init)?; + self.nbsp(); + self.word_space("="); + self.print_expr(init); } - self.s.word(";")?; - self.end()?; + self.s.word(";"); + self.end(); } - ast::StmtKind::Item(ref item) => self.print_item(item)?, + ast::StmtKind::Item(ref item) => self.print_item(item), ast::StmtKind::Expr(ref expr) => { - self.space_if_not_bol()?; - self.print_expr_outer_attr_style(expr, false)?; + self.space_if_not_bol(); + self.print_expr_outer_attr_style(expr, false); if parse::classify::expr_requires_semi_to_be_stmt(expr) { - self.s.word(";")?; + self.s.word(";"); } } ast::StmtKind::Semi(ref expr) => { - self.space_if_not_bol()?; - self.print_expr_outer_attr_style(expr, false)?; - self.s.word(";")?; + self.space_if_not_bol(); + self.print_expr_outer_attr_style(expr, false); + self.s.word(";"); } ast::StmtKind::Mac(ref mac) => { let (ref mac, style, ref attrs) = **mac; - self.space_if_not_bol()?; - self.print_outer_attributes(attrs)?; - self.print_mac(mac)?; + self.space_if_not_bol(); + self.print_outer_attributes(attrs); + self.print_mac(mac); if style == ast::MacStmtStyle::Semicolon { - self.s.word(";")?; + self.s.word(";"); } } } self.maybe_print_trailing_comment(st.span, None) } - pub fn print_block(&mut self, blk: &ast::Block) -> io::Result<()> { + crate fn print_block(&mut self, blk: &ast::Block) { self.print_block_with_attrs(blk, &[]) } - pub fn print_block_unclosed(&mut self, blk: &ast::Block) -> io::Result<()> { - self.print_block_unclosed_indent(blk, INDENT_UNIT) - } - - pub fn print_block_unclosed_with_attrs(&mut self, blk: &ast::Block, - attrs: &[ast::Attribute]) - -> io::Result<()> { - self.print_block_maybe_unclosed(blk, INDENT_UNIT, attrs, false) - } - - pub fn print_block_unclosed_indent(&mut self, blk: &ast::Block, - indented: usize) -> io::Result<()> { + crate fn print_block_unclosed_indent(&mut self, blk: &ast::Block, + indented: usize) { self.print_block_maybe_unclosed(blk, indented, &[], false) } - pub fn print_block_with_attrs(&mut self, + crate fn print_block_with_attrs(&mut self, blk: &ast::Block, - attrs: &[ast::Attribute]) -> io::Result<()> { + attrs: &[ast::Attribute]) { self.print_block_maybe_unclosed(blk, INDENT_UNIT, attrs, true) } - pub fn print_block_maybe_unclosed(&mut self, + crate fn print_block_maybe_unclosed(&mut self, blk: &ast::Block, indented: usize, attrs: &[ast::Attribute], - close_box: bool) -> io::Result<()> { + close_box: bool) { match blk.rules { - BlockCheckMode::Unsafe(..) => self.word_space("unsafe")?, + BlockCheckMode::Unsafe(..) => self.word_space("unsafe"), BlockCheckMode::Default => () } - self.maybe_print_comment(blk.span.lo())?; - self.ann.pre(self, AnnNode::Block(blk))?; - self.bopen()?; + self.maybe_print_comment(blk.span.lo()); + self.ann.pre(self, AnnNode::Block(blk)); + self.bopen(); - self.print_inner_attributes(attrs)?; + self.print_inner_attributes(attrs); for (i, st) in blk.stmts.iter().enumerate() { match st.node { ast::StmtKind::Expr(ref expr) if i == blk.stmts.len() - 1 => { - self.maybe_print_comment(st.span.lo())?; - self.space_if_not_bol()?; - self.print_expr_outer_attr_style(expr, false)?; - self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()))?; + self.maybe_print_comment(st.span.lo()); + self.space_if_not_bol(); + self.print_expr_outer_attr_style(expr, false); + self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi())); } - _ => self.print_stmt(st)?, + _ => self.print_stmt(st), } } - self.bclose_maybe_open(blk.span, indented, close_box)?; + self.bclose_maybe_open(blk.span, indented, close_box); self.ann.post(self, AnnNode::Block(blk)) } /// Print a `let pats = scrutinee` expression. - pub fn print_let(&mut self, pats: &[P], scrutinee: &ast::Expr) -> io::Result<()> { - self.s.word("let ")?; + crate fn print_let(&mut self, pats: &[P], scrutinee: &ast::Expr) { + self.s.word("let "); - self.print_pats(pats)?; - self.s.space()?; + self.print_pats(pats); + self.s.space(); - self.word_space("=")?; + self.word_space("="); self.print_expr_cond_paren( scrutinee, Self::cond_needs_par(scrutinee) @@ -1730,25 +1684,25 @@ impl<'a> State<'a> { ) } - fn print_else(&mut self, els: Option<&ast::Expr>) -> io::Result<()> { + fn print_else(&mut self, els: Option<&ast::Expr>) { match els { Some(_else) => { match _else.node { // Another `else if` block. ast::ExprKind::If(ref i, ref then, ref e) => { - self.cbox(INDENT_UNIT - 1)?; - self.ibox(0)?; - self.s.word(" else if ")?; - self.print_expr_as_cond(i)?; - self.s.space()?; - self.print_block(then)?; + self.cbox(INDENT_UNIT - 1); + self.ibox(0); + self.s.word(" else if "); + self.print_expr_as_cond(i); + 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)?; - self.ibox(0)?; - self.s.word(" else ")?; + self.cbox(INDENT_UNIT - 1); + self.ibox(0); + self.s.word(" else "); self.print_block(b) } // Constraints would be great here! @@ -1757,33 +1711,33 @@ impl<'a> State<'a> { } } } - _ => Ok(()) + _ => {} } } - pub fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block, - elseopt: Option<&ast::Expr>) -> io::Result<()> { - self.head("if")?; + crate fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block, + elseopt: Option<&ast::Expr>) { + self.head("if"); - self.print_expr_as_cond(test)?; - self.s.space()?; + self.print_expr_as_cond(test); + self.s.space(); - self.print_block(blk)?; + self.print_block(blk); self.print_else(elseopt) } - pub fn print_mac(&mut self, m: &ast::Mac) -> io::Result<()> { - self.print_path(&m.node.path, false, 0)?; - self.s.word("!")?; + crate fn print_mac(&mut self, m: &ast::Mac) { + self.print_path(&m.node.path, false, 0); + self.s.word("!"); match m.node.delim { - MacDelimiter::Parenthesis => self.popen()?, - MacDelimiter::Bracket => self.s.word("[")?, + MacDelimiter::Parenthesis => self.popen(), + MacDelimiter::Bracket => self.s.word("["), MacDelimiter::Brace => { - self.head("")?; - self.bopen()?; + self.head(""); + self.bopen(); } } - self.print_tts(m.node.stream())?; + self.print_tts(m.node.stream()); match m.node.delim { MacDelimiter::Parenthesis => self.pclose(), MacDelimiter::Bracket => self.s.word("]"), @@ -1792,19 +1746,19 @@ impl<'a> State<'a> { } - fn print_call_post(&mut self, args: &[P]) -> io::Result<()> { - self.popen()?; - self.commasep_exprs(Inconsistent, args)?; + fn print_call_post(&mut self, args: &[P]) { + self.popen(); + self.commasep_exprs(Inconsistent, args); self.pclose() } - pub fn print_expr_maybe_paren(&mut self, expr: &ast::Expr, prec: i8) -> io::Result<()> { + crate fn print_expr_maybe_paren(&mut self, expr: &ast::Expr, prec: i8) { 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<()> { + crate fn print_expr_as_cond(&mut self, expr: &ast::Expr) { self.print_expr_cond_paren(expr, Self::cond_needs_par(expr)) } @@ -1822,114 +1776,112 @@ impl<'a> State<'a> { } /// Print `expr` or `(expr)` when `needs_par` holds. - fn print_expr_cond_paren(&mut self, expr: &ast::Expr, needs_par: bool) -> io::Result<()> { + fn print_expr_cond_paren(&mut self, expr: &ast::Expr, needs_par: bool) { if needs_par { - self.popen()?; + self.popen(); } - self.print_expr(expr)?; + self.print_expr(expr); if needs_par { - self.pclose()?; + self.pclose(); } - Ok(()) } fn print_expr_vec(&mut self, exprs: &[P], - attrs: &[Attribute]) -> io::Result<()> { - self.ibox(INDENT_UNIT)?; - self.s.word("[")?; - self.print_inner_attributes_inline(attrs)?; - self.commasep_exprs(Inconsistent, &exprs[..])?; - self.s.word("]")?; - self.end() + attrs: &[Attribute]) { + self.ibox(INDENT_UNIT); + self.s.word("["); + self.print_inner_attributes_inline(attrs); + self.commasep_exprs(Inconsistent, &exprs[..]); + self.s.word("]"); + self.end(); } fn print_expr_repeat(&mut self, element: &ast::Expr, count: &ast::AnonConst, - attrs: &[Attribute]) -> io::Result<()> { - self.ibox(INDENT_UNIT)?; - self.s.word("[")?; - self.print_inner_attributes_inline(attrs)?; - self.print_expr(element)?; - self.word_space(";")?; - self.print_expr(&count.value)?; - self.s.word("]")?; - self.end() + attrs: &[Attribute]) { + self.ibox(INDENT_UNIT); + self.s.word("["); + self.print_inner_attributes_inline(attrs); + self.print_expr(element); + self.word_space(";"); + self.print_expr(&count.value); + self.s.word("]"); + self.end(); } fn print_expr_struct(&mut self, path: &ast::Path, fields: &[ast::Field], wth: &Option>, - attrs: &[Attribute]) -> io::Result<()> { - self.print_path(path, true, 0)?; - self.s.word("{")?; - self.print_inner_attributes_inline(attrs)?; + attrs: &[Attribute]) { + self.print_path(path, true, 0); + self.s.word("{"); + self.print_inner_attributes_inline(attrs); self.commasep_cmnt( Consistent, &fields[..], |s, field| { - s.ibox(INDENT_UNIT)?; + s.ibox(INDENT_UNIT); if !field.is_shorthand { - s.print_ident(field.ident)?; - s.word_space(":")?; + s.print_ident(field.ident); + s.word_space(":"); } - s.print_expr(&field.expr)?; - s.end() + s.print_expr(&field.expr); + s.end(); }, - |f| f.span)?; + |f| f.span); match *wth { Some(ref expr) => { - self.ibox(INDENT_UNIT)?; + self.ibox(INDENT_UNIT); if !fields.is_empty() { - self.s.word(",")?; - self.s.space()?; + self.s.word(","); + self.s.space(); } - self.s.word("..")?; - self.print_expr(expr)?; - self.end()?; + self.s.word(".."); + self.print_expr(expr); + self.end(); } _ => if !fields.is_empty() { - self.s.word(",")? + self.s.word(",") } } - self.s.word("}")?; - Ok(()) + self.s.word("}"); } fn print_expr_tup(&mut self, exprs: &[P], - attrs: &[Attribute]) -> io::Result<()> { - self.popen()?; - self.print_inner_attributes_inline(attrs)?; - self.commasep_exprs(Inconsistent, &exprs[..])?; + attrs: &[Attribute]) { + self.popen(); + self.print_inner_attributes_inline(attrs); + self.commasep_exprs(Inconsistent, &exprs[..]); if exprs.len() == 1 { - self.s.word(",")?; + self.s.word(","); } self.pclose() } fn print_expr_call(&mut self, func: &ast::Expr, - args: &[P]) -> io::Result<()> { + args: &[P]) { let prec = match func.node { ast::ExprKind::Field(..) => parser::PREC_FORCE_PAREN, _ => parser::PREC_POSTFIX, }; - self.print_expr_maybe_paren(func, prec)?; + self.print_expr_maybe_paren(func, prec); self.print_call_post(args) } fn print_expr_method_call(&mut self, segment: &ast::PathSegment, - args: &[P]) -> io::Result<()> { + args: &[P]) { let base_args = &args[1..]; - self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX)?; - self.s.word(".")?; - self.print_ident(segment.ident)?; + self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX); + self.s.word("."); + self.print_ident(segment.ident); if let Some(ref args) = segment.args { - self.print_generic_args(args, true)?; + self.print_generic_args(args, true); } self.print_call_post(base_args) } @@ -1937,7 +1889,7 @@ impl<'a> State<'a> { fn print_expr_binary(&mut self, op: ast::BinOp, lhs: &ast::Expr, - rhs: &ast::Expr) -> io::Result<()> { + rhs: &ast::Expr) { let assoc_op = AssocOp::from_ast_binop(op.node); let prec = assoc_op.precedence() as i8; let fixity = assoc_op.fixity(); @@ -1968,217 +1920,217 @@ impl<'a> State<'a> { _ => left_prec, }; - self.print_expr_maybe_paren(lhs, left_prec)?; - self.s.space()?; - self.word_space(op.node.to_string())?; + self.print_expr_maybe_paren(lhs, left_prec); + self.s.space(); + self.word_space(op.node.to_string()); self.print_expr_maybe_paren(rhs, right_prec) } fn print_expr_unary(&mut self, op: ast::UnOp, - expr: &ast::Expr) -> io::Result<()> { - self.s.word(ast::UnOp::to_string(op))?; + expr: &ast::Expr) { + self.s.word(ast::UnOp::to_string(op)); self.print_expr_maybe_paren(expr, parser::PREC_PREFIX) } fn print_expr_addr_of(&mut self, mutability: ast::Mutability, - expr: &ast::Expr) -> io::Result<()> { - self.s.word("&")?; - self.print_mutability(mutability)?; + expr: &ast::Expr) { + self.s.word("&"); + self.print_mutability(mutability); self.print_expr_maybe_paren(expr, parser::PREC_PREFIX) } - pub fn print_expr(&mut self, expr: &ast::Expr) -> io::Result<()> { + crate fn print_expr(&mut self, expr: &ast::Expr) { self.print_expr_outer_attr_style(expr, true) } fn print_expr_outer_attr_style(&mut self, expr: &ast::Expr, - is_inline: bool) -> io::Result<()> { - self.maybe_print_comment(expr.span.lo())?; + is_inline: bool) { + self.maybe_print_comment(expr.span.lo()); let attrs = &expr.attrs; if is_inline { - self.print_outer_attributes_inline(attrs)?; + self.print_outer_attributes_inline(attrs); } else { - self.print_outer_attributes(attrs)?; + self.print_outer_attributes(attrs); } - self.ibox(INDENT_UNIT)?; - self.ann.pre(self, AnnNode::Expr(expr))?; + self.ibox(INDENT_UNIT); + self.ann.pre(self, AnnNode::Expr(expr)); match expr.node { ast::ExprKind::Box(ref expr) => { - self.word_space("box")?; - self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)?; + self.word_space("box"); + self.print_expr_maybe_paren(expr, parser::PREC_PREFIX); } ast::ExprKind::Array(ref exprs) => { - self.print_expr_vec(&exprs[..], attrs)?; + self.print_expr_vec(&exprs[..], attrs); } ast::ExprKind::Repeat(ref element, ref count) => { - self.print_expr_repeat(element, count, attrs)?; + self.print_expr_repeat(element, count, attrs); } ast::ExprKind::Struct(ref path, ref fields, ref wth) => { - self.print_expr_struct(path, &fields[..], wth, attrs)?; + self.print_expr_struct(path, &fields[..], wth, attrs); } ast::ExprKind::Tup(ref exprs) => { - self.print_expr_tup(&exprs[..], attrs)?; + self.print_expr_tup(&exprs[..], attrs); } ast::ExprKind::Call(ref func, ref args) => { - self.print_expr_call(func, &args[..])?; + self.print_expr_call(func, &args[..]); } ast::ExprKind::MethodCall(ref segment, ref args) => { - self.print_expr_method_call(segment, &args[..])?; + self.print_expr_method_call(segment, &args[..]); } ast::ExprKind::Binary(op, ref lhs, ref rhs) => { - self.print_expr_binary(op, lhs, rhs)?; + self.print_expr_binary(op, lhs, rhs); } ast::ExprKind::Unary(op, ref expr) => { - self.print_expr_unary(op, expr)?; + self.print_expr_unary(op, expr); } ast::ExprKind::AddrOf(m, ref expr) => { - self.print_expr_addr_of(m, expr)?; + self.print_expr_addr_of(m, expr); } ast::ExprKind::Lit(ref lit) => { - self.print_literal(lit)?; + self.print_literal(lit); } ast::ExprKind::Cast(ref expr, ref ty) => { let prec = AssocOp::As.precedence() as i8; - self.print_expr_maybe_paren(expr, prec)?; - self.s.space()?; - self.word_space("as")?; - self.print_type(ty)?; + self.print_expr_maybe_paren(expr, prec); + self.s.space(); + self.word_space("as"); + self.print_type(ty); } ast::ExprKind::Type(ref expr, ref ty) => { let prec = AssocOp::Colon.precedence() as i8; - self.print_expr_maybe_paren(expr, prec)?; - self.word_space(":")?; - self.print_type(ty)?; + self.print_expr_maybe_paren(expr, prec); + self.word_space(":"); + self.print_type(ty); } ast::ExprKind::Let(ref pats, ref scrutinee) => { - self.print_let(pats, 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))?; + self.print_if(test, 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)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } - self.head("while")?; - self.print_expr_as_cond(test)?; - self.s.space()?; - self.print_block_with_attrs(blk, attrs)?; + self.head("while"); + self.print_expr_as_cond(test); + 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)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } - self.head("for")?; - self.print_pat(pat)?; - self.s.space()?; - self.word_space("in")?; - self.print_expr_as_cond(iter)?; - self.s.space()?; - self.print_block_with_attrs(blk, attrs)?; + self.head("for"); + self.print_pat(pat); + self.s.space(); + self.word_space("in"); + self.print_expr_as_cond(iter); + self.s.space(); + self.print_block_with_attrs(blk, attrs); } ast::ExprKind::Loop(ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } - self.head("loop")?; - self.s.space()?; - self.print_block_with_attrs(blk, attrs)?; + self.head("loop"); + self.s.space(); + self.print_block_with_attrs(blk, attrs); } ast::ExprKind::Match(ref expr, ref arms) => { - self.cbox(INDENT_UNIT)?; - self.ibox(4)?; - self.word_nbsp("match")?; - self.print_expr_as_cond(expr)?; - self.s.space()?; - self.bopen()?; - self.print_inner_attributes_no_trailing_hardbreak(attrs)?; + self.cbox(INDENT_UNIT); + self.ibox(4); + self.word_nbsp("match"); + self.print_expr_as_cond(expr); + self.s.space(); + self.bopen(); + self.print_inner_attributes_no_trailing_hardbreak(attrs); for arm in arms { - self.print_arm(arm)?; + self.print_arm(arm); } - self.bclose_(expr.span, INDENT_UNIT)?; + self.bclose_(expr.span, INDENT_UNIT); } ast::ExprKind::Closure( capture_clause, asyncness, movability, ref decl, ref body, _) => { - self.print_movability(movability)?; - self.print_asyncness(asyncness)?; - self.print_capture_clause(capture_clause)?; + self.print_movability(movability); + self.print_asyncness(asyncness); + self.print_capture_clause(capture_clause); - self.print_fn_block_args(decl)?; - self.s.space()?; - self.print_expr(body)?; - self.end()?; // need to close a box + self.print_fn_block_args(decl); + self.s.space(); + self.print_expr(body); + self.end(); // need to close a box // a box will be closed by print_expr, but we didn't want an overall // wrapper so we closed the corresponding opening. so create an // empty box to satisfy the close. - self.ibox(0)?; + self.ibox(0); } ast::ExprKind::Block(ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } // containing cbox, will be closed by print-block at } - self.cbox(INDENT_UNIT)?; + self.cbox(INDENT_UNIT); // head-box, will be closed by print-block after { - self.ibox(0)?; - self.print_block_with_attrs(blk, attrs)?; + self.ibox(0); + self.print_block_with_attrs(blk, attrs); } ast::ExprKind::Async(capture_clause, _, ref blk) => { - self.word_nbsp("async")?; - self.print_capture_clause(capture_clause)?; - self.s.space()?; + self.word_nbsp("async"); + self.print_capture_clause(capture_clause); + self.s.space(); // cbox/ibox in analogy to the `ExprKind::Block` arm above - self.cbox(INDENT_UNIT)?; - self.ibox(0)?; - self.print_block_with_attrs(blk, attrs)?; + self.cbox(INDENT_UNIT); + self.ibox(0); + self.print_block_with_attrs(blk, attrs); } ast::ExprKind::Await(origin, ref expr) => { match origin { ast::AwaitOrigin::MacroLike => { - self.s.word("await!")?; - self.print_expr_maybe_paren(expr, parser::PREC_FORCE_PAREN)?; + self.s.word("await!"); + self.print_expr_maybe_paren(expr, parser::PREC_FORCE_PAREN); } ast::AwaitOrigin::FieldLike => { - self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?; - self.s.word(".await")?; + self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); + self.s.word(".await"); } } } ast::ExprKind::Assign(ref lhs, ref rhs) => { let prec = AssocOp::Assign.precedence() as i8; - self.print_expr_maybe_paren(lhs, prec + 1)?; - self.s.space()?; - self.word_space("=")?; - self.print_expr_maybe_paren(rhs, prec)?; + self.print_expr_maybe_paren(lhs, prec + 1); + self.s.space(); + self.word_space("="); + self.print_expr_maybe_paren(rhs, prec); } ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => { let prec = AssocOp::Assign.precedence() as i8; - self.print_expr_maybe_paren(lhs, prec + 1)?; - self.s.space()?; - self.s.word(op.node.to_string())?; - self.word_space("=")?; - self.print_expr_maybe_paren(rhs, prec)?; + self.print_expr_maybe_paren(lhs, prec + 1); + self.s.space(); + self.s.word(op.node.to_string()); + self.word_space("="); + self.print_expr_maybe_paren(rhs, prec); } ast::ExprKind::Field(ref expr, ident) => { - self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?; - self.s.word(".")?; - self.print_ident(ident)?; + self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); + self.s.word("."); + self.print_ident(ident); } ast::ExprKind::Index(ref expr, ref index) => { - self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?; - self.s.word("[")?; - self.print_expr(index)?; - self.s.word("]")?; + self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); + self.s.word("["); + self.print_expr(index); + self.s.word("]"); } ast::ExprKind::Range(ref start, ref end, limits) => { // Special case for `Range`. `AssocOp` claims that `Range` has higher precedence @@ -2187,55 +2139,55 @@ impl<'a> State<'a> { // a "normal" binop gets parenthesized. (`LOr` is the lowest-precedence binop.) let fake_prec = AssocOp::LOr.precedence() as i8; if let Some(ref e) = *start { - self.print_expr_maybe_paren(e, fake_prec)?; + self.print_expr_maybe_paren(e, fake_prec); } if limits == ast::RangeLimits::HalfOpen { - self.s.word("..")?; + self.s.word(".."); } else { - self.s.word("..=")?; + self.s.word("..="); } if let Some(ref e) = *end { - self.print_expr_maybe_paren(e, fake_prec)?; + self.print_expr_maybe_paren(e, fake_prec); } } ast::ExprKind::Path(None, ref path) => { - self.print_path(path, true, 0)? + self.print_path(path, true, 0) } ast::ExprKind::Path(Some(ref qself), ref path) => { - self.print_qpath(path, qself, true)? + self.print_qpath(path, qself, true) } ast::ExprKind::Break(opt_label, ref opt_expr) => { - self.s.word("break")?; - self.s.space()?; + self.s.word("break"); + self.s.space(); if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.s.space()?; + self.print_ident(label.ident); + self.s.space(); } if let Some(ref expr) = *opt_expr { - self.print_expr_maybe_paren(expr, parser::PREC_JUMP)?; - self.s.space()?; + self.print_expr_maybe_paren(expr, parser::PREC_JUMP); + self.s.space(); } } ast::ExprKind::Continue(opt_label) => { - self.s.word("continue")?; - self.s.space()?; + self.s.word("continue"); + self.s.space(); if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.s.space()? + self.print_ident(label.ident); + self.s.space() } } ast::ExprKind::Ret(ref result) => { - self.s.word("return")?; + self.s.word("return"); if let Some(ref expr) = *result { - self.s.word(" ")?; - self.print_expr_maybe_paren(expr, parser::PREC_JUMP)?; + self.s.word(" "); + self.print_expr_maybe_paren(expr, parser::PREC_JUMP); } } ast::ExprKind::InlineAsm(ref a) => { - self.s.word("asm!")?; - self.popen()?; - self.print_string(&a.asm.as_str(), a.asm_str_style)?; - self.word_space(":")?; + self.s.word("asm!"); + self.popen(); + self.print_string(&a.asm.as_str(), a.asm_str_style); + self.word_space(":"); self.commasep(Inconsistent, &a.outputs, |s, out| { let constraint = out.constraint.as_str(); @@ -2243,33 +2195,30 @@ impl<'a> State<'a> { match ch.next() { Some('=') if out.is_rw => { s.print_string(&format!("+{}", ch.as_str()), - ast::StrStyle::Cooked)? + ast::StrStyle::Cooked) } - _ => s.print_string(&constraint, ast::StrStyle::Cooked)? + _ => s.print_string(&constraint, ast::StrStyle::Cooked) } - s.popen()?; - s.print_expr(&out.expr)?; - s.pclose()?; - Ok(()) - })?; - self.s.space()?; - self.word_space(":")?; + s.popen(); + s.print_expr(&out.expr); + s.pclose(); + }); + self.s.space(); + self.word_space(":"); self.commasep(Inconsistent, &a.inputs, |s, &(co, ref o)| { - s.print_string(&co.as_str(), ast::StrStyle::Cooked)?; - s.popen()?; - s.print_expr(o)?; - s.pclose()?; - Ok(()) - })?; - self.s.space()?; - self.word_space(":")?; + s.print_string(&co.as_str(), ast::StrStyle::Cooked); + s.popen(); + s.print_expr(o); + s.pclose(); + }); + self.s.space(); + self.word_space(":"); self.commasep(Inconsistent, &a.clobbers, |s, co| { - s.print_string(&co.as_str(), ast::StrStyle::Cooked)?; - Ok(()) - })?; + s.print_string(&co.as_str(), ast::StrStyle::Cooked); + }); let mut options = vec![]; if a.volatile { @@ -2283,611 +2232,572 @@ impl<'a> State<'a> { } if !options.is_empty() { - self.s.space()?; - self.word_space(":")?; + self.s.space(); + self.word_space(":"); self.commasep(Inconsistent, &options, |s, &co| { - s.print_string(co, ast::StrStyle::Cooked)?; - Ok(()) - })?; + s.print_string(co, ast::StrStyle::Cooked); + }); } - self.pclose()?; + self.pclose(); } - ast::ExprKind::Mac(ref m) => self.print_mac(m)?, + ast::ExprKind::Mac(ref m) => self.print_mac(m), ast::ExprKind::Paren(ref e) => { - self.popen()?; - self.print_inner_attributes_inline(attrs)?; - self.print_expr(e)?; - self.pclose()?; + self.popen(); + self.print_inner_attributes_inline(attrs); + self.print_expr(e); + self.pclose(); }, ast::ExprKind::Yield(ref e) => { - self.s.word("yield")?; + self.s.word("yield"); match *e { Some(ref expr) => { - self.s.space()?; - self.print_expr_maybe_paren(expr, parser::PREC_JUMP)?; + self.s.space(); + self.print_expr_maybe_paren(expr, parser::PREC_JUMP); } _ => () } } ast::ExprKind::Try(ref e) => { - self.print_expr_maybe_paren(e, parser::PREC_POSTFIX)?; - self.s.word("?")? + self.print_expr_maybe_paren(e, parser::PREC_POSTFIX); + self.s.word("?") } ast::ExprKind::TryBlock(ref blk) => { - self.head("try")?; - self.s.space()?; - self.print_block_with_attrs(blk, attrs)? + self.head("try"); + self.s.space(); + self.print_block_with_attrs(blk, attrs) } ast::ExprKind::Err => { - self.popen()?; - self.s.word("/*ERROR*/")?; - self.pclose()? + self.popen(); + self.s.word("/*ERROR*/"); + self.pclose() } } - self.ann.post(self, AnnNode::Expr(expr))?; - self.end() + self.ann.post(self, AnnNode::Expr(expr)); + self.end(); } - pub fn print_local_decl(&mut self, loc: &ast::Local) -> io::Result<()> { - self.print_pat(&loc.pat)?; + crate fn print_local_decl(&mut self, loc: &ast::Local) { + self.print_pat(&loc.pat); if let Some(ref ty) = loc.ty { - self.word_space(":")?; - self.print_type(ty)?; + self.word_space(":"); + self.print_type(ty); } - Ok(()) } - pub fn print_ident(&mut self, ident: ast::Ident) -> io::Result<()> { + crate fn print_ident(&mut self, ident: ast::Ident) { if ident.is_raw_guess() { - self.s.word(format!("r#{}", ident))?; + self.s.word(format!("r#{}", ident)); } else { - self.s.word(ident.as_str().to_string())?; + self.s.word(ident.as_str().to_string()); } self.ann.post(self, AnnNode::Ident(&ident)) } - pub fn print_usize(&mut self, i: usize) -> io::Result<()> { + crate fn print_usize(&mut self, i: usize) { self.s.word(i.to_string()) } - pub fn print_name(&mut self, name: ast::Name) -> io::Result<()> { - self.s.word(name.as_str().to_string())?; + crate fn print_name(&mut self, name: ast::Name) { + self.s.word(name.as_str().to_string()); self.ann.post(self, AnnNode::Name(&name)) } - pub fn print_for_decl(&mut self, loc: &ast::Local, - coll: &ast::Expr) -> io::Result<()> { - self.print_local_decl(loc)?; - self.s.space()?; - self.word_space("in")?; - self.print_expr(coll) - } - fn print_path(&mut self, path: &ast::Path, colons_before_params: bool, - depth: usize) - -> io::Result<()> - { - self.maybe_print_comment(path.span.lo())?; + depth: usize) { + self.maybe_print_comment(path.span.lo()); for (i, segment) in path.segments[..path.segments.len() - depth].iter().enumerate() { if i > 0 { - self.s.word("::")? + self.s.word("::") } - self.print_path_segment(segment, colons_before_params)?; + self.print_path_segment(segment, colons_before_params); } - - Ok(()) } fn print_path_segment(&mut self, segment: &ast::PathSegment, - colons_before_params: bool) - -> io::Result<()> - { + colons_before_params: bool) { if segment.ident.name != kw::PathRoot { if segment.ident.name == kw::DollarCrate { - self.print_dollar_crate(segment.ident)?; + self.print_dollar_crate(segment.ident); } else { - self.print_ident(segment.ident)?; + self.print_ident(segment.ident); } if let Some(ref args) = segment.args { - self.print_generic_args(args, colons_before_params)?; + self.print_generic_args(args, colons_before_params); } } - Ok(()) } fn print_qpath(&mut self, path: &ast::Path, qself: &ast::QSelf, colons_before_params: bool) - -> io::Result<()> { - self.s.word("<")?; - self.print_type(&qself.ty)?; + self.s.word("<"); + self.print_type(&qself.ty); if qself.position > 0 { - self.s.space()?; - self.word_space("as")?; + self.s.space(); + self.word_space("as"); let depth = path.segments.len() - qself.position; - self.print_path(path, false, depth)?; + self.print_path(path, false, depth); } - self.s.word(">")?; - self.s.word("::")?; + self.s.word(">"); + self.s.word("::"); let item_segment = path.segments.last().unwrap(); - self.print_ident(item_segment.ident)?; + self.print_ident(item_segment.ident); match item_segment.args { Some(ref args) => self.print_generic_args(args, colons_before_params), - None => Ok(()), + None => {}, } } fn print_generic_args(&mut self, args: &ast::GenericArgs, colons_before_params: bool) - -> io::Result<()> { if colons_before_params { - self.s.word("::")? + self.s.word("::") } match *args { ast::GenericArgs::AngleBracketed(ref data) => { - self.s.word("<")?; + self.s.word("<"); self.commasep(Inconsistent, &data.args, |s, generic_arg| { s.print_generic_arg(generic_arg) - })?; + }); let mut comma = data.args.len() != 0; for constraint in data.constraints.iter() { if comma { - self.word_space(",")? + self.word_space(",") } - self.print_ident(constraint.ident)?; - self.s.space()?; + self.print_ident(constraint.ident); + self.s.space(); match constraint.kind { ast::AssocTyConstraintKind::Equality { ref ty } => { - self.word_space("=")?; - self.print_type(ty)?; + self.word_space("="); + self.print_type(ty); } ast::AssocTyConstraintKind::Bound { ref bounds } => { - self.print_type_bounds(":", &*bounds)?; + self.print_type_bounds(":", &*bounds); } } comma = true; } - self.s.word(">")? + self.s.word(">") } ast::GenericArgs::Parenthesized(ref data) => { - self.s.word("(")?; + self.s.word("("); self.commasep( Inconsistent, &data.inputs, - |s, ty| s.print_type(ty))?; - self.s.word(")")?; + |s, ty| s.print_type(ty)); + self.s.word(")"); if let Some(ref ty) = data.output { - self.space_if_not_bol()?; - self.word_space("->")?; - self.print_type(ty)?; + self.space_if_not_bol(); + self.word_space("->"); + self.print_type(ty); } } } - - Ok(()) } - pub fn print_pat(&mut self, pat: &ast::Pat) -> io::Result<()> { - self.maybe_print_comment(pat.span.lo())?; - self.ann.pre(self, AnnNode::Pat(pat))?; + crate fn print_pat(&mut self, pat: &ast::Pat) { + self.maybe_print_comment(pat.span.lo()); + self.ann.pre(self, AnnNode::Pat(pat)); /* Pat isn't normalized, but the beauty of it is that it doesn't matter */ match pat.node { - PatKind::Wild => self.s.word("_")?, + PatKind::Wild => self.s.word("_"), PatKind::Ident(binding_mode, ident, ref sub) => { match binding_mode { ast::BindingMode::ByRef(mutbl) => { - self.word_nbsp("ref")?; - self.print_mutability(mutbl)?; + self.word_nbsp("ref"); + self.print_mutability(mutbl); } ast::BindingMode::ByValue(ast::Mutability::Immutable) => {} ast::BindingMode::ByValue(ast::Mutability::Mutable) => { - self.word_nbsp("mut")?; + self.word_nbsp("mut"); } } - self.print_ident(ident)?; + self.print_ident(ident); if let Some(ref p) = *sub { - self.s.word("@")?; - self.print_pat(p)?; + self.s.word("@"); + self.print_pat(p); } } PatKind::TupleStruct(ref path, ref elts, ddpos) => { - self.print_path(path, true, 0)?; - self.popen()?; + self.print_path(path, true, 0); + self.popen(); if let Some(ddpos) = ddpos { - self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(p))?; + self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(p)); if ddpos != 0 { - self.word_space(",")?; + self.word_space(","); } - self.s.word("..")?; + self.s.word(".."); if ddpos != elts.len() { - self.s.word(",")?; - self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(p))?; + self.s.word(","); + self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(p)); } } else { - self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(p))?; + self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(p)); } - self.pclose()?; + self.pclose(); } PatKind::Path(None, ref path) => { - self.print_path(path, true, 0)?; + self.print_path(path, true, 0); } PatKind::Path(Some(ref qself), ref path) => { - self.print_qpath(path, qself, false)?; + self.print_qpath(path, qself, false); } PatKind::Struct(ref path, ref fields, etc) => { - self.print_path(path, true, 0)?; - self.nbsp()?; - self.word_space("{")?; + self.print_path(path, true, 0); + self.nbsp(); + self.word_space("{"); self.commasep_cmnt( Consistent, &fields[..], |s, f| { - s.cbox(INDENT_UNIT)?; + s.cbox(INDENT_UNIT); if !f.node.is_shorthand { - s.print_ident(f.node.ident)?; - s.word_nbsp(":")?; + s.print_ident(f.node.ident); + s.word_nbsp(":"); } - s.print_pat(&f.node.pat)?; - s.end() + s.print_pat(&f.node.pat); + s.end(); }, - |f| f.node.pat.span)?; + |f| f.node.pat.span); if etc { - if !fields.is_empty() { self.word_space(",")?; } - self.s.word("..")?; + if !fields.is_empty() { self.word_space(","); } + self.s.word(".."); } - self.s.space()?; - self.s.word("}")?; + self.s.space(); + self.s.word("}"); } PatKind::Tuple(ref elts, ddpos) => { - self.popen()?; + self.popen(); if let Some(ddpos) = ddpos { - self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(p))?; + self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(p)); if ddpos != 0 { - self.word_space(",")?; + self.word_space(","); } - self.s.word("..")?; + self.s.word(".."); if ddpos != elts.len() { - self.s.word(",")?; - self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(p))?; + self.s.word(","); + self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(p)); } } else { - self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(p))?; + self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(p)); if elts.len() == 1 { - self.s.word(",")?; + self.s.word(","); } } - self.pclose()?; + self.pclose(); } PatKind::Box(ref inner) => { - self.s.word("box ")?; - self.print_pat(inner)?; + self.s.word("box "); + self.print_pat(inner); } PatKind::Ref(ref inner, mutbl) => { - self.s.word("&")?; + self.s.word("&"); if mutbl == ast::Mutability::Mutable { - self.s.word("mut ")?; + self.s.word("mut "); } - self.print_pat(inner)?; + self.print_pat(inner); } - PatKind::Lit(ref e) => self.print_expr(&**e)?, + PatKind::Lit(ref e) => self.print_expr(&**e), PatKind::Range(ref begin, ref end, Spanned { node: ref end_kind, .. }) => { - self.print_expr(begin)?; - self.s.space()?; + self.print_expr(begin); + self.s.space(); match *end_kind { - RangeEnd::Included(RangeSyntax::DotDotDot) => self.s.word("...")?, - RangeEnd::Included(RangeSyntax::DotDotEq) => self.s.word("..=")?, - RangeEnd::Excluded => self.s.word("..")?, + RangeEnd::Included(RangeSyntax::DotDotDot) => self.s.word("..."), + RangeEnd::Included(RangeSyntax::DotDotEq) => self.s.word("..="), + RangeEnd::Excluded => self.s.word(".."), } - self.print_expr(end)?; + self.print_expr(end); } PatKind::Slice(ref before, ref slice, ref after) => { - self.s.word("[")?; + self.s.word("["); self.commasep(Inconsistent, &before[..], - |s, p| s.print_pat(p))?; + |s, p| s.print_pat(p)); if let Some(ref p) = *slice { - if !before.is_empty() { self.word_space(",")?; } + if !before.is_empty() { self.word_space(","); } if let PatKind::Wild = p.node { // Print nothing } else { - self.print_pat(p)?; + self.print_pat(p); } - self.s.word("..")?; - if !after.is_empty() { self.word_space(",")?; } + self.s.word(".."); + if !after.is_empty() { self.word_space(","); } } self.commasep(Inconsistent, &after[..], - |s, p| s.print_pat(p))?; - self.s.word("]")?; + |s, p| s.print_pat(p)); + self.s.word("]"); } PatKind::Paren(ref inner) => { - self.popen()?; - self.print_pat(inner)?; - self.pclose()?; + self.popen(); + self.print_pat(inner); + self.pclose(); } - PatKind::Mac(ref m) => self.print_mac(m)?, + PatKind::Mac(ref m) => self.print_mac(m), } self.ann.post(self, AnnNode::Pat(pat)) } - fn print_pats(&mut self, pats: &[P]) -> io::Result<()> { + fn print_pats(&mut self, pats: &[P]) { let mut first = true; for p in pats { if first { first = false; } else { - self.s.space()?; - self.word_space("|")?; + self.s.space(); + self.word_space("|"); } - self.print_pat(p)?; + self.print_pat(p); } - Ok(()) } - fn print_arm(&mut self, arm: &ast::Arm) -> io::Result<()> { + fn print_arm(&mut self, arm: &ast::Arm) { // I have no idea why this check is necessary, but here it // is :( if arm.attrs.is_empty() { - self.s.space()?; - } - self.cbox(INDENT_UNIT)?; - self.ibox(0)?; - self.maybe_print_comment(arm.pats[0].span.lo())?; - self.print_outer_attributes(&arm.attrs)?; - self.print_pats(&arm.pats)?; - self.s.space()?; + self.s.space(); + } + self.cbox(INDENT_UNIT); + self.ibox(0); + self.maybe_print_comment(arm.pats[0].span.lo()); + self.print_outer_attributes(&arm.attrs); + self.print_pats(&arm.pats); + self.s.space(); if let Some(ref e) = arm.guard { - self.word_space("if")?; - self.print_expr(e)?; - self.s.space()?; + self.word_space("if"); + self.print_expr(e); + self.s.space(); } - self.word_space("=>")?; + self.word_space("=>"); match arm.body.node { ast::ExprKind::Block(ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_ident(label.ident)?; - self.word_space(":")?; + self.print_ident(label.ident); + self.word_space(":"); } // the block will close the pattern's ibox - self.print_block_unclosed_indent(blk, INDENT_UNIT)?; + self.print_block_unclosed_indent(blk, INDENT_UNIT); // If it is a user-provided unsafe block, print a comma after it if let BlockCheckMode::Unsafe(ast::UserProvided) = blk.rules { - self.s.word(",")?; + self.s.word(","); } } _ => { - self.end()?; // close the ibox for the pattern - self.print_expr(&arm.body)?; - self.s.word(",")?; + self.end(); // close the ibox for the pattern + self.print_expr(&arm.body); + self.s.word(","); } } - self.end() // close enclosing cbox + self.end(); // close enclosing cbox } - fn print_explicit_self(&mut self, explicit_self: &ast::ExplicitSelf) -> io::Result<()> { + fn print_explicit_self(&mut self, explicit_self: &ast::ExplicitSelf) { match explicit_self.node { SelfKind::Value(m) => { - self.print_mutability(m)?; + self.print_mutability(m); self.s.word("self") } SelfKind::Region(ref lt, m) => { - self.s.word("&")?; - self.print_opt_lifetime(lt)?; - self.print_mutability(m)?; + self.s.word("&"); + self.print_opt_lifetime(lt); + self.print_mutability(m); self.s.word("self") } SelfKind::Explicit(ref typ, m) => { - self.print_mutability(m)?; - self.s.word("self")?; - self.word_space(":")?; + self.print_mutability(m); + self.s.word("self"); + self.word_space(":"); self.print_type(typ) } } } - pub fn print_fn(&mut self, + crate fn print_fn(&mut self, decl: &ast::FnDecl, header: ast::FnHeader, name: Option, generics: &ast::Generics, - vis: &ast::Visibility) -> io::Result<()> { - self.print_fn_header_info(header, vis)?; + vis: &ast::Visibility) { + self.print_fn_header_info(header, vis); if let Some(name) = name { - self.nbsp()?; - self.print_ident(name)?; + self.nbsp(); + self.print_ident(name); } - self.print_generic_params(&generics.params)?; - self.print_fn_args_and_ret(decl)?; + self.print_generic_params(&generics.params); + self.print_fn_args_and_ret(decl); self.print_where_clause(&generics.where_clause) } - pub fn print_fn_args_and_ret(&mut self, decl: &ast::FnDecl) - -> io::Result<()> { - self.popen()?; - self.commasep(Inconsistent, &decl.inputs, |s, arg| s.print_arg(arg, false))?; - self.pclose()?; + crate fn print_fn_args_and_ret(&mut self, decl: &ast::FnDecl) { + self.popen(); + self.commasep(Inconsistent, &decl.inputs, |s, arg| s.print_arg(arg, false)); + self.pclose(); self.print_fn_output(decl) } - pub fn print_fn_block_args( - &mut self, - decl: &ast::FnDecl) - -> io::Result<()> { - self.s.word("|")?; - self.commasep(Inconsistent, &decl.inputs, |s, arg| s.print_arg(arg, true))?; - self.s.word("|")?; + crate fn print_fn_block_args(&mut self, decl: &ast::FnDecl) { + self.s.word("|"); + self.commasep(Inconsistent, &decl.inputs, |s, arg| s.print_arg(arg, true)); + self.s.word("|"); if let ast::FunctionRetTy::Default(..) = decl.output { - return Ok(()); + return; } - self.space_if_not_bol()?; - self.word_space("->")?; + self.space_if_not_bol(); + self.word_space("->"); match decl.output { ast::FunctionRetTy::Ty(ref ty) => { - self.print_type(ty)?; + self.print_type(ty); self.maybe_print_comment(ty.span.lo()) } ast::FunctionRetTy::Default(..) => unreachable!(), } } - pub fn print_movability(&mut self, movability: ast::Movability) - -> io::Result<()> { + crate fn print_movability(&mut self, movability: ast::Movability) { match movability { ast::Movability::Static => self.word_space("static"), - ast::Movability::Movable => Ok(()), + ast::Movability::Movable => {}, } } - pub fn print_asyncness(&mut self, asyncness: ast::IsAsync) - -> io::Result<()> { + crate fn print_asyncness(&mut self, asyncness: ast::IsAsync) { if asyncness.is_async() { - self.word_nbsp("async")?; + self.word_nbsp("async"); } - Ok(()) } - pub fn print_capture_clause(&mut self, capture_clause: ast::CaptureBy) - -> io::Result<()> { + crate fn print_capture_clause(&mut self, capture_clause: ast::CaptureBy) { match capture_clause { ast::CaptureBy::Value => self.word_space("move"), - ast::CaptureBy::Ref => Ok(()), + ast::CaptureBy::Ref => {}, } } - pub fn print_type_bounds(&mut self, prefix: &'static str, bounds: &[ast::GenericBound]) - -> io::Result<()> { + crate fn print_type_bounds(&mut self, prefix: &'static str, bounds: &[ast::GenericBound]) { if !bounds.is_empty() { - self.s.word(prefix)?; + self.s.word(prefix); let mut first = true; for bound in bounds { if !(first && prefix.is_empty()) { - self.nbsp()?; + self.nbsp(); } if first { first = false; } else { - self.word_space("+")?; + self.word_space("+"); } match bound { GenericBound::Trait(tref, modifier) => { if modifier == &TraitBoundModifier::Maybe { - self.s.word("?")?; + self.s.word("?"); } - self.print_poly_trait_ref(tref)?; + self.print_poly_trait_ref(tref); } - GenericBound::Outlives(lt) => self.print_lifetime(*lt)?, + GenericBound::Outlives(lt) => self.print_lifetime(*lt), } } } - Ok(()) } - pub fn print_lifetime(&mut self, lifetime: ast::Lifetime) -> io::Result<()> { + crate fn print_lifetime(&mut self, lifetime: ast::Lifetime) { self.print_name(lifetime.ident.name) } - pub fn print_lifetime_bounds(&mut self, lifetime: ast::Lifetime, bounds: &ast::GenericBounds) - -> io::Result<()> - { - self.print_lifetime(lifetime)?; + crate fn print_lifetime_bounds( + &mut self, lifetime: ast::Lifetime, bounds: &ast::GenericBounds) { + self.print_lifetime(lifetime); if !bounds.is_empty() { - self.s.word(": ")?; + self.s.word(": "); for (i, bound) in bounds.iter().enumerate() { if i != 0 { - self.s.word(" + ")?; + self.s.word(" + "); } match bound { - ast::GenericBound::Outlives(lt) => self.print_lifetime(*lt)?, + ast::GenericBound::Outlives(lt) => self.print_lifetime(*lt), _ => panic!(), } } } - Ok(()) } - pub fn print_generic_params( - &mut self, - generic_params: &[ast::GenericParam] - ) -> io::Result<()> { + crate fn print_generic_params(&mut self, generic_params: &[ast::GenericParam]) { if generic_params.is_empty() { - return Ok(()); + return; } - self.s.word("<")?; + self.s.word("<"); self.commasep(Inconsistent, &generic_params, |s, param| { match param.kind { ast::GenericParamKind::Lifetime => { - s.print_outer_attributes_inline(¶m.attrs)?; + s.print_outer_attributes_inline(¶m.attrs); let lt = ast::Lifetime { id: param.id, ident: param.ident }; s.print_lifetime_bounds(lt, ¶m.bounds) } ast::GenericParamKind::Type { ref default } => { - s.print_outer_attributes_inline(¶m.attrs)?; - s.print_ident(param.ident)?; - s.print_type_bounds(":", ¶m.bounds)?; + s.print_outer_attributes_inline(¶m.attrs); + s.print_ident(param.ident); + s.print_type_bounds(":", ¶m.bounds); match default { Some(ref default) => { - s.s.space()?; - s.word_space("=")?; + s.s.space(); + s.word_space("="); s.print_type(default) } - _ => Ok(()) + _ => {} } } ast::GenericParamKind::Const { ref ty } => { - s.print_outer_attributes_inline(¶m.attrs)?; - s.word_space("const")?; - s.print_ident(param.ident)?; - s.s.space()?; - s.word_space(":")?; - s.print_type(ty)?; + s.print_outer_attributes_inline(¶m.attrs); + s.word_space("const"); + s.print_ident(param.ident); + s.s.space(); + s.word_space(":"); + s.print_type(ty); s.print_type_bounds(":", ¶m.bounds) } } - })?; + }); - self.s.word(">")?; - Ok(()) + self.s.word(">"); } - pub fn print_where_clause(&mut self, where_clause: &ast::WhereClause) - -> io::Result<()> { + crate fn print_where_clause(&mut self, where_clause: &ast::WhereClause) { if where_clause.predicates.is_empty() { - return Ok(()) + return; } - self.s.space()?; - self.word_space("where")?; + self.s.space(); + self.word_space("where"); for (i, predicate) in where_clause.predicates.iter().enumerate() { if i != 0 { - self.word_space(",")?; + self.word_space(","); } match *predicate { @@ -2897,83 +2807,78 @@ impl<'a> State<'a> { ref bounds, .. }) => { - self.print_formal_generic_params(bound_generic_params)?; - self.print_type(bounded_ty)?; - self.print_type_bounds(":", bounds)?; + self.print_formal_generic_params(bound_generic_params); + self.print_type(bounded_ty); + self.print_type_bounds(":", bounds); } ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime, ref bounds, ..}) => { - self.print_lifetime_bounds(*lifetime, bounds)?; + self.print_lifetime_bounds(*lifetime, bounds); } ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{ref lhs_ty, ref rhs_ty, ..}) => { - self.print_type(lhs_ty)?; - self.s.space()?; - self.word_space("=")?; - self.print_type(rhs_ty)?; + self.print_type(lhs_ty); + self.s.space(); + self.word_space("="); + self.print_type(rhs_ty); } } } - - Ok(()) } - pub fn print_use_tree(&mut self, tree: &ast::UseTree) -> io::Result<()> { + crate fn print_use_tree(&mut self, tree: &ast::UseTree) { match tree.kind { ast::UseTreeKind::Simple(rename, ..) => { - self.print_path(&tree.prefix, false, 0)?; + self.print_path(&tree.prefix, false, 0); if let Some(rename) = rename { - self.s.space()?; - self.word_space("as")?; - self.print_ident(rename)?; + self.s.space(); + self.word_space("as"); + self.print_ident(rename); } } ast::UseTreeKind::Glob => { if !tree.prefix.segments.is_empty() { - self.print_path(&tree.prefix, false, 0)?; - self.s.word("::")?; + self.print_path(&tree.prefix, false, 0); + self.s.word("::"); } - self.s.word("*")?; + self.s.word("*"); } ast::UseTreeKind::Nested(ref items) => { if tree.prefix.segments.is_empty() { - self.s.word("{")?; + self.s.word("{"); } else { - self.print_path(&tree.prefix, false, 0)?; - self.s.word("::{")?; + self.print_path(&tree.prefix, false, 0); + self.s.word("::{"); } self.commasep(Inconsistent, &items[..], |this, &(ref tree, _)| { this.print_use_tree(tree) - })?; - self.s.word("}")?; + }); + self.s.word("}"); } } - - Ok(()) } - pub fn print_mutability(&mut self, - mutbl: ast::Mutability) -> io::Result<()> { + crate fn print_mutability(&mut self, mutbl: ast::Mutability) { match mutbl { ast::Mutability::Mutable => self.word_nbsp("mut"), - ast::Mutability::Immutable => Ok(()), + ast::Mutability::Immutable => {}, } } - pub fn print_mt(&mut self, mt: &ast::MutTy) -> io::Result<()> { - self.print_mutability(mt.mutbl)?; + crate fn print_mt(&mut self, mt: &ast::MutTy) { + self.print_mutability(mt.mutbl); self.print_type(&mt.ty) } - pub fn print_arg(&mut self, input: &ast::Arg, is_closure: bool) -> io::Result<()> { - self.ibox(INDENT_UNIT)?; + crate fn print_arg(&mut self, input: &ast::Arg, is_closure: bool) { + self.ibox(INDENT_UNIT); match input.ty.node { - ast::TyKind::Infer if is_closure => self.print_pat(&input.pat)?, + ast::TyKind::Infer if is_closure => self.print_pat(&input.pat), _ => { if let Some(eself) = input.to_self() { - self.print_explicit_self(&eself)?; + self.print_explicit_self(&eself); } else { let invalid = if let PatKind::Ident(_, ident, _) = input.pat.node { ident.name == kw::Invalid @@ -2981,49 +2886,49 @@ impl<'a> State<'a> { false }; if !invalid { - self.print_pat(&input.pat)?; - self.s.word(":")?; - self.s.space()?; + self.print_pat(&input.pat); + self.s.word(":"); + self.s.space(); } - self.print_type(&input.ty)?; + self.print_type(&input.ty); } } } - self.end() + self.end(); } - pub fn print_fn_output(&mut self, decl: &ast::FnDecl) -> io::Result<()> { + crate fn print_fn_output(&mut self, decl: &ast::FnDecl) { if let ast::FunctionRetTy::Default(..) = decl.output { - return Ok(()); + return; } - self.space_if_not_bol()?; - self.ibox(INDENT_UNIT)?; - self.word_space("->")?; + self.space_if_not_bol(); + self.ibox(INDENT_UNIT); + self.word_space("->"); match decl.output { ast::FunctionRetTy::Default(..) => unreachable!(), ast::FunctionRetTy::Ty(ref ty) => - self.print_type(ty)? + self.print_type(ty), } - self.end()?; + self.end(); match decl.output { ast::FunctionRetTy::Ty(ref output) => self.maybe_print_comment(output.span.lo()), - _ => Ok(()) + _ => {} } } - pub fn print_ty_fn(&mut self, + crate fn print_ty_fn(&mut self, abi: abi::Abi, unsafety: ast::Unsafety, decl: &ast::FnDecl, name: Option, generic_params: &[ast::GenericParam]) - -> io::Result<()> { - self.ibox(INDENT_UNIT)?; + { + self.ibox(INDENT_UNIT); if !generic_params.is_empty() { - self.s.word("for")?; - self.print_generic_params(generic_params)?; + self.s.word("for"); + self.print_generic_params(generic_params); } let generics = ast::Generics { params: Vec::new(), @@ -3037,97 +2942,71 @@ impl<'a> State<'a> { ast::FnHeader { unsafety, abi, ..ast::FnHeader::default() }, name, &generics, - &source_map::dummy_spanned(ast::VisibilityKind::Inherited))?; - self.end() + &source_map::dummy_spanned(ast::VisibilityKind::Inherited)); + self.end(); } - pub fn maybe_print_trailing_comment(&mut self, span: syntax_pos::Span, + crate fn maybe_print_trailing_comment(&mut self, span: syntax_pos::Span, next_pos: Option) - -> io::Result<()> { + { let cm = match self.cm { Some(cm) => cm, - _ => return Ok(()) + _ => return, }; if let Some(ref cmnt) = self.next_comment() { - if cmnt.style != comments::Trailing { return Ok(()) } + if cmnt.style != comments::Trailing { return; } let span_line = cm.lookup_char_pos(span.hi()); let comment_line = cm.lookup_char_pos(cmnt.pos); let next = next_pos.unwrap_or_else(|| cmnt.pos + BytePos(1)); if span.hi() < cmnt.pos && cmnt.pos < next && span_line.line == comment_line.line { - self.print_comment(cmnt)?; + self.print_comment(cmnt); } } - Ok(()) } - pub fn print_remaining_comments(&mut self) -> io::Result<()> { + crate fn print_remaining_comments(&mut self) { // If there aren't any remaining comments, then we need to manually // make sure there is a line break at the end. if self.next_comment().is_none() { - self.s.hardbreak()?; + self.s.hardbreak(); } while let Some(ref cmnt) = self.next_comment() { - self.print_comment(cmnt)?; - } - Ok(()) - } - - pub fn print_opt_abi_and_extern_if_nondefault(&mut self, - opt_abi: Option) - -> io::Result<()> { - match opt_abi { - Some(Abi::Rust) => Ok(()), - Some(abi) => { - self.word_nbsp("extern")?; - self.word_nbsp(abi.to_string()) - } - None => Ok(()) - } - } - - pub fn print_extern_opt_abi(&mut self, - opt_abi: Option) -> io::Result<()> { - match opt_abi { - Some(abi) => { - self.word_nbsp("extern")?; - self.word_nbsp(abi.to_string()) - } - None => Ok(()) + self.print_comment(cmnt); } } - pub fn print_fn_header_info(&mut self, + crate fn print_fn_header_info(&mut self, header: ast::FnHeader, - vis: &ast::Visibility) -> io::Result<()> { - self.s.word(visibility_qualified(vis, ""))?; + vis: &ast::Visibility) { + self.s.word(visibility_qualified(vis, "")); match header.constness.node { ast::Constness::NotConst => {} - ast::Constness::Const => self.word_nbsp("const")? + ast::Constness::Const => self.word_nbsp("const") } - self.print_asyncness(header.asyncness.node)?; - self.print_unsafety(header.unsafety)?; + self.print_asyncness(header.asyncness.node); + self.print_unsafety(header.unsafety); if header.abi != Abi::Rust { - self.word_nbsp("extern")?; - self.word_nbsp(header.abi.to_string())?; + self.word_nbsp("extern"); + self.word_nbsp(header.abi.to_string()); } self.s.word("fn") } - pub fn print_unsafety(&mut self, s: ast::Unsafety) -> io::Result<()> { + crate fn print_unsafety(&mut self, s: ast::Unsafety) { match s { - ast::Unsafety::Normal => Ok(()), + ast::Unsafety::Normal => {}, ast::Unsafety::Unsafe => self.word_nbsp("unsafe"), } } - pub fn print_is_auto(&mut self, s: ast::IsAuto) -> io::Result<()> { + crate fn print_is_auto(&mut self, s: ast::IsAuto) { match s { ast::IsAuto::Yes => self.word_nbsp("auto"), - ast::IsAuto::No => Ok(()), + ast::IsAuto::No => {} } } } diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs index f0cfa5a84a827..be580dc2e6a7e 100644 --- a/src/libsyntax/ptr.rs +++ b/src/libsyntax/ptr.rs @@ -41,11 +41,11 @@ pub struct P { ptr: Box } -#[allow(non_snake_case)] /// Construct a `P` from a `T` value. +#[allow(non_snake_case)] pub fn P(value: T) -> P { P { - ptr: Box::new(value) + ptr: box value } } diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index f90b76721ee16..2a9bc54b5ebda 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -26,7 +26,6 @@ use crate::mut_visit::{*, ExpectOne}; use crate::feature_gate::Features; use crate::util::map_in_place::MapInPlace; use crate::parse::{token, ParseSess}; -use crate::print::pprust; use crate::ast::{self, Ident}; use crate::ptr::P; use crate::symbol::{self, Symbol, kw, sym}; diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs index 733c4f83e37d4..f850960624ce7 100644 --- a/src/libsyntax/util/parser_testing.rs +++ b/src/libsyntax/util/parser_testing.rs @@ -20,7 +20,7 @@ pub fn string_to_stream(source_str: String) -> TokenStream { } /// Map string to parser (via tts) -pub fn string_to_parser<'a>(ps: &'a ParseSess, source_str: String) -> Parser<'a> { +pub fn string_to_parser(ps: &ParseSess, source_str: String) -> Parser<'_> { new_parser_from_source_str(ps, PathBuf::from("bogofile").into(), source_str) } diff --git a/src/libsyntax_ext/assert.rs b/src/libsyntax_ext/assert.rs index 10d323ffb89f5..637614a18bcc3 100644 --- a/src/libsyntax_ext/assert.rs +++ b/src/libsyntax_ext/assert.rs @@ -131,7 +131,7 @@ fn parse_assert<'a>( Ok(Assert { cond_expr, custom_message }) } -fn parse_custom_message<'a>(parser: &mut Parser<'a>) -> Option { +fn parse_custom_message(parser: &mut Parser<'_>) -> Option { let ts = parser.parse_tokens(); if !ts.is_empty() { Some(ts) diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index 444cf1263ce25..12482f7248e90 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -331,8 +331,8 @@ pub type CombineSubstructureFunc<'a> = pub type EnumNonMatchCollapsedFunc<'a> = Box, Span, (&[Ident], &[Ident]), &[P]) -> P + 'a>; -pub fn combine_substructure<'a>(f: CombineSubstructureFunc<'a>) - -> RefCell> { +pub fn combine_substructure(f: CombineSubstructureFunc<'_>) + -> RefCell> { RefCell::new(f) } diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs index 90d826429da4d..02b02e9b83695 100644 --- a/src/libsyntax_ext/deriving/generic/ty.rs +++ b/src/libsyntax_ext/deriving/generic/ty.rs @@ -39,10 +39,10 @@ pub enum PathKind { } impl<'a> Path<'a> { - pub fn new<'r>(path: Vec<&'r str>) -> Path<'r> { + pub fn new(path: Vec<&str>) -> Path<'_> { Path::new_(path, None, Vec::new(), PathKind::Std) } - pub fn new_local<'r>(path: &'r str) -> Path<'r> { + pub fn new_local(path: &str) -> Path<'_> { Path::new_(vec![path], None, Vec::new(), PathKind::Local) } pub fn new_<'r>(path: Vec<&'r str>, @@ -117,7 +117,7 @@ pub enum Const { pub fn borrowed_ptrty<'r>() -> PtrTy<'r> { Borrowed(None, ast::Mutability::Immutable) } -pub fn borrowed<'r>(ty: Box>) -> Ty<'r> { +pub fn borrowed(ty: Box>) -> Ty<'_> { Ptr(ty, borrowed_ptrty()) } diff --git a/src/test/codegen/issue-45222.rs b/src/test/codegen/issue-45222.rs index da65f2dfca5d1..7f99ca724cf73 100644 --- a/src/test/codegen/issue-45222.rs +++ b/src/test/codegen/issue-45222.rs @@ -1,4 +1,5 @@ // compile-flags: -O +// ignore-debug: the debug assertions get in the way #![crate_type = "lib"] diff --git a/src/test/codegen/issue-45466.rs b/src/test/codegen/issue-45466.rs index 7d6e31cc740f5..c79542767774a 100644 --- a/src/test/codegen/issue-45466.rs +++ b/src/test/codegen/issue-45466.rs @@ -1,4 +1,5 @@ // compile-flags: -O +// ignore-debug: the debug assertions get in the way #![crate_type="rlib"] diff --git a/src/test/codegen/swap-small-types.rs b/src/test/codegen/swap-small-types.rs index c8466fed7d1bd..6205e6a6559c9 100644 --- a/src/test/codegen/swap-small-types.rs +++ b/src/test/codegen/swap-small-types.rs @@ -1,5 +1,6 @@ // compile-flags: -O // only-x86_64 +// ignore-debug: the debug assertions get in the way #![crate_type = "lib"] diff --git a/src/test/compile-fail/auxiliary/panic-runtime-lang-items.rs b/src/test/compile-fail/auxiliary/panic-runtime-lang-items.rs deleted file mode 100644 index abe34a39caf34..0000000000000 --- a/src/test/compile-fail/auxiliary/panic-runtime-lang-items.rs +++ /dev/null @@ -1,15 +0,0 @@ -// no-prefer-dynamic - -#![crate_type = "rlib"] - -#![no_std] -#![feature(lang_items)] - -use core::panic::PanicInfo; - -#[lang = "panic_impl"] -fn panic_impl(info: &PanicInfo) -> ! { loop {} } -#[lang = "eh_personality"] -fn eh_personality() {} -#[lang = "eh_unwind_resume"] -fn eh_unwind_resume() {} diff --git a/src/test/compile-fail/auxiliary/panic-runtime-unwind.rs b/src/test/compile-fail/auxiliary/panic-runtime-unwind.rs deleted file mode 100644 index 97452a342ab4d..0000000000000 --- a/src/test/compile-fail/auxiliary/panic-runtime-unwind.rs +++ /dev/null @@ -1,17 +0,0 @@ -// compile-flags:-C panic=unwind -// no-prefer-dynamic - -#![feature(panic_runtime)] -#![crate_type = "rlib"] - -#![no_std] -#![panic_runtime] - -#[no_mangle] -pub extern fn __rust_maybe_catch_panic() {} - -#[no_mangle] -pub extern fn __rust_start_panic() {} - -#[no_mangle] -pub extern fn rust_eh_personality() {} diff --git a/src/test/compile-fail/auxiliary/panic-runtime-unwind2.rs b/src/test/compile-fail/auxiliary/panic-runtime-unwind2.rs deleted file mode 100644 index 97452a342ab4d..0000000000000 --- a/src/test/compile-fail/auxiliary/panic-runtime-unwind2.rs +++ /dev/null @@ -1,17 +0,0 @@ -// compile-flags:-C panic=unwind -// no-prefer-dynamic - -#![feature(panic_runtime)] -#![crate_type = "rlib"] - -#![no_std] -#![panic_runtime] - -#[no_mangle] -pub extern fn __rust_maybe_catch_panic() {} - -#[no_mangle] -pub extern fn __rust_start_panic() {} - -#[no_mangle] -pub extern fn rust_eh_personality() {} diff --git a/src/test/compile-fail/auxiliary/some-panic-impl.rs b/src/test/compile-fail/auxiliary/some-panic-impl.rs deleted file mode 100644 index 0348b3a2d760b..0000000000000 --- a/src/test/compile-fail/auxiliary/some-panic-impl.rs +++ /dev/null @@ -1,11 +0,0 @@ -// no-prefer-dynamic - -#![crate_type = "rlib"] -#![no_std] - -use core::panic::PanicInfo; - -#[panic_handler] -fn panic(info: &PanicInfo) -> ! { - loop {} -} diff --git a/src/test/compile-fail/auxiliary/wants-panic-runtime-unwind.rs b/src/test/compile-fail/auxiliary/wants-panic-runtime-unwind.rs deleted file mode 100644 index d5f0102196f48..0000000000000 --- a/src/test/compile-fail/auxiliary/wants-panic-runtime-unwind.rs +++ /dev/null @@ -1,6 +0,0 @@ -// no-prefer-dynamic - -#![crate_type = "rlib"] -#![no_std] - -extern crate panic_runtime_unwind; diff --git a/src/test/run-pass-fulldeps/issue-15778-pass.rs b/src/test/run-pass-fulldeps/issue-15778-pass.rs index 2add3ccbe36f2..35152e7f4babd 100644 --- a/src/test/run-pass-fulldeps/issue-15778-pass.rs +++ b/src/test/run-pass-fulldeps/issue-15778-pass.rs @@ -2,7 +2,8 @@ // ignore-stage1 // compile-flags: -D crate-not-okay -#![feature(plugin, rustc_attrs)] +#![feature(plugin, custom_attribute, custom_inner_attributes, rustc_attrs)] + #![plugin(lint_for_crate)] #![rustc_crate_okay] #![rustc_crate_blue] @@ -10,4 +11,4 @@ #![rustc_crate_grey] #![rustc_crate_green] -pub fn main() { } +fn main() {} diff --git a/src/test/run-pass/async-await/async-fn-size-moved-locals.rs b/src/test/run-pass/async-await/async-fn-size-moved-locals.rs new file mode 100644 index 0000000000000..139be7fe0132b --- /dev/null +++ b/src/test/run-pass/async-await/async-fn-size-moved-locals.rs @@ -0,0 +1,98 @@ +// Test that we don't duplicate storage for futures moved around in .await, and +// for futures moved into other futures. +// +// The exact sizes can change by a few bytes (we'd like to know when they do). +// What we don't want to see is the wrong multiple of 1024 (the size of BigFut) +// being reflected in the size. +// +// See issue #59123 for a full explanation. + +// edition:2018 + +#![feature(async_await)] + +use std::future::Future; +use std::pin::Pin; +use std::task::{Context, Poll}; + +const BIG_FUT_SIZE: usize = 1024; +struct BigFut([u8; BIG_FUT_SIZE]); + +impl BigFut { + fn new() -> Self { + BigFut([0; BIG_FUT_SIZE]) + } } + +impl Drop for BigFut { + fn drop(&mut self) {} +} + +impl Future for BigFut { + type Output = (); + + fn poll(self: Pin<&mut Self>, _ctx: &mut Context<'_>) -> Poll { + Poll::Ready(()) + } +} + +#[allow(dead_code)] +struct Joiner { + a: Option, + b: Option, + c: Option, +} + +impl Future for Joiner { + type Output = (); + + fn poll(self: Pin<&mut Self>, _ctx: &mut Context<'_>) -> Poll { + Poll::Ready(()) + } +} + +fn noop() {} + +async fn single() { + let x = BigFut::new(); + x.await; +} + +async fn single_with_noop() { + let x = BigFut::new(); + noop(); + x.await; +} + +async fn joined() { + let a = BigFut::new(); + let b = BigFut::new(); + let c = BigFut::new(); + + let joiner = Joiner { + a: Some(a), + b: Some(b), + c: Some(c), + }; + joiner.await +} + +async fn joined_with_noop() { + let a = BigFut::new(); + let b = BigFut::new(); + let c = BigFut::new(); + + let joiner = Joiner { + a: Some(a), + b: Some(b), + c: Some(c), + }; + noop(); + joiner.await +} + +fn main() { + assert_eq!(1028, std::mem::size_of_val(&single())); + assert_eq!(1032, std::mem::size_of_val(&single_with_noop())); + assert_eq!(3084, std::mem::size_of_val(&joined())); + assert_eq!(3084, std::mem::size_of_val(&joined_with_noop())); +} diff --git a/src/test/run-pass/attr-on-generic-formals.rs b/src/test/run-pass/attr-on-generic-formals.rs deleted file mode 100644 index 9ebf0fcb1c192..0000000000000 --- a/src/test/run-pass/attr-on-generic-formals.rs +++ /dev/null @@ -1,52 +0,0 @@ -#![allow(unused_attributes)] - -// This test ensures we can attach attributes to the formals in all -// places where generic parameter lists occur, assuming appropriate -// feature gates are enabled. -// -// (We are prefixing all tested features with `rustc_`, to ensure that -// the attributes themselves won't be rejected by the compiler when -// using `rustc_attrs` feature. There is a separate compile-fail/ test -// ensuring that the attribute feature-gating works in this context.) - -#![feature(rustc_attrs)] -#![allow(dead_code)] - -struct StLt<#[rustc_lt_struct] 'a>(&'a u32); -struct StTy<#[rustc_ty_struct] I>(I); - -enum EnLt<#[rustc_lt_enum] 'b> { A(&'b u32), B } -enum EnTy<#[rustc_ty_enum] J> { A(J), B } - -trait TrLt<#[rustc_lt_trait] 'c> { fn foo(&self, _: &'c [u32]) -> &'c u32; } -trait TrTy<#[rustc_ty_trait] K> { fn foo(&self, _: K); } - -type TyLt<#[rustc_lt_type] 'd> = &'d u32; -type TyTy<#[rustc_ty_type] L> = (L, ); - -impl<#[rustc_lt_inherent] 'e> StLt<'e> { } -impl<#[rustc_ty_inherent] M> StTy { } - -impl<#[rustc_lt_impl_for] 'f> TrLt<'f> for StLt<'f> { - fn foo(&self, _: &'f [u32]) -> &'f u32 { loop { } } -} -impl<#[rustc_ty_impl_for] N> TrTy for StTy { - fn foo(&self, _: N) { } -} - -fn f_lt<#[rustc_lt_fn] 'g>(_: &'g [u32]) -> &'g u32 { loop { } } -fn f_ty<#[rustc_ty_fn] O>(_: O) { } - -impl StTy { - fn m_lt<#[rustc_lt_meth] 'h>(_: &'h [u32]) -> &'h u32 { loop { } } - fn m_ty<#[rustc_ty_meth] P>(_: P) { } -} - -fn hof_lt(_: Q) - where Q: for <#[rustc_lt_hof] 'i> Fn(&'i [u32]) -> &'i u32 -{ -} - -fn main() { - -} diff --git a/src/test/run-pass/command-uid-gid.rs b/src/test/run-pass/command-uid-gid.rs new file mode 100644 index 0000000000000..2b52c5d104c24 --- /dev/null +++ b/src/test/run-pass/command-uid-gid.rs @@ -0,0 +1,26 @@ +#![feature(rustc_private)] + +fn main() { + #[cfg(unix)] + run() +} + +#[cfg(unix)] +fn run() { + extern crate libc; + use std::process::Command; + use std::os::unix::prelude::*; + + let mut p = Command::new("/bin/sh") + .arg("-c").arg("true") + .uid(unsafe { libc::getuid() }) + .gid(unsafe { libc::getgid() }) + .spawn().unwrap(); + assert!(p.wait().unwrap().success()); + + // if we're already root, this isn't a valid test. Most of the bots run + // as non-root though (android is an exception). + if unsafe { libc::getuid() != 0 } { + assert!(Command::new("/bin/ls").uid(0).gid(0).spawn().is_err()); + } +} diff --git a/src/test/run-pass/generator/size-moved-locals.rs b/src/test/run-pass/generator/size-moved-locals.rs new file mode 100644 index 0000000000000..37e2e0cfdcccf --- /dev/null +++ b/src/test/run-pass/generator/size-moved-locals.rs @@ -0,0 +1,62 @@ +// Test that we don't duplicate storage for a variable that is moved to another +// binding. This used to happen in the presence of unwind and drop edges (see +// `complex` below.) +// +// The exact sizes here can change (we'd like to know when they do). What we +// don't want to see is the `complex` generator size being upwards of 2048 bytes +// (which would indicate it is reserving space for two copies of Foo.) +// +// See issue #59123 for a full explanation. + +// edition:2018 + +#![feature(generators, generator_trait)] + +use std::ops::Generator; + +const FOO_SIZE: usize = 1024; +struct Foo([u8; FOO_SIZE]); + +impl Drop for Foo { + fn drop(&mut self) {} +} + +fn move_before_yield() -> impl Generator { + static || { + let first = Foo([0; FOO_SIZE]); + let _second = first; + yield; + // _second dropped here + } +} + +fn noop() {} + +fn move_before_yield_with_noop() -> impl Generator { + static || { + let first = Foo([0; FOO_SIZE]); + noop(); + let _second = first; + yield; + // _second dropped here + } +} + +// Today we don't have NRVO (we allocate space for both `first` and `second`,) +// but we can overlap `first` with `_third`. +fn overlap_move_points() -> impl Generator { + static || { + let first = Foo([0; FOO_SIZE]); + yield; + let second = first; + yield; + let _third = second; + yield; + } +} + +fn main() { + assert_eq!(1028, std::mem::size_of_val(&move_before_yield())); + assert_eq!(1032, std::mem::size_of_val(&move_before_yield_with_noop())); + assert_eq!(2056, std::mem::size_of_val(&overlap_move_points())); +} diff --git a/src/test/compile-fail/asm-src-loc.rs b/src/test/ui/asm/asm-src-loc.rs similarity index 100% rename from src/test/compile-fail/asm-src-loc.rs rename to src/test/ui/asm/asm-src-loc.rs diff --git a/src/test/ui/asm/asm-src-loc.stderr b/src/test/ui/asm/asm-src-loc.stderr new file mode 100644 index 0000000000000..c87e413bdcb36 --- /dev/null +++ b/src/test/ui/asm/asm-src-loc.stderr @@ -0,0 +1,11 @@ +error: :1:2: error: invalid instruction mnemonic 'nowayisthisavalidinstruction' + nowayisthisavalidinstruction + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + --> $DIR/asm-src-loc.rs:7:9 + | +LL | asm!("nowayisthisavalidinstruction"); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/compile-fail/issue-23595-1.rs b/src/test/ui/associated-types/issue-23595-1.rs similarity index 100% rename from src/test/compile-fail/issue-23595-1.rs rename to src/test/ui/associated-types/issue-23595-1.rs diff --git a/src/test/ui/associated-types/issue-23595-1.stderr b/src/test/ui/associated-types/issue-23595-1.stderr new file mode 100644 index 0000000000000..ec9c9d4d44d71 --- /dev/null +++ b/src/test/ui/associated-types/issue-23595-1.stderr @@ -0,0 +1,18 @@ +error[E0191]: the value of the associated types `Value` (from the trait `Hierarchy`), `ChildKey` (from the trait `Hierarchy`), `Children` (from the trait `Hierarchy`) must be specified + --> $DIR/issue-23595-1.rs:8:54 + | +LL | type Value; + | ----------- `Value` defined here +LL | type ChildKey; + | -------------- `ChildKey` defined here +LL | type Children = dyn Index; + | -------------------------------------------------^^^^^^^^^^^^^-- + | | | + | | associated type `Value` must be specified + | | associated type `ChildKey` must be specified + | | associated type `Children` must be specified + | `Children` defined here + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0191`. diff --git a/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.rs b/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.rs index ca5fdd9da859b..df9c8d894652b 100644 --- a/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.rs +++ b/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.rs @@ -6,10 +6,8 @@ struct RefIntPair<'a, 'b>(&'a u32, &'b u32); -impl<#[rustc_1] 'a, 'b, #[oops]> RefIntPair<'a, 'b> { +impl<#[rustc_dummy] 'a, 'b, #[oops]> RefIntPair<'a, 'b> { //~^ ERROR trailing attribute after generic parameter } -fn main() { - -} +fn main() {} diff --git a/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.stderr b/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.stderr index 55e7a9877846f..5b4f5222a2b14 100644 --- a/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.stderr +++ b/src/test/ui/attributes/attrs-with-no-formal-in-generics-1.stderr @@ -1,8 +1,8 @@ error: trailing attribute after generic parameter - --> $DIR/attrs-with-no-formal-in-generics-1.rs:9:25 + --> $DIR/attrs-with-no-formal-in-generics-1.rs:9:29 | -LL | impl<#[rustc_1] 'a, 'b, #[oops]> RefIntPair<'a, 'b> { - | ^^^^^^^ attributes must go before parameters +LL | impl<#[rustc_dummy] 'a, 'b, #[oops]> RefIntPair<'a, 'b> { + | ^^^^^^^ attributes must go before parameters error: aborting due to previous error diff --git a/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.rs b/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.rs index c795612acf08c..d1d044035260b 100644 --- a/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.rs +++ b/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.rs @@ -6,7 +6,7 @@ struct RefAny<'a, T>(&'a T); -impl<#[rustc_1] 'a, #[rustc_2] T, #[oops]> RefAny<'a, T> {} +impl<#[rustc_dummy] 'a, #[rustc_dummy] T, #[oops]> RefAny<'a, T> {} //~^ ERROR trailing attribute after generic parameter fn main() {} diff --git a/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.stderr b/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.stderr index acd0ae3678a7c..fce3ff7de78e8 100644 --- a/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.stderr +++ b/src/test/ui/attributes/attrs-with-no-formal-in-generics-2.stderr @@ -1,8 +1,8 @@ error: trailing attribute after generic parameter - --> $DIR/attrs-with-no-formal-in-generics-2.rs:9:35 + --> $DIR/attrs-with-no-formal-in-generics-2.rs:9:43 | -LL | impl<#[rustc_1] 'a, #[rustc_2] T, #[oops]> RefAny<'a, T> {} - | ^^^^^^^ attributes must go before parameters +LL | impl<#[rustc_dummy] 'a, #[rustc_dummy] T, #[oops]> RefAny<'a, T> {} + | ^^^^^^^ attributes must go before parameters error: aborting due to previous error diff --git a/src/test/compile-fail/chalkify/chalk_initial_program.rs b/src/test/ui/chalkify/chalk_initial_program.rs similarity index 100% rename from src/test/compile-fail/chalkify/chalk_initial_program.rs rename to src/test/ui/chalkify/chalk_initial_program.rs diff --git a/src/test/ui/chalkify/chalk_initial_program.stderr b/src/test/ui/chalkify/chalk_initial_program.stderr new file mode 100644 index 0000000000000..1319e6fca916d --- /dev/null +++ b/src/test/ui/chalkify/chalk_initial_program.stderr @@ -0,0 +1,15 @@ +error[E0277]: the trait bound `f32: Foo` is not satisfied + --> $DIR/chalk_initial_program.rs:15:5 + | +LL | gimme::(); + | ^^^^^^^^^^^^ the trait `Foo` is not implemented for `f32` + | +note: required by `gimme` + --> $DIR/chalk_initial_program.rs:9:1 + | +LL | fn gimme() { } + | ^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/compile-fail/chalkify/generic_impls.rs b/src/test/ui/chalkify/generic_impls.rs similarity index 100% rename from src/test/compile-fail/chalkify/generic_impls.rs rename to src/test/ui/chalkify/generic_impls.rs diff --git a/src/test/ui/chalkify/generic_impls.stderr b/src/test/ui/chalkify/generic_impls.stderr new file mode 100644 index 0000000000000..73f0e444be917 --- /dev/null +++ b/src/test/ui/chalkify/generic_impls.stderr @@ -0,0 +1,31 @@ +error[E0277]: the trait bound `(std::option::Option, f32): Foo` is not satisfied + --> $DIR/generic_impls.rs:12:5 + | +LL | gimme::<(Option, f32)>(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `(std::option::Option, f32)` + | + = help: the following implementations were found: + <(T, u32) as Foo> +note: required by `gimme` + --> $DIR/generic_impls.rs:7:1 + | +LL | fn gimme() { } + | ^^^^^^^^^^^^^^^^^^ + +error[E0277]: the trait bound `(i32, f32): Foo` is not satisfied + --> $DIR/generic_impls.rs:17:5 + | +LL | gimme::<(i32, f32)>(); + | ^^^^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `(i32, f32)` + | + = help: the following implementations were found: + <(T, u32) as Foo> +note: required by `gimme` + --> $DIR/generic_impls.rs:7:1 + | +LL | fn gimme() { } + | ^^^^^^^^^^^^^^^^^^ + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/compile-fail/chalkify/type_wf.rs b/src/test/ui/chalkify/type_wf.rs similarity index 100% rename from src/test/compile-fail/chalkify/type_wf.rs rename to src/test/ui/chalkify/type_wf.rs diff --git a/src/test/ui/chalkify/type_wf.stderr b/src/test/ui/chalkify/type_wf.stderr new file mode 100644 index 0000000000000..593a1fba50d9e --- /dev/null +++ b/src/test/ui/chalkify/type_wf.stderr @@ -0,0 +1,18 @@ +error[E0277]: the trait bound `{float}: Foo` is not satisfied + --> $DIR/type_wf.rs:17:13 + | +LL | let s = S { + | ^ the trait `Foo` is not implemented for `{float}` + | + = help: the following implementations were found: + + as Foo> +note: required by `S` + --> $DIR/type_wf.rs:5:1 + | +LL | struct S { + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/compile-fail/coerce-unsafe-closure-to-unsafe-fn-ptr.rs b/src/test/ui/coercion/coerce-unsafe-closure-to-unsafe-fn-ptr.rs similarity index 100% rename from src/test/compile-fail/coerce-unsafe-closure-to-unsafe-fn-ptr.rs rename to src/test/ui/coercion/coerce-unsafe-closure-to-unsafe-fn-ptr.rs diff --git a/src/test/ui/coercion/coerce-unsafe-closure-to-unsafe-fn-ptr.stderr b/src/test/ui/coercion/coerce-unsafe-closure-to-unsafe-fn-ptr.stderr new file mode 100644 index 0000000000000..a1fb1c02e4622 --- /dev/null +++ b/src/test/ui/coercion/coerce-unsafe-closure-to-unsafe-fn-ptr.stderr @@ -0,0 +1,11 @@ +error[E0133]: call to unsafe function is unsafe and requires unsafe function or block + --> $DIR/coerce-unsafe-closure-to-unsafe-fn-ptr.rs:2:31 + | +LL | let _: unsafe fn() = || { ::std::pin::Pin::new_unchecked(&0_u8); }; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function + | + = note: consult the function's documentation for information on how to avoid undefined behavior + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0133`. diff --git a/src/test/compile-fail/const-err3.rs b/src/test/ui/consts/const-err3.rs similarity index 100% rename from src/test/compile-fail/const-err3.rs rename to src/test/ui/consts/const-err3.rs diff --git a/src/test/ui/consts/const-err3.stderr b/src/test/ui/consts/const-err3.stderr new file mode 100644 index 0000000000000..467aab501227b --- /dev/null +++ b/src/test/ui/consts/const-err3.stderr @@ -0,0 +1,32 @@ +error: this expression will panic at runtime + --> $DIR/const-err3.rs:9:13 + | +LL | let b = 200u8 + 200u8 + 200u8; + | ^^^^^^^^^^^^^ attempt to add with overflow + | +note: lint level defined here + --> $DIR/const-err3.rs:2:9 + | +LL | #![deny(const_err)] + | ^^^^^^^^^ + +error: this expression will panic at runtime + --> $DIR/const-err3.rs:11:13 + | +LL | let c = 200u8 * 4; + | ^^^^^^^^^ attempt to multiply with overflow + +error: this expression will panic at runtime + --> $DIR/const-err3.rs:13:13 + | +LL | let d = 42u8 - (42u8 + 1); + | ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow + +error: index out of bounds: the len is 1 but the index is 1 + --> $DIR/const-err3.rs:15:14 + | +LL | let _e = [5u8][1]; + | ^^^^^^^^ + +error: aborting due to 4 previous errors + diff --git a/src/test/compile-fail/const-fn-error.rs b/src/test/ui/consts/const-fn-error.rs similarity index 100% rename from src/test/compile-fail/const-fn-error.rs rename to src/test/ui/consts/const-fn-error.rs diff --git a/src/test/ui/consts/const-fn-error.stderr b/src/test/ui/consts/const-fn-error.stderr new file mode 100644 index 0000000000000..392caaa78634a --- /dev/null +++ b/src/test/ui/consts/const-fn-error.stderr @@ -0,0 +1,34 @@ +error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants + --> $DIR/const-fn-error.rs:7:14 + | +LL | for i in 0..x { + | ^^^^ + +error[E0019]: constant function contains unimplemented expression type + --> $DIR/const-fn-error.rs:7:14 + | +LL | for i in 0..x { + | ^^^^ + +error[E0019]: constant function contains unimplemented expression type + --> $DIR/const-fn-error.rs:7:5 + | +LL | / for i in 0..x { +LL | | +LL | | +LL | | +LL | | +LL | | sum += i; +LL | | } + | |_____^ + +error[E0080]: evaluation of constant value failed + --> $DIR/const-fn-error.rs:7:14 + | +LL | for i in 0..x { + | ^^^^ calling non-const function ` as std::iter::IntoIterator>::into_iter` + +error: aborting due to 4 previous errors + +Some errors have detailed explanations: E0015, E0019, E0080. +For more information about an error, try `rustc --explain E0015`. diff --git a/src/test/compile-fail/issue-52443.rs b/src/test/ui/consts/issue-52443.rs similarity index 100% rename from src/test/compile-fail/issue-52443.rs rename to src/test/ui/consts/issue-52443.rs diff --git a/src/test/ui/consts/issue-52443.stderr b/src/test/ui/consts/issue-52443.stderr new file mode 100644 index 0000000000000..f6aa3bf61e881 --- /dev/null +++ b/src/test/ui/consts/issue-52443.stderr @@ -0,0 +1,55 @@ +error[E0308]: mismatched types + --> $DIR/issue-52443.rs:2:10 + | +LL | [(); & { loop { continue } } ]; + | ^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected usize, found reference + | help: consider removing the borrow: `{ loop { continue } }` + | + = note: expected type `usize` + found type `&_` + +error[E0308]: mismatched types + --> $DIR/issue-52443.rs:3:17 + | +LL | [(); loop { break }]; + | ^^^^^ expected (), found usize + | + = note: expected type `()` + found type `usize` + +error[E0019]: constant contains unimplemented expression type + --> $DIR/issue-52443.rs:4:11 + | +LL | [(); {while true {break}; 0}]; + | ^^^^^^^^^^^^^^^^^^ + +error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants + --> $DIR/issue-52443.rs:5:21 + | +LL | [(); { for _ in 0usize.. {}; 0}]; + | ^^^^^^^^ + +error[E0019]: constant contains unimplemented expression type + --> $DIR/issue-52443.rs:5:21 + | +LL | [(); { for _ in 0usize.. {}; 0}]; + | ^^^^^^^^ + +error[E0019]: constant contains unimplemented expression type + --> $DIR/issue-52443.rs:5:12 + | +LL | [(); { for _ in 0usize.. {}; 0}]; + | ^^^^^^^^^^^^^^^^^^^^ + +error[E0080]: evaluation of constant value failed + --> $DIR/issue-52443.rs:5:21 + | +LL | [(); { for _ in 0usize.. {}; 0}]; + | ^^^^^^^^ calling non-const function ` as std::iter::IntoIterator>::into_iter` + +error: aborting due to 7 previous errors + +Some errors have detailed explanations: E0015, E0019, E0080, E0308. +For more information about an error, try `rustc --explain E0015`. diff --git a/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.rs b/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.rs index 0395795ef7bfe..0f9d37292958a 100644 --- a/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.rs +++ b/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.rs @@ -5,7 +5,7 @@ const fn error(_: fn()) {} #[stable(feature = "rust1", since = "1.0.0")] #[rustc_allow_const_fn_ptr] -//~^ ERROR unless otherwise specified, attributes with the prefix `rustc_` are reserved +//~^ ERROR internal implementation detail const fn compiles(_: fn()) {} fn main() {} diff --git a/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.stderr b/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.stderr index c934307e918b9..d2ca0c8bc381b 100644 --- a/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.stderr +++ b/src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.stderr @@ -1,8 +1,8 @@ -error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics - --> $DIR/allow_const_fn_ptr_feature_gate.rs:7:3 +error[E0658]: internal implementation detail + --> $DIR/allow_const_fn_ptr_feature_gate.rs:7:1 | LL | #[rustc_allow_const_fn_ptr] - | ^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: for more information, see https://github.com/rust-lang/rust/issues/29642 = help: add #![feature(rustc_attrs)] to the crate attributes to enable diff --git a/src/test/ui/feature-gates/feature-gate-rustc-attrs.rs b/src/test/ui/feature-gates/feature-gate-rustc-attrs.rs index 5ec413cc71de0..d3a2e486416af 100644 --- a/src/test/ui/feature-gates/feature-gate-rustc-attrs.rs +++ b/src/test/ui/feature-gates/feature-gate-rustc-attrs.rs @@ -1,6 +1,23 @@ // Test that `#[rustc_*]` attributes are gated by `rustc_attrs` feature gate. -#[rustc_foo] -//~^ ERROR unless otherwise specified, attributes with the prefix `rustc_` are reserved +#![feature(decl_macro)] +mod rustc { pub macro unknown() {} } +mod unknown { pub macro rustc() {} } + +#[rustc::unknown] +//~^ ERROR attributes starting with `rustc` are reserved for use by the `rustc` compiler +//~| ERROR macro `rustc::unknown` may not be used in attributes +fn f() {} + +#[unknown::rustc] +//~^ ERROR attributes starting with `rustc` are reserved for use by the `rustc` compiler +//~| ERROR macro `unknown::rustc` may not be used in attributes +fn g() {} + +#[rustc_dummy] +//~^ ERROR used by the test suite +#[rustc_unknown] +//~^ ERROR attributes starting with `rustc` are reserved for use by the `rustc` compiler +//~| ERROR attribute `rustc_unknown` is currently unknown fn main() {} diff --git a/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr b/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr index 3c823c8d4e25f..cdc7b27a749e5 100644 --- a/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr +++ b/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr @@ -1,12 +1,60 @@ -error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics - --> $DIR/feature-gate-rustc-attrs.rs:3:3 +error[E0658]: attributes starting with `rustc` are reserved for use by the `rustc` compiler + --> $DIR/feature-gate-rustc-attrs.rs:8:3 | -LL | #[rustc_foo] - | ^^^^^^^^^ +LL | #[rustc::unknown] + | ^^^^^ | = note: for more information, see https://github.com/rust-lang/rust/issues/29642 = help: add #![feature(rustc_attrs)] to the crate attributes to enable -error: aborting due to previous error +error: macro `rustc::unknown` may not be used in attributes + --> $DIR/feature-gate-rustc-attrs.rs:8:1 + | +LL | #[rustc::unknown] + | ^^^^^^^^^^^^^^^^^ + +error[E0658]: attributes starting with `rustc` are reserved for use by the `rustc` compiler + --> $DIR/feature-gate-rustc-attrs.rs:13:12 + | +LL | #[unknown::rustc] + | ^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/29642 + = help: add #![feature(rustc_attrs)] to the crate attributes to enable + +error: macro `unknown::rustc` may not be used in attributes + --> $DIR/feature-gate-rustc-attrs.rs:13:1 + | +LL | #[unknown::rustc] + | ^^^^^^^^^^^^^^^^^ + +error[E0658]: attributes starting with `rustc` are reserved for use by the `rustc` compiler + --> $DIR/feature-gate-rustc-attrs.rs:20:3 + | +LL | #[rustc_unknown] + | ^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/29642 + = help: add #![feature(rustc_attrs)] to the crate attributes to enable + +error[E0658]: The attribute `rustc_unknown` is currently unknown to the compiler and may have meaning added to it in the future + --> $DIR/feature-gate-rustc-attrs.rs:20:3 + | +LL | #[rustc_unknown] + | ^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/29642 + = help: add #![feature(custom_attribute)] to the crate attributes to enable + +error[E0658]: used by the test suite + --> $DIR/feature-gate-rustc-attrs.rs:18:1 + | +LL | #[rustc_dummy] + | ^^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/29642 + = help: add #![feature(rustc_attrs)] to the crate attributes to enable + +error: aborting due to 7 previous errors For more information about this error, try `rustc --explain E0658`. diff --git a/src/test/ui/generic/generic-param-attrs.rs b/src/test/ui/generic/generic-param-attrs.rs index 601d2a9e0a31f..6c628914f1f8d 100644 --- a/src/test/ui/generic/generic-param-attrs.rs +++ b/src/test/ui/generic/generic-param-attrs.rs @@ -1,44 +1,38 @@ // This test previously ensured that attributes on formals in generic parameter // lists are rejected without a feature gate. -// -// (We are prefixing all tested features with `rustc_`, to ensure that -// the attributes themselves won't be rejected by the compiler when -// using `rustc_attrs` feature. There is a separate compile-fail/ test -// ensuring that the attribute feature-gating works in this context.) // compile-pass #![feature(rustc_attrs)] -#![allow(dead_code)] - -struct StLt<#[rustc_lt_struct] 'a>(&'a u32); -struct StTy<#[rustc_ty_struct] I>(I); -enum EnLt<#[rustc_lt_enum] 'b> { A(&'b u32), B } -enum EnTy<#[rustc_ty_enum] J> { A(J), B } -trait TrLt<#[rustc_lt_trait] 'c> { fn foo(&self, _: &'c [u32]) -> &'c u32; } -trait TrTy<#[rustc_ty_trait] K> { fn foo(&self, _: K); } -type TyLt<#[rustc_lt_type] 'd> = &'d u32; -type TyTy<#[rustc_ty_type] L> = (L, ); - -impl<#[rustc_lt_inherent] 'e> StLt<'e> { } -impl<#[rustc_ty_inherent] M> StTy { } -impl<#[rustc_lt_impl_for] 'f> TrLt<'f> for StLt<'f> { + +struct StLt<#[rustc_dummy] 'a>(&'a u32); +struct StTy<#[rustc_dummy] I>(I); +enum EnLt<#[rustc_dummy] 'b> { A(&'b u32), B } +enum EnTy<#[rustc_dummy] J> { A(J), B } +trait TrLt<#[rustc_dummy] 'c> { fn foo(&self, _: &'c [u32]) -> &'c u32; } +trait TrTy<#[rustc_dummy] K> { fn foo(&self, _: K); } +type TyLt<#[rustc_dummy] 'd> = &'d u32; +type TyTy<#[rustc_dummy] L> = (L, ); + +impl<#[rustc_dummy] 'e> StLt<'e> { } +impl<#[rustc_dummy] M> StTy { } +impl<#[rustc_dummy] 'f> TrLt<'f> for StLt<'f> { fn foo(&self, _: &'f [u32]) -> &'f u32 { loop { } } } -impl<#[rustc_ty_impl_for] N> TrTy for StTy { +impl<#[rustc_dummy] N> TrTy for StTy { fn foo(&self, _: N) { } } -fn f_lt<#[rustc_lt_fn] 'g>(_: &'g [u32]) -> &'g u32 { loop { } } -fn f_ty<#[rustc_ty_fn] O>(_: O) { } +fn f_lt<#[rustc_dummy] 'g>(_: &'g [u32]) -> &'g u32 { loop { } } +fn f_ty<#[rustc_dummy] O>(_: O) { } impl StTy { - fn m_lt<#[rustc_lt_meth] 'h>(_: &'h [u32]) -> &'h u32 { loop { } } - fn m_ty<#[rustc_ty_meth] P>(_: P) { } + fn m_lt<#[rustc_dummy] 'h>(_: &'h [u32]) -> &'h u32 { loop { } } + fn m_ty<#[rustc_dummy] P>(_: P) { } } fn hof_lt(_: Q) - where Q: for <#[rustc_lt_hof] 'i> Fn(&'i [u32]) -> &'i u32 + where Q: for <#[rustc_dummy] 'i> Fn(&'i [u32]) -> &'i u32 {} fn main() {} diff --git a/src/test/ui/imports/empty-extern-arg-wasm.rs b/src/test/ui/imports/empty-extern-arg-wasm.rs new file mode 100644 index 0000000000000..572fb85c24599 --- /dev/null +++ b/src/test/ui/imports/empty-extern-arg-wasm.rs @@ -0,0 +1,5 @@ +// compile-flags: --extern std= +// error-pattern: can't find crate for `std` +// only-wasm32 + +fn main() {} diff --git a/src/test/ui/imports/empty-extern-arg-wasm.stderr b/src/test/ui/imports/empty-extern-arg-wasm.stderr new file mode 100644 index 0000000000000..26dba1c2363ef --- /dev/null +++ b/src/test/ui/imports/empty-extern-arg-wasm.stderr @@ -0,0 +1,9 @@ +error: extern location for std does not exist: + +error[E0463]: can't find crate for `std` + | + = note: the `wasm32-unknown-unknown` target may not be installed + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0463`. diff --git a/src/test/compile-fail/empty-extern-arg.rs b/src/test/ui/imports/empty-extern-arg.rs similarity index 84% rename from src/test/compile-fail/empty-extern-arg.rs rename to src/test/ui/imports/empty-extern-arg.rs index ae28fcad903be..730a0225516f9 100644 --- a/src/test/compile-fail/empty-extern-arg.rs +++ b/src/test/ui/imports/empty-extern-arg.rs @@ -1,4 +1,5 @@ // compile-flags: --extern std= // error-pattern: can't find crate for `std` +// ignore-wasm32 fn main() {} diff --git a/src/test/ui/imports/empty-extern-arg.stderr b/src/test/ui/imports/empty-extern-arg.stderr new file mode 100644 index 0000000000000..c81a647b094f9 --- /dev/null +++ b/src/test/ui/imports/empty-extern-arg.stderr @@ -0,0 +1,7 @@ +error: extern location for std does not exist: + +error[E0463]: can't find crate for `std` + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0463`. diff --git a/src/test/compile-fail/auxiliary/weak-lang-items.rs b/src/test/ui/lang-item/auxiliary/weak-lang-items.rs similarity index 100% rename from src/test/compile-fail/auxiliary/weak-lang-items.rs rename to src/test/ui/lang-item/auxiliary/weak-lang-items.rs diff --git a/src/test/ui/lang-item-missing.rs b/src/test/ui/lang-item/lang-item-missing.rs similarity index 100% rename from src/test/ui/lang-item-missing.rs rename to src/test/ui/lang-item/lang-item-missing.rs diff --git a/src/test/ui/lang-item-missing.stderr b/src/test/ui/lang-item/lang-item-missing.stderr similarity index 100% rename from src/test/ui/lang-item-missing.stderr rename to src/test/ui/lang-item/lang-item-missing.stderr diff --git a/src/test/ui/required-lang-item.rs b/src/test/ui/lang-item/required-lang-item.rs similarity index 100% rename from src/test/ui/required-lang-item.rs rename to src/test/ui/lang-item/required-lang-item.rs diff --git a/src/test/ui/required-lang-item.stderr b/src/test/ui/lang-item/required-lang-item.stderr similarity index 100% rename from src/test/ui/required-lang-item.stderr rename to src/test/ui/lang-item/required-lang-item.stderr diff --git a/src/test/ui/unknown-language-item.rs b/src/test/ui/lang-item/unknown-language-item.rs similarity index 100% rename from src/test/ui/unknown-language-item.rs rename to src/test/ui/lang-item/unknown-language-item.rs diff --git a/src/test/ui/unknown-language-item.stderr b/src/test/ui/lang-item/unknown-language-item.stderr similarity index 100% rename from src/test/ui/unknown-language-item.stderr rename to src/test/ui/lang-item/unknown-language-item.stderr diff --git a/src/test/compile-fail/weak-lang-item.rs b/src/test/ui/lang-item/weak-lang-item.rs similarity index 100% rename from src/test/compile-fail/weak-lang-item.rs rename to src/test/ui/lang-item/weak-lang-item.rs diff --git a/src/test/ui/lang-item/weak-lang-item.stderr b/src/test/ui/lang-item/weak-lang-item.stderr new file mode 100644 index 0000000000000..b7c040c7a850b --- /dev/null +++ b/src/test/ui/lang-item/weak-lang-item.stderr @@ -0,0 +1,19 @@ +error[E0259]: the name `core` is defined multiple times + --> $DIR/weak-lang-item.rs:8:1 + | +LL | extern crate core; + | ^^^^^^^^^^^^^^^^^^ `core` reimported here + | + = note: `core` must be defined only once in the type namespace of this module +help: you can use `as` to change the binding name of the import + | +LL | extern crate core as other_core; + | + +error: `#[panic_handler]` function required, but not found + +error: language item required, but not found: `eh_personality` + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0259`. diff --git a/src/test/compile-fail/issue-10755.rs b/src/test/ui/linkage/issue-10755.rs similarity index 100% rename from src/test/compile-fail/issue-10755.rs rename to src/test/ui/linkage/issue-10755.rs diff --git a/src/test/ui/linkage/issue-10755.stderr b/src/test/ui/linkage/issue-10755.stderr new file mode 100644 index 0000000000000..db64944d44ff7 --- /dev/null +++ b/src/test/ui/linkage/issue-10755.stderr @@ -0,0 +1,6 @@ +error: linker `llllll` not found + | + = note: No such file or directory (os error 2) + +error: aborting due to previous error + diff --git a/src/test/ui/fn_must_use.rs b/src/test/ui/lint/fn_must_use.rs similarity index 100% rename from src/test/ui/fn_must_use.rs rename to src/test/ui/lint/fn_must_use.rs diff --git a/src/test/ui/fn_must_use.stderr b/src/test/ui/lint/fn_must_use.stderr similarity index 100% rename from src/test/ui/fn_must_use.stderr rename to src/test/ui/lint/fn_must_use.stderr diff --git a/src/test/ui/lint/lint-non-ascii-idents.rs b/src/test/ui/lint/lint-non-ascii-idents.rs new file mode 100644 index 0000000000000..057329a0a650c --- /dev/null +++ b/src/test/ui/lint/lint-non-ascii-idents.rs @@ -0,0 +1,11 @@ +#![feature(non_ascii_idents)] +#![deny(non_ascii_idents)] + +const חלודה: usize = 2; //~ ERROR identifier contains non-ASCII characters + +fn coöperation() {} //~ ERROR identifier contains non-ASCII characters + +fn main() { + let naïveté = 2; //~ ERROR identifier contains non-ASCII characters + println!("{}", naïveté); //~ ERROR identifier contains non-ASCII characters +} diff --git a/src/test/ui/lint/lint-non-ascii-idents.stderr b/src/test/ui/lint/lint-non-ascii-idents.stderr new file mode 100644 index 0000000000000..56925846e956b --- /dev/null +++ b/src/test/ui/lint/lint-non-ascii-idents.stderr @@ -0,0 +1,32 @@ +error: identifier contains non-ASCII characters + --> $DIR/lint-non-ascii-idents.rs:4:7 + | +LL | const חלודה: usize = 2; + | ^^^^^ + | +note: lint level defined here + --> $DIR/lint-non-ascii-idents.rs:2:9 + | +LL | #![deny(non_ascii_idents)] + | ^^^^^^^^^^^^^^^^ + +error: identifier contains non-ASCII characters + --> $DIR/lint-non-ascii-idents.rs:6:4 + | +LL | fn coöperation() {} + | ^^^^^^^^^^^ + +error: identifier contains non-ASCII characters + --> $DIR/lint-non-ascii-idents.rs:9:9 + | +LL | let naïveté = 2; + | ^^^^^^^ + +error: identifier contains non-ASCII characters + --> $DIR/lint-non-ascii-idents.rs:10:20 + | +LL | println!("{}", naïveté); + | ^^^^^^^ + +error: aborting due to 4 previous errors + diff --git a/src/test/compile-fail/must_use-in-stdlib-traits.rs b/src/test/ui/lint/must_use-in-stdlib-traits.rs similarity index 100% rename from src/test/compile-fail/must_use-in-stdlib-traits.rs rename to src/test/ui/lint/must_use-in-stdlib-traits.rs diff --git a/src/test/ui/lint/must_use-in-stdlib-traits.stderr b/src/test/ui/lint/must_use-in-stdlib-traits.stderr new file mode 100644 index 0000000000000..4d5f4b25cb424 --- /dev/null +++ b/src/test/ui/lint/must_use-in-stdlib-traits.stderr @@ -0,0 +1,47 @@ +error: unused implementer of `std::iter::Iterator` that must be used + --> $DIR/must_use-in-stdlib-traits.rs:42:4 + | +LL | iterator(); + | ^^^^^^^^^^^ + | +note: lint level defined here + --> $DIR/must_use-in-stdlib-traits.rs:1:9 + | +LL | #![deny(unused_must_use)] + | ^^^^^^^^^^^^^^^ + = note: iterators are lazy and do nothing unless consumed + +error: unused implementer of `std::future::Future` that must be used + --> $DIR/must_use-in-stdlib-traits.rs:43:4 + | +LL | future(); + | ^^^^^^^^^ + | + = note: futures do nothing unless you `.await` or poll them + +error: unused implementer of `std::ops::FnOnce` that must be used + --> $DIR/must_use-in-stdlib-traits.rs:44:4 + | +LL | square_fn_once(); + | ^^^^^^^^^^^^^^^^^ + | + = note: closures are lazy and do nothing unless called + +error: unused implementer of `std::ops::FnMut` that must be used + --> $DIR/must_use-in-stdlib-traits.rs:45:4 + | +LL | square_fn_mut(); + | ^^^^^^^^^^^^^^^^ + | + = note: closures are lazy and do nothing unless called + +error: unused implementer of `std::ops::Fn` that must be used + --> $DIR/must_use-in-stdlib-traits.rs:46:4 + | +LL | square_fn(); + | ^^^^^^^^^^^^ + | + = note: closures are lazy and do nothing unless called + +error: aborting due to 5 previous errors + diff --git a/src/test/ui/meta-expected-error-correct-rev.a.stderr b/src/test/ui/meta-test/meta-expected-error-correct-rev.a.stderr similarity index 100% rename from src/test/ui/meta-expected-error-correct-rev.a.stderr rename to src/test/ui/meta-test/meta-expected-error-correct-rev.a.stderr diff --git a/src/test/ui/meta-expected-error-correct-rev.rs b/src/test/ui/meta-test/meta-expected-error-correct-rev.rs similarity index 100% rename from src/test/ui/meta-expected-error-correct-rev.rs rename to src/test/ui/meta-test/meta-expected-error-correct-rev.rs diff --git a/src/test/ui/meta-test/meta-expected-error-wrong-rev.a.stderr b/src/test/ui/meta-test/meta-expected-error-wrong-rev.a.stderr new file mode 100644 index 0000000000000..72b7285a953ac --- /dev/null +++ b/src/test/ui/meta-test/meta-expected-error-wrong-rev.a.stderr @@ -0,0 +1,13 @@ +error[E0308]: mismatched types + --> $DIR/meta-expected-error-wrong-rev.rs:13:18 + | +LL | let x: u32 = 22_usize; + | ^^^^^^^^ expected u32, found usize +help: change the type of the numeric literal from `usize` to `u32` + | +LL | let x: u32 = 22_u32; + | ^^^^^^ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/compile-fail/meta-expected-error-wrong-rev.rs b/src/test/ui/meta-test/meta-expected-error-wrong-rev.rs similarity index 100% rename from src/test/compile-fail/meta-expected-error-wrong-rev.rs rename to src/test/ui/meta-test/meta-expected-error-wrong-rev.rs diff --git a/src/test/ui/nll/ty-outlives/projection-implied-bounds.rs b/src/test/ui/nll/ty-outlives/projection-implied-bounds.rs index 1245ce8583e29..fb50dce1af616 100644 --- a/src/test/ui/nll/ty-outlives/projection-implied-bounds.rs +++ b/src/test/ui/nll/ty-outlives/projection-implied-bounds.rs @@ -1,10 +1,7 @@ -// compile-flags:-Zborrowck=mir -Zverbose - // Test that we can deduce when projections like `T::Item` outlive the // function body. Test that this does not imply that `T: 'a` holds. -#![allow(warnings)] -#![feature(rustc_attrs)] +// compile-flags:-Zborrowck=mir -Zverbose use std::cell::Cell; @@ -18,7 +15,6 @@ where f(&value, Cell::new(&n)); } -#[rustc_errors] fn generic1(value: T) { // No error here: twice(value, |value_ref, item| invoke1(item)); @@ -30,7 +26,6 @@ where { } -#[rustc_errors] fn generic2(value: T) { twice(value, |value_ref, item| invoke2(value_ref, item)); //~^ ERROR the parameter type `T` may not live long enough diff --git a/src/test/ui/nll/ty-outlives/projection-implied-bounds.stderr b/src/test/ui/nll/ty-outlives/projection-implied-bounds.stderr index 9cdb78a10281c..9f0c60c1e1705 100644 --- a/src/test/ui/nll/ty-outlives/projection-implied-bounds.stderr +++ b/src/test/ui/nll/ty-outlives/projection-implied-bounds.stderr @@ -1,5 +1,5 @@ error[E0310]: the parameter type `T` may not live long enough - --> $DIR/projection-implied-bounds.rs:35:18 + --> $DIR/projection-implied-bounds.rs:30:18 | LL | twice(value, |value_ref, item| invoke2(value_ref, item)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/src/test/ui/nll/ty-outlives/ty-param-implied-bounds.rs b/src/test/ui/nll/ty-outlives/ty-param-implied-bounds.rs index f61f54f80a78b..6a9ef3b5ce07f 100644 --- a/src/test/ui/nll/ty-outlives/ty-param-implied-bounds.rs +++ b/src/test/ui/nll/ty-outlives/ty-param-implied-bounds.rs @@ -4,9 +4,6 @@ // Test that we assume that universal types like `T` outlive the // function body. -#![allow(warnings)] -#![feature(rustc_attrs)] - use std::cell::Cell; fn twice(value: T, mut f: F) @@ -17,7 +14,6 @@ where f(Cell::new(&value)); } -#[rustc_errors] fn generic(value: T) { // No error here: twice(value, |r| invoke(r)); diff --git a/src/test/compile-fail/not-utf8.bin b/src/test/ui/not-utf8.bin similarity index 100% rename from src/test/compile-fail/not-utf8.bin rename to src/test/ui/not-utf8.bin diff --git a/src/test/compile-fail/not-utf8.rs b/src/test/ui/not-utf8.rs similarity index 100% rename from src/test/compile-fail/not-utf8.rs rename to src/test/ui/not-utf8.rs diff --git a/src/test/ui/not-utf8.stderr b/src/test/ui/not-utf8.stderr new file mode 100644 index 0000000000000..2f0b6e0a56228 --- /dev/null +++ b/src/test/ui/not-utf8.stderr @@ -0,0 +1,8 @@ +error: couldn't read $DIR/not-utf8.bin: stream did not contain valid UTF-8 + --> $DIR/not-utf8.rs:4:5 + | +LL | include!("not-utf8.bin") + | ^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/object-lifetime/object-lifetime-default.stderr b/src/test/ui/object-lifetime/object-lifetime-default.stderr index 2642cdff2bf6a..f71c8cd0e0c39 100644 --- a/src/test/ui/object-lifetime/object-lifetime-default.stderr +++ b/src/test/ui/object-lifetime/object-lifetime-default.stderr @@ -1,20 +1,20 @@ -error: 'a,Ambiguous - --> $DIR/object-lifetime-default.rs:24:1 +error: BaseDefault + --> $DIR/object-lifetime-default.rs:6:1 | -LL | struct G<'a,'b,T:'a,U:'a+'b>(&'a T, &'b U); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | struct A(T); + | ^^^^^^^^^^^^^^^ -error: 'a,'b - --> $DIR/object-lifetime-default.rs:21:1 +error: BaseDefault + --> $DIR/object-lifetime-default.rs:9:1 | -LL | struct F<'a,'b,T:'a,U:'b>(&'a T, &'b U); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | struct B<'a,T>(&'a (), T); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: 'b - --> $DIR/object-lifetime-default.rs:18:1 +error: 'a + --> $DIR/object-lifetime-default.rs:12:1 | -LL | struct E<'a,'b:'a,T:'b>(&'a T, &'b T); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | struct C<'a,T:'a>(&'a T); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ error: Ambiguous --> $DIR/object-lifetime-default.rs:15:1 @@ -22,23 +22,23 @@ error: Ambiguous LL | struct D<'a,'b,T:'a+'b>(&'a T, &'b T); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: 'a - --> $DIR/object-lifetime-default.rs:12:1 +error: 'b + --> $DIR/object-lifetime-default.rs:18:1 | -LL | struct C<'a,T:'a>(&'a T); - | ^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | struct E<'a,'b:'a,T:'b>(&'a T, &'b T); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: BaseDefault - --> $DIR/object-lifetime-default.rs:9:1 +error: 'a,'b + --> $DIR/object-lifetime-default.rs:21:1 | -LL | struct B<'a,T>(&'a (), T); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | struct F<'a,'b,T:'a,U:'b>(&'a T, &'b U); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: BaseDefault - --> $DIR/object-lifetime-default.rs:6:1 +error: 'a,Ambiguous + --> $DIR/object-lifetime-default.rs:24:1 | -LL | struct A(T); - | ^^^^^^^^^^^^^^^ +LL | struct G<'a,'b,T:'a,U:'a+'b>(&'a T, &'b U); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 7 previous errors diff --git a/src/test/compile-fail/panic-handler-missing.rs b/src/test/ui/panic-handler/panic-handler-missing.rs similarity index 100% rename from src/test/compile-fail/panic-handler-missing.rs rename to src/test/ui/panic-handler/panic-handler-missing.rs diff --git a/src/test/ui/panic-handler/panic-handler-missing.stderr b/src/test/ui/panic-handler/panic-handler-missing.stderr new file mode 100644 index 0000000000000..53f7b0336ec77 --- /dev/null +++ b/src/test/ui/panic-handler/panic-handler-missing.stderr @@ -0,0 +1,4 @@ +error: `#[panic_handler]` function required, but not found + +error: aborting due to previous error + diff --git a/src/test/compile-fail/panic-handler-twice.rs b/src/test/ui/panic-handler/panic-handler-twice.rs similarity index 100% rename from src/test/compile-fail/panic-handler-twice.rs rename to src/test/ui/panic-handler/panic-handler-twice.rs diff --git a/src/test/ui/panic-handler/panic-handler-twice.stderr b/src/test/ui/panic-handler/panic-handler-twice.stderr new file mode 100644 index 0000000000000..10e128495376b --- /dev/null +++ b/src/test/ui/panic-handler/panic-handler-twice.stderr @@ -0,0 +1,14 @@ +error[E0152]: duplicate lang item found: `panic_impl`. + --> $DIR/panic-handler-twice.rs:12:1 + | +LL | / fn panic(info: &PanicInfo) -> ! { +LL | | +LL | | loop {} +LL | | } + | |_^ + | + = note: first defined in crate `some_panic_impl`. + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0152`. diff --git a/src/test/compile-fail/auxiliary/depends.rs b/src/test/ui/panic-runtime/auxiliary/depends.rs similarity index 100% rename from src/test/compile-fail/auxiliary/depends.rs rename to src/test/ui/panic-runtime/auxiliary/depends.rs diff --git a/src/test/compile-fail/auxiliary/needs-panic-runtime.rs b/src/test/ui/panic-runtime/auxiliary/needs-panic-runtime.rs similarity index 100% rename from src/test/compile-fail/auxiliary/needs-panic-runtime.rs rename to src/test/ui/panic-runtime/auxiliary/needs-panic-runtime.rs diff --git a/src/test/compile-fail/runtime-depend-on-needs-runtime.rs b/src/test/ui/panic-runtime/auxiliary/runtime-depend-on-needs-runtime.rs similarity index 100% rename from src/test/compile-fail/runtime-depend-on-needs-runtime.rs rename to src/test/ui/panic-runtime/auxiliary/runtime-depend-on-needs-runtime.rs diff --git a/src/test/compile-fail/runtime-depend-on-needs-runtime.stderr b/src/test/ui/panic-runtime/auxiliary/runtime-depend-on-needs-runtime.stderr similarity index 100% rename from src/test/compile-fail/runtime-depend-on-needs-runtime.stderr rename to src/test/ui/panic-runtime/auxiliary/runtime-depend-on-needs-runtime.stderr diff --git a/src/test/compile-fail/two-panic-runtimes.rs b/src/test/ui/panic-runtime/auxiliary/two-panic-runtimes.rs similarity index 100% rename from src/test/compile-fail/two-panic-runtimes.rs rename to src/test/ui/panic-runtime/auxiliary/two-panic-runtimes.rs diff --git a/src/test/compile-fail/want-abort-got-unwind.rs b/src/test/ui/panic-runtime/auxiliary/want-abort-got-unwind.rs similarity index 100% rename from src/test/compile-fail/want-abort-got-unwind.rs rename to src/test/ui/panic-runtime/auxiliary/want-abort-got-unwind.rs diff --git a/src/test/compile-fail/want-abort-got-unwind2.rs b/src/test/ui/panic-runtime/auxiliary/want-abort-got-unwind2.rs similarity index 100% rename from src/test/compile-fail/want-abort-got-unwind2.rs rename to src/test/ui/panic-runtime/auxiliary/want-abort-got-unwind2.rs diff --git a/src/test/ui/proc-macro/expand-to-unstable-2.rs b/src/test/ui/proc-macro/expand-to-unstable-2.rs index 4b4ba52ecd726..437ae93093470 100644 --- a/src/test/ui/proc-macro/expand-to-unstable-2.rs +++ b/src/test/ui/proc-macro/expand-to-unstable-2.rs @@ -1,12 +1,12 @@ // aux-build:derive-unstable-2.rs -#![allow(warnings)] - #[macro_use] extern crate derive_unstable_2; #[derive(Unstable)] -//~^ ERROR: reserved for internal compiler +//~^ ERROR attributes starting with `rustc` are reserved for use by the `rustc` compiler +//~| ERROR attribute `rustc_foo` is currently unknown to the compiler + struct A; fn main() { diff --git a/src/test/ui/proc-macro/expand-to-unstable-2.stderr b/src/test/ui/proc-macro/expand-to-unstable-2.stderr index e2f51dd3d5dd2..803773db88e96 100644 --- a/src/test/ui/proc-macro/expand-to-unstable-2.stderr +++ b/src/test/ui/proc-macro/expand-to-unstable-2.stderr @@ -1,5 +1,5 @@ -error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics - --> $DIR/expand-to-unstable-2.rs:8:10 +error[E0658]: attributes starting with `rustc` are reserved for use by the `rustc` compiler + --> $DIR/expand-to-unstable-2.rs:6:10 | LL | #[derive(Unstable)] | ^^^^^^^^ @@ -7,6 +7,15 @@ LL | #[derive(Unstable)] = note: for more information, see https://github.com/rust-lang/rust/issues/29642 = help: add #![feature(rustc_attrs)] to the crate attributes to enable -error: aborting due to previous error +error[E0658]: The attribute `rustc_foo` is currently unknown to the compiler and may have meaning added to it in the future + --> $DIR/expand-to-unstable-2.rs:6:10 + | +LL | #[derive(Unstable)] + | ^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/29642 + = help: add #![feature(custom_attribute)] to the crate attributes to enable + +error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0658`. diff --git a/src/test/ui/reserved/reserved-attr-on-macro.rs b/src/test/ui/reserved/reserved-attr-on-macro.rs index 96c63ba4db8c9..cb535362266c0 100644 --- a/src/test/ui/reserved/reserved-attr-on-macro.rs +++ b/src/test/ui/reserved/reserved-attr-on-macro.rs @@ -1,5 +1,7 @@ #[rustc_attribute_should_be_reserved] -//~^ ERROR unless otherwise specified, attributes with the prefix `rustc_` are reserved +//~^ ERROR attribute `rustc_attribute_should_be_reserved` is currently unknown +//~| ERROR attributes starting with `rustc` are reserved for use by the `rustc` compiler + macro_rules! foo { () => (()); } diff --git a/src/test/ui/reserved/reserved-attr-on-macro.stderr b/src/test/ui/reserved/reserved-attr-on-macro.stderr index c8738d1ed3429..0c62c82017e18 100644 --- a/src/test/ui/reserved/reserved-attr-on-macro.stderr +++ b/src/test/ui/reserved/reserved-attr-on-macro.stderr @@ -1,4 +1,4 @@ -error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics +error[E0658]: attributes starting with `rustc` are reserved for use by the `rustc` compiler --> $DIR/reserved-attr-on-macro.rs:1:3 | LL | #[rustc_attribute_should_be_reserved] @@ -7,14 +7,23 @@ LL | #[rustc_attribute_should_be_reserved] = note: for more information, see https://github.com/rust-lang/rust/issues/29642 = help: add #![feature(rustc_attrs)] to the crate attributes to enable +error[E0658]: The attribute `rustc_attribute_should_be_reserved` is currently unknown to the compiler and may have meaning added to it in the future + --> $DIR/reserved-attr-on-macro.rs:1:3 + | +LL | #[rustc_attribute_should_be_reserved] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/29642 + = help: add #![feature(custom_attribute)] to the crate attributes to enable + error: cannot determine resolution for the macro `foo` - --> $DIR/reserved-attr-on-macro.rs:8:5 + --> $DIR/reserved-attr-on-macro.rs:10:5 | LL | foo!(); | ^^^ | = note: import resolution is stuck, try simplifying macro imports -error: aborting due to 2 previous errors +error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0658`. diff --git a/src/test/compile-fail/specialization/issue-50452.rs b/src/test/ui/specialization/issue-50452.rs similarity index 100% rename from src/test/compile-fail/specialization/issue-50452.rs rename to src/test/ui/specialization/issue-50452.rs diff --git a/src/test/ui/specialization/issue-50452.stderr b/src/test/ui/specialization/issue-50452.stderr new file mode 100644 index 0000000000000..5e6f223916798 --- /dev/null +++ b/src/test/ui/specialization/issue-50452.stderr @@ -0,0 +1,16 @@ +error[E0520]: `foo` specializes an item from a parent `impl`, but that item is not marked `default` + --> $DIR/issue-50452.rs:11:5 + | +LL | fn foo() {} + | ^^^^^^^^^^^ cannot specialize default item `foo` +... +LL | / impl Foo for T { +LL | | fn foo() {} +LL | | } + | |_- parent `impl` is here + | + = note: to specialize, `foo` in the parent `impl` must be marked `default` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0520`. diff --git a/src/test/ui/suggestions/attribute-typos.rs b/src/test/ui/suggestions/attribute-typos.rs index 13c6308b97e85..0e10131ce8d1f 100644 --- a/src/test/ui/suggestions/attribute-typos.rs +++ b/src/test/ui/suggestions/attribute-typos.rs @@ -1,13 +1,11 @@ -#[deprcated] //~ ERROR E0658 -fn foo() {} //~| HELP a built-in attribute with a similar name exists - //~| SUGGESTION deprecated - //~| HELP add #![feature(custom_attribute)] to the crate attributes to enable +#[deprcated] //~ ERROR attribute `deprcated` is currently unknown +fn foo() {} -#[tests] //~ ERROR E0658 -fn bar() {} //~| HELP a built-in attribute with a similar name exists - //~| SUGGESTION test - //~| HELP add #![feature(custom_attribute)] to the crate attributes to enable +#[tests] //~ ERROR attribute `tests` is currently unknown to the compiler +fn bar() {} -#[rustc_err] //~ ERROR E0658 -fn main() {} //~| HELP add #![feature(rustc_attrs)] to the crate attributes to enable - // don't suggest rustc attributes +#[rustc_err] +//~^ ERROR attribute `rustc_err` is currently unknown +//~| ERROR attributes starting with `rustc` are reserved for use by the `rustc` compiler + +fn main() {} diff --git a/src/test/ui/suggestions/attribute-typos.stderr b/src/test/ui/suggestions/attribute-typos.stderr index 8367ff20aa408..958688b4d3906 100644 --- a/src/test/ui/suggestions/attribute-typos.stderr +++ b/src/test/ui/suggestions/attribute-typos.stderr @@ -1,5 +1,5 @@ -error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics - --> $DIR/attribute-typos.rs:11:3 +error[E0658]: attributes starting with `rustc` are reserved for use by the `rustc` compiler + --> $DIR/attribute-typos.rs:7:3 | LL | #[rustc_err] | ^^^^^^^^^ @@ -7,8 +7,17 @@ LL | #[rustc_err] = note: for more information, see https://github.com/rust-lang/rust/issues/29642 = help: add #![feature(rustc_attrs)] to the crate attributes to enable +error[E0658]: The attribute `rustc_err` is currently unknown to the compiler and may have meaning added to it in the future + --> $DIR/attribute-typos.rs:7:3 + | +LL | #[rustc_err] + | ^^^^^^^^^ + | + = note: for more information, see https://github.com/rust-lang/rust/issues/29642 + = help: add #![feature(custom_attribute)] to the crate attributes to enable + error[E0658]: The attribute `tests` is currently unknown to the compiler and may have meaning added to it in the future - --> $DIR/attribute-typos.rs:6:3 + --> $DIR/attribute-typos.rs:4:3 | LL | #[tests] | ^^^^^ help: a built-in attribute with a similar name exists: `test` @@ -25,6 +34,6 @@ LL | #[deprcated] = note: for more information, see https://github.com/rust-lang/rust/issues/29642 = help: add #![feature(custom_attribute)] to the crate attributes to enable -error: aborting due to 3 previous errors +error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0658`. diff --git a/src/test/ui/issues/issue-17954.rs b/src/test/ui/thread-local/issue-17954.rs similarity index 100% rename from src/test/ui/issues/issue-17954.rs rename to src/test/ui/thread-local/issue-17954.rs diff --git a/src/test/ui/issues/issue-17954.stderr b/src/test/ui/thread-local/issue-17954.stderr similarity index 100% rename from src/test/ui/issues/issue-17954.stderr rename to src/test/ui/thread-local/issue-17954.stderr diff --git a/src/test/ui/thread-local/issue-43733-2-wasm.rs b/src/test/ui/thread-local/issue-43733-2-wasm.rs new file mode 100644 index 0000000000000..69d8762e91862 --- /dev/null +++ b/src/test/ui/thread-local/issue-43733-2-wasm.rs @@ -0,0 +1,30 @@ +// only-wasm32 + +#![feature(cfg_target_thread_local, thread_local_internals)] + +// On platforms *without* `#[thread_local]`, use +// a custom non-`Sync` type to fake the same error. +#[cfg(not(target_thread_local))] +struct Key { + _data: std::cell::UnsafeCell>, + _flag: std::cell::Cell<()>, +} + +#[cfg(not(target_thread_local))] +impl Key { + const fn new() -> Self { + Key { + _data: std::cell::UnsafeCell::new(None), + _flag: std::cell::Cell::new(()), + } + } +} + +#[cfg(target_thread_local)] +use std::thread::__FastLocalKeyInner as Key; + +static __KEY: Key<()> = Key::new(); +//~^ ERROR `std::cell::UnsafeCell>` cannot be shared between threads +//~| ERROR cannot be shared between threads safely [E0277] + +fn main() {} diff --git a/src/test/ui/thread-local/issue-43733-2-wasm.stderr b/src/test/ui/thread-local/issue-43733-2-wasm.stderr new file mode 100644 index 0000000000000..123d3dab9b8f6 --- /dev/null +++ b/src/test/ui/thread-local/issue-43733-2-wasm.stderr @@ -0,0 +1,23 @@ +error[E0277]: `std::cell::UnsafeCell>` cannot be shared between threads safely + --> $DIR/issue-43733-2-wasm.rs:26:1 + | +LL | static __KEY: Key<()> = Key::new(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `std::cell::UnsafeCell>` cannot be shared between threads safely + | + = help: within `Key<()>`, the trait `std::marker::Sync` is not implemented for `std::cell::UnsafeCell>` + = note: required because it appears within the type `Key<()>` + = note: shared static variables must have a type that implements `Sync` + +error[E0277]: `std::cell::Cell<()>` cannot be shared between threads safely + --> $DIR/issue-43733-2-wasm.rs:26:1 + | +LL | static __KEY: Key<()> = Key::new(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `std::cell::Cell<()>` cannot be shared between threads safely + | + = help: within `Key<()>`, the trait `std::marker::Sync` is not implemented for `std::cell::Cell<()>` + = note: required because it appears within the type `Key<()>` + = note: shared static variables must have a type that implements `Sync` + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/compile-fail/issue-43733-2.rs b/src/test/ui/thread-local/issue-43733-2.rs similarity index 97% rename from src/test/compile-fail/issue-43733-2.rs rename to src/test/ui/thread-local/issue-43733-2.rs index dae27c4785f15..2ed81da8e9b64 100644 --- a/src/test/compile-fail/issue-43733-2.rs +++ b/src/test/ui/thread-local/issue-43733-2.rs @@ -1,3 +1,5 @@ +// ignore-wasm32 + #![feature(cfg_target_thread_local, thread_local_internals)] // On platforms *without* `#[thread_local]`, use diff --git a/src/test/ui/thread-local/issue-43733-2.stderr b/src/test/ui/thread-local/issue-43733-2.stderr new file mode 100644 index 0000000000000..7d97a9086590c --- /dev/null +++ b/src/test/ui/thread-local/issue-43733-2.stderr @@ -0,0 +1,24 @@ +error[E0277]: `std::cell::Cell` cannot be shared between threads safely + --> $DIR/issue-43733-2.rs:26:1 + | +LL | static __KEY: Key<()> = Key::new(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `std::cell::Cell` cannot be shared between threads safely + | + = help: within `std::thread::__FastLocalKeyInner<()>`, the trait `std::marker::Sync` is not implemented for `std::cell::Cell` + = note: required because it appears within the type `std::thread::__FastLocalKeyInner<()>` + = note: shared static variables must have a type that implements `Sync` + +error[E0277]: `std::cell::UnsafeCell>` cannot be shared between threads safely + --> $DIR/issue-43733-2.rs:26:1 + | +LL | static __KEY: Key<()> = Key::new(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `std::cell::UnsafeCell>` cannot be shared between threads safely + | + = help: within `std::thread::__FastLocalKeyInner<()>`, the trait `std::marker::Sync` is not implemented for `std::cell::UnsafeCell>` + = note: required because it appears within the type `std::thread::local::lazy::LazyKeyInner<()>` + = note: required because it appears within the type `std::thread::__FastLocalKeyInner<()>` + = note: shared static variables must have a type that implements `Sync` + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/ui/issues/issue-43733.rs b/src/test/ui/thread-local/issue-43733.rs similarity index 100% rename from src/test/ui/issues/issue-43733.rs rename to src/test/ui/thread-local/issue-43733.rs diff --git a/src/test/ui/issues/issue-43733.stderr b/src/test/ui/thread-local/issue-43733.stderr similarity index 100% rename from src/test/ui/issues/issue-43733.stderr rename to src/test/ui/thread-local/issue-43733.stderr diff --git a/src/test/ui/thread-local-in-ctfe.nll.stderr b/src/test/ui/thread-local/thread-local-in-ctfe.nll.stderr similarity index 100% rename from src/test/ui/thread-local-in-ctfe.nll.stderr rename to src/test/ui/thread-local/thread-local-in-ctfe.nll.stderr diff --git a/src/test/ui/thread-local-in-ctfe.rs b/src/test/ui/thread-local/thread-local-in-ctfe.rs similarity index 100% rename from src/test/ui/thread-local-in-ctfe.rs rename to src/test/ui/thread-local/thread-local-in-ctfe.rs diff --git a/src/test/ui/thread-local-in-ctfe.stderr b/src/test/ui/thread-local/thread-local-in-ctfe.stderr similarity index 100% rename from src/test/ui/thread-local-in-ctfe.stderr rename to src/test/ui/thread-local/thread-local-in-ctfe.stderr diff --git a/src/test/ui/thread-local-mutation.rs b/src/test/ui/thread-local/thread-local-mutation.rs similarity index 100% rename from src/test/ui/thread-local-mutation.rs rename to src/test/ui/thread-local/thread-local-mutation.rs diff --git a/src/test/ui/thread-local-mutation.stderr b/src/test/ui/thread-local/thread-local-mutation.stderr similarity index 100% rename from src/test/ui/thread-local-mutation.stderr rename to src/test/ui/thread-local/thread-local-mutation.stderr diff --git a/src/tools/rustfmt b/src/tools/rustfmt index d33450247b17d..44149d6ba4054 160000 --- a/src/tools/rustfmt +++ b/src/tools/rustfmt @@ -1 +1 @@ -Subproject commit d33450247b17d92a951d9663822c5a3635a37dde +Subproject commit 44149d6ba4054b80e9d7009431eb2c5e501bb1fe