[[package]]
name = "rls"
-version = "0.122.0"
+version = "0.123.0"
dependencies = [
"cargo 0.24.0",
"env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
"racer 2.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-analysis 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-analysis 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-data 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-rustc 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-vfs 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustfmt-nightly 0.2.13",
+ "rustfmt-nightly 0.2.14",
"serde 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "rls-analysis"
-version = "0.7.1"
+version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"derive-new 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"arena 0.0.0",
"log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc 0.0.0",
+ "rustc_data_structures 0.0.0",
"rustc_errors 0.0.0",
"syntax 0.0.0",
"syntax_pos 0.0.0",
"rustc 0.0.0",
"rustc-demangle 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc_allocator 0.0.0",
+ "rustc_apfloat 0.0.0",
"rustc_back 0.0.0",
"rustc_const_math 0.0.0",
"rustc_data_structures 0.0.0",
[[package]]
name = "rustfmt-nightly"
-version = "0.2.13"
+version = "0.2.14"
dependencies = [
"diff 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
"rustc_data_structures 0.0.0",
"serialize 0.0.0",
+ "unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
"checksum regex 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1731164734096285ec2a5ec7fea5248ae2f5485b3feeb0115af4fda2183b2d1b"
"checksum regex-syntax 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "f9ec002c35e86791825ed294b50008eea9ddfc8def4420124fbc6b08db834957"
"checksum regex-syntax 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad890a5eef7953f55427c50575c680c42841653abd2b028b68cd223d157f62db"
-"checksum rls-analysis 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f3e4c03af262074324e732ba2313ce74968b4262b060367ed4d52940b6586fa1"
+"checksum rls-analysis 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "10fbe17ed9da2fa3686ebb018958e194a4a25f0b3a78382bfe334d09d3c641f4"
"checksum rls-data 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "48257ceade23c2e01a3ca8d2fc4226101b107f6a3c868f829cf3fd2f204a1fe6"
"checksum rls-rustc 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b21ea952e9bf1569929abf1bb920262cde04b7b1b26d8e0260286302807299d2"
"checksum rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d7c7046dc6a92f2ae02ed302746db4382e75131b9ce20ce967259f6b5867a6a"
install_sh(builder, "docs", "rust-docs", stage, Some(host));
}
-pub fn install_std(builder: &Builder, stage: u32) {
- for target in &builder.build.targets {
- install_sh(builder, "std", "rust-std", stage, Some(*target));
- }
+pub fn install_std(builder: &Builder, stage: u32, target: Interned<String>) {
+ install_sh(builder, "std", "rust-std", stage, Some(target));
}
pub fn install_cargo(builder: &Builder, stage: u32, host: Interned<String>) {
install_docs(builder, self.stage, self.target);
};
Std, "src/libstd", true, only_hosts: true, {
- builder.ensure(dist::Std {
- compiler: builder.compiler(self.stage, self.host),
- target: self.target
- });
- install_std(builder, self.stage);
+ for target in &builder.build.targets {
+ builder.ensure(dist::Std {
+ compiler: builder.compiler(self.stage, self.host),
+ target: *target
+ });
+ install_std(builder, self.stage, *target);
+ }
};
Cargo, "cargo", _config.extended, only_hosts: true, {
builder.ensure(dist::Cargo { stage: self.stage, target: self.target });
install_cargo(builder, self.stage, self.target);
};
Rls, "rls", _config.extended, only_hosts: true, {
- builder.ensure(dist::Rls { stage: self.stage, target: self.target });
- install_rls(builder, self.stage, self.target);
+ if builder.ensure(dist::Rls { stage: self.stage, target: self.target }).is_some() {
+ install_rls(builder, self.stage, self.target);
+ } else {
+ println!("skipping Install RLS stage{} ({})", self.stage, self.target);
+ }
};
Analysis, "analysis", _config.extended, only_hosts: false, {
builder.ensure(dist::Analysis {
}
}
-const OPENSSL_VERS: &'static str = "1.0.2k";
+const OPENSSL_VERS: &'static str = "1.0.2m";
const OPENSSL_SHA256: &'static str =
- "6b3977c61f2aedf0f96367dcfb5c6e578cf37e7b8d913b4ecb6643c3cb88d8c0";
+ "8c6ff15ec6b319b50788f42c7abc2890c08ba5a1cdcd3810eb9092deada37b0f";
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Openssl {
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/tools/clippy")
+ let builder = run.builder;
+ run.path("src/tools/clippy").default_condition(builder.build.config.extended)
}
fn make_run(run: RunConfig) {
# Reference
* [The Rust official site](https://www.rust-lang.org)
-* [The Rust reference](https://doc.rust-lang.org/reference.html)
+* [The Rust reference](https://doc.rust-lang.org/reference/index.html)
# Docs
--- /dev/null
+# `non_exhaustive`
+
+The tracking issue for this feature is: [#44109]
+
+[#44109]: https://github.com/rust-lang/rust/issues/44109
+
+------------------------
+
+The `non_exhaustive` gate allows you to use the `#[non_exhaustive]` attribute
+on structs and enums. When applied within a crate, users of the crate will need
+to use the `_` pattern when matching enums and use the `..` pattern when
+matching structs. Structs marked as `non_exhaustive` will not be able to be
+created normally outside of the defining crate. This is demonstrated below:
+
+```rust,ignore (pseudo-Rust)
+use std::error::Error as StdError;
+
+#[non_exhaustive]
+pub enum Error {
+ Message(String),
+ Other,
+}
+impl StdError for Error {
+ fn description(&self) -> &str {
+ // This will not error, despite being marked as non_exhaustive, as this
+ // enum is defined within the current crate, it can be matched
+ // exhaustively.
+ match *self {
+ Message(ref s) => s,
+ Other => "other or unknown error",
+ }
+ }
+}
+```
+
+```rust,ignore (pseudo-Rust)
+use mycrate::Error;
+
+// This will not error as the non_exhaustive Error enum has been matched with
+// a wildcard.
+match error {
+ Message(ref s) => ...,
+ Other => ...,
+ _ => ...,
+}
+```
+
+```rust,ignore (pseudo-Rust)
+#[non_exhaustive]
+pub struct Config {
+ pub window_width: u16,
+ pub window_height: u16,
+}
+
+// We can create structs as normal within the defining crate when marked as
+// non_exhaustive.
+let config = Config { window_width: 640, window_height: 480 };
+
+// We can match structs exhaustively when within the defining crate.
+if let Ok(Config { window_width, window_height }) = load_config() {
+ // ...
+}
+```
+
+```rust,ignore (pseudo-Rust)
+use mycrate::Config;
+
+// We cannot create a struct like normal if it has been marked as
+// non_exhaustive.
+let config = Config { window_width: 640, window_height: 480 };
+// By adding the `..` we can match the config as below outside of the crate
+// when marked non_exhaustive.
+let &Config { window_width, window_height, .. } = config;
+```
+
```rust
#![feature(optin_builtin_traits)]
-trait Valid {}
-
-impl Valid for .. {}
+auto trait Valid {}
struct True;
struct False;
normal1 = compress_normal(normal1)
print("""\
-// Copyright 2012-2016 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
current
}
-pub fn is_printable(x: char) -> bool {
+pub(crate) fn is_printable(x: char) -> bool {
let x = x as u32;
let lower = x as u16;
if x < 0x10000 {
make_test!(split_a_str, s, s.split("a").count());
make_test!(trim_ascii_char, s, {
- use std::ascii::AsciiExt;
s.trim_matches(|c: char| c.is_ascii())
});
make_test!(trim_left_ascii_char, s, {
- use std::ascii::AsciiExt;
s.trim_left_matches(|c: char| c.is_ascii())
});
make_test!(trim_right_ascii_char, s, {
- use std::ascii::AsciiExt;
s.trim_right_matches(|c: char| c.is_ascii())
});
/// # Examples
///
/// ```
- /// use std::ascii::AsciiExt;
/// use std::borrow::Cow;
///
/// let mut cow = Cow::Borrowed("foo");
#![cfg_attr(not(test), feature(generator_trait))]
#![cfg_attr(test, feature(rand, test))]
#![feature(allow_internal_unstable)]
+#![feature(ascii_ctype)]
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(cfg_target_has_atomic)]
impl<T> RawVec<T, Heap> {
/// Creates the biggest possible RawVec (on the system heap)
/// without allocating. If T has positive size, then this makes a
- /// RawVec with capacity 0. If T has 0 size, then it it makes a
+ /// RawVec with capacity 0. If T has 0 size, then it makes a
/// RawVec with capacity `usize::MAX`. Useful for implementing
/// delayed allocation.
pub fn new() -> Self {
}
}
+// FIXME(LukasKalbertodt): the `not(stage0)` constraint can be removed in the
+// future once the stage0 compiler is new enough to know about the `slice_u8`
+// lang item.
+#[lang = "slice_u8"]
+#[cfg(all(not(stage0), not(test)))]
+impl [u8] {
+ /// Checks if all bytes in this slice are within the ASCII range.
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn is_ascii(&self) -> bool {
+ self.iter().all(|b| b.is_ascii())
+ }
+
+ /// Returns a vector containing a copy of this slice where each byte
+ /// is mapped to its ASCII upper case equivalent.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To uppercase the value in-place, use [`make_ascii_uppercase`].
+ ///
+ /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn to_ascii_uppercase(&self) -> Vec<u8> {
+ let mut me = self.to_vec();
+ me.make_ascii_uppercase();
+ me
+ }
+
+ /// Returns a vector containing a copy of this slice where each byte
+ /// is mapped to its ASCII lower case equivalent.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To lowercase the value in-place, use [`make_ascii_lowercase`].
+ ///
+ /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn to_ascii_lowercase(&self) -> Vec<u8> {
+ let mut me = self.to_vec();
+ me.make_ascii_lowercase();
+ me
+ }
+
+ /// Checks that two slices are an ASCII case-insensitive match.
+ ///
+ /// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
+ /// but without allocating and copying temporaries.
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool {
+ self.len() == other.len() &&
+ self.iter().zip(other).all(|(a, b)| {
+ a.eq_ignore_ascii_case(b)
+ })
+ }
+
+ /// Converts this slice to its ASCII upper case equivalent in-place.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new uppercased value without modifying the existing one, use
+ /// [`to_ascii_uppercase`].
+ ///
+ /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn make_ascii_uppercase(&mut self) {
+ for byte in self {
+ byte.make_ascii_uppercase();
+ }
+ }
+
+ /// Converts this slice to its ASCII lower case equivalent in-place.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new lowercased value without modifying the existing one, use
+ /// [`to_ascii_lowercase`].
+ ///
+ /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn make_ascii_lowercase(&mut self) {
+ for byte in self {
+ byte.make_ascii_lowercase();
+ }
+ }
+
+ /// Checks if all bytes of this slice are ASCII alphabetic characters:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphabetic(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_alphabetic())
+ }
+
+ /// Checks if all bytes of this slice are ASCII uppercase characters:
+ /// U+0041 'A' ... U+005A 'Z'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_uppercase(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_uppercase())
+ }
+
+ /// Checks if all bytes of this slice are ASCII lowercase characters:
+ /// U+0061 'a' ... U+007A 'z'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_lowercase(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_lowercase())
+ }
+
+ /// Checks if all bytes of this slice are ASCII alphanumeric characters:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z', or
+ /// - U+0030 '0' ... U+0039 '9'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphanumeric(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_alphanumeric())
+ }
+
+ /// Checks if all bytes of this slice are ASCII decimal digit:
+ /// U+0030 '0' ... U+0039 '9'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_digit(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_digit())
+ }
+
+ /// Checks if all bytes of this slice are ASCII hexadecimal digits:
+ ///
+ /// - U+0030 '0' ... U+0039 '9', or
+ /// - U+0041 'A' ... U+0046 'F', or
+ /// - U+0061 'a' ... U+0066 'f'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_hexdigit(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_hexdigit())
+ }
+
+ /// Checks if all bytes of this slice are ASCII punctuation characters:
+ ///
+ /// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
+ /// - U+003A ... U+0040 `: ; < = > ? @`, or
+ /// - U+005B ... U+0060 `[ \\ ] ^ _ \``, or
+ /// - U+007B ... U+007E `{ | } ~`
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_punctuation(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_punctuation())
+ }
+
+ /// Checks if all bytes of this slice are ASCII graphic characters:
+ /// U+0021 '@' ... U+007E '~'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_graphic(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_graphic())
+ }
+
+ /// Checks if all bytes of this slice are ASCII whitespace characters:
+ /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
+ /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
+ ///
+ /// Rust uses the WhatWG Infra Standard's [definition of ASCII
+ /// whitespace][infra-aw]. There are several other definitions in
+ /// wide use. For instance, [the POSIX locale][pct] includes
+ /// U+000B VERTICAL TAB as well as all the above characters,
+ /// but—from the very same specification—[the default rule for
+ /// "field splitting" in the Bourne shell][bfs] considers *only*
+ /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
+ ///
+ /// If you are writing a program that will process an existing
+ /// file format, check what that format's definition of whitespace is
+ /// before using this function.
+ ///
+ /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
+ /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
+ /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_whitespace(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_whitespace())
+ }
+
+ /// Checks if all bytes of this slice are ASCII control characters:
+ ///
+ /// - U+0000 NUL ... U+001F UNIT SEPARATOR, or
+ /// - U+007F DELETE.
+ ///
+ /// Note that most ASCII whitespace characters are control
+ /// characters, but SPACE is not.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_control(&self) -> bool {
+ self.iter().all(|b| b.is_ascii_control())
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
// Extension traits for slices over specific kinds of data
////////////////////////////////////////////////////////////////////////////////
/// # Examples
///
/// ```
- /// use std::ascii::AsciiExt;
- ///
/// let mut v = String::from("hello");
/// // correct length
/// assert!(v.get_mut(0..5).is_some());
/// Basic usage:
///
/// ```
- /// use std::ascii::AsciiExt;
- ///
/// let mut s = "Per Martin-Löf".to_string();
/// {
/// let (first, last) = s.split_at_mut(3);
s.extend((0..n).map(|_| self));
s
}
+
+ /// Checks if all characters in this string are within the ASCII range.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let ascii = "hello!\n";
+ /// let non_ascii = "Grüße, Jürgen ❤";
+ ///
+ /// assert!(ascii.is_ascii());
+ /// assert!(!non_ascii.is_ascii());
+ /// ```
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn is_ascii(&self) -> bool {
+ // We can treat each byte as character here: all multibyte characters
+ // start with a byte that is not in the ascii range, so we will stop
+ // there already.
+ self.bytes().all(|b| b.is_ascii())
+ }
+
+ /// Returns a copy of this string where each character is mapped to its
+ /// ASCII upper case equivalent.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To uppercase the value in-place, use [`make_ascii_uppercase`].
+ ///
+ /// To uppercase ASCII characters in addition to non-ASCII characters, use
+ /// [`to_uppercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let s = "Grüße, Jürgen ❤";
+ ///
+ /// assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());
+ /// ```
+ ///
+ /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase
+ /// [`to_uppercase`]: #method.to_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ #[cfg(not(stage0))]
+ pub fn to_ascii_uppercase(&self) -> String {
+ let mut bytes = self.as_bytes().to_vec();
+ bytes.make_ascii_uppercase();
+ // make_ascii_uppercase() preserves the UTF-8 invariant.
+ unsafe { String::from_utf8_unchecked(bytes) }
+ }
+
+ /// Returns a copy of this string where each character is mapped to its
+ /// ASCII lower case equivalent.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To lowercase the value in-place, use [`make_ascii_lowercase`].
+ ///
+ /// To lowercase ASCII characters in addition to non-ASCII characters, use
+ /// [`to_lowercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let s = "Grüße, Jürgen ❤";
+ ///
+ /// assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
+ /// ```
+ ///
+ /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase
+ /// [`to_lowercase`]: #method.to_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ #[cfg(not(stage0))]
+ pub fn to_ascii_lowercase(&self) -> String {
+ let mut bytes = self.as_bytes().to_vec();
+ bytes.make_ascii_lowercase();
+ // make_ascii_lowercase() preserves the UTF-8 invariant.
+ unsafe { String::from_utf8_unchecked(bytes) }
+ }
+
+ /// Checks that two strings are an ASCII case-insensitive match.
+ ///
+ /// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
+ /// but without allocating and copying temporaries.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// assert!("Ferris".eq_ignore_ascii_case("FERRIS"));
+ /// assert!("Ferrös".eq_ignore_ascii_case("FERRöS"));
+ /// assert!(!"Ferrös".eq_ignore_ascii_case("FERRÖS"));
+ /// ```
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ #[cfg(not(stage0))]
+ pub fn eq_ignore_ascii_case(&self, other: &str) -> bool {
+ self.as_bytes().eq_ignore_ascii_case(other.as_bytes())
+ }
+
+ /// Converts this string to its ASCII upper case equivalent in-place.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new uppercased value without modifying the existing one, use
+ /// [`to_ascii_uppercase`].
+ ///
+ /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[cfg(not(stage0))]
+ pub fn make_ascii_uppercase(&mut self) {
+ let me = unsafe { self.as_bytes_mut() };
+ me.make_ascii_uppercase()
+ }
+
+ /// Converts this string to its ASCII lower case equivalent in-place.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new lowercased value without modifying the existing one, use
+ /// [`to_ascii_lowercase`].
+ ///
+ /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[cfg(not(stage0))]
+ pub fn make_ascii_lowercase(&mut self) {
+ let me = unsafe { self.as_bytes_mut() };
+ me.make_ascii_lowercase()
+ }
+
+ /// Checks if all characters of this string are ASCII alphabetic
+ /// characters:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphabetic(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_alphabetic())
+ }
+
+ /// Checks if all characters of this string are ASCII uppercase characters:
+ /// U+0041 'A' ... U+005A 'Z'.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// // Only ascii uppercase characters
+ /// assert!("HELLO".is_ascii_uppercase());
+ ///
+ /// // While all characters are ascii, 'y' and 'e' are not uppercase
+ /// assert!(!"Bye".is_ascii_uppercase());
+ ///
+ /// // While all characters are uppercase, 'Ü' is not ascii
+ /// assert!(!"TSCHÜSS".is_ascii_uppercase());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_uppercase(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_uppercase())
+ }
+
+ /// Checks if all characters of this string are ASCII lowercase characters:
+ /// U+0061 'a' ... U+007A 'z'.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// // Only ascii uppercase characters
+ /// assert!("hello".is_ascii_lowercase());
+ ///
+ /// // While all characters are ascii, 'B' is not lowercase
+ /// assert!(!"Bye".is_ascii_lowercase());
+ ///
+ /// // While all characters are lowercase, 'Ü' is not ascii
+ /// assert!(!"tschüss".is_ascii_lowercase());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_lowercase(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_lowercase())
+ }
+
+ /// Checks if all characters of this string are ASCII alphanumeric
+ /// characters:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z', or
+ /// - U+0030 '0' ... U+0039 '9'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphanumeric(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_alphanumeric())
+ }
+
+ /// Checks if all characters of this string are ASCII decimal digit:
+ /// U+0030 '0' ... U+0039 '9'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_digit(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_digit())
+ }
+
+ /// Checks if all characters of this string are ASCII hexadecimal digits:
+ ///
+ /// - U+0030 '0' ... U+0039 '9', or
+ /// - U+0041 'A' ... U+0046 'F', or
+ /// - U+0061 'a' ... U+0066 'f'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_hexdigit(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_hexdigit())
+ }
+
+ /// Checks if all characters of this string are ASCII punctuation
+ /// characters:
+ ///
+ /// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
+ /// - U+003A ... U+0040 `: ; < = > ? @`, or
+ /// - U+005B ... U+0060 `[ \\ ] ^ _ \``, or
+ /// - U+007B ... U+007E `{ | } ~`
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_punctuation(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_punctuation())
+ }
+
+ /// Checks if all characters of this string are ASCII graphic characters:
+ /// U+0021 '@' ... U+007E '~'.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_graphic(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_graphic())
+ }
+
+ /// Checks if all characters of this string are ASCII whitespace characters:
+ /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
+ /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
+ ///
+ /// Rust uses the WhatWG Infra Standard's [definition of ASCII
+ /// whitespace][infra-aw]. There are several other definitions in
+ /// wide use. For instance, [the POSIX locale][pct] includes
+ /// U+000B VERTICAL TAB as well as all the above characters,
+ /// but—from the very same specification—[the default rule for
+ /// "field splitting" in the Bourne shell][bfs] considers *only*
+ /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
+ ///
+ /// If you are writing a program that will process an existing
+ /// file format, check what that format's definition of whitespace is
+ /// before using this function.
+ ///
+ /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
+ /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
+ /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_whitespace(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_whitespace())
+ }
+
+ /// Checks if all characters of this string are ASCII control characters:
+ ///
+ /// - U+0000 NUL ... U+001F UNIT SEPARATOR, or
+ /// - U+007F DELETE.
+ ///
+ /// Note that most ASCII whitespace characters are control
+ /// characters, but SPACE is not.
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_control(&self) -> bool {
+ self.bytes().all(|b| b.is_ascii_control())
+ }
}
/// Converts a boxed slice of bytes to a boxed string slice without checking
/// Basic usage:
///
/// ```
- /// use std::ascii::AsciiExt;
- ///
/// let mut s = String::from("foobar");
/// let s_mut_str = s.as_mut_str();
///
#[test]
fn test_split_at_mut() {
- use std::ascii::AsciiExt;
let mut s = "Hello World".to_string();
{
let (a, b) = s.split_at_mut(5);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::ascii::AsciiExt;
use std::borrow::Cow;
use std::mem::size_of;
use std::panic;
assert_eq!(vec, vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
}
}
-
-
/// # Examples
///
/// ```
- /// use std::ascii::AsciiExt;
- ///
/// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
///
/// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
// ABI
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_alloc(size: usize,
align: usize,
err: *mut u8) -> *mut u8 {
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_oom(err: *const u8) -> ! {
System.oom((*(err as *const AllocErr)).clone())
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_dealloc(ptr: *mut u8,
size: usize,
align: usize) {
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_usable_size(layout: *const u8,
min: *mut usize,
max: *mut usize) {
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_realloc(ptr: *mut u8,
_old_size: usize,
old_align: usize,
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_alloc_zeroed(size: usize,
align: usize,
err: *mut u8) -> *mut u8 {
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_alloc_excess(size: usize,
align: usize,
excess: *mut usize,
err: *mut u8) -> *mut u8 {
let p = __rde_alloc(size, align, err);
if !p.is_null() {
- *excess = size;
+ let flags = align_to_flags(align);
+ *excess = nallocx(size, flags) as usize;
}
return p
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_realloc_excess(ptr: *mut u8,
old_size: usize,
old_align: usize,
err: *mut u8) -> *mut u8 {
let p = __rde_realloc(ptr, old_size, old_align, new_size, new_align, err);
if !p.is_null() {
- *excess = new_size;
+ let flags = align_to_flags(new_align);
+ *excess = nallocx(new_size, flags) as usize;
}
- return p
+ p
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_grow_in_place(ptr: *mut u8,
old_size: usize,
old_align: usize,
}
#[no_mangle]
- #[linkage = "external"]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rde_shrink_in_place(ptr: *mut u8,
_old_size: usize,
old_align: usize,
fi
fi
+
+case "${host_os}" in
+darwin*)
+ have_mmap=no ;;
+esac
+
if test "$have_mmap" = "no"; then
VIEW_FILE=read.lo
ALLOC_FILE=alloc.lo
AC_CHECK_FUNC(mmap, [have_mmap=yes], [have_mmap=no])
fi
fi
+
+case "${host_os}" in
+darwin*)
+ have_mmap=no ;;
+esac
+
if test "$have_mmap" = "no"; then
VIEW_FILE=read.lo
ALLOC_FILE=alloc.lo
-// Copyright 2012-2016 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
current
}
-pub fn is_printable(x: char) -> bool {
+pub(crate) fn is_printable(x: char) -> bool {
let x = x as u32;
let lower = x as u16;
if x < 0x10000 {
if 0x2b81e <= x && x < 0x2b820 {
return false;
}
- if 0x2cea2 <= x && x < 0x2f800 {
+ if 0x2cea2 <= x && x < 0x2ceb0 {
+ return false;
+ }
+ if 0x2ebe1 <= x && x < 0x2f800 {
return false;
}
if 0x2fa1e <= x && x < 0xe0100 {
(0x05, 8),
(0x06, 3),
(0x07, 4),
- (0x08, 7),
+ (0x08, 8),
(0x09, 16),
(0x0a, 27),
- (0x0b, 24),
+ (0x0b, 25),
(0x0c, 22),
- (0x0d, 20),
+ (0x0d, 18),
(0x0e, 22),
(0x0f, 4),
(0x10, 3),
(0x18, 2),
(0x19, 3),
(0x1a, 7),
- (0x1c, 1),
+ (0x1d, 1),
(0x1f, 22),
(0x20, 3),
- (0x23, 1),
(0x2b, 5),
(0x2c, 2),
(0x2d, 11),
(0x2e, 1),
(0x30, 3),
- (0x31, 1),
+ (0x31, 3),
(0x32, 2),
(0xa7, 1),
(0xa8, 2),
0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57,
0x58, 0x60, 0x88, 0x8b, 0x8c, 0x90, 0x1c, 0x1d,
0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0x2e, 0x2f, 0x3f,
- 0x5c, 0x5d, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91,
- 0x92, 0xa9, 0xb1, 0xba, 0xbb, 0xc5, 0xc6, 0xc9,
- 0xca, 0xde, 0xe4, 0xe5, 0x04, 0x11, 0x12, 0x29,
- 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a,
- 0x5d, 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba,
- 0xbb, 0xc6, 0xca, 0xce, 0xcf, 0xe4, 0xe5, 0x04,
- 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
- 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65,
- 0x84, 0x91, 0x9b, 0x9d, 0xc9, 0xce, 0xcf, 0x04,
- 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65,
- 0x84, 0x8d, 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5,
- 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x04, 0x0d, 0x11,
- 0x3b, 0x3c, 0x45, 0x49, 0x64, 0x65, 0x80, 0x81,
+ 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e,
+ 0x91, 0x92, 0xa9, 0xb1, 0xba, 0xbb, 0xc5, 0xc6,
+ 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0x04, 0x11, 0x12,
+ 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49,
+ 0x4a, 0x5d, 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4,
+ 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf, 0xe4, 0xe5,
+ 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31,
+ 0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e,
+ 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, 0xc9, 0xce,
+ 0xcf, 0x04, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57,
+ 0x64, 0x65, 0x84, 0x8d, 0x91, 0xa9, 0xb4, 0xba,
+ 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x04,
+ 0x0d, 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x81,
0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, 0xd7, 0xf0,
0xf1, 0x83, 0x85, 0x86, 0x89, 0x8b, 0x8c, 0x98,
0xa0, 0xa4, 0xa6, 0xa8, 0xa9, 0xac, 0xba, 0xbe,
0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe,
0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e,
0x0f, 0x1f, 0x6e, 0x6f, 0x1c, 0x1d, 0x5f, 0x7d,
- 0x7e, 0xae, 0xaf, 0xf7, 0x16, 0x17, 0x1e, 0x1f,
+ 0x7e, 0xae, 0xaf, 0xfa, 0x16, 0x17, 0x1e, 0x1f,
0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e,
0x7e, 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0,
- 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0xff, 0x74, 0x75,
- 0x96, 0x97, 0xc9, 0x2f, 0x5f, 0x26, 0x2e, 0x2f,
- 0xa7, 0xaf, 0xb7, 0xbf, 0xc7, 0xcf, 0xd7, 0xdf,
- 0x9a, 0x40, 0x97, 0x98, 0x8f, 0x1f, 0xff, 0xaf,
- 0xfe, 0xff, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b,
- 0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee, 0xef,
- 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90,
- 0x91, 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9,
- 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, 0xfe, 0xff,
+ 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74, 0x75, 0x96,
+ 0x97, 0xc9, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7,
+ 0xaf, 0xb7, 0xbf, 0xc7, 0xcf, 0xd7, 0xdf, 0x9a,
+ 0x40, 0x97, 0x98, 0x2f, 0x30, 0x8f, 0x1f, 0xff,
+ 0xaf, 0xfe, 0xff, 0xce, 0xff, 0x4e, 0x4f, 0x5a,
+ 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee,
+ 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45,
+ 0x90, 0x91, 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8,
+ 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, 0xfe, 0xff,
];
const SINGLETONS1U: &'static [(u8, u8)] = &[
(0x00, 6),
(0x13, 18),
(0x14, 2),
(0x15, 2),
+ (0x1a, 3),
(0x1c, 5),
+ (0x1d, 4),
(0x24, 1),
(0x6a, 3),
(0x6b, 2),
(0xee, 32),
(0xf0, 4),
(0xf1, 1),
- (0xf9, 4),
+ (0xf9, 1),
];
const SINGLETONS1L: &'static [u8] = &[
0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e,
0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12,
0x29, 0x31, 0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49,
0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5a, 0x5c, 0xb6,
- 0xb7, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x6f, 0x5f,
- 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, 0x28,
- 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8,
- 0xad, 0xba, 0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15,
- 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, 0xcc,
- 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0xc5,
- 0xc6, 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33,
- 0x38, 0x3a, 0x48, 0x4a, 0x4c, 0x50, 0x53, 0x55,
- 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65,
- 0x66, 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4,
- 0xaa, 0xaf, 0xb0, 0xc0, 0xd0, 0x2f, 0x1f, 0x31,
- 0x32, 0x3f,
+ 0xb7, 0x84, 0x85, 0x9d, 0x09, 0x37, 0x90, 0x91,
+ 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x6f, 0x5f, 0xee,
+ 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, 0x28, 0x55,
+ 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad,
+ 0xba, 0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d,
+ 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, 0xcc, 0xcd,
+ 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0xc5, 0xc6,
+ 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38,
+ 0x3a, 0x48, 0x4a, 0x4c, 0x50, 0x53, 0x55, 0x56,
+ 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
+ 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa,
+ 0xaf, 0xb0, 0xc0, 0xd0, 0x2f, 0x3f,
];
const NORMAL0: &'static [u8] = &[
0x00, 0x20,
0x05, 0x11,
0x81, 0xac, 0x0e,
0x3b, 0x05,
- 0x5f, 0x41,
+ 0x6b, 0x35,
0x1e, 0x16,
0x80, 0xdf, 0x03,
0x19, 0x08,
0x01, 0x04,
- 0x20, 0x05,
+ 0x22, 0x03,
0x0a, 0x04,
0x34, 0x04,
0x07, 0x03,
0x10, 0x0b,
0x50, 0x0f,
0x12, 0x07,
- 0x01, 0x07,
- 0x4d, 0x08,
+ 0x55, 0x08,
0x02, 0x04,
0x1c, 0x0a,
0x09, 0x03,
0x10, 0x08,
0x56, 0x07,
0x02, 0x07,
- 0x15, 0x0e,
- 0x4f, 0x04,
+ 0x15, 0x0d,
+ 0x50, 0x04,
0x43, 0x03,
0x2d, 0x03,
0x01, 0x04,
0x3c, 0x37,
0x08, 0x08,
0x2a, 0x06,
- 0x80, 0xf6, 0x05,
- 0x82, 0x04, 0x11,
+ 0x82, 0xff, 0x11,
0x18, 0x08,
0x2f, 0x11,
0x2d, 0x03,
- 0x1f, 0x11,
+ 0x20, 0x10,
0x21, 0x0f,
0x80, 0x8c, 0x04,
0x82, 0x97, 0x19,
0x0b, 0x15,
0x87, 0x5a, 0x03,
- 0x15, 0x1a,
+ 0x16, 0x19,
0x04, 0x10,
0x80, 0xf4, 0x05,
0x2f, 0x05,
0x3b, 0x07,
0x02, 0x0e,
0x18, 0x09,
- 0x80, 0xa5, 0x3b,
+ 0x80, 0xaa, 0x36,
0x74, 0x0c,
0x80, 0xd6, 0x1a,
0x0c, 0x05,
0x80, 0xff, 0x05,
- 0x29, 0x03,
- 0x80, 0x8a, 0x05,
+ 0x80, 0xb6, 0x05,
0x24, 0x0c,
0x9b, 0xc6, 0x0a,
- 0xd2, 0x16, 0x2a,
+ 0xd2, 0x2b, 0x15,
0x84, 0x8d, 0x03,
0x37, 0x09,
0x81, 0x5c, 0x14,
0x1d, 0x03,
0x31, 0x0f,
0x1c, 0x04,
- 0x24, 0x0c,
- 0x1b, 0x05,
+ 0x24, 0x09,
+ 0x1e, 0x05,
0x2b, 0x05,
0x44, 0x04,
0x0e, 0x2a,
0x0f, 0x04,
0x10, 0x81, 0x60,
0x53, 0x0c,
- 0x01, 0x81, 0xc0,
+ 0x01, 0x81, 0x00,
+ 0x48, 0x08,
+ 0x53, 0x1d,
0x39, 0x81, 0x07,
0x46, 0x0a,
0x1d, 0x03,
- 0x47, 0x83, 0x49,
+ 0x47, 0x49,
+ 0x37, 0x03,
+ 0x0e, 0x08,
+ 0x0a, 0x82, 0xa6,
0x83, 0x9a, 0x66,
0x75, 0x0b,
0x80, 0xc4, 0x8a, 0xbc,
0x45, 0x0b,
0x2f, 0x10,
0x11, 0x40,
- 0x01, 0x1f,
+ 0x02, 0x1e,
0x97, 0xed, 0x13,
0x82, 0xf3, 0xa5, 0x0d,
- 0x02, 0x8b, 0xfe,
+ 0x81, 0x1f, 0x51,
+ 0x81, 0x8c, 0x89, 0x04,
0x6b, 0x05,
0x0d, 0x03,
0x09, 0x07,
0x1d, 0x0d,
0x2c, 0x04,
0x09, 0x07,
- 0x02, 0x80, 0xae,
- 0x83, 0xd3, 0x0d,
+ 0x02, 0x0e,
+ 0x06, 0x80, 0x9a,
+ 0x83, 0xd5, 0x0b,
0x0d, 0x03,
- 0x07, 0x09,
+ 0x09, 0x07,
0x74, 0x0c,
0x55, 0x2b,
0x0c, 0x04,
0x38, 0x08,
0x0a, 0x06,
0x28, 0x08,
- 0x1e, 0x62,
- 0x18, 0x08,
- 0x1c, 0x04,
- 0x0f, 0x21,
- 0x12, 0x2e,
- 0x01, 0x86, 0x3f,
+ 0x1e, 0x52,
+ 0x0c, 0x04,
+ 0x3d, 0x03,
+ 0x1c, 0x14,
+ 0x18, 0x28,
+ 0x01, 0x0f,
+ 0x17, 0x86, 0x19,
];
mod char_private;
mod iter_private;
mod tuple;
+mod unit;
}
#[stable(feature = "rust1", since = "1.0.0")]
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
unsafe impl Send for .. { }
#[stable(feature = "rust1", since = "1.0.0")]
}
#[stable(feature = "rust1", since = "1.0.0")]
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
unsafe impl Sync for .. { }
#[stable(feature = "rust1", since = "1.0.0")]
#[lang = "freeze"]
unsafe trait Freeze {}
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
unsafe impl Freeze for .. {}
impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
use convert::{Infallible, TryFrom};
use fmt;
use intrinsics;
+use ops;
use str::FromStr;
/// Provides intentionally-wrapped arithmetic on `T`.
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn next_power_of_two(self) -> Self {
- self.one_less_than_next_power_of_two() + 1
+ // Call the trait to get overflow checks
+ ops::Add::add(self.one_less_than_next_power_of_two(), 1)
}
/// Returns the smallest power of two greater than or equal to `n`. If
intrinsics::add_with_overflow,
intrinsics::sub_with_overflow,
intrinsics::mul_with_overflow }
+
+
+ /// Checks if the value is within the ASCII range.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let ascii = 97u8;
+ /// let non_ascii = 150u8;
+ ///
+ /// assert!(ascii.is_ascii());
+ /// assert!(!non_ascii.is_ascii());
+ /// ```
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn is_ascii(&self) -> bool {
+ *self & 128 == 0
+ }
+
+ /// Makes a copy of the value in its ASCII upper case equivalent.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To uppercase the value in-place, use [`make_ascii_uppercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let lowercase_a = 97u8;
+ ///
+ /// assert_eq!(65, lowercase_a.to_ascii_uppercase());
+ /// ```
+ ///
+ /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn to_ascii_uppercase(&self) -> u8 {
+ ASCII_UPPERCASE_MAP[*self as usize]
+ }
+
+ /// Makes a copy of the value in its ASCII lower case equivalent.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To lowercase the value in-place, use [`make_ascii_lowercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let uppercase_a = 65u8;
+ ///
+ /// assert_eq!(97, uppercase_a.to_ascii_lowercase());
+ /// ```
+ ///
+ /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn to_ascii_lowercase(&self) -> u8 {
+ ASCII_LOWERCASE_MAP[*self as usize]
+ }
+
+ /// Checks that two values are an ASCII case-insensitive match.
+ ///
+ /// This is equivalent to `to_ascii_lowercase(a) == to_ascii_lowercase(b)`.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let lowercase_a = 97u8;
+ /// let uppercase_a = 65u8;
+ ///
+ /// assert!(lowercase_a.eq_ignore_ascii_case(&uppercase_a));
+ /// ```
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn eq_ignore_ascii_case(&self, other: &u8) -> bool {
+ self.to_ascii_lowercase() == other.to_ascii_lowercase()
+ }
+
+ /// Converts this value to its ASCII upper case equivalent in-place.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new uppercased value without modifying the existing one, use
+ /// [`to_ascii_uppercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let mut byte = b'a';
+ ///
+ /// byte.make_ascii_uppercase();
+ ///
+ /// assert_eq!(b'A', byte);
+ /// ```
+ ///
+ /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn make_ascii_uppercase(&mut self) {
+ *self = self.to_ascii_uppercase();
+ }
+
+ /// Converts this value to its ASCII lower case equivalent in-place.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new lowercased value without modifying the existing one, use
+ /// [`to_ascii_lowercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let mut byte = b'A';
+ ///
+ /// byte.make_ascii_lowercase();
+ ///
+ /// assert_eq!(b'a', byte);
+ /// ```
+ ///
+ /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn make_ascii_lowercase(&mut self) {
+ *self = self.to_ascii_lowercase();
+ }
+
+ /// Checks if the value is an ASCII alphabetic character:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(uppercase_a.is_ascii_alphabetic());
+ /// assert!(uppercase_g.is_ascii_alphabetic());
+ /// assert!(a.is_ascii_alphabetic());
+ /// assert!(g.is_ascii_alphabetic());
+ /// assert!(!zero.is_ascii_alphabetic());
+ /// assert!(!percent.is_ascii_alphabetic());
+ /// assert!(!space.is_ascii_alphabetic());
+ /// assert!(!lf.is_ascii_alphabetic());
+ /// assert!(!esc.is_ascii_alphabetic());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphabetic(&self) -> bool {
+ if *self >= 0x80 { return false; }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ L | Lx | U | Ux => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII uppercase character:
+ /// U+0041 'A' ... U+005A 'Z'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(uppercase_a.is_ascii_uppercase());
+ /// assert!(uppercase_g.is_ascii_uppercase());
+ /// assert!(!a.is_ascii_uppercase());
+ /// assert!(!g.is_ascii_uppercase());
+ /// assert!(!zero.is_ascii_uppercase());
+ /// assert!(!percent.is_ascii_uppercase());
+ /// assert!(!space.is_ascii_uppercase());
+ /// assert!(!lf.is_ascii_uppercase());
+ /// assert!(!esc.is_ascii_uppercase());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_uppercase(&self) -> bool {
+ if *self >= 0x80 { return false }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ U | Ux => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII lowercase character:
+ /// U+0061 'a' ... U+007A 'z'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(!uppercase_a.is_ascii_lowercase());
+ /// assert!(!uppercase_g.is_ascii_lowercase());
+ /// assert!(a.is_ascii_lowercase());
+ /// assert!(g.is_ascii_lowercase());
+ /// assert!(!zero.is_ascii_lowercase());
+ /// assert!(!percent.is_ascii_lowercase());
+ /// assert!(!space.is_ascii_lowercase());
+ /// assert!(!lf.is_ascii_lowercase());
+ /// assert!(!esc.is_ascii_lowercase());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_lowercase(&self) -> bool {
+ if *self >= 0x80 { return false }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ L | Lx => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII alphanumeric character:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z', or
+ /// - U+0030 '0' ... U+0039 '9'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(uppercase_a.is_ascii_alphanumeric());
+ /// assert!(uppercase_g.is_ascii_alphanumeric());
+ /// assert!(a.is_ascii_alphanumeric());
+ /// assert!(g.is_ascii_alphanumeric());
+ /// assert!(zero.is_ascii_alphanumeric());
+ /// assert!(!percent.is_ascii_alphanumeric());
+ /// assert!(!space.is_ascii_alphanumeric());
+ /// assert!(!lf.is_ascii_alphanumeric());
+ /// assert!(!esc.is_ascii_alphanumeric());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphanumeric(&self) -> bool {
+ if *self >= 0x80 { return false }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ D | L | Lx | U | Ux => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII decimal digit:
+ /// U+0030 '0' ... U+0039 '9'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(!uppercase_a.is_ascii_digit());
+ /// assert!(!uppercase_g.is_ascii_digit());
+ /// assert!(!a.is_ascii_digit());
+ /// assert!(!g.is_ascii_digit());
+ /// assert!(zero.is_ascii_digit());
+ /// assert!(!percent.is_ascii_digit());
+ /// assert!(!space.is_ascii_digit());
+ /// assert!(!lf.is_ascii_digit());
+ /// assert!(!esc.is_ascii_digit());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_digit(&self) -> bool {
+ if *self >= 0x80 { return false }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ D => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII hexadecimal digit:
+ ///
+ /// - U+0030 '0' ... U+0039 '9', or
+ /// - U+0041 'A' ... U+0046 'F', or
+ /// - U+0061 'a' ... U+0066 'f'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(uppercase_a.is_ascii_hexdigit());
+ /// assert!(!uppercase_g.is_ascii_hexdigit());
+ /// assert!(a.is_ascii_hexdigit());
+ /// assert!(!g.is_ascii_hexdigit());
+ /// assert!(zero.is_ascii_hexdigit());
+ /// assert!(!percent.is_ascii_hexdigit());
+ /// assert!(!space.is_ascii_hexdigit());
+ /// assert!(!lf.is_ascii_hexdigit());
+ /// assert!(!esc.is_ascii_hexdigit());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_hexdigit(&self) -> bool {
+ if *self >= 0x80 { return false }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ D | Lx | Ux => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII punctuation character:
+ ///
+ /// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
+ /// - U+003A ... U+0040 `: ; < = > ? @`, or
+ /// - U+005B ... U+0060 `[ \\ ] ^ _ \``, or
+ /// - U+007B ... U+007E `{ | } ~`
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(!uppercase_a.is_ascii_punctuation());
+ /// assert!(!uppercase_g.is_ascii_punctuation());
+ /// assert!(!a.is_ascii_punctuation());
+ /// assert!(!g.is_ascii_punctuation());
+ /// assert!(!zero.is_ascii_punctuation());
+ /// assert!(percent.is_ascii_punctuation());
+ /// assert!(!space.is_ascii_punctuation());
+ /// assert!(!lf.is_ascii_punctuation());
+ /// assert!(!esc.is_ascii_punctuation());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_punctuation(&self) -> bool {
+ if *self >= 0x80 { return false }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ P => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII graphic character:
+ /// U+0021 '@' ... U+007E '~'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(uppercase_a.is_ascii_graphic());
+ /// assert!(uppercase_g.is_ascii_graphic());
+ /// assert!(a.is_ascii_graphic());
+ /// assert!(g.is_ascii_graphic());
+ /// assert!(zero.is_ascii_graphic());
+ /// assert!(percent.is_ascii_graphic());
+ /// assert!(!space.is_ascii_graphic());
+ /// assert!(!lf.is_ascii_graphic());
+ /// assert!(!esc.is_ascii_graphic());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_graphic(&self) -> bool {
+ if *self >= 0x80 { return false; }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ Ux | U | Lx | L | D | P => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII whitespace character:
+ /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
+ /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
+ ///
+ /// Rust uses the WhatWG Infra Standard's [definition of ASCII
+ /// whitespace][infra-aw]. There are several other definitions in
+ /// wide use. For instance, [the POSIX locale][pct] includes
+ /// U+000B VERTICAL TAB as well as all the above characters,
+ /// but—from the very same specification—[the default rule for
+ /// "field splitting" in the Bourne shell][bfs] considers *only*
+ /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
+ ///
+ /// If you are writing a program that will process an existing
+ /// file format, check what that format's definition of whitespace is
+ /// before using this function.
+ ///
+ /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
+ /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
+ /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(!uppercase_a.is_ascii_whitespace());
+ /// assert!(!uppercase_g.is_ascii_whitespace());
+ /// assert!(!a.is_ascii_whitespace());
+ /// assert!(!g.is_ascii_whitespace());
+ /// assert!(!zero.is_ascii_whitespace());
+ /// assert!(!percent.is_ascii_whitespace());
+ /// assert!(space.is_ascii_whitespace());
+ /// assert!(lf.is_ascii_whitespace());
+ /// assert!(!esc.is_ascii_whitespace());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_whitespace(&self) -> bool {
+ if *self >= 0x80 { return false; }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ Cw | W => true,
+ _ => false
+ }
+ }
+
+ /// Checks if the value is an ASCII control character:
+ /// U+0000 NUL ... U+001F UNIT SEPARATOR, or U+007F DELETE.
+ /// Note that most ASCII whitespace characters are control
+ /// characters, but SPACE is not.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = b'A';
+ /// let uppercase_g = b'G';
+ /// let a = b'a';
+ /// let g = b'g';
+ /// let zero = b'0';
+ /// let percent = b'%';
+ /// let space = b' ';
+ /// let lf = b'\n';
+ /// let esc = 0x1b_u8;
+ ///
+ /// assert!(!uppercase_a.is_ascii_control());
+ /// assert!(!uppercase_g.is_ascii_control());
+ /// assert!(!a.is_ascii_control());
+ /// assert!(!g.is_ascii_control());
+ /// assert!(!zero.is_ascii_control());
+ /// assert!(!percent.is_ascii_control());
+ /// assert!(!space.is_ascii_control());
+ /// assert!(lf.is_ascii_control());
+ /// assert!(esc.is_ascii_control());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_control(&self) -> bool {
+ if *self >= 0x80 { return false; }
+ match ASCII_CHARACTER_CLASS[*self as usize] {
+ C | Cw => true,
+ _ => false
+ }
+ }
}
#[lang = "u16"]
// Float -> Float
impl_from! { f32, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
+
+static ASCII_LOWERCASE_MAP: [u8; 256] = [
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+ b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
+ b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
+ b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
+ b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
+ b'@',
+
+ b'a', b'b', b'c', b'd', b'e', b'f', b'g',
+ b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
+ b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
+ b'x', b'y', b'z',
+
+ b'[', b'\\', b']', b'^', b'_',
+ b'`', b'a', b'b', b'c', b'd', b'e', b'f', b'g',
+ b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
+ b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
+ b'x', b'y', b'z', b'{', b'|', b'}', b'~', 0x7f,
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+ 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+ 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+ 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+ 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+ 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+ 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+ 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+ 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+ 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+ 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+ 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+ 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+];
+
+static ASCII_UPPERCASE_MAP: [u8; 256] = [
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+ b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
+ b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
+ b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
+ b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
+ b'@', b'A', b'B', b'C', b'D', b'E', b'F', b'G',
+ b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
+ b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
+ b'X', b'Y', b'Z', b'[', b'\\', b']', b'^', b'_',
+ b'`',
+
+ b'A', b'B', b'C', b'D', b'E', b'F', b'G',
+ b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
+ b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
+ b'X', b'Y', b'Z',
+
+ b'{', b'|', b'}', b'~', 0x7f,
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+ 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+ 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+ 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+ 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+ 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+ 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+ 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+ 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+ 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+ 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+ 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+ 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+];
+
+enum AsciiCharacterClass {
+ C, // control
+ Cw, // control whitespace
+ W, // whitespace
+ D, // digit
+ L, // lowercase
+ Lx, // lowercase hex digit
+ U, // uppercase
+ Ux, // uppercase hex digit
+ P, // punctuation
+}
+use self::AsciiCharacterClass::*;
+
+static ASCII_CHARACTER_CLASS: [AsciiCharacterClass; 128] = [
+// _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _a _b _c _d _e _f
+ C, C, C, C, C, C, C, C, C, Cw,Cw,C, Cw,Cw,C, C, // 0_
+ C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, // 1_
+ W, P, P, P, P, P, P, P, P, P, P, P, P, P, P, P, // 2_
+ D, D, D, D, D, D, D, D, D, D, P, P, P, P, P, P, // 3_
+ P, Ux,Ux,Ux,Ux,Ux,Ux,U, U, U, U, U, U, U, U, U, // 4_
+ U, U, U, U, U, U, U, U, U, U, U, P, P, P, P, P, // 5_
+ P, Lx,Lx,Lx,Lx,Lx,Lx,L, L, L, L, L, L, L, L, L, // 6_
+ L, L, L, L, L, L, L, L, L, L, L, P, P, P, P, C, // 7_
+];
/// Implementing `Deref` for smart pointers makes accessing the data behind them
/// convenient, which is why they implement `Deref`. On the other hand, the
/// rules regarding `Deref` and [`DerefMut`] were designed specifically to
-/// accomodate smart pointers. Because of this, **`Deref` should only be
+/// accommodate smart pointers. Because of this, **`Deref` should only be
/// implemented for smart pointers** to avoid confusion.
///
/// For similar reasons, **this trait should never fail**. Failure during
/// Implementing `DerefMut` for smart pointers makes mutating the data behind
/// them convenient, which is why they implement `DerefMut`. On the other hand,
/// the rules regarding [`Deref`] and `DerefMut` were designed specifically to
-/// accomodate smart pointers. Because of this, **`DerefMut` should only be
+/// accommodate smart pointers. Because of this, **`DerefMut` should only be
/// implemented for smart pointers** to avoid confusion.
///
/// For similar reasons, **this trait should never fail**. Failure during
/// ```
#[stable(feature = "ptr_as_ref", since = "1.9.0")]
#[inline]
- pub unsafe fn as_ref<'a>(self) -> Option<&'a T> where T: Sized {
- if self.is_null() {
+ pub unsafe fn as_ref<'a>(self) -> Option<&'a T> {
+ // Check for null via a cast to a thin pointer, so fat pointers are only
+ // considering their "data" part for null-ness.
+ if (self as *const u8).is_null() {
None
} else {
Some(&*self)
/// ```
#[stable(feature = "ptr_as_ref", since = "1.9.0")]
#[inline]
- pub unsafe fn as_ref<'a>(self) -> Option<&'a T> where T: Sized {
- if self.is_null() {
+ pub unsafe fn as_ref<'a>(self) -> Option<&'a T> {
+ // Check for null via a cast to a thin pointer, so fat pointers are only
+ // considering their "data" part for null-ness.
+ if (self as *const u8).is_null() {
None
} else {
Some(&*self)
/// ```
#[stable(feature = "ptr_as_ref", since = "1.9.0")]
#[inline]
- pub unsafe fn as_mut<'a>(self) -> Option<&'a mut T> where T: Sized {
- if self.is_null() {
+ pub unsafe fn as_mut<'a>(self) -> Option<&'a mut T> {
+ // Check for null via a cast to a thin pointer, so fat pointers are only
+ // considering their "data" part for null-ness.
+ if (self as *mut u8).is_null() {
None
} else {
Some(&mut *self)
}
}
+#[stable(feature = "atomic_from", since = "1.23.0")]
+impl<T> From<*mut T> for AtomicPtr<T> {
+ #[inline]
+ fn from(p: *mut T) -> Self { Self::new(p) }
+}
+
#[cfg(target_has_atomic = "ptr")]
macro_rules! atomic_int {
($stable:meta, $const_unstable:meta,
}
}
+ #[stable(feature = "atomic_from", since = "1.23.0")]
+ impl From<$int_type> for $atomic_type {
+ #[inline]
+ fn from(v: $int_type) -> Self { Self::new(v) }
+ }
+
#[$stable_debug]
impl fmt::Debug for $atomic_type {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let p = &u as *const isize;
assert_eq!(p.as_ref().unwrap(), &2);
}
+
+ // Pointers to unsized types -- slices
+ let s: &mut [u8] = &mut [1, 2, 3];
+ let cs: *const [u8] = s;
+ assert_eq!(cs.as_ref(), Some(&*s));
+
+ let ms: *mut [u8] = s;
+ assert_eq!(ms.as_ref(), Some(&*s));
+
+ let cz: *const [u8] = &[];
+ assert_eq!(cz.as_ref(), Some(&[][..]));
+
+ let mz: *mut [u8] = &mut [];
+ assert_eq!(mz.as_ref(), Some(&[][..]));
+
+ let ncs: *const [u8] = null::<[u8; 3]>();
+ assert_eq!(ncs.as_ref(), None);
+
+ let nms: *mut [u8] = null_mut::<[u8; 3]>();
+ assert_eq!(nms.as_ref(), None);
+
+ // Pointers to unsized types -- trait objects
+ let ci: *const ToString = &3;
+ assert!(ci.as_ref().is_some());
+
+ let mi: *mut ToString = &mut 3;
+ assert!(mi.as_ref().is_some());
+
+ let nci: *const ToString = null::<isize>();
+ assert!(nci.as_ref().is_none());
+
+ let nmi: *mut ToString = null_mut::<isize>();
+ assert!(nmi.as_ref().is_none());
}
}
let p = &mut u as *mut isize;
assert!(p.as_mut().unwrap() == &mut 2);
}
+
+ // Pointers to unsized types -- slices
+ let s: &mut [u8] = &mut [1, 2, 3];
+ let ms: *mut [u8] = s;
+ assert_eq!(ms.as_mut(), Some(s));
+
+ let mz: *mut [u8] = &mut [];
+ assert_eq!(mz.as_mut(), Some(&mut [][..]));
+
+ let nms: *mut [u8] = null_mut::<[u8; 3]>();
+ assert_eq!(nms.as_mut(), None);
+
+ // Pointers to unsized types -- trait objects
+ let mi: *mut ToString = &mut 3;
+ assert!(mi.as_mut().is_some());
+
+ let nmi: *mut ToString = null_mut::<isize>();
+ assert!(nmi.as_mut().is_none());
}
}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use iter::FromIterator;
+
+/// Collapses all unit items from an iterator into one.
+///
+/// This is more useful when combined with higher-level abstractions, like
+/// collecting to a `Result<(), E>` where you only care about errors:
+///
+/// ```
+/// use std::io::*;
+/// let data = vec![1, 2, 3, 4, 5];
+/// let res: Result<()> = data.iter()
+/// .map(|x| writeln!(stdout(), "{}", x))
+/// .collect();
+/// assert!(res.is_ok());
+/// ```
+#[stable(feature = "unit_from_iter", since = "1.23.0")]
+impl FromIterator<()> for () {
+ fn from_iter<I: IntoIterator<Item=()>>(iter: I) -> Self {
+ iter.into_iter().for_each(|()| {})
+ }
+}
// Represents metadata from an extern crate.
[input] CrateMetadata(CrateNum),
- // Represents some artifact that we save to disk. Note that these
- // do not have a def-id as part of their identifier.
- [] WorkProduct(WorkProductId),
-
// Represents different phases in the compiler.
[] RegionScopeTree(DefId),
[eval_always] Coherence,
[] SuperPredicatesOfItem(DefId),
[] TraitDefOfItem(DefId),
[] AdtDefOfItem(DefId),
- [] IsDefaultImpl(DefId),
+ [] IsAutoImpl(DefId),
[] ImplTraitRef(DefId),
[] ImplPolarity(DefId),
[] ClosureKind(DefId),
// The set of impls for a given trait.
[] TraitImpls(DefId),
- [] AllLocalTraitImpls,
-
- // Trait selection cache is a little funny. Given a trait
- // reference like `Foo: SomeTrait<Bar>`, there could be
- // arbitrarily many def-ids to map on in there (e.g., `Foo`,
- // `SomeTrait`, `Bar`). We could have a vector of them, but it
- // requires heap-allocation, and trait sel in general can be a
- // surprisingly hot path. So instead we pick two def-ids: the
- // trait def-id, and the first def-id in the input types. If there
- // is no def-id in the input types, then we use the trait def-id
- // again. So for example:
- //
- // - `i32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
- // - `u32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
- // - `Clone: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
- // - `Vec<i32>: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Vec }`
- // - `String: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: String }`
- // - `Foo: Trait<Bar>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
- // - `Foo: Trait<i32>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
- // - `(Foo, Bar): Trait` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
- // - `i32: Trait<Foo>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
- //
- // You can see that we map many trait refs to the same
- // trait-select node. This is not a problem, it just means
- // imprecision in our dep-graph tracking. The important thing is
- // that for any given trait-ref, we always map to the **same**
- // trait-select node.
+ [input] AllLocalTraitImpls,
+
[anon] TraitSelect,
[] ParamEnv(DefId),
[] DescribeDef(DefId),
- [] DefSpan(DefId),
+
+ // FIXME(mw): DefSpans are not really inputs since they are derived from
+ // HIR. But at the moment HIR hashing still contains some hacks that allow
+ // to make type debuginfo to be source location independent. Declaring
+ // DefSpan an input makes sure that changes to these are always detected
+ // regardless of HIR hashing.
+ [input] DefSpan(DefId),
[] LookupStability(DefId),
[] LookupDeprecationEntry(DefId),
[] ItemBodyNestedBodies(DefId),
[eval_always] LintLevels,
[] Specializes { impl1: DefId, impl2: DefId },
[input] InScopeTraits(DefIndex),
- [] ModuleExports(DefId),
+ [input] ModuleExports(DefId),
[] IsSanitizerRuntime(CrateNum),
[] IsProfilerRuntime(CrateNum),
[] GetPanicStrategy(CrateNum),
[] NativeLibraries(CrateNum),
[] PluginRegistrarFn(CrateNum),
[] DeriveRegistrarFn(CrateNum),
- [] CrateDisambiguator(CrateNum),
- [] CrateHash(CrateNum),
- [] OriginalCrateName(CrateNum),
+ [input] CrateDisambiguator(CrateNum),
+ [input] CrateHash(CrateNum),
+ [input] OriginalCrateName(CrateNum),
[] ImplementationsOfTrait { krate: CrateNum, trait_id: DefId },
[] AllTraitImplementations(CrateNum),
[] IsDllimportForeignItem(DefId),
[] IsStaticallyIncludedForeignItem(DefId),
[] NativeLibraryKind(DefId),
- [] LinkArgs,
+ [input] LinkArgs,
- [] NamedRegion(DefIndex),
- [] IsLateBound(DefIndex),
- [] ObjectLifetimeDefaults(DefIndex),
+ [input] NamedRegion(DefIndex),
+ [input] IsLateBound(DefIndex),
+ [input] ObjectLifetimeDefaults(DefIndex),
[] Visibility(DefId),
[] DepKind(CrateNum),
- [] CrateName(CrateNum),
+ [input] CrateName(CrateNum),
[] ItemChildren(DefId),
[] ExternModStmtCnum(DefId),
- [] GetLangItems,
+ [input] GetLangItems,
[] DefinedLangItems(CrateNum),
[] MissingLangItems(CrateNum),
[] ExternConstBody(DefId),
[] VisibleParentMap,
[] MissingExternCrateItem(CrateNum),
[] UsedCrateSource(CrateNum),
- [] PostorderCnums,
- [] HasCloneClosures(CrateNum),
- [] HasCopyClosures(CrateNum),
+ [input] PostorderCnums,
+ [input] HasCloneClosures(CrateNum),
+ [input] HasCopyClosures(CrateNum),
// This query is not expected to have inputs -- as a result, it's
// not a good candidate for "replay" because it's essentially a
// may save a bit of time.
[anon] EraseRegionsTy { ty: Ty<'tcx> },
- [] Freevars(DefId),
- [] MaybeUnusedTraitImport(DefId),
+ [input] Freevars(DefId),
+ [input] MaybeUnusedTraitImport(DefId),
[] MaybeUnusedExternCrates,
[] StabilityIndex,
- [] AllCrateNums,
+ [input] AllCrateNums,
[] ExportedSymbols(CrateNum),
[eval_always] CollectAndPartitionTranslationItems,
[] ExportName(DefId),
[] IsTranslatedFunction(DefId),
[] CodegenUnit(InternedString),
[] CompileCodegenUnit(InternedString),
- [] OutputFilenames,
+ [input] OutputFilenames,
[anon] NormalizeTy,
// We use this for most things when incr. comp. is turned off.
[] Null,
hash: fingerprint
}
}
-
- pub fn to_dep_node(self) -> DepNode {
- DepNode {
- kind: DepKind::WorkProduct,
- hash: self.hash,
- }
- }
}
impl_stable_hash_for!(struct ::dep_graph::WorkProductId {
}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct DepNodeIndex {
- index: u32,
-}
-
-impl Idx for DepNodeIndex {
- fn new(idx: usize) -> Self {
- debug_assert!((idx & 0xFFFF_FFFF) == idx);
- DepNodeIndex { index: idx as u32 }
- }
- fn index(self) -> usize {
- self.index as usize
- }
-}
+newtype_index!(DepNodeIndex);
impl DepNodeIndex {
- const INVALID: DepNodeIndex = DepNodeIndex {
- index: ::std::u32::MAX,
- };
+ const INVALID: DepNodeIndex = DepNodeIndex(::std::u32::MAX);
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
}
pub fn fingerprint_of(&self, dep_node: &DepNode) -> Fingerprint {
- self.fingerprints.borrow()[dep_node]
+ match self.fingerprints.borrow().get(dep_node) {
+ Some(&fingerprint) => fingerprint,
+ None => {
+ bug!("Could not find current fingerprint for {:?}", dep_node)
+ }
+ }
}
pub fn prev_fingerprint_of(&self, dep_node: &DepNode) -> Option<Fingerprint> {
return None
}
None => {
- if dep_dep_node.kind.is_input() {
- // This input does not exist anymore.
- debug_assert!(dep_dep_node.extract_def_id(tcx).is_none(),
- "Encountered input {:?} without color",
- dep_dep_node);
- debug!("try_mark_green({:?}) - END - dependency {:?} \
- was deleted input", dep_node, dep_dep_node);
- return None;
+ // We don't know the state of this dependency. If it isn't
+ // an input node, let's try to mark it green recursively.
+ if !dep_dep_node.kind.is_input() {
+ debug!("try_mark_green({:?}) --- state of dependency {:?} \
+ is unknown, trying to mark it green", dep_node,
+ dep_dep_node);
+
+ if let Some(node_index) = self.try_mark_green(tcx, dep_dep_node) {
+ debug!("try_mark_green({:?}) --- managed to MARK \
+ dependency {:?} as green", dep_node, dep_dep_node);
+ current_deps.push(node_index);
+ continue;
+ }
+ } else if cfg!(debug_assertions) {
+ match dep_dep_node.kind {
+ DepKind::Hir |
+ DepKind::HirBody |
+ DepKind::CrateMetadata => {
+ assert!(dep_dep_node.extract_def_id(tcx).is_none(),
+ "Input {:?} should have been pre-allocated but wasn't.",
+ dep_dep_node);
+ }
+ _ => {
+ // For other kinds of inputs it's OK to be
+ // forced.
+ }
+ }
}
- debug!("try_mark_green({:?}) --- state of dependency {:?} \
- is unknown, trying to mark it green", dep_node,
- dep_dep_node);
-
- // We don't know the state of this dependency. Let's try to
- // mark it green.
- if let Some(node_index) = self.try_mark_green(tcx, dep_dep_node) {
- debug!("try_mark_green({:?}) --- managed to MARK \
- dependency {:?} as green", dep_node, dep_dep_node);
- current_deps.push(node_index);
- } else {
- // We failed to mark it green, so we try to force the query.
- debug!("try_mark_green({:?}) --- trying to force \
- dependency {:?}", dep_node, dep_dep_node);
- if ::ty::maps::force_from_dep_node(tcx, dep_dep_node) {
- let dep_dep_node_color = data.colors
- .borrow()
- .get(dep_dep_node)
- .cloned();
- match dep_dep_node_color {
- Some(DepNodeColor::Green(node_index)) => {
- debug!("try_mark_green({:?}) --- managed to \
- FORCE dependency {:?} to green",
- dep_node, dep_dep_node);
- current_deps.push(node_index);
- }
- Some(DepNodeColor::Red) => {
- debug!("try_mark_green({:?}) - END - \
- dependency {:?} was red after forcing",
- dep_node,
- dep_dep_node);
- return None
- }
- None => {
- bug!("try_mark_green() - Forcing the DepNode \
- should have set its color")
- }
+ // We failed to mark it green, so we try to force the query.
+ debug!("try_mark_green({:?}) --- trying to force \
+ dependency {:?}", dep_node, dep_dep_node);
+ if ::ty::maps::force_from_dep_node(tcx, dep_dep_node) {
+ let dep_dep_node_color = data.colors
+ .borrow()
+ .get(dep_dep_node)
+ .cloned();
+ match dep_dep_node_color {
+ Some(DepNodeColor::Green(node_index)) => {
+ debug!("try_mark_green({:?}) --- managed to \
+ FORCE dependency {:?} to green",
+ dep_node, dep_dep_node);
+ current_deps.push(node_index);
+ }
+ Some(DepNodeColor::Red) => {
+ debug!("try_mark_green({:?}) - END - \
+ dependency {:?} was red after forcing",
+ dep_node,
+ dep_dep_node);
+ return None
+ }
+ None => {
+ bug!("try_mark_green() - Forcing the DepNode \
+ should have set its color")
}
- } else {
- // The DepNode could not be forced.
- debug!("try_mark_green({:?}) - END - dependency {:?} \
- could not be forced", dep_node, dep_dep_node);
- return None
}
+ } else {
+ // The DepNode could not be forced.
+ debug!("try_mark_green({:?}) - END - dependency {:?} \
+ could not be forced", dep_node, dep_dep_node);
+ return None
}
}
}
read_set: _,
reads
} = popped_node {
- debug_assert_eq!(node, key);
+ assert_eq!(node, key);
+
+ // If this is an input node, we expect that it either has no
+ // dependencies, or that it just depends on DepKind::CrateMetadata
+ // or DepKind::Krate. This happens for some "thin wrapper queries"
+ // like `crate_disambiguator` which sometimes have zero deps (for
+ // when called for LOCAL_CRATE) or they depend on a CrateMetadata
+ // node.
+ if cfg!(debug_assertions) {
+ if node.kind.is_input() && reads.len() > 0 &&
+ // FIXME(mw): Special case for DefSpan until Spans are handled
+ // better in general.
+ node.kind != DepKind::DefSpan &&
+ reads.iter().any(|&i| {
+ !(self.nodes[i].kind == DepKind::CrateMetadata ||
+ self.nodes[i].kind == DepKind::Krate)
+ })
+ {
+ bug!("Input node {:?} with unexpected reads: {:?}",
+ node,
+ reads.iter().map(|&i| self.nodes[i]).collect::<Vec<_>>())
+ }
+ }
+
self.alloc_node(node, reads)
} else {
bug!("pop_task() - Expected regular task to be popped")
read_set: _,
reads
} = popped_node {
+ debug_assert!(!kind.is_input());
+
let mut fingerprint = self.anon_id_seed;
let mut hasher = StableHasher::new();
use std::fmt;
use std::u32;
-#[derive(Clone, Copy, Eq, Ord, PartialOrd, PartialEq, Hash, Debug)]
-pub struct CrateNum(u32);
+newtype_index!(CrateNum
+ {
+ derive[Debug]
+ ENCODABLE = custom
-impl Idx for CrateNum {
- fn new(value: usize) -> Self {
- assert!(value < (u32::MAX) as usize);
- CrateNum(value as u32)
- }
-
- fn index(self) -> usize {
- self.0 as usize
- }
-}
-
-/// Item definitions in the currently-compiled crate would have the CrateNum
-/// LOCAL_CRATE in their DefId.
-pub const LOCAL_CRATE: CrateNum = CrateNum(0);
+ /// Item definitions in the currently-compiled crate would have the CrateNum
+ /// LOCAL_CRATE in their DefId.
+ const LOCAL_CRATE = 0,
-/// Virtual crate for builtin macros
-// FIXME(jseyfried): this is also used for custom derives until proc-macro crates get `CrateNum`s.
-pub const BUILTIN_MACROS_CRATE: CrateNum = CrateNum(u32::MAX);
+ /// Virtual crate for builtin macros
+ // FIXME(jseyfried): this is also used for custom derives until proc-macro crates get
+ // `CrateNum`s.
+ const BUILTIN_MACROS_CRATE = u32::MAX,
-/// A CrateNum value that indicates that something is wrong.
-pub const INVALID_CRATE: CrateNum = CrateNum(u32::MAX - 1);
+ /// A CrateNum value that indicates that something is wrong.
+ const INVALID_CRATE = u32::MAX - 1,
+ });
impl CrateNum {
pub fn new(x: usize) -> CrateNum {
///
/// Since the DefIndex is mostly treated as an opaque ID, you probably
/// don't have to care about these ranges.
-#[derive(Clone, Eq, Ord, PartialOrd, PartialEq, RustcEncodable,
- RustcDecodable, Hash, Copy)]
-pub struct DefIndex(u32);
+newtype_index!(DefIndex
+ {
+ DEBUG_FORMAT = custom,
-impl Idx for DefIndex {
- fn new(value: usize) -> Self {
- assert!(value < (u32::MAX) as usize);
- DefIndex(value as u32)
- }
+ /// The start of the "high" range of DefIndexes.
+ const DEF_INDEX_HI_START = 1 << 31,
- fn index(self) -> usize {
- self.0 as usize
- }
-}
+ /// The crate root is always assigned index 0 by the AST Map code,
+ /// thanks to `NodeCollector::new`.
+ const CRATE_DEF_INDEX = 0,
+ });
impl fmt::Debug for DefIndex {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
}
impl DefIndex {
- #[inline]
- pub fn new(x: usize) -> DefIndex {
- assert!(x < (u32::MAX as usize));
- DefIndex(x as u32)
- }
-
#[inline]
pub fn from_u32(x: u32) -> DefIndex {
DefIndex(x)
}
}
-/// The start of the "high" range of DefIndexes.
-const DEF_INDEX_HI_START: DefIndex = DefIndex(1 << 31);
-
-/// The crate root is always assigned index 0 by the AST Map code,
-/// thanks to `NodeCollector::new`.
-pub const CRATE_DEF_INDEX: DefIndex = DefIndex(0);
-
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
pub enum DefIndexAddressSpace {
Low = 0,
// visit_enum_def() takes care of visiting the Item's NodeId
visitor.visit_enum_def(enum_definition, type_parameters, item.id, item.span)
}
- ItemDefaultImpl(_, ref trait_ref) => {
+ ItemAutoImpl(_, ref trait_ref) => {
visitor.visit_id(item.id);
visitor.visit_trait_ref(trait_ref)
}
visitor.visit_id(item.id);
visitor.visit_variant_data(struct_definition, item.name, generics, item.id, item.span);
}
- ItemTrait(_, ref generics, ref bounds, ref trait_item_refs) => {
+ ItemTrait(.., ref generics, ref bounds, ref trait_item_refs) => {
visitor.visit_id(item.id);
visitor.visit_generics(generics);
walk_list!(visitor, visit_ty_param_bound, bounds);
exported_macros: Vec<hir::MacroDef>,
trait_impls: BTreeMap<DefId, Vec<NodeId>>,
- trait_default_impl: BTreeMap<DefId, NodeId>,
+ trait_auto_impl: BTreeMap<DefId, NodeId>,
is_generator: bool,
impl_items: BTreeMap::new(),
bodies: BTreeMap::new(),
trait_impls: BTreeMap::new(),
- trait_default_impl: BTreeMap::new(),
+ trait_auto_impl: BTreeMap::new(),
exported_macros: Vec::new(),
catch_scopes: Vec::new(),
loop_scopes: Vec::new(),
ItemKind::Union(_, ref generics) |
ItemKind::Enum(_, ref generics) |
ItemKind::Ty(_, ref generics) |
- ItemKind::Trait(_, ref generics, ..) => {
+ ItemKind::Trait(_, _, ref generics, ..) => {
let def_id = self.lctx.resolver.definitions().local_def_id(item.id);
let count = generics.lifetimes.len();
self.lctx.type_def_lifetime_params.insert(def_id, count);
bodies: self.bodies,
body_ids,
trait_impls: self.trait_impls,
- trait_default_impl: self.trait_default_impl,
+ trait_auto_impl: self.trait_auto_impl,
}
}
return n;
}
assert!(!def_id.is_local());
- let n = self.cstore.item_generics_cloned_untracked(def_id).regions.len();
+ let n = self.cstore
+ .item_generics_cloned_untracked(def_id, self.sess)
+ .regions
+ .len();
self.type_def_lifetime_params.insert(def_id, n);
n
});
let vdata = self.lower_variant_data(vdata);
hir::ItemUnion(vdata, self.lower_generics(generics))
}
- ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
+ ItemKind::AutoImpl(unsafety, ref trait_ref) => {
let trait_ref = self.lower_trait_ref(trait_ref);
if let Def::Trait(def_id) = trait_ref.path.def {
- self.trait_default_impl.insert(def_id, id);
+ self.trait_auto_impl.insert(def_id, id);
}
- hir::ItemDefaultImpl(self.lower_unsafety(unsafety),
+ hir::ItemAutoImpl(self.lower_unsafety(unsafety),
trait_ref)
}
ItemKind::Impl(unsafety,
self.lower_ty(ty),
new_impl_items)
}
- ItemKind::Trait(unsafety, ref generics, ref bounds, ref items) => {
+ ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref items) => {
let bounds = self.lower_bounds(bounds);
let items = items.iter().map(|item| self.lower_trait_item_ref(item)).collect();
- hir::ItemTrait(self.lower_unsafety(unsafety),
+ hir::ItemTrait(self.lower_is_auto(is_auto),
+ self.lower_unsafety(unsafety),
self.lower_generics(generics),
bounds,
items)
}
}
+ fn lower_is_auto(&mut self, a: IsAuto) -> hir::IsAuto {
+ match a {
+ IsAuto::Yes => hir::IsAuto::Yes,
+ IsAuto::No => hir::IsAuto::No,
+ }
+ }
+
fn lower_unsafety(&mut self, u: Unsafety) -> hir::Unsafety {
match u {
Unsafety::Unsafe => hir::Unsafety::Unsafe,
impl_items: _,
bodies: _,
trait_impls: _,
- trait_default_impl: _,
+ trait_auto_impl: _,
body_ids: _,
} = *krate;
// Pick the def data. This need not be unique, but the more
// information we encapsulate into
let def_data = match i.node {
- ItemKind::DefaultImpl(..) | ItemKind::Impl(..) =>
+ ItemKind::AutoImpl(..) | ItemKind::Impl(..) =>
DefPathData::Impl,
ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) | ItemKind::Trait(..) |
ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) | ItemKind::Ty(..) =>
CRATE_DEF_INDEX};
use ich::Fingerprint;
use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::indexed_vec::IndexVec;
+use rustc_data_structures::indexed_vec::{IndexVec, Idx};
use rustc_data_structures::stable_hasher::StableHasher;
use serialize::{Encodable, Decodable, Encoder, Decoder};
use session::CrateDisambiguator;
/// if the node is a body owner, otherwise returns `None`.
pub fn maybe_body_owned_by(&self, id: NodeId) -> Option<BodyId> {
if let Some(entry) = self.find_entry(id) {
+ if self.dep_graph.is_fully_enabled() {
+ let hir_id_owner = self.node_to_hir_id(id).owner;
+ let def_path_hash = self.definitions.def_path_hash(hir_id_owner);
+ self.dep_graph.read(def_path_hash.to_dep_node(DepKind::HirBody));
+ }
+
if let Some(body_id) = entry.associated_body() {
// For item-like things and closures, the associated
// body has its own distinct id, and that is returned
self.forest.krate.trait_impls.get(&trait_did).map_or(&[], |xs| &xs[..])
}
- pub fn trait_default_impl(&self, trait_did: DefId) -> Option<NodeId> {
+ pub fn trait_auto_impl(&self, trait_did: DefId) -> Option<NodeId> {
self.dep_graph.read(DepNode::new_no_params(DepKind::AllLocalTraitImpls));
// NB: intentionally bypass `self.forest.krate()` so that we
// do not trigger a read of the whole krate here
- self.forest.krate.trait_default_impl.get(&trait_did).cloned()
+ self.forest.krate.trait_auto_impl.get(&trait_did).cloned()
}
pub fn trait_is_auto(&self, trait_did: DefId) -> bool {
- self.trait_default_impl(trait_did).is_some()
+ self.trait_auto_impl(trait_did).is_some()
}
/// Get the attributes on the krate. This is preferable to
/// from a node to the root of the ast (unless you get the same id back here
/// that can happen if the id is not in the map itself or is just weird).
pub fn get_parent_node(&self, id: NodeId) -> NodeId {
+ if self.dep_graph.is_fully_enabled() {
+ let hir_id_owner = self.node_to_hir_id(id).owner;
+ let def_path_hash = self.definitions.def_path_hash(hir_id_owner);
+ self.dep_graph.read(def_path_hash.to_dep_node(DepKind::HirBody));
+ }
+
self.find_entry(id).and_then(|x| x.parent_node()).unwrap_or(id)
}
ItemUnion(..) => "union",
ItemTrait(..) => "trait",
ItemImpl(..) => "impl",
- ItemDefaultImpl(..) => "default impl",
+ ItemAutoImpl(..) => "default impl",
};
format!("{} {}{}", item_str, path_str(), id_str)
}
pub impl_items: BTreeMap<ImplItemId, ImplItem>,
pub bodies: BTreeMap<BodyId, Body>,
pub trait_impls: BTreeMap<DefId, Vec<NodeId>>,
- pub trait_default_impl: BTreeMap<DefId, NodeId>,
+ pub trait_auto_impl: BTreeMap<DefId, NodeId>,
/// A list of the body ids written out in the order in which they
/// appear in the crate. If you're going to process all the bodies
pub has_implicit_self: bool,
}
+/// Is the trait definition an auto trait?
+#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub enum IsAuto {
+ Yes,
+ No
+}
+
#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum Unsafety {
Unsafe,
/// A union definition, e.g. `union Foo<A, B> {x: A, y: B}`
ItemUnion(VariantData, Generics),
/// Represents a Trait Declaration
- ItemTrait(Unsafety, Generics, TyParamBounds, HirVec<TraitItemRef>),
+ ItemTrait(IsAuto, Unsafety, Generics, TyParamBounds, HirVec<TraitItemRef>),
- // Default trait implementations
+ /// Auto trait implementations
///
/// `impl Trait for .. {}`
- ItemDefaultImpl(Unsafety, TraitRef),
+ ItemAutoImpl(Unsafety, TraitRef),
/// An implementation, eg `impl<A> Trait for Foo { .. }`
ItemImpl(Unsafety,
ImplPolarity,
ItemUnion(..) => "union",
ItemTrait(..) => "trait",
ItemImpl(..) |
- ItemDefaultImpl(..) => "item",
+ ItemAutoImpl(..) => "item",
}
}
ItemEnum(_, ref generics) |
ItemStruct(_, ref generics) |
ItemUnion(_, ref generics) |
- ItemTrait(_, ref generics, _, _) |
+ ItemTrait(_, _, ref generics, _, _) |
ItemImpl(_, _, _, ref generics, _, _, _)=> generics,
_ => return None
})
self.head(&visibility_qualified(&item.vis, "union"))?;
self.print_struct(struct_def, generics, item.name, item.span, true)?;
}
- hir::ItemDefaultImpl(unsafety, ref trait_ref) => {
+ hir::ItemAutoImpl(unsafety, ref trait_ref) => {
self.head("")?;
self.print_visibility(&item.vis)?;
self.print_unsafety(unsafety)?;
}
self.bclose(item.span)?;
}
- hir::ItemTrait(unsafety, ref generics, ref bounds, ref trait_items) => {
+ hir::ItemTrait(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_name(item.name)?;
Fixity::None => (prec + 1, prec + 1),
};
+ let left_prec = match (&lhs.node, op.node) {
+ // These cases need parens: `x as i32 < y` has the parser thinking that `i32 < y` is
+ // the beginning of a path type. It starts trying to parse `x as (i32 < y ...` instead
+ // of `(x as i32) < ...`. We need to convince it _not_ to do that.
+ (&hir::ExprCast { .. }, hir::BinOp_::BiLt) |
+ (&hir::ExprCast { .. }, hir::BinOp_::BiShl) => parser::PREC_FORCE_PAREN,
+ _ => left_prec,
+ };
+
self.print_expr_maybe_paren(lhs, left_prec)?;
self.s.space()?;
self.word_space(op.node.as_str())?;
hir::Unsafety::Unsafe => self.word_nbsp("unsafe"),
}
}
+
+ pub fn print_is_auto(&mut self, s: hir::IsAuto) -> io::Result<()> {
+ match s {
+ hir::IsAuto::Yes => self.word_nbsp("auto"),
+ hir::IsAuto::No => Ok(()),
+ }
+ }
}
// Dup'ed from parse::classify, but adapted for the HIR.
match binop {
hir::BiAdd |
hir::BiSub |
+ hir::BiShl |
+ hir::BiShr |
hir::BiMul => self.overflow_checks_enabled,
hir::BiDiv |
hir::BiBitXor |
hir::BiBitAnd |
hir::BiBitOr |
- hir::BiShl |
- hir::BiShr |
hir::BiEq |
hir::BiLt |
hir::BiLe |
targeted_by_break,
} = *self;
- let non_item_stmts = || stmts.iter().filter(|stmt| {
- match stmt.node {
- hir::StmtDecl(ref decl, _) => {
- match decl.node {
- // If this is a declaration of a nested item, we don't
- // want to leave any trace of it in the hash value, not
- // even that it exists. Otherwise changing the position
- // of nested items would invalidate the containing item
- // even though that does not constitute a semantic
- // change.
- hir::DeclItem(_) => false,
- hir::DeclLocal(_) => true
- }
- }
- hir::StmtExpr(..) |
- hir::StmtSemi(..) => true
- }
- });
-
- let count = non_item_stmts().count();
-
- count.hash_stable(hcx, hasher);
-
- for stmt in non_item_stmts() {
- stmt.hash_stable(hcx, hasher);
- }
-
+ stmts.hash_stable(hcx, hasher);
expr.hash_stable(hcx, hasher);
rules.hash_stable(hcx, hasher);
span.hash_stable(hcx, hasher);
hir::ItemForeignMod(..) |
hir::ItemGlobalAsm(..) |
hir::ItemMod(..) |
- hir::ItemDefaultImpl(..) |
+ hir::ItemAutoImpl(..) |
hir::ItemTrait(..) |
hir::ItemImpl(..) |
hir::ItemTy(..) |
ItemEnum(enum_def, generics),
ItemStruct(variant_data, generics),
ItemUnion(variant_data, generics),
- ItemTrait(unsafety, generics, bounds, item_refs),
- ItemDefaultImpl(unsafety, trait_ref),
+ ItemTrait(is_auto, unsafety, generics, bounds, item_refs),
+ ItemAutoImpl(unsafety, trait_ref),
ItemImpl(unsafety, impl_polarity, impl_defaultness, generics, trait_ref, ty, impl_item_refs)
});
MutImmutable
});
+impl_stable_hash_for!(enum hir::IsAuto {
+ Yes,
+ No
+});
impl_stable_hash_for!(enum hir::Unsafety {
Unsafe,
mir::TerminatorKind::Drop { .. } |
mir::TerminatorKind::DropAndReplace { .. } |
mir::TerminatorKind::Yield { .. } |
- mir::TerminatorKind::Call { .. } => false,
+ mir::TerminatorKind::Call { .. } |
+ mir::TerminatorKind::FalseEdges { .. } => false,
};
if hash_spans_unconditionally {
target.hash_stable(hcx, hasher);
cleanup.hash_stable(hcx, hasher);
}
+ mir::TerminatorKind::FalseEdges { ref real_target, ref imaginary_targets } => {
+ real_target.hash_stable(hcx, hasher);
+ for target in imaginary_targets {
+ target.hash_stable(hcx, hasher);
+ }
+ }
}
}
}
end_pos: _,
ref lines,
ref multibyte_chars,
+ ref non_narrow_chars,
} = *self;
name.hash_stable(hcx, hasher);
for &char_pos in multibyte_chars.iter() {
stable_multibyte_char(char_pos, start_pos).hash_stable(hcx, hasher);
}
+
+ let non_narrow_chars = non_narrow_chars.borrow();
+ non_narrow_chars.len().hash_stable(hcx, hasher);
+ for &char_pos in non_narrow_chars.iter() {
+ stable_non_narrow_char(char_pos, start_pos).hash_stable(hcx, hasher);
+ }
}
}
(pos.0 - filemap_start.0, bytes as u32)
}
+
+fn stable_non_narrow_char(swc: ::syntax_pos::NonNarrowChar,
+ filemap_start: ::syntax_pos::BytePos)
+ -> (u32, u32) {
+ let pos = swc.pos();
+ let width = swc.width();
+
+ (pos.0 - filemap_start.0, width as u32)
+}
def_id: _,
unsafety,
paren_sugar,
- has_default_impl,
+ has_auto_impl,
def_path_hash,
} = *self;
unsafety.hash_stable(hcx, hasher);
paren_sugar.hash_stable(hcx, hasher);
- has_default_impl.hash_stable(hcx, hasher);
+ has_auto_impl.hash_stable(hcx, hasher);
def_path_hash.hash_stable(hcx, hasher);
}
}
match self {
&VtableImpl(ref table_impl) => table_impl.hash_stable(hcx, hasher),
- &VtableDefaultImpl(ref table_def_impl) => table_def_impl.hash_stable(hcx, hasher),
+ &VtableAutoImpl(ref table_def_impl) => table_def_impl.hash_stable(hcx, hasher),
&VtableParam(ref table_param) => table_param.hash_stable(hcx, hasher),
&VtableObject(ref table_obj) => table_obj.hash_stable(hcx, hasher),
&VtableBuiltin(ref table_builtin) => table_builtin.hash_stable(hcx, hasher),
}
impl<'gcx, N> HashStable<StableHashingContext<'gcx>>
-for traits::VtableDefaultImplData<N> where N: HashStable<StableHashingContext<'gcx>> {
+for traits::VtableAutoImplData<N> where N: HashStable<StableHashingContext<'gcx>> {
fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>,
hasher: &mut StableHasher<W>) {
- let traits::VtableDefaultImplData {
+ let traits::VtableAutoImplData {
trait_def_id,
ref nested,
} = *self;
flexibility, because perhaps the user intended for A and B to end up
as different types and not the same type.
-Pictorally, what this does is to take two distinct variables with
+Pictorially, what this does is to take two distinct variables with
(hopefully not completely) distinct type ranges and produce one with
the intersection.
use infer::error_reporting::util::AnonymousArgInfo;
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
- // This method prints the error message for lifetime errors when both the concerned regions
- // are anonymous.
- // Consider a case where we have
- // fn foo(x: &mut Vec<&u8>, y: &u8)
- // { x.push(y); }.
- // The example gives
- // fn foo(x: &mut Vec<&u8>, y: &u8) {
- // --- --- these references are declared with different lifetimes...
- // x.push(y);
- // ^ ...but data from `y` flows into `x` here
- // It has been extended for the case of structs too.
- // Consider the example
- // struct Ref<'a> { x: &'a u32 }
- // fn foo(mut x: Vec<Ref>, y: Ref) {
- // --- --- these structs are declared with different lifetimes...
- // x.push(y);
- // ^ ...but data from `y` flows into `x` here
- // }
- // It will later be extended to trait objects.
+ /// Print the error message for lifetime errors when both the concerned regions are anonymous.
+ ///
+ /// Consider a case where we have
+ ///
+ /// ```no_run
+ /// fn foo(x: &mut Vec<&u8>, y: &u8) {
+ /// x.push(y);
+ /// }
+ /// ```
+ ///
+ /// The example gives
+ ///
+ /// ```text
+ /// fn foo(x: &mut Vec<&u8>, y: &u8) {
+ /// --- --- these references are declared with different lifetimes...
+ /// x.push(y);
+ /// ^ ...but data from `y` flows into `x` here
+ /// ```
+ ///
+ /// It has been extended for the case of structs too.
+ ///
+ /// Consider the example
+ ///
+ /// ```no_run
+ /// struct Ref<'a> { x: &'a u32 }
+ /// ```
+ ///
+ /// ```text
+ /// fn foo(mut x: Vec<Ref>, y: Ref) {
+ /// --- --- these structs are declared with different lifetimes...
+ /// x.push(y);
+ /// ^ ...but data from `y` flows into `x` here
+ /// }
+ /// ````
+ ///
+ /// It will later be extended to trait objects.
pub fn try_report_anon_anon_conflict(&self, error: &RegionResolutionError<'tcx>) -> bool {
let (span, sub, sup) = match *error {
ConcreteFailure(ref origin, sub, sup) => (origin.span(), sub, sup),
errors: &Vec<RegionResolutionError<'tcx>>) {
debug!("report_region_errors(): {} errors to start", errors.len());
+ if self.tcx.sess.opts.debugging_opts.nll {
+ for error in errors {
+ match *error {
+ RegionResolutionError::ConcreteFailure(ref origin, ..) |
+ RegionResolutionError::GenericBoundFailure(ref origin, ..) => {
+ self.tcx.sess.span_warn(
+ origin.span(),
+ "not reporting region error due to -Znll");
+ }
+
+ RegionResolutionError::SubSupConflict(ref rvo, ..) => {
+ self.tcx.sess.span_warn(
+ rvo.span(),
+ "not reporting region error due to -Znll");
+ }
+ }
+ }
+
+ return;
+ }
+
// try to pre-process the errors, which will group some of them
// together into a `ProcessedErrors` group:
let errors = self.process_errors(errors);
use ty;
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
- // This method generates the error message for the case when
- // the function arguments consist of a named region and an anonymous
- // region and corresponds to `ConcreteFailure(..)`
+ /// When given a `ConcreteFailure` for a function with arguments containing a named region and
+ /// an anonymous region, emit an descriptive diagnostic error.
pub fn try_report_named_anon_conflict(&self, error: &RegionResolutionError<'tcx>) -> bool {
let (span, sub, sup) = match *error {
ConcreteFailure(ref origin, sub, sup) => (origin.span(), sub, sup),
_ => return false, // inapplicable
};
- debug!("try_report_named_anon_conflict(sub={:?}, sup={:?})",
- sub,
- sup);
+ debug!("try_report_named_anon_conflict(sub={:?}, sup={:?})", sub, sup);
// Determine whether the sub and sup consist of one named region ('a)
// and one anonymous (elided) region. If so, find the parameter arg
};
debug!("try_report_named_anon_conflict: named = {:?}", named);
- debug!("try_report_named_anon_conflict: anon_arg_info = {:?}",
- anon_arg_info);
- debug!("try_report_named_anon_conflict: region_info = {:?}",
- region_info);
+ debug!("try_report_named_anon_conflict: anon_arg_info = {:?}", anon_arg_info);
+ debug!("try_report_named_anon_conflict: region_info = {:?}", region_info);
let (arg, new_ty, br, is_first, scope_def_id, is_impl_item) = (anon_arg_info.arg,
anon_arg_info.arg_ty,
.span_label(span, format!("lifetime `{}` required", named))
.emit();
return true;
-
}
}
_ => false,
}
}
+ ty::ReEarlyBound(_) => true,
_ => false,
}
}
.filter(|&&r| !skol_resolution_map.contains_key(r))
.cloned()
.next()
- .expect("no representative region");
+ .unwrap_or_else(|| {
+ bug!("no representative region for `{:?}` in `{:?}`",
+ skol, regions)
+ });
(skol, representative)
})
use graphviz as dot;
use hir::def_id::DefIndex;
+use rustc_data_structures::indexed_vec::Idx;
use ty;
use middle::free_region::RegionRelations;
use middle::region;
use hir::intravisit::{self, FnKind};
use hir;
use session::Session;
+#[cfg(stage0)]
use std::ascii::AsciiExt;
use std::hash;
use syntax::ast;
fn item_children_untracked(&self, did: DefId, sess: &Session) -> Vec<def::Export>;
fn load_macro_untracked(&self, did: DefId, sess: &Session) -> LoadedMacro;
fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum>;
- fn item_generics_cloned_untracked(&self, def: DefId) -> ty::Generics;
+ fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics;
fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem;
fn postorder_cnums_untracked(&self) -> Vec<CrateNum>;
{ bug!("crate_data_as_rc_any") }
// item info
fn visibility_untracked(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
- fn item_generics_cloned_untracked(&self, def: DefId) -> ty::Generics
+ fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics
{ bug!("item_generics_cloned") }
// trait/impl-item info
hir::ItemStruct(..) |
hir::ItemUnion(..) |
hir::ItemTrait(..) |
- hir::ItemDefaultImpl(..) |
+ hir::ItemAutoImpl(..) |
hir::ItemImpl(..) => self.tcx.sess.codemap().def_span(item.span),
_ => item.span,
};
use syntax::ast;
use syntax::ptr::P;
use syntax_pos::Span;
-use util::nodemap::ItemLocalMap;
+use util::nodemap::ItemLocalSet;
///////////////////////////////////////////////////////////////////////////
// The Delegate trait
param_env: ty::ParamEnv<'tcx>,
region_scope_tree: &'a region::ScopeTree,
tables: &'a ty::TypeckTables<'tcx>,
- rvalue_promotable_map: Option<Rc<ItemLocalMap<bool>>>)
+ rvalue_promotable_map: Option<Rc<ItemLocalSet>>)
-> Self
{
ExprUseVisitor {
debug!("lub_free_regions(r_a={:?}, r_b={:?}) = {:?}", r_a, r_b, result);
result
}
+
+ /// Returns all regions that are known to outlive `r_a`. For
+ /// example, in a function:
+ ///
+ /// ```
+ /// fn foo<'a, 'b: 'a, 'c: 'b>() { .. }
+ /// ```
+ ///
+ /// if `r_a` represents `'a`, this function would return `{'b, 'c}`.
+ pub fn regions_that_outlive<'a, 'gcx>(&self, r_a: Region<'tcx>) -> Vec<&Region<'tcx>> {
+ assert!(is_free(r_a));
+ self.relation.greater_than(&r_a)
+ }
}
fn is_free(r: Region) -> bool {
CharImplItem, "char", char_impl;
StrImplItem, "str", str_impl;
SliceImplItem, "slice", slice_impl;
+ SliceU8ImplItem, "slice_u8", slice_u8_impl;
ConstPtrImplItem, "const_ptr", const_ptr_impl;
MutPtrImplItem, "mut_ptr", mut_ptr_impl;
I8ImplItem, "i8", i8_impl;
use std::fmt;
use std::rc::Rc;
-use util::nodemap::ItemLocalMap;
+use util::nodemap::ItemLocalSet;
#[derive(Clone, PartialEq)]
pub enum Categorization<'tcx> {
pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
pub region_scope_tree: &'a region::ScopeTree,
pub tables: &'a ty::TypeckTables<'tcx>,
- rvalue_promotable_map: Option<Rc<ItemLocalMap<bool>>>,
+ rvalue_promotable_map: Option<Rc<ItemLocalSet>>,
infcx: Option<&'a InferCtxt<'a, 'gcx, 'tcx>>,
}
pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>,
region_scope_tree: &'a region::ScopeTree,
tables: &'a ty::TypeckTables<'tcx>,
- rvalue_promotable_map: Option<Rc<ItemLocalMap<bool>>>)
+ rvalue_promotable_map: Option<Rc<ItemLocalSet>>)
-> MemCategorizationContext<'a, 'tcx, 'tcx> {
MemCategorizationContext {
tcx,
expr_ty: Ty<'tcx>)
-> cmt<'tcx> {
let hir_id = self.tcx.hir.node_to_hir_id(id);
- let promotable = self.rvalue_promotable_map.as_ref().map(|m| m[&hir_id.local_id])
+ let promotable = self.rvalue_promotable_map.as_ref().map(|m| m.contains(&hir_id.local_id))
.unwrap_or(false);
// Always promote `[T; 0]` (even when e.g. borrowed mutably).
hir::ItemMod(..) | hir::ItemForeignMod(..) |
hir::ItemImpl(..) | hir::ItemTrait(..) |
hir::ItemStruct(..) | hir::ItemEnum(..) |
- hir::ItemUnion(..) | hir::ItemDefaultImpl(..) |
+ hir::ItemUnion(..) | hir::ItemAutoImpl(..) |
hir::ItemGlobalAsm(..) => {}
}
}
newtype_index!(FirstStatementIndex
{
- DEBUG_FORMAT = "{}",
- MAX = SCOPE_DATA_REMAINDER_MAX,
+ pub idx
+ MAX = SCOPE_DATA_REMAINDER_MAX
});
impl From<ScopeData> for Scope {
hir::ItemExternCrate(_) |
hir::ItemUse(..) |
hir::ItemMod(..) |
- hir::ItemDefaultImpl(..) |
+ hir::ItemAutoImpl(..) |
hir::ItemForeignMod(..) |
hir::ItemGlobalAsm(..) => {
// These sorts of items have no lifetime parameters at all.
hir::ItemEnum(_, ref generics) |
hir::ItemStruct(_, ref generics) |
hir::ItemUnion(_, ref generics) |
- hir::ItemTrait(_, ref generics, ..) |
+ hir::ItemTrait(_, _, ref generics, ..) |
hir::ItemImpl(_, _, _, ref generics, ..) => {
// These kinds of items have only early bound lifetime parameters.
let mut index = if let hir::ItemTrait(..) = item.node {
hir::ItemUnion(_, ref generics) |
hir::ItemEnum(_, ref generics) |
hir::ItemTy(_, ref generics) |
- hir::ItemTrait(_, ref generics, ..) => {
+ hir::ItemTrait(_, _, ref generics, ..) => {
let result = object_lifetime_defaults_for_item(hir_map, generics);
// Debugging aid.
index += 1; // Self comes first.
}
match parent.node {
- hir::ItemTrait(_, ref generics, ..) |
+ hir::ItemTrait(_, _, ref generics, ..) |
hir::ItemImpl(_, _, _, ref generics, ..) => {
index += (generics.lifetimes.len() + generics.ty_params.len()) as u32;
}
&map.object_lifetime_defaults[&id]
} else {
let cstore = self.cstore;
+ let sess = self.sess;
self.xcrate_object_lifetime_defaults.entry(def_id).or_insert_with(|| {
- cstore.item_generics_cloned_untracked(def_id).types.into_iter().map(|def| {
+ cstore.item_generics_cloned_untracked(def_id, sess)
+ .types
+ .into_iter()
+ .map(|def| {
def.object_lifetime_default
}).collect()
})
/// Indicates the end of the dropping of a generator
GeneratorDrop,
+
+ FalseEdges {
+ real_target: BasicBlock,
+ imaginary_targets: Vec<BasicBlock>
+ },
}
impl<'tcx> Terminator<'tcx> {
}
Assert { target, cleanup: Some(unwind), .. } => vec![target, unwind].into_cow(),
Assert { ref target, .. } => slice::ref_slice(target).into_cow(),
+ FalseEdges { ref real_target, ref imaginary_targets } => {
+ let mut s = vec![*real_target];
+ s.extend_from_slice(imaginary_targets);
+ s.into_cow()
+ }
}
}
vec![target]
}
Assert { ref mut target, cleanup: Some(ref mut unwind), .. } => vec![target, unwind],
- Assert { ref mut target, .. } => vec![target]
+ Assert { ref mut target, .. } => vec![target],
+ FalseEdges { ref mut real_target, ref mut imaginary_targets } => {
+ let mut s = vec![real_target];
+ s.extend(imaginary_targets.iter_mut());
+ s
+ }
}
}
}
}
write!(fmt, ")")
- }
+ },
+ FalseEdges { .. } => write!(fmt, "falseEdges")
}
}
}
Assert { cleanup: None, .. } => vec!["".into()],
Assert { .. } =>
- vec!["success".into_cow(), "unwind".into_cow()]
+ vec!["success".into_cow(), "unwind".into_cow()],
+ FalseEdges { ref imaginary_targets, .. } => {
+ let mut l = vec!["real".into()];
+ l.resize(imaginary_targets.len() + 1, "imaginary".into());
+ l
+ }
}
}
}
newtype_index!(Promoted { DEBUG_FORMAT = "promoted[{}]" });
+
#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
pub enum Literal<'tcx> {
Value {
Resume => Resume,
Return => Return,
Unreachable => Unreachable,
+ FalseEdges { real_target, ref imaginary_targets } =>
+ FalseEdges { real_target, imaginary_targets: imaginary_targets.clone() }
};
Terminator {
source_info: self.source_info,
Resume |
Return |
GeneratorDrop |
- Unreachable => false
+ Unreachable |
+ FalseEdges { .. } => false
}
}
}
fn visit_ty(&mut self,
ty: & $($mutability)* Ty<'tcx>,
- _: Lookup) {
+ _: TyContext) {
self.super_ty(ty);
}
}
fn visit_local_decl(&mut self,
+ local: Local,
local_decl: & $($mutability)* LocalDecl<'tcx>) {
- self.super_local_decl(local_decl);
+ self.super_local_decl(local, local_decl);
}
fn visit_local(&mut self,
self.visit_visibility_scope_data(scope);
}
- let lookup = Lookup::Src(SourceInfo {
+ let lookup = TyContext::SourceInfo(SourceInfo {
span: mir.span,
scope: ARGUMENT_VISIBILITY_SCOPE,
});
self.visit_ty(&$($mutability)* mir.return_ty, lookup);
- for local_decl in &$($mutability)* mir.local_decls {
- self.visit_local_decl(local_decl);
+ for local in mir.local_decls.indices() {
+ self.visit_local_decl(local, & $($mutability)* mir.local_decls[local]);
}
self.visit_span(&$($mutability)* mir.span);
for operand in lvalues {
self.visit_lvalue(& $($mutability)* operand.lval,
LvalueContext::Validate, location);
- self.visit_ty(& $($mutability)* operand.ty, Lookup::Loc(location));
+ self.visit_ty(& $($mutability)* operand.ty,
+ TyContext::Location(location));
}
}
StatementKind::SetDiscriminant{ ref $($mutability)* lvalue, .. } => {
ref values,
ref targets } => {
self.visit_operand(discr, source_location);
- self.visit_ty(switch_ty, Lookup::Loc(source_location));
+ self.visit_ty(switch_ty, TyContext::Location(source_location));
for value in &values[..] {
self.visit_const_int(value, source_location);
}
self.visit_operand(value, source_location);
self.visit_branch(block, resume);
drop.map(|t| self.visit_branch(block, t));
+
}
+ TerminatorKind::FalseEdges { real_target, ref imaginary_targets } => {
+ self.visit_branch(block, real_target);
+ for target in imaginary_targets {
+ self.visit_branch(block, *target);
+ }
+ }
}
}
ref $($mutability)* operand,
ref $($mutability)* ty) => {
self.visit_operand(operand, location);
- self.visit_ty(ty, Lookup::Loc(location));
+ self.visit_ty(ty, TyContext::Location(location));
}
Rvalue::BinaryOp(_bin_op,
}
Rvalue::NullaryOp(_op, ref $($mutability)* ty) => {
- self.visit_ty(ty, Lookup::Loc(location));
+ self.visit_ty(ty, TyContext::Location(location));
}
Rvalue::Aggregate(ref $($mutability)* kind,
let kind = &$($mutability)* **kind;
match *kind {
AggregateKind::Array(ref $($mutability)* ty) => {
- self.visit_ty(ty, Lookup::Loc(location));
+ self.visit_ty(ty, TyContext::Location(location));
}
AggregateKind::Tuple => {
}
ref $($mutability)* ty,
} = *static_;
self.visit_def_id(def_id, location);
- self.visit_ty(ty, Lookup::Loc(location));
+ self.visit_ty(ty, TyContext::Location(location));
}
fn super_projection(&mut self,
ProjectionElem::Subslice { from: _, to: _ } => {
}
ProjectionElem::Field(_field, ref $($mutability)* ty) => {
- self.visit_ty(ty, Lookup::Loc(location));
+ self.visit_ty(ty, TyContext::Location(location));
}
ProjectionElem::Index(ref $($mutability)* local) => {
self.visit_local(local, LvalueContext::Consume, location);
}
fn super_local_decl(&mut self,
+ local: Local,
local_decl: & $($mutability)* LocalDecl<'tcx>) {
let LocalDecl {
mutability: _,
is_user_variable: _,
} = *local_decl;
- self.visit_ty(ty, Lookup::Src(*source_info));
+ self.visit_ty(ty, TyContext::LocalDecl {
+ local,
+ source_info: *source_info,
+ });
self.visit_source_info(source_info);
self.visit_visibility_scope(lexical_scope);
}
} = *constant;
self.visit_span(span);
- self.visit_ty(ty, Lookup::Loc(location));
+ self.visit_ty(ty, TyContext::Location(location));
self.visit_literal(literal, location);
}
make_mir_visitor!(Visitor,);
make_mir_visitor!(MutVisitor,mut);
+/// Extra information passed to `visit_ty` and friends to give context
+/// about where the type etc appears.
#[derive(Copy, Clone, Debug)]
-pub enum Lookup {
- Loc(Location),
- Src(SourceInfo),
+pub enum TyContext {
+ LocalDecl {
+ /// The index of the local variable we are visiting.
+ local: Local,
+
+ /// The source location where this local variable was declared.
+ source_info: SourceInfo,
+ },
+
+ Location(Location),
+
+ SourceInfo(SourceInfo),
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
}
}
+ fn from_shorthand(shorthand: &str) -> Option<Self> {
+ Some(match shorthand {
+ "asm" => OutputType::Assembly,
+ "llvm-ir" => OutputType::LlvmAssembly,
+ "mir" => OutputType::Mir,
+ "llvm-bc" => OutputType::Bitcode,
+ "obj" => OutputType::Object,
+ "metadata" => OutputType::Metadata,
+ "link" => OutputType::Exe,
+ "dep-info" => OutputType::DepInfo,
+ _ => return None,
+ })
+ }
+
+ fn shorthands_display() -> String {
+ format!(
+ "`{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`",
+ OutputType::Bitcode.shorthand(),
+ OutputType::Assembly.shorthand(),
+ OutputType::LlvmAssembly.shorthand(),
+ OutputType::Mir.shorthand(),
+ OutputType::Object.shorthand(),
+ OutputType::Metadata.shorthand(),
+ OutputType::Exe.shorthand(),
+ OutputType::DepInfo.shorthand(),
+ )
+ }
+
pub fn extension(&self) -> &'static str {
match *self {
OutputType::Bitcode => "bc",
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ErrorOutputType {
HumanReadable(ColorConfig),
- Json,
+ Json(bool),
Short(ColorConfig),
}
TargetFeatures,
RelocationModels,
CodeModels,
+ TlsModels,
TargetSpec,
NativeStaticLibs,
}
outputs
});
-pub const RUST_CGU_EXT: &str = "rust-cgu";
+pub const RUST_CGU_EXT: &str = "rcgu";
impl OutputFilenames {
pub fn path(&self, flavor: OutputType) -> PathBuf {
"print high-level information about incremental reuse (or the lack thereof)"),
incremental_dump_hash: bool = (false, parse_bool, [UNTRACKED],
"dump hash information in textual format to stdout"),
+ incremental_verify_ich: bool = (false, parse_bool, [UNTRACKED],
+ "verify incr. comp. hashes of green query instances"),
dump_dep_graph: bool = (false, parse_bool, [UNTRACKED],
"dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv)"),
query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
"enable ThinLTO when possible"),
inline_in_all_cgus: Option<bool> = (None, parse_opt_bool, [TRACKED],
"control whether #[inline] functions are in all cgus"),
+ tls_model: Option<String> = (None, parse_opt_string, [TRACKED],
+ "choose the TLS model to use (rustc --print tls-models for details)"),
+ saturating_float_casts: bool = (false, parse_bool, [TRACKED],
+ "make casts between integers and floats safe: clip out-of-range inputs to the min/max \
+ integer or to infinity respectively, and turn `NAN` into 0 when casting to integers"),
}
pub fn default_lib_output() -> CrateType {
print on stdout",
"[crate-name|file-names|sysroot|cfg|target-list|\
target-cpus|target-features|relocation-models|\
- code-models|target-spec-json|native-static-libs]"),
+ code-models|tls-models|target-spec-json|native-static-libs]"),
opt::flagmulti_s("g", "", "Equivalent to -C debuginfo=2"),
opt::flagmulti_s("O", "", "Equivalent to -C opt-level=2"),
opt::opt_s("o", "", "Write output to <filename>", "FILENAME"),
let error_format = if matches.opts_present(&["error-format".to_owned()]) {
match matches.opt_str("error-format").as_ref().map(|s| &s[..]) {
Some("human") => ErrorOutputType::HumanReadable(color),
- Some("json") => ErrorOutputType::Json,
+ Some("json") => ErrorOutputType::Json(false),
+ Some("pretty-json") => ErrorOutputType::Json(true),
Some("short") => ErrorOutputType::Short(color),
None => ErrorOutputType::HumanReadable(color),
})
});
- let debugging_opts = build_debugging_options(matches, error_format);
+ let mut debugging_opts = build_debugging_options(matches, error_format);
+
+ if !debugging_opts.unstable_options && error_format == ErrorOutputType::Json(true) {
+ early_error(ErrorOutputType::Json(false),
+ "--error-format=pretty-json is unstable");
+ }
let mut output_types = BTreeMap::new();
if !debugging_opts.parse_only {
for list in matches.opt_strs("emit") {
for output_type in list.split(',') {
let mut parts = output_type.splitn(2, '=');
- let output_type = match parts.next().unwrap() {
- "asm" => OutputType::Assembly,
- "llvm-ir" => OutputType::LlvmAssembly,
- "mir" => OutputType::Mir,
- "llvm-bc" => OutputType::Bitcode,
- "obj" => OutputType::Object,
- "metadata" => OutputType::Metadata,
- "link" => OutputType::Exe,
- "dep-info" => OutputType::DepInfo,
- part => {
- early_error(error_format, &format!("unknown emission type: `{}`",
- part))
- }
+ let shorthand = parts.next().unwrap();
+ let output_type = match OutputType::from_shorthand(shorthand) {
+ Some(output_type) => output_type,
+ None => early_error(error_format, &format!(
+ "unknown emission type: `{}` - expected one of: {}",
+ shorthand, OutputType::shorthands_display(),
+ )),
};
let path = parts.next().map(PathBuf::from);
output_types.insert(output_type, path);
prints.push(PrintRequest::CodeModels);
cg.code_model = None;
}
+ if debugging_opts.tls_model.as_ref().map_or(false, |s| s == "help") {
+ prints.push(PrintRequest::TlsModels);
+ debugging_opts.tls_model = None;
+ }
let cg = cg;
"target-features" => PrintRequest::TargetFeatures,
"relocation-models" => PrintRequest::RelocationModels,
"code-models" => PrintRequest::CodeModels,
+ "tls-models" => PrintRequest::TlsModels,
"native-static-libs" => PrintRequest::NativeStaticLibs,
"target-spec-json" => {
if nightly_options::is_unstable_enabled(matches) {
let mut v5 = super::basic_options();
// Reference
- v1.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v1.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v1.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v1.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v1.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
+ v1.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
// Native changed
- v2.search_paths.add_path("native=XXX", super::ErrorOutputType::Json);
- v2.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
+ v2.search_paths.add_path("native=XXX", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
// Crate changed
- v2.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v2.search_paths.add_path("crate=XXX", super::ErrorOutputType::Json);
- v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
+ v2.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("crate=XXX", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
// Dependency changed
- v3.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v3.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v3.search_paths.add_path("dependency=XXX", super::ErrorOutputType::Json);
- v3.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v3.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
+ v3.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("dependency=XXX", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
// Framework changed
- v4.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v4.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v4.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v4.search_paths.add_path("framework=XXX", super::ErrorOutputType::Json);
- v4.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
+ v4.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("framework=XXX", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
// All changed
- v5.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v5.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v5.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v5.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v5.search_paths.add_path("all=XXX", super::ErrorOutputType::Json);
+ v5.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v5.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v5.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v5.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v5.search_paths.add_path("all=XXX", super::ErrorOutputType::Json(false));
assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
let mut v4 = super::basic_options();
// Reference
- v1.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v1.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v1.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v1.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v1.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
-
- v2.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v2.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
-
- v3.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v3.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
- v3.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v3.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v3.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
-
- v4.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
- v4.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
- v4.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
- v4.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
- v4.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
+ v1.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v1.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
+
+ v2.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
+
+ v3.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v3.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
+
+ v4.search_paths.add_path("all=mno", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("native=abc", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("crate=def", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ v4.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json(false));
assert!(v1.dep_tracking_hash() == v2.dep_tracking_hash());
assert!(v1.dep_tracking_hash() == v3.dep_tracking_hash());
opts.cg.code_model = Some(String::from("code model"));
assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
+ opts = reference.clone();
+ opts.debugging_opts.tls_model = Some(String::from("tls model"));
+ assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
+
opts = reference.clone();
opts.cg.metadata = vec![String::from("A"), String::from("B")];
assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
match self.opts.error_format {
// when outputting JSON for tool consumption, the tool might want
// the duplicates
- config::ErrorOutputType::Json => {
+ config::ErrorOutputType::Json(_) => {
do_method()
},
_ => {
(config::ErrorOutputType::HumanReadable(_), Some(dst)) => {
Box::new(EmitterWriter::new(dst, Some(codemap.clone()), false))
}
- (config::ErrorOutputType::Json, None) => {
- Box::new(JsonEmitter::stderr(Some(registry), codemap.clone()))
+ (config::ErrorOutputType::Json(pretty), None) => {
+ Box::new(JsonEmitter::stderr(Some(registry), codemap.clone(), pretty))
}
- (config::ErrorOutputType::Json, Some(dst)) => {
- Box::new(JsonEmitter::new(dst, Some(registry), codemap.clone()))
+ (config::ErrorOutputType::Json(pretty), Some(dst)) => {
+ Box::new(JsonEmitter::new(dst, Some(registry), codemap.clone(), pretty))
}
(config::ErrorOutputType::Short(color_config), None) => {
Box::new(EmitterWriter::stderr(color_config, Some(codemap.clone()), true))
config::ErrorOutputType::HumanReadable(color_config) => {
Box::new(EmitterWriter::stderr(color_config, None, false))
}
- config::ErrorOutputType::Json => Box::new(JsonEmitter::basic()),
+ config::ErrorOutputType::Json(pretty) => Box::new(JsonEmitter::basic(pretty)),
config::ErrorOutputType::Short(color_config) => {
Box::new(EmitterWriter::stderr(color_config, None, true))
}
config::ErrorOutputType::HumanReadable(color_config) => {
Box::new(EmitterWriter::stderr(color_config, None, false))
}
- config::ErrorOutputType::Json => Box::new(JsonEmitter::basic()),
+ config::ErrorOutputType::Json(pretty) => Box::new(JsonEmitter::basic(pretty)),
config::ErrorOutputType::Short(color_config) => {
Box::new(EmitterWriter::stderr(color_config, None, true))
}
/// Vtable identifying a particular impl.
VtableImpl(VtableImplData<'tcx, N>),
- /// Vtable for default trait implementations
+ /// Vtable for auto trait implementations
/// This carries the information and nested obligations with regards
- /// to a default implementation for a trait `Trait`. The nested obligations
+ /// to an auto implementation for a trait `Trait`. The nested obligations
/// ensure the trait implementation holds for all the constituent types.
- VtableDefaultImpl(VtableDefaultImplData<N>),
+ VtableAutoImpl(VtableAutoImplData<N>),
/// Successful resolution to an obligation provided by the caller
/// for some type parameter. The `Vec<N>` represents the
}
#[derive(Clone)]
-pub struct VtableDefaultImplData<N> {
+pub struct VtableAutoImplData<N> {
pub trait_def_id: DefId,
pub nested: Vec<N>
}
VtableImpl(i) => i.nested,
VtableParam(n) => n,
VtableBuiltin(i) => i.nested,
- VtableDefaultImpl(d) => d.nested,
+ VtableAutoImpl(d) => d.nested,
VtableClosure(c) => c.nested,
VtableGenerator(c) => c.nested,
VtableObject(d) => d.nested,
&mut VtableImpl(ref mut i) => &mut i.nested,
&mut VtableParam(ref mut n) => n,
&mut VtableBuiltin(ref mut i) => &mut i.nested,
- &mut VtableDefaultImpl(ref mut d) => &mut d.nested,
+ &mut VtableAutoImpl(ref mut d) => &mut d.nested,
&mut VtableGenerator(ref mut c) => &mut c.nested,
&mut VtableClosure(ref mut c) => &mut c.nested,
&mut VtableObject(ref mut d) => &mut d.nested,
vtable_base: o.vtable_base,
nested: o.nested.into_iter().map(f).collect(),
}),
- VtableDefaultImpl(d) => VtableDefaultImpl(VtableDefaultImplData {
+ VtableAutoImpl(d) => VtableAutoImpl(VtableAutoImplData {
trait_def_id: d.trait_def_id,
nested: d.nested.into_iter().map(f).collect(),
}),
// projection. And the projection where clause is handled
// in `assemble_candidates_from_param_env`.
}
- super::VtableDefaultImpl(..) |
+ super::VtableAutoImpl(..) |
super::VtableBuiltin(..) => {
// These traits have no associated types.
span_bug!(
confirm_fn_pointer_candidate(selcx, obligation, data),
super::VtableObject(_) =>
confirm_object_candidate(selcx, obligation, obligation_trait_ref),
- super::VtableDefaultImpl(..) |
+ super::VtableAutoImpl(..) |
super::VtableParam(..) |
super::VtableBuiltin(..) =>
// we don't create Select candidates with this kind of resolution
use super::Selection;
use super::SelectionResult;
use super::{VtableBuiltin, VtableImpl, VtableParam, VtableClosure, VtableGenerator,
- VtableFnPointer, VtableObject, VtableDefaultImpl};
+ VtableFnPointer, VtableObject, VtableAutoImpl};
use super::{VtableImplData, VtableObjectData, VtableBuiltinData, VtableGeneratorData,
- VtableClosureData, VtableDefaultImplData, VtableFnPointerData};
+ VtableClosureData, VtableAutoImplData, VtableFnPointerData};
use super::util;
use dep_graph::{DepNodeIndex, DepKind};
BuiltinCandidate { has_nested: bool },
ParamCandidate(ty::PolyTraitRef<'tcx>),
ImplCandidate(DefId),
- DefaultImplCandidate(DefId),
+ AutoImplCandidate(DefId),
/// This is a trait matching with a projected type as `Self`, and
/// we found an applicable bound in the trait definition.
}
}
ImplCandidate(def_id) => ImplCandidate(def_id),
- DefaultImplCandidate(def_id) => DefaultImplCandidate(def_id),
+ AutoImplCandidate(def_id) => AutoImplCandidate(def_id),
ProjectionCandidate => ProjectionCandidate,
FnPointerCandidate => FnPointerCandidate,
ObjectCandidate => ObjectCandidate,
fn coinductive_predicate(&self, predicate: ty::Predicate<'tcx>) -> bool {
let result = match predicate {
ty::Predicate::Trait(ref data) => {
- self.tcx().trait_has_default_impl(data.def_id())
+ self.tcx().trait_is_auto(data.def_id())
}
_ => {
false
self.assemble_candidates_from_projected_tys(obligation, &mut candidates);
self.assemble_candidates_from_caller_bounds(stack, &mut candidates)?;
- // Default implementations have lower priority, so we only
+ // Auto implementations have lower priority, so we only
// consider triggering a default if there is no other impl that can apply.
if candidates.vec.is_empty() {
- self.assemble_candidates_from_default_impls(obligation, &mut candidates)?;
+ self.assemble_candidates_from_auto_impls(obligation, &mut candidates)?;
}
debug!("candidate list size: {}", candidates.vec.len());
Ok(candidates)
Ok(())
}
- fn assemble_candidates_from_default_impls(&mut self,
+ fn assemble_candidates_from_auto_impls(&mut self,
obligation: &TraitObligation<'tcx>,
candidates: &mut SelectionCandidateSet<'tcx>)
-> Result<(), SelectionError<'tcx>>
{
// OK to skip binder here because the tests we do below do not involve bound regions
let self_ty = *obligation.self_ty().skip_binder();
- debug!("assemble_candidates_from_default_impls(self_ty={:?})", self_ty);
+ debug!("assemble_candidates_from_auto_impls(self_ty={:?})", self_ty);
let def_id = obligation.predicate.def_id();
- if self.tcx().trait_has_default_impl(def_id) {
+ if self.tcx().trait_is_auto(def_id) {
match self_ty.sty {
ty::TyDynamic(..) => {
// For object types, we don't know what the closed
// this path.
}
ty::TyInfer(ty::TyVar(_)) => {
- // the defaulted impl might apply, we don't know
+ // the auto impl might apply, we don't know
candidates.ambiguous = true;
}
_ => {
- candidates.vec.push(DefaultImplCandidate(def_id.clone()))
+ candidates.vec.push(AutoImplCandidate(def_id.clone()))
}
}
}
match other.candidate {
ObjectCandidate |
ParamCandidate(_) | ProjectionCandidate => match victim.candidate {
- DefaultImplCandidate(..) => {
+ AutoImplCandidate(..) => {
bug!(
"default implementations shouldn't be recorded \
when there are other valid candidates");
Ok(VtableParam(obligations))
}
- DefaultImplCandidate(trait_def_id) => {
- let data = self.confirm_default_impl_candidate(obligation, trait_def_id);
- Ok(VtableDefaultImpl(data))
+ AutoImplCandidate(trait_def_id) => {
+ let data = self.confirm_auto_impl_candidate(obligation, trait_def_id);
+ Ok(VtableAutoImpl(data))
}
ImplCandidate(impl_def_id) => {
///
/// 1. For each constituent type `Y` in `X`, `Y : Foo` holds
/// 2. For each where-clause `C` declared on `Foo`, `[Self => X] C` holds.
- fn confirm_default_impl_candidate(&mut self,
+ fn confirm_auto_impl_candidate(&mut self,
obligation: &TraitObligation<'tcx>,
trait_def_id: DefId)
- -> Vtable
DefaultImplData<PredicateObligation<'tcx>>
+ -> Vtable
AutoImplData<PredicateObligation<'tcx>>
{
- debug!("confirm_default_impl_candidate({:?}, {:?})",
+ debug!("confirm_auto_impl_candidate({:?}, {:?})",
obligation,
trait_def_id);
// binder is moved below
let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
let types = self.constituent_types_for_ty(self_ty);
- self.vtable_default_impl(obligation, trait_def_id, ty::Binder(types))
+ self.vtable_auto_impl(obligation, trait_def_id, ty::Binder(types))
}
- /// See `confirm_default_impl_candidate`
- fn vtable_default_impl(&mut self,
+ /// See `confirm_auto_impl_candidate`
+ fn vtable_auto_impl(&mut self,
obligation: &TraitObligation<'tcx>,
trait_def_id: DefId,
nested: ty::Binder<Vec<Ty<'tcx>>>)
- -> Vtable
DefaultImplData<PredicateObligation<'tcx>>
+ -> Vtable
AutoImplData<PredicateObligation<'tcx>>
{
- debug!("vtable_default_impl: nested={:?}", nested);
+ debug!("vtable_auto_impl: nested={:?}", nested);
let cause = obligation.derived_cause(BuiltinDerivedObligation);
let mut obligations = self.collect_predicates_for_types(
obligations.extend(trait_obligations);
- debug!("vtable_default_impl: obligations={:?}", obligations);
+ debug!("vtable_auto_impl: obligations={:?}", obligations);
- VtableDefaultImplData {
+ VtableAutoImplData {
trait_def_id,
nested: obligations
}
super::VtableImpl(ref v) =>
write!(f, "{:?}", v),
- super::VtableDefaultImpl(ref t) =>
+ super::VtableAutoImpl(ref t) =>
write!(f, "{:?}", t),
super::VtableClosure(ref d) =>
}
}
-impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableDefaultImplData<N> {
+impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableAutoImplData<N> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "VtableDefaultImplData(trait_def_id={:?}, nested={:?})",
+ write!(f, "VtableAutoImplData(trait_def_id={:?}, nested={:?})",
self.trait_def_id,
self.nested)
}
})
})
}
- traits::VtableDefaultImpl(t) => Some(traits::VtableDefaultImpl(t)),
+ traits::VtableAutoImpl(t) => Some(traits::VtableAutoImpl(t)),
traits::VtableGenerator(traits::VtableGeneratorData {
closure_def_id,
substs,
}
}
-impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableDefaultImplData<N> {
+impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableAutoImplData<N> {
fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
- traits::VtableDefaultImplData {
+ traits::VtableAutoImplData {
trait_def_id: self.trait_def_id,
nested: self.nested.fold_with(folder),
}
fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
match *self {
traits::VtableImpl(ref v) => traits::VtableImpl(v.fold_with(folder)),
- traits::VtableDefaultImpl(ref t) => traits::VtableDefaultImpl(t.fold_with(folder)),
+ traits::VtableAutoImpl(ref t) => traits::VtableAutoImpl(t.fold_with(folder)),
traits::VtableGenerator(ref d) => {
traits::VtableGenerator(d.fold_with(folder))
}
fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
match *self {
traits::VtableImpl(ref v) => v.visit_with(visitor),
- traits::VtableDefaultImpl(ref t) => t.visit_with(visitor),
+ traits::VtableAutoImpl(ref t) => t.visit_with(visitor),
traits::VtableGenerator(ref d) => d.visit_with(visitor),
traits::VtableClosure(ref d) => d.visit_with(visitor),
traits::VtableFnPointer(ref d) => d.visit_with(visitor),
let substituted = self.erase_regions(&substituted);
AssociatedTypeNormalizer::new(self).fold(&substituted)
}
+
+ pub fn trans_apply_param_substs_env<T>(
+ self,
+ param_substs: &Substs<'tcx>,
+ param_env: ty::ParamEnv<'tcx>,
+ value: &T,
+ ) -> T
+ where
+ T: TransNormalize<'tcx>,
+ {
+ debug!(
+ "apply_param_substs_env(param_substs={:?}, value={:?}, param_env={:?})",
+ param_substs,
+ value,
+ param_env,
+ );
+ let substituted = value.subst(self, param_substs);
+ let substituted = self.erase_regions(&substituted);
+ AssociatedTypeNormalizerEnv::new(self, param_env).fold(&substituted)
+ }
}
struct AssociatedTypeNormalizer<'a, 'gcx: 'a> {
}
}
+struct AssociatedTypeNormalizerEnv<'a, 'gcx: 'a> {
+ tcx: TyCtxt<'a, 'gcx, 'gcx>,
+ param_env: ty::ParamEnv<'gcx>,
+}
+
+impl<'a, 'gcx> AssociatedTypeNormalizerEnv<'a, 'gcx> {
+ fn new(tcx: TyCtxt<'a, 'gcx, 'gcx>, param_env: ty::ParamEnv<'gcx>) -> Self {
+ Self { tcx, param_env }
+ }
+
+ fn fold<T: TypeFoldable<'gcx>>(&mut self, value: &T) -> T {
+ if !value.has_projections() {
+ value.clone()
+ } else {
+ value.fold_with(self)
+ }
+ }
+}
+
+impl<'a, 'gcx> TypeFolder<'gcx, 'gcx> for AssociatedTypeNormalizerEnv<'a, 'gcx> {
+ fn tcx<'c>(&'c self) -> TyCtxt<'c, 'gcx, 'gcx> {
+ self.tcx
+ }
+
+ fn fold_ty(&mut self, ty: Ty<'gcx>) -> Ty<'gcx> {
+ if !ty.has_projections() {
+ ty
+ } else {
+ debug!("AssociatedTypeNormalizerEnv: ty={:?}", ty);
+ self.tcx.normalize_associated_type_in_env(&ty, self.param_env)
+ }
+ }
+}
+
// Implement DepTrackingMapConfig for `trait_cache`
pub struct TraitSelectionCache<'tcx> {
data: PhantomData<&'tcx ()>
resolve_associated_item(tcx, &item, param_env, trait_def_id, substs)
} else {
let ty = tcx.type_of(def_id);
- let item_type = tcx.trans_apply_param_substs(substs, &ty);
+ let item_type = tcx.trans_apply_param_substs_env(substs, param_env, &ty);
let def = match item_type.sty {
ty::TyFnDef(..) if {
None
}
}
- traits::VtableDefaultImpl(..) | traits::VtableParam(..) => None
+ traits::VtableAutoImpl(..) | traits::VtableParam(..) => None
}
}
// Always use types for non-local impls, where types are always
// available, and filename/line-number is mostly uninteresting.
- let use_types = !self.is_default_impl(impl_def_id) && (!impl_def_id.is_local() || {
+ let use_types = !self.is_auto_impl(impl_def_id) && (!impl_def_id.is_local() || {
// Otherwise, use filename/line-number if forced.
let force_no_types = FORCE_IMPL_FILENAME_LINE.with(|f| f.get());
!force_no_types
use ty::layout::{Layout, LayoutError};
use ty::steal::Steal;
use ty::subst::Substs;
-use util::nodemap::{DefIdSet, DefIdMap, ItemLocalMap};
+use util::nodemap::{DefIdSet, DefIdMap, ItemLocalSet};
use util::common::{profq_msg, ProfileQueriesMsg};
use rustc_data_structures::indexed_set::IdxSetBuf;
/// True if this is a foreign item (i.e., linked via `extern { ... }`).
[] fn is_foreign_item: IsForeignItem(DefId) -> bool,
- /// True if this is a default impl (aka impl Foo for ..)
- [] fn is_default_impl: IsDefaultImpl(DefId) -> bool,
+ /// True if this is an auto impl (aka impl Foo for ..)
+ [] fn is_auto_impl: IsAutoImpl(DefId) -> bool,
/// Get a map with the variance of every item; use `item_variance`
/// instead.
[] fn is_exported_symbol: IsExportedSymbol(DefId) -> bool,
[] fn item_body_nested_bodies: ItemBodyNestedBodies(DefId) -> ExternBodyNestedBodies,
[] fn const_is_rvalue_promotable_to_static: ConstIsRvaluePromotableToStatic(DefId) -> bool,
- [] fn rvalue_promotable_map: RvaluePromotableMap(DefId) -> Rc<ItemLocalMap<bool>>,
+ [] fn rvalue_promotable_map: RvaluePromotableMap(DefId) -> Rc<ItemLocalSet>,
[] fn is_mir_available: IsMirAvailable(DefId) -> bool,
[] fn vtable_methods: vtable_methods_node(ty::PolyTraitRef<'tcx>)
-> Rc<Vec<Option<(DefId, &'tcx Substs<'tcx>)>>>,
return Self::load_from_disk_and_cache_in_memory(tcx,
key,
span,
- dep_node_index)
+ dep_node_index,
+ &dep_node)
}
}
fn load_from_disk_and_cache_in_memory(tcx: TyCtxt<'a, $tcx, 'lcx>,
key: $K,
span: Span,
- dep_node_index: DepNodeIndex)
+ dep_node_index: DepNodeIndex,
+ dep_node: &DepNode)
-> Result<$V, CycleError<'a, $tcx>>
{
debug_assert!(tcx.dep_graph.is_green(dep_node_index));
})
})?;
+ // If -Zincremental-verify-ich is specified, re-hash results from
+ // the cache and make sure that they have the expected fingerprint.
+ if tcx.sess.opts.debugging_opts.incremental_verify_ich {
+ use rustc_data_structures::stable_hasher::{StableHasher, HashStable};
+ use ich::Fingerprint;
+
+ assert!(Some(tcx.dep_graph.fingerprint_of(dep_node)) ==
+ tcx.dep_graph.prev_fingerprint_of(dep_node),
+ "Fingerprint for green query instance not loaded \
+ from cache: {:?}", dep_node);
+
+ debug!("BEGIN verify_ich({:?})", dep_node);
+ let mut hcx = tcx.create_stable_hashing_context();
+ let mut hasher = StableHasher::new();
+
+ result.hash_stable(&mut hcx, &mut hasher);
+
+ let new_hash: Fingerprint = hasher.finish();
+ debug!("END verify_ich({:?})", dep_node);
+
+ let old_hash = tcx.dep_graph.fingerprint_of(dep_node);
+
+ assert!(new_hash == old_hash, "Found unstable fingerprints \
+ for {:?}", dep_node);
+ }
+
if tcx.sess.opts.debugging_opts.query_dep_graph {
tcx.dep_graph.mark_loaded_from_cache(dep_node_index, true);
}
DepKind::EraseRegionsTy |
DepKind::NormalizeTy |
- // These are just odd
- DepKind::Null |
- DepKind::WorkProduct => {
+ // This one should never occur in this context
+ DepKind::Null => {
bug!("force_from_dep_node() - Encountered {:?}", dep_node.kind)
}
DepKind::SuperPredicatesOfItem => { force!(super_predicates_of, def_id!()); }
DepKind::TraitDefOfItem => { force!(trait_def, def_id!()); }
DepKind::AdtDefOfItem => { force!(adt_def, def_id!()); }
- DepKind::IsDefaultImpl => { force!(is_default_impl, def_id!()); }
+ DepKind::IsAutoImpl => { force!(is_auto_impl, def_id!()); }
DepKind::ImplTraitRef => { force!(impl_trait_ref, def_id!()); }
DepKind::ImplPolarity => { force!(impl_polarity, def_id!()); }
DepKind::ClosureKind => { force!(closure_kind, def_id!()); }
const IS_FUNDAMENTAL = 1 << 2;
const IS_UNION = 1 << 3;
const IS_BOX = 1 << 4;
+ /// Indicates whether this abstract data type will be expanded on in future (new
+ /// fields/variants) and as such, whether downstream crates must match exhaustively on the
+ /// fields/variants of this data type.
+ ///
+ /// See RFC 2008 (https://github.com/rust-lang/rfcs/pull/2008).
+ const IS_NON_EXHAUSTIVE = 1 << 5;
}
}
if Some(did) == tcx.lang_items().owned_box() {
flags = flags | AdtFlags::IS_BOX;
}
+ if tcx.has_attr(did, "non_exhaustive") {
+ flags = flags | AdtFlags::IS_NON_EXHAUSTIVE;
+ }
match kind {
AdtKind::Enum => flags = flags | AdtFlags::IS_ENUM,
AdtKind::Union => flags = flags | AdtFlags::IS_UNION,
self.flags.intersects(AdtFlags::IS_ENUM)
}
+ #[inline]
+ pub fn is_non_exhaustive(&self) -> bool {
+ self.flags.intersects(AdtFlags::IS_NON_EXHAUSTIVE)
+ }
+
/// Returns the kind of the ADT - Struct or Enum.
#[inline]
pub fn adt_kind(&self) -> AdtKind {
self.get_attrs(did).iter().any(|item| item.check_name(attr))
}
- pub fn trait_has_default_impl(self, trait_def_id: DefId) -> bool {
- self.trait_def(trait_def_id).has_default_impl
+ /// Returns true if this is an `auto trait`.
+ ///
+ /// NB. For a limited time, also returns true if `impl Trait for .. { }` is in the code-base.
+ pub fn trait_is_auto(self, trait_def_id: DefId) -> bool {
+ self.trait_def(trait_def_id).has_auto_impl
}
pub fn generator_layout(self, def_id: DefId) -> &'tcx GeneratorLayout<'tcx> {
/// be usable with the sugar (or without it).
pub paren_sugar: bool,
- pub has_default_impl: bool,
+ pub has_auto_impl: bool,
/// The ICH of this trait's DefPath, cached here so it doesn't have to be
/// recomputed all the time.
pub fn new(def_id: DefId,
unsafety: hir::Unsafety,
paren_sugar: bool,
- has_default_impl: bool,
+ has_auto_impl: bool,
def_path_hash: DefPathHash)
-> TraitDef {
TraitDef {
def_id,
paren_sugar,
unsafety,
- has_default_impl,
+ has_auto_impl,
def_path_hash,
}
}
pub type NodeSet = FxHashSet<ast::NodeId>;
pub type DefIdSet = FxHashSet<DefId>;
+pub type ItemLocalSet = FxHashSet<ItemLocalId>;
pub fn NodeMap<T>() -> NodeMap<T> { FxHashMap() }
pub fn DefIdMap<T>() -> DefIdMap<T> { FxHashMap() }
pub fn ItemLocalMap<T>() -> ItemLocalMap<T> { FxHashMap() }
pub fn NodeSet() -> NodeSet { FxHashSet() }
pub fn DefIdSet() -> DefIdSet { FxHashSet() }
+pub fn ItemLocalSet() -> ItemLocalSet { FxHashSet() }
let no_mangle = Symbol::intern("no_mangle");
let no_mangle = self.cx.meta_word(self.span, no_mangle);
+
+ let special = Symbol::intern("rustc_std_internal_symbol");
+ let special = self.cx.meta_word(self.span, special);
vec![
self.cx.attribute(self.span, linkage),
self.cx.attribute(self.span, no_mangle),
+ self.cx.attribute(self.span, special),
]
}
}
impl<T> StatusAnd<T> {
- fn map<F: FnOnce(T) -> U, U>(self, f: F) -> StatusAnd<U> {
+ pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> StatusAnd<U> {
StatusAnd {
status: self.status,
value: f(self.value),
fn from_bits(input: u128) -> Self;
fn from_i128_r(input: i128, round: Round) -> StatusAnd<Self> {
if input < 0 {
- Self::from_u128_r(-input as u128, -round).map(|r| -r)
+ Self::from_u128_r(input.wrapping_neg() as u128, -round).map(|r| -r)
} else {
Self::from_u128_r(input as u128, round)
}
pub relocation_model: String,
/// Code model to use. Corresponds to `llc -code-model=$code_model`. Defaults to "default".
pub code_model: String,
+ /// TLS model to use. Options are "global-dynamic" (default), "local-dynamic", "initial-exec"
+ /// and "local-exec". This is similar to the -ftls-model option in GCC/Clang.
+ pub tls_model: String,
/// Do not emit code that uses the "red zone", if the ABI has one. Defaults to false.
pub disable_redzone: bool,
/// Eliminate frame pointers from stack frames if possible. Defaults to true.
executables: false,
relocation_model: "pic".to_string(),
code_model: "default".to_string(),
+ tls_model: "global-dynamic".to_string(),
disable_redzone: false,
eliminate_frame_pointer: true,
function_sections: true,
key!(executables, bool);
key!(relocation_model);
key!(code_model);
+ key!(tls_model);
key!(disable_redzone, bool);
key!(eliminate_frame_pointer, bool);
key!(function_sections, bool);
target_option_val!(executables);
target_option_val!(relocation_model);
target_option_val!(code_model);
+ target_option_val!(tls_model);
target_option_val!(disable_redzone);
target_option_val!(eliminate_frame_pointer);
target_option_val!(function_sections);
}
}
+ fn is_non_exhaustive_enum(&self, ty: Ty<'tcx>) -> bool {
+ match ty.sty {
+ ty::TyAdt(adt_def, ..) => adt_def.is_enum() && adt_def.is_non_exhaustive(),
+ _ => false,
+ }
+ }
+
+ fn is_local(&self, ty: Ty<'tcx>) -> bool {
+ match ty.sty {
+ ty::TyAdt(adt_def, ..) => adt_def.did.is_local(),
+ _ => false,
+ }
+ }
+
fn is_variant_uninhabited(&self,
variant: &'tcx ty::VariantDef,
substs: &'tcx ty::subst::Substs<'tcx>)
let is_privately_empty =
all_ctors.is_empty() && !cx.is_uninhabited(pcx.ty);
- debug!("missing_ctors={:?} is_privately_empty={:?}", missing_ctors,
- is_privately_empty);
- if missing_ctors.is_empty() && !is_privately_empty {
+ let is_declared_nonexhaustive =
+ cx.is_non_exhaustive_enum(pcx.ty) && !cx.is_local(pcx.ty);
+ debug!("missing_ctors={:?} is_privately_empty={:?} is_declared_nonexhaustive={:?}",
+ missing_ctors, is_privately_empty, is_declared_nonexhaustive);
+
+ // For privately empty and non-exhaustive enums, we work as if there were an "extra"
+ // `_` constructor for the type, so we can never match over all constructors.
+ let is_non_exhaustive = is_privately_empty || is_declared_nonexhaustive;
+
+ if missing_ctors.is_empty() && !is_non_exhaustive {
all_ctors.into_iter().map(|c| {
is_useful_specialized(cx, matrix, v, c.clone(), pcx.ty, witness)
}).find(|result| result.is_useful()).unwrap_or(NotUseful)
match is_useful(cx, &matrix, &v[1..], witness) {
UsefulWithWitness(pats) => {
let cx = &*cx;
- let new_witnesses = if used_ctors.is_empty() {
+ // In this case, there's at least one "free"
+ // constructor that is only matched against by
+ // wildcard patterns.
+ //
+ // There are 2 ways we can report a witness here.
+ // Commonly, we can report all the "free"
+ // constructors as witnesses, e.g. if we have:
+ //
+ // ```
+ // enum Direction { N, S, E, W }
+ // let Direction::N = ...;
+ // ```
+ //
+ // we can report 3 witnesses: `S`, `E`, and `W`.
+ //
+ // However, there are 2 cases where we don't want
+ // to do this and instead report a single `_` witness:
+ //
+ // 1) If the user is matching against a non-exhaustive
+ // enum, there is no point in enumerating all possible
+ // variants, because the user can't actually match
+ // against them himself, e.g. in an example like:
+ // ```
+ // let err: io::ErrorKind = ...;
+ // match err {
+ // io::ErrorKind::NotFound => {},
+ // }
+ // ```
+ // we don't want to show every possible IO error,
+ // but instead have `_` as the witness (this is
+ // actually *required* if the user specified *all*
+ // IO errors, but is probably what we want in every
+ // case).
+ //
+ // 2) If the user didn't actually specify a constructor
+ // in this arm, e.g. in
+ // ```
+ // let x: (Direction, Direction, bool) = ...;
+ // let (_, _, false) = x;
+ // ```
+ // we don't want to show all 16 possible witnesses
+ // `(<direction-1>, <direction-2>, true)` - we are
+ // satisfied with `(_, _, true)`. In this case,
+ // `used_ctors` is empty.
+ let new_witnesses = if is_non_exhaustive || used_ctors.is_empty() {
// All constructors are unused. Add wild patterns
// rather than each individual constructor
pats.into_iter().map(|mut witness| {
ConstFloat { bits, ty: self.ty }
}
}
+
+/// This is `f32::MAX + (0.5 ULP)` as an integer. Numbers greater or equal to this
+/// are rounded to infinity when converted to `f32`.
+///
+/// NB: Computed as maximum significand with an extra 1 bit added (for the half ULP)
+/// shifted by the maximum exponent (accounting for normalization).
+pub const MAX_F32_PLUS_HALF_ULP: u128 = ((1 << (Single::PRECISION + 1)) - 1)
+ << (Single::MAX_EXP - Single::PRECISION as i16);
}
impl BitMatrix {
- // Create a new `rows x columns` matrix, initially empty.
+ /// Create a new `rows x columns` matrix, initially empty.
pub fn new(rows: usize, columns: usize) -> BitMatrix {
// For every element, we need one bit for every other
// element. Round up to an even number of u64s.
(start, start + u64s_per_row)
}
- pub fn add(&mut self, source: usize, target: usize) -> bool {
- let (start, _) = self.range(source);
- let (word, mask) = word_mask(target);
+ /// Sets the cell at `(row, column)` to true. Put another way, add
+ /// `column` to the bitset for `row`.
+ ///
+ /// Returns true if this changed the matrix, and false otherwies.
+ pub fn add(&mut self, row: usize, column: usize) -> bool {
+ let (start, _) = self.range(row);
+ let (word, mask) = word_mask(column);
let vector = &mut self.vector[..];
let v1 = vector[start + word];
let v2 = v1 | mask;
v1 != v2
}
- /// Do the bits from `source` contain `target`?
- ///
- /// Put another way, if the matrix represents (transitive)
- /// reachability, can `source` reach `target`?
- pub fn contains(&self, source: usize, target: usize) -> bool {
- let (start, _) = self.range(source);
- let (word, mask) = word_mask(target);
+ /// Do the bits from `row` contain `column`? Put another way, is
+ /// the matrix cell at `(row, column)` true? Put yet another way,
+ /// if the matrix represents (transitive) reachability, can
+ /// `row` reach `column`?
+ pub fn contains(&self, row: usize, column: usize) -> bool {
+ let (start, _) = self.range(row);
+ let (word, mask) = word_mask(column);
(self.vector[start + word] & mask) != 0
}
- /// Returns those indices that are reachable from both `a` and
- /// `b`. This is an O(n) operation where `n` is the number of
- /// elements (somewhat independent from the actual size of the
+ /// Returns those indices that are true in rows `a` and `b`. This
+ /// is an O(n) operation where `n` is the number of elements
+ /// (somewhat independent from the actual size of the
/// intersection, in particular).
pub fn intersection(&self, a: usize, b: usize) -> Vec<usize> {
let (a_start, a_end) = self.range(a);
result
}
- /// Add the bits from `read` to the bits from `write`,
+ /// Add the bits from row `read` to the bits from row `write`,
/// return true if anything changed.
///
/// This is used when computing transitive reachability because if
changed
}
+ /// Iterates through all the columns set to true in a given row of
+ /// the matrix.
pub fn iter<'a>(&'a self, row: usize) -> BitVectorIter<'a> {
let (start, end) = self.range(row);
BitVectorIter {
// Use default constants
($name:ident) => (
newtype_index!(
- @type[$name]
- @max[::std::u32::MAX]
- @debug_format["{}"]);
+ // Leave out derives marker so we can use its absence to ensure it comes first
+ @type [$name]
+ @max [::std::u32::MAX]
+ @debug_format ["{}"]);
);
// Define any constants
($name:ident { $($tokens:tt)+ }) => (
newtype_index!(
- @type[$name]
- @max[::std::u32::MAX]
- @debug_format["{}"]
- $($tokens)+);
+ // Leave out derives marker so we can use its absence to ensure it comes first
+ @type [$name]
+ @max [::std::u32::MAX]
+ @debug_format ["{}"]
+ $($tokens)+);
);
// ---- private rules ----
// Base case, user-defined constants (if any) have already been defined
- (@type[$type:ident] @max[$max:expr] @debug_format[$debug_format:expr]) => (
- #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord,
- RustcEncodable, RustcDecodable)]
- pub struct $type(pub u32);
+ (@derives [$($derives:ident,)*]
+ @pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]) => (
+ #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, $($derives),*)]
+ pub struct $type($($pub)* u32);
impl Idx for $type {
fn new(value: usize) -> Self {
assert!(value < ($max) as usize);
$type(value as u32)
}
+
fn index(self) -> usize {
self.0 as usize
}
}
+ newtype_index!(
+ @handle_debug
+ @derives [$($derives,)*]
+ @type [$type]
+ @debug_format [$debug_format]);
+ );
+
+ // base case for handle_debug where format is custom. No Debug implementation is emitted.
+ (@handle_debug
+ @derives [$($_derives:ident,)*]
+ @type [$type:ident]
+ @debug_format [custom]) => ();
+
+ // base case for handle_debug, no debug overrides found, so use default
+ (@handle_debug
+ @derives []
+ @type [$type:ident]
+ @debug_format [$debug_format:tt]) => (
impl ::std::fmt::Debug for $type {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(fmt, $debug_format, self.0)
}
);
+ // Debug is requested for derive, don't generate any Debug implementation.
+ (@handle_debug
+ @derives [Debug, $($derives:ident,)*]
+ @type [$type:ident]
+ @debug_format [$debug_format:tt]) => ();
+
+ // It's not Debug, so just pop it off the front of the derives stack and check the rest.
+ (@handle_debug
+ @derives [$_derive:ident, $($derives:ident,)*]
+ @type [$type:ident]
+ @debug_format [$debug_format:tt]) => (
+ newtype_index!(
+ @handle_debug
+ @derives [$($derives,)*]
+ @type [$type]
+ @debug_format [$debug_format]);
+ );
+
+ // Handle the case where someone wants to make the internal field public
+ (@type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ pub idx
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @pub [pub]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
+ );
+
+ // The default case is that the internal field is private
+ (@type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @pub []
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
+ );
+
+ // Append comma to end of derives list if it's missing
+ (@pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ derive [$($derives:ident),*]
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ derive [$($derives,)*]
+ $($tokens)*);
+ );
+
+ // By not including the @derives marker in this list nor in the default args, we can force it
+ // to come first if it exists. When encodable is custom, just use the derives list as-is.
+ (@pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ derive [$($derives:ident,)+]
+ ENCODABLE = custom
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @derives [$($derives,)+]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
+ );
+
+ // By not including the @derives marker in this list nor in the default args, we can force it
+ // to come first if it exists. When encodable isn't custom, add serialization traits by default.
+ (@pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ derive [$($derives:ident,)+]
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @derives [$($derives,)+ RustcDecodable, RustcEncodable,]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
+ );
+
+ // The case where no derives are added, but encodable is overriden. Don't
+ // derive serialization traits
+ (@pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ ENCODABLE = custom
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @derives []
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
+ );
+
+ // The case where no derives are added, add serialization derives by default
+ (@pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @derives [RustcDecodable, RustcEncodable,]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
+ );
+
// Rewrite final without comma to one that includes comma
- (@type[$type:ident] @max[$max:expr] @debug_format[$debug_format:expr]
- $name:ident = $constant:expr) => (
- newtype_index!(@type[$type] @max[$max] @debug_format[$debug_format] $name = $constant,);
+ (@derives [$($derives:ident,)*]
+ @pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ $name:ident = $constant:expr) => (
+ newtype_index!(
+ @derives [$($derives,)*]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $name = $constant,);
);
// Rewrite final const without comma to one that includes comma
- (@type[$type:ident] @max[$_max:expr] @debug_format[$debug_format:expr]
- const $name:ident = $constant:expr) => (
- newtype_index!(@type[$type]
- @max[$max]
- @debug_format[$debug_format]
- const $name = $constant,);
+ (@derives [$($derives:ident,)*]
+ @pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$_max:expr]
+ @debug_format [$debug_format:tt]
+ $(#[doc = $doc:expr])*
+ const $name:ident = $constant:expr) => (
+ newtype_index!(
+ @derives [$($derives,)*]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $(#[doc = $doc])* const $name = $constant,);
);
// Replace existing default for max
- (@type[$type:ident] @max[$_max:expr] @debug_format[$debug_format:expr]
- MAX = $max:expr, $($tokens:tt)*) => (
- newtype_index!(@type[$type] @max[$max] @debug_format[$debug_format] $($tokens)*);
+ (@derives [$($derives:ident,)*]
+ @pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$_max:expr]
+ @debug_format [$debug_format:tt]
+ MAX = $max:expr,
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @derives [$($derives,)*]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
);
// Replace existing default for debug_format
- (@type[$type:ident] @max[$max:expr] @debug_format[$_debug_format:expr]
- DEBUG_FORMAT = $debug_format:expr, $($tokens:tt)*) => (
- newtype_index!(@type[$type] @max[$max] @debug_format[$debug_format] $($tokens)*);
+ (@derives [$($derives:ident,)*]
+ @pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$_debug_format:tt]
+ DEBUG_FORMAT = $debug_format:tt,
+ $($tokens:tt)*) => (
+ newtype_index!(
+ @derives [$($derives,)*]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
);
- // Assign a user-defined constant (as final param)
- (@type[$type:ident] @max[$max:expr] @debug_format[$debug_format:expr]
- const $name:ident = $constant:expr, $($tokens:tt)*) => (
+ // Assign a user-defined constant
+ (@derives [$($derives:ident,)*]
+ @pub [$($pub:tt)*]
+ @type [$type:ident]
+ @max [$max:expr]
+ @debug_format [$debug_format:tt]
+ $(#[doc = $doc:expr])*
+ const $name:ident = $constant:expr,
+ $($tokens:tt)*) => (
+ $(#[doc = $doc])*
pub const $name: $type = $type($constant);
- newtype_index!(@type[$type] @max[$max] @debug_format[$debug_format] $($tokens)*);
+ newtype_index!(
+ @derives [$($derives,)*]
+ @pub [$($pub)*]
+ @type [$type]
+ @max [$max]
+ @debug_format [$debug_format]
+ $($tokens)*);
);
}
}
}
- /// Returns a vector of all things less than `a`.
+ /// Returns a vector of all things greater than `a`.
///
/// Really this probably ought to be `impl Iterator<Item=&T>`, but
/// I'm too lazy to make that work, and -- given the caching
/// strategy -- it'd be a touch tricky anyhow.
- pub fn less_than(&self, a: &T) -> Vec<&T> {
+ pub fn greater_than(&self, a: &T) -> Vec<&T> {
match self.index(a) {
Some(a) => self.with_closure(|closure| {
closure.iter(a.0).map(|i| &self.elements[i]).collect()
pub mod write {
pub const RELOC_MODEL_ARGS: [(&'static str, ()); 0] = [];
pub const CODE_GEN_MODEL_ARGS: [(&'static str, ()); 0] = [];
+ pub const TLS_MODEL_ARGS: [(&'static str, ()); 0] = [];
}
}
}
}
println!("");
}
+ PrintRequest::TlsModels => {
+ println!("Available TLS models:");
+ for &(name, _) in rustc_trans::back::write::TLS_MODEL_ARGS.iter(){
+ println!(" {}", name);
+ }
+ println!("");
+ }
PrintRequest::TargetCPUs | PrintRequest::TargetFeatures => {
rustc_trans::print(*req, sess);
}
hir::ItemUnion(..) |
hir::ItemTrait(..) |
hir::ItemImpl(..) |
- hir::ItemDefaultImpl(..) => None,
+ hir::ItemAutoImpl(..) => None,
hir::ItemMod(ref m) => search_mod(this, m, idx, names),
};
use self::Destination::*;
-use syntax_pos::{DUMMY_SP, FileMap, Span, MultiSpan, CharPos};
+use syntax_pos::{DUMMY_SP, FileMap, Span, MultiSpan};
use {Level, CodeSuggestion, DiagnosticBuilder, SubDiagnostic, CodeMapper, DiagnosticId};
use RenderSpan::*;
// 6..7. This is degenerate input, but it's best to degrade
// gracefully -- and the parser likes to supply a span like
// that for EOF, in particular.
- if lo.col == hi.col && lo.line == hi.line {
- hi.col = CharPos(lo.col.0 + 1);
+ if lo.col_display == hi.col_display && lo.line == hi.line {
+ hi.col_display += 1;
}
let ann_type = if lo.line != hi.line {
depth: 1,
line_start: lo.line,
line_end: hi.line,
- start_col: lo.col.0,
- end_col: hi.col.0,
+ start_col: lo.col_display,
+ end_col: hi.col_display,
is_primary: span_label.is_primary,
label: span_label.label.clone(),
};
AnnotationType::Singleline
};
let ann = Annotation {
- start_col: lo.col.0,
- end_col: hi.col.0,
+ start_col: lo.col_display,
+ end_col: hi.col_display,
is_primary: span_label.is_primary,
label: span_label.label.clone(),
annotation_type: ann_type,
//HirItem::ItemTrait(..) => ("ItemTrait", LABELS_TRAIT),
// `impl Trait for .. {}`
- HirItem::ItemDefaultImpl(..) => ("ItemDefaultImpl", LABELS_IMPL),
+ HirItem::ItemAutoImpl(..) => ("ItemAutoImpl", LABELS_IMPL),
// An implementation, eg `impl<A> Trait for Foo { .. }`
HirItem::ItemImpl(..) => ("ItemImpl", LABELS_IMPL),
#[derive(PartialEq)]
pub enum MethodLateContext {
- TraitDefaultImpl,
+ TraitAutoImpl,
TraitImpl,
PlainImpl,
}
let def_id = cx.tcx.hir.local_def_id(id);
let item = cx.tcx.associated_item(def_id);
match item.container {
- ty::TraitContainer(..) => MethodLateContext::TraitDefaultImpl,
+ ty::TraitContainer(..) => MethodLateContext::TraitAutoImpl,
ty::ImplContainer(cid) => {
match cx.tcx.impl_trait_ref(cid) {
Some(_) => MethodLateContext::TraitImpl,
MethodLateContext::PlainImpl => {
self.check_snake_case(cx, "method", &name.as_str(), Some(span))
}
- MethodLateContext::TraitDefaultImpl => {
+ MethodLateContext::TraitAutoImpl => {
self.check_snake_case(cx, "trait method", &name.as_str(), Some(span))
}
_ => (),
// hardwired lints from librustc
pub use lint::builtin::*;
+declare_lint! {
+ pub AUTO_IMPL,
+ Deny,
+ "The form `impl Foo for .. {}` will be removed, please use `auto trait Foo {}`"
+}
+
+#[derive(Copy, Clone)]
+pub struct AutoImpl;
+
+impl LintPass for AutoImpl {
+ fn get_lints(&self) -> LintArray {
+ lint_array!(AUTO_IMPL)
+ }
+}
+
+impl EarlyLintPass for AutoImpl {
+ fn check_item(&mut self, cx: &EarlyContext, item: &ast::Item) {
+ let msg = "The form `impl Foo for .. {}` will be removed, please use `auto trait Foo {}`";
+ match item.node {
+ ast::ItemKind::AutoImpl(..) => cx.span_lint(AUTO_IMPL, item.span, msg),
+ _ => ()
+ }
+ }
+}
+
declare_lint! {
WHILE_TRUE,
Warn,
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match it.node {
- hir::ItemTrait(hir::Unsafety::Unsafe, ..) => {
+ hir::ItemTrait(_, hir::Unsafety::Unsafe, ..) => {
self.report_unsafe(cx, it.span, "declaration of an `unsafe` trait")
}
}
}
}
+
+/// Lint for items marked `pub` that aren't reachable from other crates
+pub struct UnreachablePub;
+
+declare_lint! {
+ UNREACHABLE_PUB,
+ Allow,
+ "`pub` items not reachable from crate root"
+}
+
+impl LintPass for UnreachablePub {
+ fn get_lints(&self) -> LintArray {
+ lint_array!(UNREACHABLE_PUB)
+ }
+}
+
+impl UnreachablePub {
+ fn perform_lint(&self, cx: &LateContext, what: &str, id: ast::NodeId,
+ vis: &hir::Visibility, span: Span, exportable: bool) {
+ if !cx.access_levels.is_reachable(id) && *vis == hir::Visibility::Public {
+ let def_span = cx.tcx.sess.codemap().def_span(span);
+ let mut err = cx.struct_span_lint(UNREACHABLE_PUB, def_span,
+ &format!("unreachable `pub` {}", what));
+ // visibility is token at start of declaration (can be macro
+ // variable rather than literal `pub`)
+ let pub_span = cx.tcx.sess.codemap().span_until_char(def_span, ' ');
+ let replacement = if cx.tcx.sess.features.borrow().crate_visibility_modifier {
+ "crate"
+ } else {
+ "pub(crate)"
+ }.to_owned();
+ err.span_suggestion(pub_span, "consider restricting its visibility", replacement);
+ if exportable {
+ err.help("or consider exporting it for use by other crates");
+ }
+ err.emit();
+ }
+ }
+}
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnreachablePub {
+ fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
+ self.perform_lint(cx, "item", item.id, &item.vis, item.span, true);
+ }
+
+ fn check_foreign_item(&mut self, cx: &LateContext, foreign_item: &hir::ForeignItem) {
+ self.perform_lint(cx, "item", foreign_item.id, &foreign_item.vis, foreign_item.span, true);
+ }
+
+ fn check_struct_field(&mut self, cx: &LateContext, field: &hir::StructField) {
+ self.perform_lint(cx, "field", field.id, &field.vis, field.span, false);
+ }
+
+ fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) {
+ self.perform_lint(cx, "item", impl_item.id, &impl_item.vis, impl_item.span, false);
+ }
+}
AnonymousParameters,
IllegalFloatLiteralPattern,
UnusedDocComment,
+ AutoImpl,
);
add_early_builtin_with_new!(sess,
PluginAsLibrary,
MutableTransmutes,
UnionsWithDropFields,
+ UnreachablePub,
);
add_builtin_with_new!(sess,
// - Eventually, remove lint
store.register_future_incompatible(sess,
vec![
+ FutureIncompatibleInfo {
+ id: LintId::of(AUTO_IMPL),
+ reference: "issue #13231 <https://github.com/rust-lang/rust/issues/13231>",
+ },
FutureIncompatibleInfo {
id: LintId::of(PRIVATE_IN_PUBLIC),
reference: "issue #34537 <https://github.com/rust-lang/rust/issues/34537>",
pub len: usize,
}
+/// LLVMThreadLocalMode
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub enum ThreadLocalMode {
+ NotThreadLocal,
+ GeneralDynamic,
+ LocalDynamic,
+ InitialExec,
+ LocalExec
+}
+
// Opaque pointer types
#[allow(missing_copy_implementations)]
pub enum Module_opaque {}
pub fn LLVMGetInitializer(GlobalVar: ValueRef) -> ValueRef;
pub fn LLVMSetInitializer(GlobalVar: ValueRef, ConstantVal: ValueRef);
pub fn LLVMSetThreadLocal(GlobalVar: ValueRef, IsThreadLocal: Bool);
+ pub fn LLVMSetThreadLocalMode(GlobalVar: ValueRef, Mode: ThreadLocalMode);
pub fn LLVMIsGlobalConstant(GlobalVar: ValueRef) -> Bool;
pub fn LLVMSetGlobalConstant(GlobalVar: ValueRef, IsConstant: Bool);
pub fn LLVMRustGetNamedValue(M: ModuleRef, Name: *const c_char) -> ValueRef;
LLVMSetThreadLocal(global, is_thread_local as Bool);
}
}
+pub fn set_thread_local_mode(global: ValueRef, mode: ThreadLocalMode) {
+ unsafe {
+ LLVMSetThreadLocalMode(global, mode);
+ }
+}
impl Attribute {
pub fn apply_llfn(&self, idx: AttributePlace, llfn: ValueRef) {
let cnum_map = self.resolve_crate_deps(root, &crate_root, &metadata, cnum, span, dep_kind);
let def_path_table = record_time(&self.sess.perf_stats.decode_def_path_tables_time, || {
- crate_root.def_path_table.decode(&metadata)
+ crate_root.def_path_table.decode((&metadata, self.sess))
});
- let exported_symbols = crate_root.exported_symbols.decode(&metadata).collect();
-
+ let exported_symbols = crate_root.exported_symbols
+ .decode((&metadata, self.sess))
+ .collect();
let trait_impls = crate_root
.impls
- .decode(&metadata)
+ .decode((&metadata, self.sess))
.map(|trait_impls| (trait_impls.trait_id, trait_impls.impls))
.collect();
let dllimports: FxHashSet<_> = cmeta
.root
.native_libraries
- .decode(&cmeta)
+ .decode((&cmeta, self.sess))
.filter(|lib| relevant_lib(self.sess, lib) &&
lib.kind == cstore::NativeLibraryKind::NativeUnknown)
.flat_map(|lib| {
let mut needs_panic_runtime = attr::contains_name(&krate.attrs,
"needs_panic_runtime");
+ let sess = self.sess;
self.cstore.iter_crate_data(|cnum, data| {
needs_panic_runtime = needs_panic_runtime ||
- data.needs_panic_runtime();
- if data.is_panic_runtime() {
+ data.needs_panic_runtime(sess);
+ if data.is_panic_runtime(sess) {
// Inject a dependency from all #![needs_panic_runtime] to this
// #![panic_runtime] crate.
self.inject_dependency_if(cnum, "a panic runtime",
- &|data| data.needs_panic_runtime());
+ &|data| data.needs_panic_runtime(sess));
runtime_found = runtime_found || data.dep_kind.get() == DepKind::Explicit;
}
});
// Sanity check the loaded crate to ensure it is indeed a panic runtime
// and the panic strategy is indeed what we thought it was.
- if !data.is_panic_runtime() {
+ if !data.is_panic_runtime(self.sess) {
self.sess.err(&format!("the crate `{}` is not a panic runtime",
name));
}
self.sess.injected_panic_runtime.set(Some(cnum));
self.inject_dependency_if(cnum, "a panic runtime",
- &|data| data.needs_panic_runtime());
+ &|data| data.needs_panic_runtime(self.sess));
}
fn inject_sanitizer_runtime(&mut self) {
PathKind::Crate, dep_kind);
// Sanity check the loaded crate to ensure it is indeed a sanitizer runtime
- if !data.is_sanitizer_runtime() {
+ if !data.is_sanitizer_runtime(self.sess) {
self.sess.err(&format!("the crate `{}` is not a sanitizer runtime",
name));
}
PathKind::Crate, dep_kind);
// Sanity check the loaded crate to ensure it is indeed a profiler runtime
- if !data.is_profiler_runtime() {
+ if !data.is_profiler_runtime(self.sess) {
self.sess.err(&format!("the crate `profiler_builtins` is not \
a profiler runtime"));
}
let mut needs_allocator = attr::contains_name(&krate.attrs,
"needs_allocator");
self.cstore.iter_crate_data(|_, data| {
- needs_allocator = needs_allocator || data.needs_allocator();
+ needs_allocator = needs_allocator || data.needs_allocator(self.sess);
});
if !needs_allocator {
return
Some(data) => {
// We have an allocator. We detect separately what kind it is, to allow for some
// flexibility in misconfiguration.
- let attrs = data.get_item_attrs(CRATE_DEF_INDEX);
+ let attrs = data.get_item_attrs(CRATE_DEF_INDEX, self.sess);
let kind_interned = attr::first_attr_value_str_by_name(&attrs, "rustc_alloc_kind")
.map(Symbol::as_str);
let kind_str = kind_interned
use rustc::hir::map::definitions::DefPathTable;
use rustc::hir::svh::Svh;
use rustc::middle::cstore::{DepKind, ExternCrate, MetadataLoader};
-use rustc::session::CrateDisambiguator;
+use rustc::session::{Session, CrateDisambiguator};
use rustc_back::PanicStrategy;
use rustc_data_structures::indexed_vec::IndexVec;
use rustc::util::nodemap::{FxHashMap, FxHashSet, NodeMap};
self.root.disambiguator
}
- pub fn needs_allocator(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn needs_allocator(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_name(&attrs, "needs_allocator")
}
self.root.has_default_lib_allocator.clone()
}
- pub fn is_panic_runtime(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn is_panic_runtime(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_name(&attrs, "panic_runtime")
}
- pub fn needs_panic_runtime(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn needs_panic_runtime(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_name(&attrs, "needs_panic_runtime")
}
- pub fn is_compiler_builtins(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn is_compiler_builtins(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_name(&attrs, "compiler_builtins")
}
- pub fn is_sanitizer_runtime(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn is_sanitizer_runtime(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_name(&attrs, "sanitizer_runtime")
}
- pub fn is_profiler_runtime(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn is_profiler_runtime(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_name(&attrs, "profiler_runtime")
}
- pub fn is_no_builtins(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn is_no_builtins(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_name(&attrs, "no_builtins")
}
- pub fn has_copy_closures(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn has_copy_closures(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_feature_attr(&attrs, "copy_closures")
}
- pub fn has_clone_closures(&self) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
+ pub fn has_clone_closures(&self, sess: &Session) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX, sess);
attr::contains_feature_attr(&attrs, "clone_closures")
}
provide! { <'tcx> tcx, def_id, other, cdata,
type_of => { cdata.get_type(def_id.index, tcx) }
- generics_of => { tcx.alloc_generics(cdata.get_generics(def_id.index)) }
+ generics_of => {
+ tcx.alloc_generics(cdata.get_generics(def_id.index, tcx.sess))
+ }
predicates_of => { cdata.get_predicates(def_id.index, tcx) }
super_predicates_of => { cdata.get_super_predicates(def_id.index, tcx) }
trait_def => {
- tcx.alloc_trait_def(cdata.get_trait_def(def_id.index))
+ tcx.alloc_trait_def(cdata.get_trait_def(def_id.index, tcx.sess))
}
adt_def => { cdata.get_adt_def(def_id.index, tcx) }
adt_destructor => {
inherent_impls => { Rc::new(cdata.get_inherent_implementations_for_type(def_id.index)) }
is_const_fn => { cdata.is_const_fn(def_id.index) }
is_foreign_item => { cdata.is_foreign_item(def_id.index) }
- is_default_impl => { cdata.is_default_impl(def_id.index) }
+ is_auto_impl => { cdata.is_auto_impl(def_id.index) }
describe_def => { cdata.get_def(def_id.index) }
def_span => { cdata.get_span(def_id.index, &tcx.sess) }
lookup_stability => {
lookup_deprecation_entry => {
cdata.get_deprecation(def_id.index).map(DeprecationEntry::external)
}
- item_attrs => { cdata.get_item_attrs(def_id.index) }
+ item_attrs => { cdata.get_item_attrs(def_id.index, tcx.sess) }
// FIXME(#38501) We've skipped a `read` on the `HirBody` of
// a `fn` when encoding, so the dep-tracking wouldn't work.
// This is only used by rustdoc anyway, which shouldn't have
is_mir_available => { cdata.is_item_mir_available(def_id.index) }
dylib_dependency_formats => { Rc::new(cdata.get_dylib_dependency_formats()) }
- is_panic_runtime => { cdata.is_panic_runtime() }
- is_compiler_builtins => { cdata.is_compiler_builtins() }
+ is_panic_runtime => { cdata.is_panic_runtime(tcx.sess) }
+ is_compiler_builtins => { cdata.is_compiler_builtins(tcx.sess) }
has_global_allocator => { cdata.has_global_allocator() }
- is_sanitizer_runtime => { cdata.is_sanitizer_runtime() }
- is_profiler_runtime => { cdata.is_profiler_runtime() }
+ is_sanitizer_runtime => { cdata.is_sanitizer_runtime(tcx.sess) }
+ is_profiler_runtime => { cdata.is_profiler_runtime(tcx.sess) }
panic_strategy => { cdata.panic_strategy() }
extern_crate => { Rc::new(cdata.extern_crate.get()) }
- is_no_builtins => { cdata.is_no_builtins() }
+ is_no_builtins => { cdata.is_no_builtins(tcx.sess) }
impl_defaultness => { cdata.get_impl_defaultness(def_id.index) }
exported_symbol_ids => { Rc::new(cdata.get_exported_symbols()) }
- native_libraries => { Rc::new(cdata.get_native_libraries()) }
+ native_libraries => { Rc::new(cdata.get_native_libraries(tcx.sess)) }
plugin_registrar_fn => {
cdata.root.plugin_registrar_fn.map(|index| {
DefId { krate: def_id.krate, index }
used_crate_source => { Rc::new(cdata.source.clone()) }
- has_copy_closures => { cdata.has_copy_closures() }
- has_clone_closures => { cdata.has_clone_closures() }
+ has_copy_closures => { cdata.has_copy_closures(tcx.sess) }
+ has_clone_closures => { cdata.has_clone_closures(tcx.sess) }
}
pub fn provide_local<'tcx>(providers: &mut Providers<'tcx>) {
self.get_crate_data(def.krate).get_visibility(def.index)
}
- fn item_generics_cloned_untracked(&self, def: DefId) -> ty::Generics {
- self.get_crate_data(def.krate).get_generics(def.index)
+ fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics {
+ self.get_crate_data(def.krate).get_generics(def.index, sess)
}
fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem
let body = filemap_to_stream(&sess.parse_sess, filemap, None);
// Mark the attrs as used
- let attrs = data.get_item_attrs(id.index);
+ let attrs = data.get_item_attrs(id.index, sess);
for attr in attrs.iter() {
attr::mark_used(attr);
}
use std::u32;
use rustc_serialize::{Decodable, Decoder, SpecializedDecoder, opaque};
+use rustc_data_structures::indexed_vec::Idx;
use syntax::attr;
use syntax::ast::{self, Ident};
use syntax::codemap;
}
}
+
+impl<'a, 'tcx> Metadata<'a, 'tcx> for (&'a MetadataBlob, &'a Session) {
+ fn raw_bytes(self) -> &'a [u8] {
+ let (blob, _) = self;
+ &blob.0
+ }
+
+ fn sess(self) -> Option<&'a Session> {
+ let (_, sess) = self;
+ Some(sess)
+ }
+}
+
+
impl<'a, 'tcx> Metadata<'a, 'tcx> for &'a CrateMetadata {
fn raw_bytes(self) -> &'a [u8] {
self.blob.raw_bytes()
let sess = if let Some(sess) = self.sess {
sess
} else {
- return Ok(Span::new(lo, hi, NO_EXPANSION));
+ bug!("Cannot decode Span without Session.")
};
let (lo, hi) = if lo > hi {
// originate from the same filemap.
let last_filemap = &imported_filemaps[self.last_filemap_index];
- if lo >= last_filemap.original_start_pos && lo <= last_filemap.original_end_pos &&
+ if lo >= last_filemap.original_start_pos &&
+ lo <= last_filemap.original_end_pos &&
hi >= last_filemap.original_start_pos &&
hi <= last_filemap.original_end_pos {
last_filemap
}
};
- let lo = (lo - filemap.original_start_pos) + filemap.translated_filemap.start_pos;
- let hi = (hi - filemap.original_start_pos) + filemap.translated_filemap.start_pos;
+ let lo = (lo + filemap.translated_filemap.start_pos) - filemap.original_start_pos;
+ let hi = (hi + filemap.translated_filemap.start_pos) - filemap.original_start_pos;
Ok(Span::new(lo, hi, NO_EXPANSION))
}
EntryKind::ForeignMod |
EntryKind::Impl(_) |
- EntryKind::DefaultImpl(_) |
+ EntryKind::AutoImpl(_) |
EntryKind::Field |
EntryKind::Generator(_) |
EntryKind::Closure(_) => return None,
}
}
- pub fn get_trait_def(&self, item_id: DefIndex) -> ty::TraitDef {
+ pub fn get_trait_def(&self, item_id: DefIndex, sess: &Session) -> ty::TraitDef {
let data = match self.entry(item_id).kind {
- EntryKind::Trait(data) => data.decode(self),
+ EntryKind::Trait(data) => data.decode((self, sess)),
_ => bug!(),
};
ty::TraitDef::new(self.local_def_id(item_id),
data.unsafety,
data.paren_sugar,
- data.has_default_impl,
+ data.has_auto_impl,
self.def_path_table.def_path_hash(item_id))
}
}
}
- pub fn get_generics(&self, item_id: DefIndex) -> ty::Generics {
- self.entry(item_id).generics.unwrap().decode(self)
+ pub fn get_generics(&self,
+ item_id: DefIndex,
+ sess: &Session)
+ -> ty::Generics {
+ self.entry(item_id).generics.unwrap().decode((self, sess))
}
pub fn get_type(&self, id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx> {
continue;
}
EntryKind::Impl(_) |
- EntryKind::DefaultImpl(_) => continue,
+ EntryKind::AutoImpl(_) => continue,
_ => {}
}
}
}
- pub fn get_item_attrs(&self, node_id: DefIndex) -> Rc<[ast::Attribute]> {
+ pub fn get_item_attrs(&self, node_id: DefIndex, sess: &Session) -> Rc<[ast::Attribute]> {
let (node_as, node_index) =
(node_id.address_space().index(), node_id.as_array_index());
if self.is_proc_macro(node_id) {
if def_key.disambiguated_data.data == DefPathData::StructCtor {
item = self.entry(def_key.parent.unwrap());
}
- let result: Rc<[ast::Attribute]> = Rc::from(self.get_attributes(&item));
+ let result: Rc<[ast::Attribute]> = Rc::from(self.get_attributes(&item, sess));
let vec_ = &mut self.attribute_cache.borrow_mut()[node_as];
if vec_.len() < node_index + 1 {
vec_.resize(node_index + 1, None);
.collect()
}
- fn get_attributes(&self, item: &Entry<'tcx>) -> Vec<ast::Attribute> {
+ fn get_attributes(&self, item: &Entry<'tcx>
, sess: &Session) -> Vec<ast::Attribute> {
item.attributes
- .decode(self)
+ .decode((self, sess))
.map(|mut attr| {
// Need new unique IDs: old thread-local IDs won't map to new threads.
attr.id = attr::mk_attr_id();
}
- pub fn get_native_libraries(&self) -> Vec<NativeLibrary> {
- self.root.native_libraries.decode(self).collect()
+ pub fn get_native_libraries(&self, sess: &Session) -> Vec<NativeLibrary> {
+ self.root.native_libraries.decode((self, sess)).collect()
}
pub fn get_dylib_dependency_formats(&self) -> Vec<(CrateNum, LinkagePreference)> {
self.dllimport_foreign_items.contains(&id)
}
- pub fn is_default_impl(&self, impl_id: DefIndex) -> bool {
+ pub fn is_auto_impl(&self, impl_id: DefIndex) -> bool {
match self.entry(impl_id).kind {
- EntryKind::DefaultImpl(_) => true,
+ EntryKind::AutoImpl(_) => true,
_ => false,
}
}
end_pos,
lines,
multibyte_chars,
+ non_narrow_chars,
.. } = filemap_to_import;
let source_length = (end_pos - start_pos).to_usize();
for mbc in &mut multibyte_chars {
mbc.pos = mbc.pos - start_pos;
}
+ let mut non_narrow_chars = non_narrow_chars.into_inner();
+ for swc in &mut non_narrow_chars {
+ *swc = *swc - start_pos;
+ }
let local_version = local_codemap.new_imported_filemap(name,
name_was_remapped,
src_hash,
source_length,
lines,
- multibyte_chars);
+ multibyte_chars,
+ non_narrow_chars);
debug!("CrateMetaData::imported_filemaps alloc \
filemap {:?} original (start_pos {:?} end_pos {:?}) \
translated (start_pos {:?} end_pos {:?})",
fn encode_struct_ctor(&mut self, (adt_def_id, def_id): (DefId, DefId)) -> Entry<'tcx> {
debug!("IsolatedEncoder::encode_struct_ctor({:?})", def_id);
let tcx = self.tcx;
- let variant = tcx.adt_def(adt_def_id).struct_variant();
+ let adt_def = tcx.adt_def(adt_def_id);
+ let variant = adt_def.struct_variant();
let data = VariantData {
ctor_kind: variant.ctor_kind,
}
}
+ // If the structure is marked as non_exhaustive then lower the visibility
+ // to within the crate.
+ if adt_def.is_non_exhaustive() && ctor_vis == ty::Visibility::Public {
+ ctor_vis = ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX));
+ }
+
let repr_options = get_repr_options(&tcx, adt_def_id);
Entry {
ctor_sig: None,
}), repr_options)
}
- hir::ItemDefaultImpl(..) => {
+ hir::ItemAutoImpl(..) => {
let data = ImplData {
polarity: hir::ImplPolarity::Positive,
defaultness: hir::Defaultness::Final,
trait_ref: tcx.impl_trait_ref(def_id).map(|trait_ref| self.lazy(&trait_ref)),
};
- EntryKind::DefaultImpl(self.lazy(&data))
+ EntryKind::AutoImpl(self.lazy(&data))
}
hir::ItemImpl(_, polarity, defaultness, ..) => {
let trait_ref = tcx.impl_trait_ref(def_id);
let data = TraitData {
unsafety: trait_def.unsafety,
paren_sugar: trait_def.paren_sugar,
- has_default_impl: tcx.trait_has_default_impl(def_id),
+ has_auto_impl: tcx.trait_is_auto(def_id),
super_predicates: self.lazy(&tcx.super_predicates_of(def_id)),
};
hir::ItemGlobalAsm(..) |
hir::ItemExternCrate(..) |
hir::ItemUse(..) |
- hir::ItemDefaultImpl(..) |
+ hir::ItemAutoImpl(..) |
hir::ItemTy(..) => {
// no sub-item recording needed in these cases
}
Generator(Lazy<GeneratorData<'tcx>>),
Trait(Lazy<TraitData<'tcx>>),
Impl(Lazy<ImplData<'tcx>>),
- DefaultImpl(Lazy<ImplData<'tcx>>),
+ AutoImpl(Lazy<ImplData<'tcx>>),
Method(Lazy<MethodData<'tcx>>),
AssociatedType(AssociatedContainer),
AssociatedConst(AssociatedContainer, u8),
EntryKind::Trait(ref trait_data) => {
trait_data.hash_stable(hcx, hasher);
}
- EntryKind::DefaultImpl(ref impl_data) |
+ EntryKind::AutoImpl(ref impl_data) |
EntryKind::Impl(ref impl_data) => {
impl_data.hash_stable(hcx, hasher);
}
pub struct TraitData<'tcx> {
pub unsafety: hir::Unsafety,
pub paren_sugar: bool,
- pub has_default_impl: bool,
+ pub has_auto_impl: bool,
pub super_predicates: Lazy<ty::GenericPredicates<'tcx>>,
}
impl_stable_hash_for!(struct TraitData<'tcx> {
unsafety,
paren_sugar,
- has_default_impl,
+ has_auto_impl,
super_predicates
});
TerminatorKind::Resume |
TerminatorKind::Return |
TerminatorKind::GeneratorDrop |
- TerminatorKind::Unreachable => {
+ TerminatorKind::Unreachable |
+ TerminatorKind::FalseEdges { .. } => {
// no data used, thus irrelevant to borrowck
}
}
use rustc::hir;
use hair::*;
use syntax::ast::{Name, NodeId};
-use syntax_pos::{DUMMY_SP, Span};
+use syntax_pos::Span;
// helper functions, broken out by category:
mod simplify;
(body, scope.unwrap_or(self.visibility_scope))
}).collect();
+ // create binding start block for link them by false edges
+ let candidate_count = arms.iter().fold(0, |ac, c| ac + c.patterns.len());
+ let pre_binding_blocks: Vec<_> = (0..candidate_count + 1)
+ .map(|_| self.cfg.start_new_block()).collect();
+
// assemble a list of candidates: there is one candidate per
// pattern, which means there may be more than one candidate
// *per arm*. These candidates are kept sorted such that the
// highest priority candidate comes first in the list.
// (i.e. same order as in source)
+
let candidates: Vec<_> =
arms.iter()
.enumerate()
arm.patterns.iter()
.map(move |pat| (arm_index, pat, arm.guard.clone()))
})
- .map(|(arm_index, pattern, guard)| {
+ .zip(pre_binding_blocks.iter().zip(pre_binding_blocks.iter().skip(1)))
+ .map(|((arm_index, pattern, guard),
+ (pre_binding_block, next_candidate_pre_binding_block))| {
Candidate {
span: pattern.span,
match_pairs: vec![MatchPair::new(discriminant_lvalue.clone(), pattern)],
bindings: vec![],
guard,
arm_index,
+ pre_binding_block: *pre_binding_block,
+ next_candidate_pre_binding_block: *next_candidate_pre_binding_block,
}
})
.collect();
+ let outer_source_info = self.source_info(span);
+ self.cfg.terminate(*pre_binding_blocks.last().unwrap(),
+ outer_source_info, TerminatorKind::Unreachable);
+
// this will generate code to test discriminant_lvalue and
// branch to the appropriate arm block
let otherwise = self.match_candidates(span, &mut arm_blocks, candidates, block);
match_pairs: vec![MatchPair::new(initializer.clone(), &irrefutable_pat)],
bindings: vec![],
guard: None,
- arm_index: 0, // since we don't call `match_candidates`, this field is unused
+
+ // since we don't call `match_candidates`, next fields is unused
+ arm_index: 0,
+ pre_binding_block: block,
+ next_candidate_pre_binding_block: block
};
// Simplify the candidate. Since the pattern is irrefutable, this should
// ...and then we branch to arm with this index.
arm_index: usize,
+
+ // ...and the blocks for add false edges between candidates
+ pre_binding_block: BasicBlock,
+ next_candidate_pre_binding_block: BasicBlock,
}
#[derive(Clone, Debug)]
candidates.iter().take_while(|c| c.match_pairs.is_empty()).count();
debug!("match_candidates: {:?} candidates fully matched", fully_matched);
let mut unmatched_candidates = candidates.split_off(fully_matched);
- for (index, candidate) in candidates.into_iter().enumerate() {
+
+ let fully_matched_with_guard =
+ candidates.iter().take_while(|c| c.guard.is_some()).count();
+
+ let unreachable_candidates = if fully_matched_with_guard + 1 < candidates.len() {
+ candidates.split_off(fully_matched_with_guard + 1)
+ } else {
+ vec![]
+ };
+
+ for candidate in candidates {
// If so, apply any bindings, test the guard (if any), and
// branch to the arm.
- let is_last = index == fully_matched - 1;
- if let Some(b) = self.bind_and_guard_matched_candidate(block, arm_blocks,
- candidate, is_last) {
+ if let Some(b) = self.bind_and_guard_matched_candidate(block, arm_blocks, candidate) {
block = b;
} else {
// if None is returned, then any remaining candidates
// are unreachable (at least not through this path).
- return vec![];
+ // Link them with false edges.
+ debug!("match_candidates: add false edges for unreachable {:?} and unmatched {:?}",
+ unreachable_candidates, unmatched_candidates);
+ for candidate in unreachable_candidates {
+ let source_info = self.source_info(candidate.span);
+ let target = self.cfg.start_new_block();
+ if let Some(otherwise) = self.bind_and_guard_matched_candidate(target,
+ arm_blocks,
+ candidate) {
+ self.cfg.terminate(otherwise, source_info, TerminatorKind::Unreachable);
+ }
+ }
+
+ if unmatched_candidates.is_empty() {
+ return vec![]
+ } else {
+ let target = self.cfg.start_new_block();
+ return self.match_candidates(span, arm_blocks, unmatched_candidates, target);
+ }
}
}
self.test_candidates(span, arm_blocks, &unmatched_candidates, block);
// If the target candidates were exhaustive, then we are done.
- if otherwise.is_empty() {
- return vec![];
- }
+ // But for borrowck continue build decision tree.
// If all candidates were sorted into `target_candidates` somewhere, then
// the initial set was inexhaustive.
fn bind_and_guard_matched_candidate<'pat>(&mut self,
mut block: BasicBlock,
arm_blocks: &mut ArmBlocks,
- candidate: Candidate<'pat, 'tcx>,
- is_last_arm: bool)
+ candidate: Candidate<'pat, 'tcx>)
-> Option<BasicBlock> {
debug!("bind_and_guard_matched_candidate(block={:?}, candidate={:?})",
block, candidate);
debug_assert!(candidate.match_pairs.is_empty());
- self.bind_matched_candidate(block, candidate.bindings);
-
let arm_block = arm_blocks.blocks[candidate.arm_index];
+ let candidate_source_info = self.source_info(candidate.span);
+
+ self.cfg.terminate(block, candidate_source_info,
+ TerminatorKind::Goto { target: candidate.pre_binding_block });
+
+ block = self.cfg.start_new_block();
+ self.cfg.terminate(candidate.pre_binding_block, candidate_source_info,
+ TerminatorKind::FalseEdges {
+ real_target: block,
+ imaginary_targets:
+ vec![candidate.next_candidate_pre_binding_block]});
+
+ self.bind_matched_candidate(block, candidate.bindings);
if let Some(guard) = candidate.guard {
// the block to branch to if the guard fails; if there is no
let guard = self.hir.mirror(guard);
let source_info = self.source_info(guard.span);
let cond = unpack!(block = self.as_local_operand(block, guard));
- let otherwise = self.cfg.start_new_block();
+
+ let false_edge_block = self.cfg.start_new_block();
self.cfg.terminate(block, source_info,
- TerminatorKind::if_(self.hir.tcx(), cond, arm_block, otherwise));
- Some(otherwise)
- } else if !is_last_arm {
- // Add always true guard in case of more than one arm
- // it creates false edges and allow MIR borrowck detects errors
- // FIXME(#45184) -- permit "false edges"
- let source_info = self.source_info(candidate.span);
- let true_expr = Expr {
- temp_lifetime: None,
- ty: self.hir.tcx().types.bool,
- span: DUMMY_SP,
- kind: ExprKind::Literal{literal: self.hir.true_literal()},
- };
- let cond = unpack!(block = self.as_local_operand(block, true_expr));
+ TerminatorKind::if_(self.hir.tcx(), cond, arm_block,
+ false_edge_block));
+
let otherwise = self.cfg.start_new_block();
- self.cfg.terminate(block, source_info,
- TerminatorKind::if_(self.hir.tcx(), cond, arm_block, otherwise));
+ self.cfg.terminate(false_edge_block, source_info,
+ TerminatorKind::FalseEdges {
+ real_target: otherwise,
+ imaginary_targets:
+ vec![candidate.next_candidate_pre_binding_block] });
Some(otherwise)
} else {
- let source_info = self.source_info(candidate.span);
- self.cfg.terminate(block, source_info,
- TerminatorKind::Goto { target: arm_block });
+ self.cfg.terminate(block, candidate_source_info,
+ TerminatorKind::Goto { target: arm_block });
None
}
}
bindings: candidate.bindings.clone(),
guard: candidate.guard.clone(),
arm_index: candidate.arm_index,
+ pre_binding_block: candidate.pre_binding_block,
+ next_candidate_pre_binding_block: candidate.next_candidate_pre_binding_block,
}
}
bindings: candidate.bindings.clone(),
guard: candidate.guard.clone(),
arm_index: candidate.arm_index,
+ pre_binding_block: candidate.pre_binding_block,
+ next_candidate_pre_binding_block: candidate.next_candidate_pre_binding_block,
}
}
use rustc::middle::region;
use rustc::mir::*;
use rustc::mir::transform::MirSource;
-use rustc::mir::visit::{MutVisitor, Lookup};
+use rustc::mir::visit::{MutVisitor, TyContext};
use rustc::ty::{self, Ty, TyCtxt};
use rustc::ty::subst::Substs;
use rustc::util::nodemap::NodeMap;
}
impl<'a, 'gcx: 'tcx, 'tcx> MutVisitor<'tcx> for GlobalizeMir<'a, 'gcx> {
- fn visit_ty(&mut self, ty: &mut Ty<'tcx>, _: Lookup) {
+ fn visit_ty(&mut self, ty: &mut Ty<'tcx>, _: TyContext) {
if let Some(lifted) = self.tcx.lift(ty) {
*ty = lifted;
} else {
location_map: FxHashMap<Location, BorrowIndex>,
region_map: FxHashMap<Region<'tcx>, FxHashSet<BorrowIndex>>,
region_span_map: FxHashMap<RegionKind, Span>,
- nonlexical_regioncx: Option<&'a RegionInferenceContext>,
+ nonlexical_regioncx: Option<&'a RegionInferenceContext<'tcx>>,
}
// temporarily allow some dead fields: `kind` and `region` will be
impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
- nonlexical_regioncx: Option<&'a RegionInferenceContext>)
+ nonlexical_regioncx: Option<&'a RegionInferenceContext<'tcx>>)
-> Self {
let mut visitor = GatherBorrows { idx_vec: IndexVec::new(),
location_map: FxHashMap(),
location: Location) {
if let Some(regioncx) = self.nonlexical_regioncx {
for (borrow_index, borrow_data) in self.borrows.iter_enumerated() {
- let borrow_region = regioncx.region_value(borrow_data.region.to_region_index());
- if !borrow_region.may_contain(location) && location != borrow_data.location {
- debug!("kill_loans_out_of_scope_at_location: kill{:?} \
- location={:?} borrow_data={:?}", borrow_index, location, borrow_data);
- sets.kill(&borrow_index);
+ let borrow_region = borrow_data.region.to_region_index();
+ if !regioncx.region_contains_point(borrow_region, location) {
+ // The region checker really considers the borrow
+ // to start at the point **after** the location of
+ // the borrow, but the borrow checker puts the gen
+ // directly **on** the location of the
+ // borrow. This results in a gen/kill both being
+ // generated for same point if we are not
+ // careful. Probably we should change the point of
+ // the gen, but for now we hackily account for the
+ // mismatch here by not generating a kill for the
+ // location on the borrow itself.
+ if location != borrow_data.location {
+ sets.kill(&borrow_index);
+ }
}
}
}
self.propagate_bits_into_entry_set_for(in_out, changed, dest_bb);
}
}
+ mir::TerminatorKind::FalseEdges { ref real_target, ref imaginary_targets } => {
+ self.propagate_bits_into_entry_set_for(in_out, changed, real_target);
+ for target in imaginary_targets {
+ self.propagate_bits_into_entry_set_for(in_out, changed, target);
+ }
+ }
}
}
TerminatorKind::Goto { target: _ } |
TerminatorKind::Resume |
TerminatorKind::GeneratorDrop |
+ TerminatorKind::FalseEdges { .. } |
TerminatorKind::Unreachable => { }
TerminatorKind::Return => {
TerminatorKind::GeneratorDrop |
TerminatorKind::Resume |
TerminatorKind::Return |
- TerminatorKind::Unreachable => {
+ TerminatorKind::Unreachable |
+ TerminatorKind::FalseEdges { .. } => {
// safe (at least as emitted during MIR construction)
}
use rustc::middle::region;
use rustc::mir::transform::{MirPass, MirSource};
use rustc::mir::{BasicBlock, Location, Mir, Rvalue, Statement, StatementKind};
-use rustc::mir::visit::{MutVisitor, Visitor, Lookup};
+use rustc::mir::visit::{MutVisitor, Visitor, TyContext};
use rustc::ty::{Ty, RegionKind, TyCtxt};
pub struct CleanEndRegions;
self.super_rvalue(rvalue, location);
}
- fn visit_ty(&mut self, ty: &Ty<'tcx>, _: Lookup) {
+ fn visit_ty(&mut self, ty: &Ty<'tcx>, _: TyContext) {
// Gather regions that occur in types
for re in ty.walk().flat_map(|t| t.regions()) {
match *re {
use rustc::ty::subst::Substs;
use rustc::ty::{self, Ty, TyCtxt};
use rustc::mir::*;
-use rustc::mir::visit::{MutVisitor, Lookup};
+use rustc::mir::visit::{MutVisitor, TyContext};
use rustc::mir::transform::{MirPass, MirSource};
struct EraseRegionsVisitor<'a, 'tcx: 'a> {
}
impl<'a, 'tcx> MutVisitor<'tcx> for EraseRegionsVisitor<'a, 'tcx> {
- fn visit_ty(&mut self, ty: &mut Ty<'tcx>, _: Lookup) {
+ fn visit_ty(&mut self, ty: &mut Ty<'tcx>, _: TyContext) {
if !self.in_validation_statement {
*ty = self.tcx.erase_regions(ty);
}
}
}
TerminatorKind::Unreachable => { }
+ TerminatorKind::FalseEdges { ref mut real_target, ref mut imaginary_targets } => {
+ *real_target = self.update_target(*real_target);
+ for target in imaginary_targets {
+ *target = self.update_target(*target);
+ }
+ }
}
}
pub(super) fn generate_constraints<'a, 'gcx, 'tcx>(
infcx: &InferCtxt<'a, 'gcx, 'tcx>,
- regioncx: &mut RegionInferenceContext,
+ regioncx: &mut RegionInferenceContext<'tcx>,
mir: &Mir<'tcx>,
mir_source: MirSource,
liveness: &LivenessResults,
struct ConstraintGeneration<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
infcx: &'cx InferCtxt<'cx, 'gcx, 'tcx>,
- regioncx: &'cx mut RegionInferenceContext,
+ regioncx: &'cx mut RegionInferenceContext<'tcx>,
mir: &'cx Mir<'tcx>,
liveness: &'cx LivenessResults,
mir_source: MirSource,
_borrowed_lv: &Lvalue<'tcx>,
) {
let tcx = self.infcx.tcx;
+ let span = self.mir.source_info(location).span;
let destination_ty = destination_lv.ty(self.mir, tcx).to_ty(tcx);
let destination_region = match destination_ty.sty {
_ => bug!()
};
- self.regioncx.add_outlives(borrow_region.to_region_index(),
+ self.regioncx.add_outlives(span,
+ borrow_region.to_region_index(),
destination_region.to_region_index(),
location.successor_within_block());
}
},
}
- self.regioncx.add_outlives(base_region.to_region_index(),
+ let span = self.mir.source_info(location).span;
+ self.regioncx.add_outlives(span,
+ base_region.to_region_index(),
borrow_region.to_region_index(),
location.successor_within_block());
}
let destination_ty = destination_lv.ty(self.mir, tcx).to_ty(tcx);
let rv_ty = rv.ty(self.mir, tcx);
+ let span = self.mir.source_info(location).span;
for (a, b) in subtype::outlives_pairs(tcx, rv_ty, destination_ty) {
- self.regioncx.add_outlives(a, b, location.successor_within_block());
+ self.regioncx.add_outlives(span, a, b, location.successor_within_block());
}
}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Code to extract the free regions declared on a function and the
+//! relationships between them. For example:
+//!
+//! ```
+//! fn foo<'a, 'b, 'c: 'b>() { }
+//! ```
+//!
+//! here we would be returning a map assigning each of `{'a, 'b, 'c}`
+//! to an index, as well as the `FreeRegionMap` which can compute
+//! relationships between them.
+//!
+//! The code in this file doesn't *do anything* with those results; it
+//! just returns them for other code to use.
+
+use rustc::infer::InferCtxt;
+use rustc::middle::free_region::FreeRegionMap;
+use rustc::mir::transform::MirSource;
+use rustc::ty;
+use rustc::ty::subst::Substs;
+use rustc::util::nodemap::FxHashMap;
+
+#[derive(Debug)]
+pub struct FreeRegions<'tcx> {
+ /// Given a free region defined on this function (either early- or
+ /// late-bound), this maps it to its internal region index. The
+ /// corresponding variable will be "capped" so that it cannot
+ /// grow.
+ pub indices: FxHashMap<ty::Region<'tcx>, usize>,
+
+ /// The map from the typeck tables telling us how to relate free regions.
+ pub free_region_map: &'tcx FreeRegionMap<'tcx>,
+}
+
+pub fn free_regions<'a, 'gcx, 'tcx>(
+ infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+ source: MirSource,
+) -> FreeRegions<'tcx> {
+ debug!("free_regions(source={:?})", source);
+
+ let item_id = source.item_id();
+ let item_def_id = infcx.tcx.hir.local_def_id(item_id);
+
+ let mut indices = FxHashMap();
+
+ // Extract the early regions.
+ let item_substs = Substs::identity_for_item(infcx.tcx, item_def_id);
+ for item_subst in item_substs {
+ if let Some(region) = item_subst.as_region() {
+ insert_free_region(&mut indices, region);
+ }
+ }
+
+ // Extract the late-bound regions. Use the liberated fn sigs,
+ // where the late-bound regions will have been converted into free
+ // regions, and add them to the map.
+ let fn_hir_id = infcx.tcx.hir.node_to_hir_id(item_id);
+ let tables = infcx.tcx.typeck_tables_of(item_def_id);
+ let fn_sig = tables.liberated_fn_sigs()[fn_hir_id].clone();
+ infcx
+ .tcx
+ .for_each_free_region(&fn_sig.inputs_and_output, |region| {
+ if let ty::ReFree(_) = *region {
+ insert_free_region(&mut indices, region);
+ }
+ });
+
+ debug!("free_regions: indices={:#?}", indices);
+
+ FreeRegions { indices, free_region_map: &tables.free_region_map }
+}
+
+fn insert_free_region<'tcx>(
+ free_regions: &mut FxHashMap<ty::Region<'tcx>, usize>,
+ region: ty::Region<'tcx>,
+) {
+ let len = free_regions.len();
+ free_regions.entry(region).or_insert(len);
+}
// except according to those terms.
use rustc::ty::{self, RegionKind};
-use rustc::mir::{Location, Mir};
+use rustc::mir::Mir;
use rustc::mir::transform::MirSource;
use rustc::infer::InferCtxt;
use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::indexed_vec::Idx;
use std::collections::BTreeSet;
-use std::fmt;
use util::liveness::{self, LivenessMode, LivenessResult, LocalSet};
use util as mir_util;
use self::mir_util::PassWhere;
mod constraint_generation;
+mod free_regions;
mod subtype;
pub(crate) mod region_infer;
infcx: &InferCtxt<'a, 'gcx, 'tcx>,
source: MirSource,
mir: &mut Mir<'tcx>,
-) -> RegionInferenceContext {
+) -> RegionInferenceContext<'tcx> {
+ // Compute named region information.
+ let free_regions = &free_regions::free_regions(infcx, source);
+
// Replace all regions with fresh inference variables.
- let num_region_variables = renumber::renumber_mir(infcx, mir);
+ let num_region_variables = renumber::renumber_mir(infcx, free_regions, mir);
// Compute what is live where.
let liveness = &LivenessResults {
// Create the region inference context, generate the constraints,
// and then solve them.
- let mut regioncx = RegionInferenceContext::new(num_region_variables);
+ let mut regioncx = RegionInferenceContext::new(free_regions, num_region_variables, mir);
constraint_generation::generate_constraints(infcx, &mut regioncx, &mir, source, liveness);
- let errors = regioncx.solve(infcx, &mir);
-
- assert!(errors.is_empty(), "FIXME: report region inference failures");
+ regioncx.solve(infcx, &mir);
// Dump MIR results into a file, if that is enabled. This let us
// write unit-tests.
});
}
-#[derive(Clone, Default, PartialEq, Eq)]
-pub struct Region {
- points: BTreeSet<Location>,
-}
-
-impl fmt::Debug for Region {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
- write!(formatter, "{:?}", self.points)
- }
-}
-
-impl Region {
- pub fn add_point(&mut self, point: Location) -> bool {
- self.points.insert(point)
- }
-
- pub fn may_contain(&self, point: Location) -> bool {
- self.points.contains(&point)
- }
-}
-
newtype_index!(RegionIndex {
DEBUG_FORMAT = "'_#{}r",
});
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::{Region, RegionIndex};
-use std::mem;
+use super::RegionIndex;
+use super::free_regions::FreeRegions;
use rustc::infer::InferCtxt;
use rustc::mir::{Location, Mir};
-use rustc_data_structures::indexed_vec::IndexVec;
+use rustc::ty;
+use rustc_data_structures::indexed_vec::{Idx, IndexVec};
use rustc_data_structures::fx::FxHashSet;
+use std::collections::BTreeSet;
+use std::fmt;
+use syntax_pos::Span;
-pub struct RegionInferenceContext {
+pub struct RegionInferenceContext<'tcx> {
/// Contains the definition for every region variable. Region
/// variables are identified by their index (`RegionIndex`). The
/// definition contains information about where the region came
/// from as well as its final inferred value.
- definitions: IndexVec<RegionIndex, RegionDefinition>,
+ definitions: IndexVec<RegionIndex, RegionDefinition<'tcx>>,
+
+ /// The indices of all "free regions" in scope. These are the
+ /// lifetime parameters (anonymous and named) declared in the
+ /// function signature:
+ ///
+ /// fn foo<'a, 'b>(x: &Foo<'a, 'b>)
+ /// ^^ ^^ ^
+ ///
+ /// These indices will be from 0..N, as it happens, but we collect
+ /// them into a vector for convenience.
+ free_regions: Vec<RegionIndex>,
/// The constraints we have accumulated and used during solving.
constraints: Vec<Constraint>,
+}
+
+#[derive(Default)]
+struct RegionDefinition<'tcx> {
+ /// If this is a free-region, then this is `Some(X)` where `X` is
+ /// the name of the region.
+ name: Option<ty::Region<'tcx>>,
+
+ /// If true, this is a constant region which cannot grow larger.
+ /// This is used for named regions as well as `'static`.
+ constant: bool,
+
+ /// The current value of this inference variable. This starts out
+ /// empty, but grows as we add constraints. The final value is
+ /// determined when `solve()` is executed.
+ value: Region,
+}
- /// List of errors we have accumulated as we add constraints.
- /// After solving is done, this is replaced with an empty vector.
- errors: Vec<InferenceError>,
+/// The value of an individual region variable. Region variables
+/// consist of a set of points in the CFG as well as a set of "free
+/// regions", which are sometimes written as `end(R)`. These
+/// correspond to the named lifetimes and refer to portions of the
+/// caller's control-flow graph -- specifically some portion that can
+/// be reached after we return.
+#[derive(Clone, Default, PartialEq, Eq)]
+struct Region {
+ points: BTreeSet<Location>,
+ free_regions: BTreeSet<RegionIndex>,
}
-pub struct InferenceError {
- pub constraint_point: Location,
- pub name: (), // FIXME(nashenas88) RegionName
+impl fmt::Debug for Region {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ formatter
+ .debug_set()
+ .entries(&self.points)
+ .entries(&self.free_regions)
+ .finish()
+ }
}
-#[derive(Default)]
-struct RegionDefinition {
- name: (), // FIXME(nashenas88) RegionName
- value: Region,
- capped: bool,
+impl Region {
+ fn add_point(&mut self, point: Location) -> bool {
+ self.points.insert(point)
+ }
+
+ fn add_free_region(&mut self, region: RegionIndex) -> bool {
+ self.free_regions.insert(region)
+ }
+
+ fn contains_point(&self, point: Location) -> bool {
+ self.points.contains(&point)
+ }
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct Constraint {
- sub: RegionIndex,
+ /// Where did this constraint arise?
+ span: Span,
+
+ /// The region SUP must outlive SUB...
sup: RegionIndex,
+
+ /// Region that must be outlived.
+ sub: RegionIndex,
+
+ /// At this location.
point: Location,
}
-impl RegionInferenceContext {
- pub fn new(num_region_variables: usize) -> Self {
- Self {
+impl<'a, 'gcx, 'tcx> RegionInferenceContext<'tcx> {
+ /// Creates a new region inference context with a total of
+ /// `num_region_variables` valid inference variables; the first N
+ /// of those will be constant regions representing the free
+ /// regions defined in `free_regions`.
+ pub fn new(
+ free_regions: &FreeRegions<'tcx>,
+ num_region_variables: usize,
+ mir: &Mir<'tcx>,
+ ) -> Self {
+ let mut result = Self {
definitions: (0..num_region_variables)
.map(|_| RegionDefinition::default())
.collect(),
constraints: Vec::new(),
- errors: Vec::new(),
- }
+ free_regions: Vec::new(),
+ };
+
+ result.init_free_regions(free_regions, mir);
+
+ result
}
+ /// Initializes the region variables for each free region
+ /// (lifetime parameter). The first N variables always correspond
+ /// to the free regions appearing in the function signature (both
+ /// named and anonymous) and where clauses. This function iterates
+ /// over those regions and initializes them with minimum values.
+ ///
+ /// For example:
+ ///
+ /// fn foo<'a, 'b>(..) where 'a: 'b
+ ///
+ /// would initialize two variables like so:
+ ///
+ /// R0 = { CFG, R0 } // 'a
+ /// R1 = { CFG, R0, R1 } // 'b
+ ///
+ /// Here, R0 represents `'a`, and it contains (a) the entire CFG
+ /// and (b) any free regions that it outlives, which in this case
+ /// is just itself. R1 (`'b`) in contrast also outlives `'a` and
+ /// hence contains R0 and R1.
+ fn init_free_regions(&mut self, free_regions: &FreeRegions<'tcx>, mir: &Mir<'tcx>) {
+ let &FreeRegions {
+ ref indices,
+ ref free_region_map,
+ } = free_regions;
+
+ // For each free region X:
+ for (free_region, index) in indices {
+ let variable = RegionIndex::new(*index);
+
+ self.free_regions.push(variable);
+
+ // Initialize the name and a few other details.
+ self.definitions[variable].name = Some(free_region);
+ self.definitions[variable].constant = true;
+
+ // Add all nodes in the CFG to `definition.value`.
+ for (block, block_data) in mir.basic_blocks().iter_enumerated() {
+ let definition = &mut self.definitions[variable];
+ for statement_index in 0..block_data.statements.len() + 1 {
+ let location = Location {
+ block,
+ statement_index,
+ };
+ definition.value.add_point(location);
+ }
+ }
+
+ // Add `end(X)` into the set for X.
+ self.definitions[variable].value.add_free_region(variable);
+
+ // Go through each region Y that outlives X (i.e., where
+ // Y: X is true). Add `end(X)` into the set for `Y`.
+ for superregion in free_region_map.regions_that_outlive(&free_region) {
+ let superregion_index = RegionIndex::new(indices[superregion]);
+ self.definitions[superregion_index]
+ .value
+ .add_free_region(variable);
+ }
+
+ debug!(
+ "init_free_regions: region variable for `{:?}` is `{:?}` with value `{:?}`",
+ free_region,
+ variable,
+ self.definitions[variable].value
+ );
+ }
+ }
/// Returns an iterator over all the region indices.
pub fn regions(&self) -> impl Iterator<Item = RegionIndex> {
self.definitions.indices()
}
- /// Returns the inferred value for the region `r`.
+ /// Returns true if the region `r` contains the point `p`.
///
/// Until `solve()` executes, this value is not particularly meaningful.
- pub fn region_value(&self, r: RegionIndex) -> &Region {
- &self.definitions[r].value
+ pub fn region_contains_point(&self, r: RegionIndex, p: Location) -> bool {
+ self.definitions[r].value.contains_point(p)
}
- /// Flags a region as being "capped" -- this means that if its
- /// value is required to grow as a result of some constraint
- /// (e.g., `add_live_point` or `add_outlives`), that indicates an
- /// error. This is used for the regions representing named
- /// lifetime parameters on a function: they get initialized to
- /// their complete value, and then "capped" so that they can no
- /// longer grow.
- #[allow(dead_code)]
- pub(super) fn cap_var(&mut self, v: RegionIndex) {
- self.definitions[v].capped = true;
+ /// Returns access to the value of `r` for debugging purposes.
+ pub(super) fn region_value(&self, r: RegionIndex) -> &fmt::Debug {
+ &self.definitions[r].value
}
+ /// Indicates that the region variable `v` is live at the point `point`.
pub(super) fn add_live_point(&mut self, v: RegionIndex, point: Location) {
debug!("add_live_point({:?}, {:?})", v, point);
let definition = &mut self.definitions[v];
- if definition.value.add_point(point) {
- if definition.capped {
- self.errors.push(InferenceError {
- constraint_point: point,
- name: definition.name,
- });
- }
+ if !definition.constant {
+ definition.value.add_point(point);
+ } else {
+ // Constants are used for free regions, which already
+ // contain all the points in the control-flow graph.
+ assert!(definition.value.contains_point(point));
}
}
- pub(super) fn add_outlives(&mut self, sup: RegionIndex, sub: RegionIndex, point: Location) {
+ /// Indicates that the region variable `sup` must outlive `sub` is live at the point `point`.
+ pub(super) fn add_outlives(
+ &mut self,
+ span: Span,
+ sup: RegionIndex,
+ sub: RegionIndex,
+ point: Location,
+ ) {
debug!("add_outlives({:?}: {:?} @ {:?}", sup, sub, point);
- self.constraints.push(Constraint { sup, sub, point });
+ self.constraints.push(Constraint {
+ span,
+ sup,
+ sub,
+ point,
+ });
}
/// Perform region inference.
- pub(super) fn solve<'a, 'gcx, 'tcx>(
+ pub(super) fn solve(&mut self, infcx: &InferCtxt<'a, 'gcx, 'tcx>, mir: &Mir<'tcx>) {
+ let errors = self.propagate_constraints(mir);
+
+ // worst error msg ever
+ for (fr1, span, fr2) in errors {
+ infcx.tcx.sess.span_err(
+ span,
+ &format!(
+ "free region `{}` does not outlive `{}`",
+ self.definitions[fr1].name.unwrap(),
+ self.definitions[fr2].name.unwrap()
+ ),
+ );
+ }
+ }
+
+ /// Propagate the region constraints: this will grow the values
+ /// for each region variable until all the constraints are
+ /// satisfied. Note that some values may grow **too** large to be
+ /// feasible, but we check this later.
+ fn propagate_constraints(
&mut self,
- infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
- mir: &'a Mir<'tcx>,
- ) -> Vec<InferenceError>
- where
- 'gcx: 'tcx + 'a,
- 'tcx: 'a,
- {
+ mir: &Mir<'tcx>,
+ ) -> Vec<(RegionIndex, Span, RegionIndex)> {
let mut changed = true;
- let mut dfs = Dfs::new(infcx, mir);
+ let mut dfs = Dfs::new(mir);
+ let mut error_regions = FxHashSet();
+ let mut errors = vec![];
while changed {
changed = false;
for constraint in &self.constraints {
+ debug!("constraint: {:?}", constraint);
let sub = &self.definitions[constraint.sub].value.clone();
let sup_def = &mut self.definitions[constraint.sup];
- debug!("constraint: {:?}", constraint);
+
debug!(" sub (before): {:?}", sub);
debug!(" sup (before): {:?}", sup_def.value);
- if dfs.copy(sub, &mut sup_def.value, constraint.point) {
- changed = true;
- if sup_def.capped {
- // This is kind of a hack, but when we add a
- // constraint, the "point" is always the point
- // AFTER the action that induced the
- // constraint. So report the error on the
- // action BEFORE that.
- assert!(constraint.point.statement_index > 0);
- let p = Location {
- block: constraint.point.block,
- statement_index: constraint.point.statement_index - 1,
- };
-
- self.errors.push(InferenceError {
- constraint_point: p,
- name: sup_def.name,
- });
+ if !sup_def.constant {
+ // If this is not a constant, then grow the value as needed to
+ // accommodate the outlives constraint.
+
+ if dfs.copy(sub, &mut sup_def.value, constraint.point) {
+ changed = true;
}
- }
- debug!(" sup (after) : {:?}", sup_def.value);
- debug!(" changed : {:?}", changed);
+ debug!(" sup (after) : {:?}", sup_def.value);
+ debug!(" changed : {:?}", changed);
+ } else {
+ // If this is a constant, check whether it *would
+ // have* to grow in order for the constraint to be
+ // satisfied. If so, create an error.
+
+ let mut sup_value = sup_def.value.clone();
+ if dfs.copy(sub, &mut sup_value, constraint.point) {
+ // Constant values start out with the entire
+ // CFG, so it must be some new free region
+ // that was added. Find one.
+ let &new_region = sup_value
+ .free_regions
+ .difference(&sup_def.value.free_regions)
+ .next()
+ .unwrap();
+ debug!(" new_region : {:?}", new_region);
+ if error_regions.insert(constraint.sup) {
+ errors.push((constraint.sup, constraint.span, new_region));
+ }
+ }
+ }
}
debug!("\n");
}
-
- mem::replace(&mut self.errors, Vec::new())
+ errors
}
}
-struct Dfs<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> {
- #[allow(dead_code)] infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+struct Dfs<'a, 'tcx: 'a> {
mir: &'a Mir<'tcx>,
}
-impl<'a, 'gcx: 'tcx, 'tcx: 'a> Dfs<'a, 'gcx, 'tcx> {
- fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>, mir: &'a Mir<'tcx>) -> Self {
- Self { infcx, mir }
+impl<'a, 'tcx> Dfs<'a, 'tcx> {
+ fn new(mir: &'a Mir<'tcx>) -> Self {
+ Self { mir }
}
fn copy(
while let Some(p) = stack.pop() {
debug!(" dfs: p={:?}", p);
- if !from_region.may_contain(p) {
+ if !from_region.contains_point(p) {
debug!(" not in from-region");
continue;
}
};
if successor_points.is_empty() {
- // FIXME handle free regions
// If we reach the END point in the graph, then copy
// over any skolemized end points in the `from_region`
// and make sure they are included in the `to_region`.
- // for region_decl in self.infcx.tcx.tables.borrow().free_region_map() {
- // // FIXME(nashenas88) figure out skolemized_end points
- // let block = self.env.graph.skolemized_end(region_decl.name);
- // let skolemized_end_point = Location {
- // block,
- // statement_index: 0,
- // };
- // changed |= to_region.add_point(skolemized_end_point);
- // }
+
+ debug!(" dfs: free_regions={:?}", from_region.free_regions);
+ for &fr in &from_region.free_regions {
+ changed |= to_region.free_regions.insert(fr);
+ }
} else {
stack.extend(successor_points);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rustc::ty::TypeFoldable;
+use rustc_data_structures::indexed_vec::Idx;
use rustc::ty::subst::{Kind, Substs};
-use rustc::ty::{Ty, ClosureSubsts, RegionVid, RegionKind};
-use rustc::mir::{Mir, Location, Rvalue, BasicBlock, Statement, StatementKind};
-use rustc::mir::visit::{MutVisitor, Lookup};
+use rustc::ty::{self, ClosureSubsts, RegionKind, RegionVid, Ty, TypeFoldable};
+use rustc::mir::{BasicBlock, Local, Location, Mir, Rvalue, Statement, StatementKind};
+use rustc::mir::visit::{MutVisitor, TyContext};
use rustc::infer::{self as rustc_infer, InferCtxt};
use syntax_pos::DUMMY_SP;
use std::collections::HashMap;
+use super::free_regions::FreeRegions;
+
/// Replaces all free regions appearing in the MIR with fresh
/// inference variables, returning the number of variables created.
-pub fn renumber_mir<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
- mir: &mut Mir<'tcx>)
- -> usize
-{
- let mut visitor = NLLVisitor::new(infcx);
+pub fn renumber_mir<'a, 'gcx, 'tcx>(
+ infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+ free_regions: &FreeRegions<'tcx>,
+ mir: &mut Mir<'tcx>,
+) -> usize {
+ // Create inference variables for each of the free regions
+ // declared on the function signature.
+ let free_region_inference_vars = (0..free_regions.indices.len())
+ .map(|_| {
+ infcx.next_region_var(rustc_infer::MiscVariable(DUMMY_SP))
+ })
+ .collect();
+
+ let mut visitor = NLLVisitor {
+ infcx,
+ lookup_map: HashMap::new(),
+ num_region_variables: free_regions.indices.len(),
+ free_regions,
+ free_region_inference_vars,
+ arg_count: mir.arg_count,
+ };
visitor.visit_mir(mir);
visitor.num_region_variables
}
struct NLLVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
- lookup_map: HashMap<RegionVid, Lookup>,
+ lookup_map: HashMap<RegionVid, TyContext>,
num_region_variables: usize,
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+ free_regions: &'a FreeRegions<'tcx>,
+ free_region_inference_vars: Vec<ty::Region<'tcx>>,
+ arg_count: usize,
}
impl<'a, 'gcx, 'tcx> NLLVisitor<'a, 'gcx, 'tcx> {
- pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self {
- NLLVisitor {
- infcx,
- lookup_map: HashMap::new(),
- num_region_variables: 0
- }
+ /// Replaces all regions appearing in `value` with fresh inference
+ /// variables. This is what we do for almost the entire MIR, with
+ /// the exception of the declared types of our arguments.
+ fn renumber_regions<T>(&mut self, value: &T) -> T
+ where
+ T: TypeFoldable<'tcx>,
+ {
+ self.infcx
+ .tcx
+ .fold_regions(value, &mut false, |_region, _depth| {
+ self.num_region_variables += 1;
+ self.infcx
+ .next_region_var(rustc_infer::MiscVariable(DUMMY_SP))
+ })
}
- fn renumber_regions<T>(&mut self, value: &T) -> T where T: TypeFoldable<'tcx> {
- self.infcx.tcx.fold_regions(value, &mut false, |_region, _depth| {
- self.num_region_variables += 1;
- self.infcx.next_region_var(rustc_infer::MiscVariable(DUMMY_SP))
- })
+ /// Renumbers the regions appearing in `value`, but those regions
+ /// are expected to be free regions from the function signature.
+ fn renumber_free_regions<T>(&mut self, value: &T) -> T
+ where
+ T: TypeFoldable<'tcx>,
+ {
+ self.infcx
+ .tcx
+ .fold_regions(value, &mut false, |region, _depth| {
+ let index = self.free_regions.indices[®ion];
+ self.free_region_inference_vars[index]
+ })
}
- fn store_region(&mut self, region: &RegionKind, lookup: Lookup) {
+ fn store_region(&mut self, region: &RegionKind, lookup: TyContext) {
if let RegionKind::ReVar(rid) = *region {
self.lookup_map.entry(rid).or_insert(lookup);
}
}
- fn store_ty_regions(&mut self, ty: &Ty<'tcx>, lookup: Lookup) {
+ fn store_ty_regions(&mut self, ty: &Ty<'tcx>, ty_context: TyContext) {
for region in ty.regions() {
- self.store_region(region, lookup);
+ self.store_region(region, ty_context);
}
}
- fn store_kind_regions(&mut self, kind: &'tcx Kind, lookup: Lookup) {
+ fn store_kind_regions(&mut self, kind: &'tcx Kind, ty_context: TyContext) {
if let Some(ty) = kind.as_type() {
- self.store_ty_regions(&ty, lookup);
+ self.store_ty_regions(&ty, ty_context);
} else if let Some(region) = kind.as_region() {
- self.store_region(region, lookup);
+ self.store_region(region, ty_context);
}
}
+
+ fn is_argument_or_return_slot(&self, local: Local) -> bool {
+ // The first argument is return slot, next N are arguments.
+ local.index() <= self.arg_count
+ }
}
impl<'a, 'gcx, 'tcx> MutVisitor<'tcx> for NLLVisitor<'a, 'gcx, 'tcx> {
- fn visit_ty(&mut self, ty: &mut Ty<'tcx>, lookup: Lookup) {
+ fn visit_ty(&mut self, ty: &mut Ty<'tcx>, ty_context: TyContext) {
+ let is_arg = match ty_context {
+ TyContext::LocalDecl { local, .. } => self.is_argument_or_return_slot(local),
+ _ => false,
+ };
+
let old_ty = *ty;
- *ty = self.renumber_regions(&old_ty);
- self.store_ty_regions(ty, lookup);
+ *ty = if is_arg {
+ self.renumber_free_regions(&old_ty)
+ } else {
+ self.renumber_regions(&old_ty)
+ };
+ self.store_ty_regions(ty, ty_context);
}
fn visit_substs(&mut self, substs: &mut &'tcx Substs<'tcx>, location: Location) {
- *substs = self.renumber_regions(&{*substs});
- let lookup = Lookup::Loc(location);
+ *substs = self.renumber_regions(&{ *substs });
+ let ty_context = TyContext::Location(location);
for kind in *substs {
- self.store_kind_regions(kind, lookup);
+ self.store_kind_regions(kind, ty_context);
}
}
Rvalue::Ref(ref mut r, _, _) => {
let old_r = *r;
*r = self.renumber_regions(&old_r);
- let lookup = Lookup::Loc(location);
- self.store_region(r, lookup);
+ let ty_context = TyContext::Location(location);
+ self.store_region(r, ty_context);
}
Rvalue::Use(..) |
Rvalue::Repeat(..) |
self.super_rvalue(rvalue, location);
}
- fn visit_closure_substs(&mut self,
- substs: &mut ClosureSubsts<'tcx>,
- location: Location) {
+ fn visit_closure_substs(&mut self, substs: &mut ClosureSubsts<'tcx>, location: Location) {
*substs = self.renumber_regions(substs);
- let lookup = Lookup::Loc(location);
+ let ty_context = TyContext::Location(location);
for kind in substs.substs {
- self.store_kind_regions(kind, lookup);
+ self.store_kind_regions(kind, ty_context);
}
}
- fn visit_statement(&mut self,
- block: BasicBlock,
- statement: &mut Statement<'tcx>,
- location: Location) {
+ fn visit_statement(
+ &mut self,
+ block: BasicBlock,
+ statement: &mut Statement<'tcx>,
+ location: Location,
+ ) {
if let StatementKind::EndRegion(_) = statement.kind {
statement.kind = StatementKind::Nop;
}
TerminatorKind::Unreachable |
TerminatorKind::GeneratorDrop |
TerminatorKind::Yield { .. } |
- TerminatorKind::SwitchInt { .. } => {
+ TerminatorKind::SwitchInt { .. } |
+ TerminatorKind::FalseEdges { .. } => {
/* nothing to do */
},
TerminatorKind::Call { cleanup: ref mut unwind, .. } |
TerminatorKind::Resume |
TerminatorKind::GeneratorDrop |
TerminatorKind::Yield { .. } |
- TerminatorKind::Unreachable => None,
+ TerminatorKind::Unreachable |
+ TerminatorKind::FalseEdges { .. } => None,
TerminatorKind::Return => {
// Check for unused values. This usually means
}), expected, .. } if cond == expected => {
TerminatorKind::Goto { target: target }
},
+ TerminatorKind::FalseEdges { real_target, .. } => {
+ TerminatorKind::Goto { target: real_target }
+ },
_ => continue
};
}
self.sanitize_type(rvalue, rval_ty);
}
- fn visit_local_decl(&mut self, local_decl: &LocalDecl<'tcx>) {
- self.super_local_decl(local_decl);
+ fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) {
+ self.super_local_decl(local, local_decl);
self.sanitize_type(local_decl, local_decl.ty);
}
TerminatorKind::Return |
TerminatorKind::GeneratorDrop |
TerminatorKind::Unreachable |
- TerminatorKind::Drop { .. } => {
+ TerminatorKind::Drop { .. } |
+ TerminatorKind::FalseEdges { .. } => {
// no checks needed for these
}
self.assert_iscleanup(mir, block, cleanup, true);
}
}
+ TerminatorKind::FalseEdges { real_target, ref imaginary_targets } => {
+ self.assert_iscleanup(mir, block, real_target, is_cleanup);
+ for target in imaginary_targets {
+ self.assert_iscleanup(mir, block, *target, is_cleanup);
+ }
+ }
}
}
}
}
+ fn invalid_non_exhaustive_attribute(&self, variant: &Variant) {
+ let has_non_exhaustive = variant.node.attrs.iter()
+ .any(|attr| attr.check_name("non_exhaustive"));
+ if has_non_exhaustive {
+ self.err_handler().span_err(variant.span,
+ "#[non_exhaustive] is not yet supported on variants");
+ }
+ }
+
fn invalid_visibility(&self, vis: &Visibility, span: Span, note: Option<&str>) {
if vis != &Visibility::Inherited {
let mut err = struct_span_err!(self.session,
item.span,
Some("place qualifiers on individual impl items instead"));
}
- ItemKind::DefaultImpl(..) => {
+ ItemKind::AutoImpl(..) => {
self.invalid_visibility(&item.vis, item.span, None);
}
ItemKind::ForeignMod(..) => {
}
ItemKind::Enum(ref def, _) => {
for variant in &def.variants {
+ self.invalid_non_exhaustive_attribute(variant);
for field in variant.node.data.fields() {
self.invalid_visibility(&field.vis, field.span, None);
}
}
}
- ItemKind::Trait(.., ref bounds, ref trait_items) => {
+ ItemKind::Trait(is_auto, _, ref generics, ref bounds, ref trait_items) => {
+ if is_auto == IsAuto::Yes {
+ // Auto traits cannot have generics, super traits nor contain items.
+ if !generics.ty_params.is_empty() {
+ self.err_handler().span_err(item.span,
+ "auto traits cannot have generics");
+ }
+ if !bounds.is_empty() {
+ self.err_handler().span_err(item.span,
+ "auto traits cannot have super traits");
+ }
+ if !trait_items.is_empty() {
+ self.err_handler().span_err(item.span,
+ "auto traits cannot contain items");
+ }
+ }
self.no_questions_in_bounds(bounds, "supertraits", true);
for trait_item in trait_items {
if let TraitItemKind::Method(ref sig, ref block) = trait_item.node {
use rustc::ty::subst::Substs;
use rustc::traits::Reveal;
use rustc::util::common::ErrorReported;
-use rustc::util::nodemap::{ItemLocalMap, NodeSet};
+use rustc::util::nodemap::{ItemLocalSet, NodeSet};
use rustc::lint::builtin::CONST_ERR;
use rustc::hir::{self, PatKind, RangeEnd};
use std::rc::Rc;
.expect("rvalue_promotable_map invoked with non-local def-id");
let body_id = tcx.hir.body_owned_by(node_id);
let body_hir_id = tcx.hir.node_to_hir_id(body_id.node_id);
- tcx.rvalue_promotable_map(def_id).contains_key(&body_hir_id.local_id)
+ tcx.rvalue_promotable_map(def_id).contains(&body_hir_id.local_id)
}
fn rvalue_promotable_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
- -> Rc<ItemLocalMap<bool>>
+ -> Rc<ItemLocalSet>
{
let outer_def_id = tcx.closure_base_def_id(def_id);
if outer_def_id != def_id {
mut_rvalue_borrows: NodeSet(),
param_env: ty::ParamEnv::empty(Reveal::UserFacing),
identity_substs: Substs::empty(),
- result_map: ItemLocalMap(),
+ result: ItemLocalSet(),
};
// `def_id` should be a `Body` owner
let body_id = tcx.hir.body_owned_by(node_id);
visitor.visit_nested_body(body_id);
- Rc::new(visitor.result_map)
+ Rc::new(visitor.result)
}
struct CheckCrateVisitor<'a, 'tcx: 'a> {
param_env: ty::ParamEnv<'tcx>,
identity_substs: &'tcx Substs<'tcx>,
tables: &'a ty::TypeckTables<'tcx>,
- result_map: ItemLocalMap<bool>,
+ result: ItemLocalSet,
}
impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
}
}
- self.result_map.insert(ex.hir_id.local_id, self.promotable);
+ if self.promotable {
+ self.result.insert(ex.hir_id.local_id);
+ }
self.promotable &= outer;
}
}
use rustc_const_math::{ConstUsize};
use rustc::mir::{AggregateKind, AssertMessage, BasicBlock, BasicBlockData};
-use rustc::mir::{Constant, Literal, Location, LocalDecl};
+use rustc::mir::{Constant, Literal, Location, Local, LocalDecl};
use rustc::mir::{Lvalue, LvalueElem, LvalueProjection};
use rustc::mir::{Mir, Operand, ProjectionElem};
use rustc::mir::{Rvalue, SourceInfo, Statement, StatementKind};
TerminatorKind::Assert { .. } => "TerminatorKind::Assert",
TerminatorKind::GeneratorDrop => "TerminatorKind::GeneratorDrop",
TerminatorKind::Yield { .. } => "TerminatorKind::Yield",
+ TerminatorKind::FalseEdges { .. } => "TerminatorKind::FalseEdges",
}, kind);
self.super_terminator_kind(block, kind, location);
}
}
fn visit_local_decl(&mut self,
+ local: Local,
local_decl: &LocalDecl<'tcx>) {
self.record("LocalDecl", local_decl);
- self.super_local_decl(local_decl);
+ self.super_local_decl(local, local_decl);
}
fn visit_visibility_scope(&mut self,
let def_id = self.tcx.hir.local_def_id(item.id);
cmp::min(self.item_ty_level(def_id), self.impl_trait_level(def_id))
}
- hir::ItemDefaultImpl(..) => {
+ hir::ItemAutoImpl(..) => {
let def_id = self.tcx.hir.local_def_id(item.id);
self.impl_trait_level(def_id)
}
}
hir::ItemUse(..) | hir::ItemStatic(..) | hir::ItemConst(..) |
hir::ItemGlobalAsm(..) | hir::ItemTy(..) | hir::ItemMod(..) |
- hir::ItemFn(..) | hir::ItemExternCrate(..) | hir::ItemDefaultImpl(..) => {}
+ hir::ItemFn(..) | hir::ItemExternCrate(..) | hir::ItemAutoImpl(..) => {}
}
// Mark all items in interfaces of reachable items as reachable
// Reexports are handled in visit_mod
hir::ItemUse(..) => {}
// The interface is empty
- hir::ItemDefaultImpl(..) => {}
+ hir::ItemAutoImpl(..) => {}
// The interface is empty
hir::ItemGlobalAsm(..) => {}
// Visit everything
ctor_vis = field_vis;
}
}
+
+ // If the structure is marked as non_exhaustive then lower the
+ // visibility to within the crate.
+ let struct_def_id = self.tcx.hir.get_parent_did(node_id);
+ let adt_def = self.tcx.adt_def(struct_def_id);
+ if adt_def.is_non_exhaustive() && ctor_vis == ty::Visibility::Public {
+ ctor_vis = ty::Visibility::Restricted(
+ DefId::local(CRATE_DEF_INDEX));
+ }
+
return ctor_vis;
}
node => bug!("unexpected node kind: {:?}", node)
}
}
// The interface is empty
- hir::ItemDefaultImpl(..) => {}
+ hir::ItemAutoImpl(..) => {}
// An inherent impl is public when its type is public
// Subitems of inherent impls have their own publicity
hir::ItemImpl(.., None, _, ref impl_item_refs) => {
arena = { path = "../libarena" }
rustc_errors = { path = "../librustc_errors" }
syntax_pos = { path = "../libsyntax_pos" }
+rustc_data_structures = { path = "../librustc_data_structures" }
// These items live in both the type and value namespaces.
ItemKind::Struct(ref struct_def, _) => {
// Define a name in the type namespace.
- let def = Def::Struct(self.definitions.local_def_id(item.id));
+ let def_id = self.definitions.local_def_id(item.id);
+ let def = Def::Struct(def_id);
self.define(parent, ident, TypeNS, (def, vis, sp, expansion));
- // Record field names for error reporting.
let mut ctor_vis = vis;
+
+ let has_non_exhaustive = item.attrs.iter()
+ .any(|item| item.check_name("non_exhaustive"));
+
+ // If the structure is marked as non_exhaustive then lower the visibility
+ // to within the crate.
+ if has_non_exhaustive && vis == ty::Visibility::Public {
+ ctor_vis = ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX));
+ }
+
+ // Record field names for error reporting.
let field_names = struct_def.fields().iter().filter_map(|field| {
let field_vis = self.resolve_visibility(&field.vis);
if ctor_vis.is_at_least(field_vis, &*self) {
self.insert_field_names(item_def_id, field_names);
}
- ItemKind::DefaultImpl(..) | ItemKind::Impl(..) => {}
+ ItemKind::AutoImpl(..) | ItemKind::Impl(..) => {}
ItemKind::Trait(..) => {
let def_id = self.definitions.local_def_id(item.id);
// value namespace, they are reserved for possible future use.
let ctor_kind = CtorKind::from_ast(&variant.node.data);
let ctor_def = Def::VariantCtor(def_id, ctor_kind);
+
self.define(parent, ident, ValueNS, (ctor_def, vis, variant.span, expansion));
}
extern crate arena;
#[macro_use]
extern crate rustc;
+extern crate rustc_data_structures;
use self::Namespace::*;
use self::TypeParameters::*;
|this| visit::walk_item(this, item));
}
- ItemKind::DefaultImpl(_, ref trait_ref) => {
+ ItemKind::AutoImpl(_, ref trait_ref) => {
self.with_optional_trait_ref(Some(trait_ref), |this, _| {
// Resolve type arguments in trait path
visit::walk_trait_ref(this, trait_ref);
item.id,
impl_items),
- ItemKind::Trait(_, ref generics, ref bounds, ref trait_items) => {
+ ItemKind::Trait(.., ref generics, ref bounds, ref trait_items) => {
// Create a new rib for the trait-wide type parameters.
self.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind), |this| {
let local_def_id = this.definitions.local_def_id(item.id);
}
}
err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?",
- path_str));
+ path_str));
return (err, candidates);
}
_ => {}
use Namespace::{self, MacroNS};
use build_reduced_graph::BuildReducedGraphVisitor;
use resolve_imports::ImportResolver;
+use rustc_data_structures::indexed_vec::Idx;
use rustc::hir::def_id::{DefId, BUILTIN_MACROS_CRATE, CRATE_DEF_INDEX, DefIndex};
use rustc::hir::def::{Def, Export};
use rustc::hir::map::{self, DefCollector};
let mut collector = PathCollector::new();
collector.visit_pat(&arg.pat);
let span_utils = self.span.clone();
- for &(id, ref p, ..) in &collector.collected_paths {
+
+ for (id, i, sp, ..) in collector.collected_idents {
let hir_id = self.tcx.hir.node_to_hir_id(id);
let typ = match self.save_ctxt.tables.node_id_to_type_opt(hir_id) {
Some(s) => s.to_string(),
None => continue,
};
- // get the span only for the name of the variable (I hope the path is only ever a
- // variable name, but who knows?)
- let sub_span = span_utils.span_for_last_ident(p.span);
- if !self.span.filter_generated(sub_span, p.span) {
+ let sub_span = span_utils.span_for_last_ident(sp);
+ if !self.span.filter_generated(sub_span, sp) {
let id = ::id_from_node_id(id, &self.save_ctxt);
let span = self.span_from_span(sub_span.expect("No span found for variable"));
kind: DefKind::Local,
id,
span,
- name: path_to_string(p),
- qualname: format!("{}::{}", qualname, path_to_string(p)),
+ name: i.to_string(),
+ qualname: format!("{}::{}", qualname, i.to_string()),
value: typ,
parent: None,
children: vec![],
}
}
- fn process_trait_ref(&mut self, trait_ref: &'l ast::TraitRef) {
- let trait_ref_data = self.save_ctxt.get_trait_ref_data(trait_ref);
- if let Some(trait_ref_data) = trait_ref_data {
- self.dumper.dump_ref(trait_ref_data);
- }
- self.process_path(trait_ref.ref_id, &trait_ref.path);
- }
-
fn process_struct_field_def(&mut self, field: &ast::StructField, parent_id: NodeId) {
let field_data = self.save_ctxt.get_field_data(field, parent_id);
if let Some(field_data) = field_data {
item: &'l ast::Item,
def: &'l ast::VariantData,
ty_params: &'l ast::Generics) {
+ debug!("process_struct {:?} {:?}", item, item.span);
let name = item.ident.to_string();
let qualname = format!("::{}", self.tcx.node_path_str(item.id));
- let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Struct);
- let (value, fields) =
- if let ast::ItemKind::Struct(ast::VariantData::Struct(ref fields, _), _) = item.node
- {
- let include_priv_fields = !self.save_ctxt.config.pub_only;
- let fields_str = fields
- .iter()
- .enumerate()
- .filter_map(|(i, f)| {
- if include_priv_fields || f.vis == ast::Visibility::Public {
- f.ident.map(|i| i.to_string()).or_else(|| Some(i.to_string()))
- } else {
- None
- }
- })
- .collect::<Vec<_>>()
- .join(", ");
- let value = format!("{} {{ {} }}", name, fields_str);
- (value, fields.iter().map(|f| ::id_from_node_id(f.id, &self.save_ctxt)).collect())
- } else {
- (String::new(), vec![])
+ let (kind, keyword) = match item.node {
+ ast::ItemKind::Struct(_, _) => (DefKind::Struct, keywords::Struct),
+ ast::ItemKind::Union(_, _) => (DefKind::Union, keywords::Union),
+ _ => unreachable!(),
+ };
+
+ let sub_span = self.span.sub_span_after_keyword(item.span, keyword);
+ let (value, fields) = match item.node {
+ ast::ItemKind::Struct(ast::VariantData::Struct(ref fields, _), _) |
+ ast::ItemKind::Union(ast::VariantData::Struct(ref fields, _), _) => {
+ let include_priv_fields = !self.save_ctxt.config.pub_only;
+ let fields_str = fields
+ .iter()
+ .enumerate()
+ .filter_map(|(i, f)| {
+ if include_priv_fields || f.vis == ast::Visibility::Public {
+ f.ident.map(|i| i.to_string()).or_else(|| Some(i.to_string()))
+ } else {
+ None
+ }
+ })
+ .collect::<Vec<_>>()
+ .join(", ");
+ let value = format!("{} {{ {} }}", name, fields_str);
+ (value, fields.iter().map(|f| ::id_from_node_id(f.id, &self.save_ctxt)).collect())
+ }
+ _ => (String::new(), vec![])
};
if !self.span.filter_generated(sub_span, item.span) {
let span = self.span_from_span(sub_span.expect("No span found for struct"));
- let kind = match item.node {
- ast::ItemKind::Struct(_, _) => DefKind::Struct,
- ast::ItemKind::Union(_, _) => DefKind::Union,
- _ => unreachable!(),
- };
self.dumper.dump_def(item.vis == ast::Visibility::Public, Def {
kind,
id: ::id_from_node_id(item.id, &self.save_ctxt),
}
}
- fn process_path(&mut self, id: NodeId, path: &ast::Path) {
+ fn process_path(&mut self, id: NodeId, path: &'l ast::Path) {
+ debug!("process_path {:?}", path);
let path_data = self.save_ctxt.get_path_data(id, path);
if generated_code(path.span) && path_data.is_none() {
return;
self.dumper.dump_ref(path_data);
+ // Type parameters
+ for seg in &path.segments {
+ if let Some(ref params) = seg.parameters {
+ match **params {
+ ast::PathParameters::AngleBracketed(ref data) => {
+ for t in &data.types {
+ self.visit_ty(t);
+ }
+ }
+ ast::PathParameters::Parenthesized(ref data) => {
+ for t in &data.inputs {
+ self.visit_ty(t);
+ }
+ if let Some(ref t) = data.output {
+ self.visit_ty(t);
+ }
+ }
+ }
+ }
+ }
+
// Modules or types in the path prefix.
match self.save_ctxt.get_path_def(id) {
HirDef::Method(did) => {
walk_list!(self, visit_expr, base);
}
- fn process_method_call(&mut self, ex: &'l ast::Expr, args: &'l [P<ast::Expr>]) {
+ fn process_method_call(&mut self,
+ ex: &'l ast::Expr,
+ seg: &'l ast::PathSegment,
+ args: &'l [P<ast::Expr>]) {
+ debug!("process_method_call {:?} {:?}", ex, ex.span);
if let Some(mcd) = self.save_ctxt.get_expr_data(ex) {
down_cast_data!(mcd, RefData, ex.span);
if !generated_code(ex.span) {
}
}
+ // Explicit types in the turbo-fish.
+ if let Some(ref params) = seg.parameters {
+ if let ast::PathParameters::AngleBracketed(ref data) = **params {
+ for t in &data.types {
+ self.visit_ty(t);
+ }
+ }
+ }
+
// walk receiver and args
walk_list!(self, visit_expr, args);
}
collector.visit_pat(&p);
self.visit_pat(&p);
- for &(id, ref p, immut) in &collector.collected_paths {
+ for (id, i, sp, immut) in collector.collected_idents {
let mut value = match immut {
ast::Mutability::Immutable => value.to_string(),
_ => String::new(),
// Get the span only for the name of the variable (I hope the path
// is only ever a variable name, but who knows?).
- let sub_span = self.span.span_for_last_ident(p.span);
+ let sub_span = self.span.span_for_last_ident(sp);
// Rust uses the id of the pattern for var lookups, so we'll use it too.
- if !self.span.filter_generated(sub_span, p.span) {
- let qualname = format!("{}${}", path_to_string(p), id);
+ if !self.span.filter_generated(sub_span, sp) {
+ let qualname = format!("{}${}", i.to_string(), id);
let id = ::id_from_node_id(id, &self.save_ctxt);
let span = self.span_from_span(sub_span.expect("No span found for variable"));
kind: DefKind::Local,
id,
span,
- name: path_to_string(p),
+ name: i.to_string(),
qualname,
value: typ,
parent: None,
ref impl_items) => {
self.process_impl(item, ty_params, trait_ref, &typ, impl_items)
}
- Trait(_, ref generics, ref trait_refs, ref methods) =>
+ Trait(_, _, ref generics, ref trait_refs, ref methods) =>
self.process_trait(item, generics, trait_refs, methods),
Mod(ref m) => {
self.process_mod(item);
for param in generics.ty_params.iter() {
for bound in param.bounds.iter() {
if let ast::TraitTyParamBound(ref trait_ref, _) = *bound {
- self.process_trait_ref(&trait_ref.trait_ref);
+ self.process_path(trait_ref.trait_ref.ref_id, &trait_ref.trait_ref.path)
}
}
if let Some(ref ty) = param.default {
let def = self.save_ctxt.get_path_def(hir_expr.id);
self.process_struct_lit(ex, path, fields, adt.variant_of_def(def), base)
}
- ast::ExprKind::MethodCall(.., ref args) => self.process_method_call(ex, args),
+ ast::ExprKind::MethodCall(ref seg, ref args) => self.process_method_call(ex, seg, args),
ast::ExprKind::Field(ref sub_ex, _) => {
self.visit_expr(&sub_ex);
let value = self.span.snippet(subexpression.span);
self.process_var_decl(pattern, value);
debug!("for loop, walk sub-expr: {:?}", subexpression.node);
- visit::walk_expr(self, subexpression);
+ self.visit_expr(subexpression);
visit::walk_block(self, block);
}
ast::ExprKind::IfLet(ref pattern, ref subexpression, ref block, ref opt_else) => {
let value = self.span.snippet(subexpression.span);
self.process_var_decl(pattern, value);
- visit::walk_expr(self, subexpression);
+ self.visit_expr(subexpression);
visit::walk_block(self, block);
- opt_else.as_ref().map(|el| visit::walk_expr(self, el));
+ opt_else.as_ref().map(|el| self.visit_expr(el));
}
ast::ExprKind::Repeat(ref element, ref count) => {
self.visit_expr(element);
self.visit_pat(&pattern);
}
- // This is to get around borrow checking, because we need mut self to call process_path.
- let mut paths_to_process = vec![];
-
// process collected paths
- for &(id, ref p, immut) in &collector.collected_paths {
+ for (id, i, sp, immut) in collector.collected_idents {
match self.save_ctxt.get_path_def(id) {
HirDef::Local(id) => {
let mut value = if immut == ast::Mutability::Immutable {
- self.span.snippet(p.span).to_string()
+ self.span.snippet(sp).to_string()
} else {
"<mutable>".to_string()
};
value.push_str(": ");
value.push_str(&typ);
- assert!(p.segments.len() == 1,
- "qualified path for local variable def in arm");
- if !self.span.filter_generated(Some(p.span), p.span) {
- let qualname = format!("{}${}", path_to_string(p), id);
+ if !self.span.filter_generated(Some(sp), sp) {
+ let qualname = format!("{}${}", i.to_string(), id);
let id = ::id_from_node_id(id, &self.save_ctxt);
- let span = self.span_from_span(p.span);
+ let span = self.span_from_span(sp);
self.dumper.dump_def(false, Def {
kind: DefKind::Local,
id,
span,
- name: path_to_string(p),
+ name: i.to_string(),
qualname,
value: typ,
parent: None,
});
}
}
- HirDef::StructCtor(..) | HirDef::VariantCtor(..) |
- HirDef::Const(..) | HirDef::AssociatedConst(..) |
- HirDef::Struct(..) | HirDef::Variant(..) |
- HirDef::TyAlias(..) | HirDef::AssociatedTy(..) |
- HirDef::SelfTy(..) => {
- paths_to_process.push((id, p.clone()))
- }
- def => error!("unexpected definition kind when processing collected paths: {:?}",
+ def => error!("unexpected definition kind when processing collected idents: {:?}",
def),
}
}
- for &(id, ref path) in &paths_to_process {
+ for (id, ref path) in collector.collected_paths {
self.process_path(id, path);
}
walk_list!(self, visit_expr, &arm.guard);
}
}
}
- ast::ExprKind::MethodCall(..) => {
+ ast::ExprKind::MethodCall(ref seg, ..) => {
let expr_hir_id = self.tcx.hir.definitions().node_to_hir_id(expr.id);
let method_id = self.tables.type_dependent_defs()[expr_hir_id].def_id();
let (def_id, decl_id) = match self.tcx.associated_item(method_id).container {
ty::ImplContainer(_) => (Some(method_id), None),
ty::TraitContainer(_) => (None, Some(method_id)),
};
- let sub_span = self.span_utils.sub_span_for_meth_name(expr.span);
- filter!(self.span_utils, sub_span, expr.span, None);
- let span = self.span_from_span(sub_span.unwrap());
+ let sub_span = seg.span;
+ filter!(self.span_utils, Some(sub_span), expr.span, None);
+ let span = self.span_from_span(sub_span);
Some(Data::RefData(Ref {
kind: RefKind::Function,
span,
Node::NodeItem(&hir::Item { node: hir::ItemUse(ref path, _), .. }) |
Node::NodeVisibility(&hir::Visibility::Restricted { ref path, .. }) => path.def,
- Node::NodeExpr(&hir::Expr { node: hir::ExprPath(ref qpath), .. }) |
Node::NodeExpr(&hir::Expr { node: hir::ExprStruct(ref qpath, ..), .. }) |
+ Node::NodeExpr(&hir::Expr { node: hir::ExprPath(ref qpath), .. }) |
Node::NodePat(&hir::Pat { node: hir::PatKind::Path(ref qpath), .. }) |
Node::NodePat(&hir::Pat { node: hir::PatKind::Struct(ref qpath, ..), .. }) |
Node::NodePat(&hir::Pat { node: hir::PatKind::TupleStruct(ref qpath, ..), .. }) => {
}
pub fn get_path_data(&self, id: NodeId, path: &ast::Path) -> Option<Ref> {
+ // Returns true if the path is function type sugar, e.g., `Fn(A) -> B`.
+ fn fn_type(path: &ast::Path) -> bool {
+ if path.segments.len() != 1 {
+ return false;
+ }
+ if let Some(ref params) = path.segments[0].parameters {
+ if let ast::PathParameters::Parenthesized(_) = **params {
+ return true;
+ }
+ }
+ false
+ }
+
+ if path.segments.is_empty() {
+ return None;
+ }
+
let def = self.get_path_def(id);
- let sub_span = self.span_utils.span_for_last_ident(path.span);
- filter!(self.span_utils, sub_span, path.span, None);
+ let last_seg = &path.segments[path.segments.len() - 1];
+ let sub_span = last_seg.span;
+ filter!(self.span_utils, Some(sub_span), path.span, None);
match def {
HirDef::Upvar(id, ..) |
HirDef::Local(id) => {
- let span = self.span_from_span(sub_span.unwrap());
+ let span = self.span_from_span(sub_span);
Some(Ref {
kind: RefKind::Variable,
span,
HirDef::Static(..) |
HirDef::Const(..) |
HirDef::AssociatedConst(..) |
- HirDef::StructCtor(..) |
HirDef::VariantCtor(..) => {
- let span = self.span_from_span(sub_span.unwrap());
+ let span = self.span_from_span(sub_span);
Some(Ref {
kind: RefKind::Variable,
span,
ref_id: id_from_def_id(def.def_id()),
})
}
+ HirDef::Trait(def_id) if fn_type(path) => {
+ // Function type bounds are desugared in the parser, so we have to
+ // special case them here.
+ let fn_span = self.span_utils.span_for_first_ident(path.span);
+ fn_span.map(|span| Ref {
+ kind: RefKind::Type,
+ span: self.span_from_span(span),
+ ref_id: id_from_def_id(def_id),
+ })
+ }
HirDef::Struct(def_id) |
HirDef::Variant(def_id, ..) |
HirDef::Union(def_id) |
HirDef::AssociatedTy(def_id) |
HirDef::Trait(def_id) |
HirDef::TyParam(def_id) => {
- let span = self.span_from_span(sub_span.unwrap());
+ let span = self.span_from_span(sub_span);
Some(Ref {
kind: RefKind::Type,
span,
ref_id: id_from_def_id(def_id),
})
}
+ HirDef::StructCtor(def_id, _) => {
+ // This is a reference to a tuple struct where the def_id points
+ // to an invisible constructor function. That is not a very useful
+ // def, so adjust to point to the tuple struct itself.
+ let span = self.span_from_span(sub_span);
+ let parent_def_id = self.tcx.parent_def_id(def_id).unwrap();
+ Some(Ref {
+ kind: RefKind::Type,
+ span,
+ ref_id: id_from_def_id(parent_def_id),
+ })
+ }
HirDef::Method(decl_id) => {
- let sub_span = self.span_utils.sub_span_for_meth_name(path.span);
- filter!(self.span_utils, sub_span, path.span, None);
let def_id = if decl_id.is_local() {
let ti = self.tcx.associated_item(decl_id);
self.tcx.associated_items(ti.container.id())
} else {
None
};
- let span = self.span_from_span(sub_span.unwrap());
+ let span = self.span_from_span(sub_span);
Some(Ref {
kind: RefKind::Function,
span,
})
}
HirDef::Fn(def_id) => {
- let span = self.span_from_span(sub_span.unwrap());
+ let span = self.span_from_span(sub_span);
Some(Ref {
kind: RefKind::Function,
span,
})
}
HirDef::Mod(def_id) => {
- let span = self.span_from_span(sub_span.unwrap());
+ let span = self.span_from_span(sub_span);
Some(Ref {
kind: RefKind::Mod,
span,
sig
}
-// An AST visitor for collecting paths from patterns.
-struct PathCollector {
- // The Row field identifies the kind of pattern.
- collected_paths: Vec<(NodeId, ast::Path, ast::Mutability)>,
+// An AST visitor for collecting paths (e.g., the names of structs) and formal
+// variables (idents) from patterns.
+struct PathCollector<'l> {
+ collected_paths: Vec<(NodeId, &'l ast::Path)>,
+ collected_idents: Vec<(NodeId, ast::Ident, Span, ast::Mutability)>,
}
-impl PathCollector {
- fn new() -> PathCollector {
- PathCollector { collected_paths: vec![] }
+impl<'l> PathCollector<'l> {
+ fn new() -> PathCollector<'l> {
+ PathCollector {
+ collected_paths: vec![],
+ collected_idents: vec![],
+ }
}
}
-impl<'a> Visitor<'a> for PathCollector {
- fn visit_pat(&mut self, p: &ast::Pat) {
+impl<'l, 'a: 'l> Visitor<'a> for PathCollector<'l> {
+ fn visit_pat(&mut self, p: &'a ast::Pat) {
match p.node {
PatKind::Struct(ref path, ..) => {
- self.collected_paths.push((p.id, path.clone(),
- ast::Mutability::Mutable));
+ self.collected_paths.push((p.id, path));
}
PatKind::TupleStruct(ref path, ..) |
PatKind::Path(_, ref path) => {
- self.collected_paths.push((p.id, path.clone(),
- ast::Mutability::Mutable));
+ self.collected_paths.push((p.id, path));
}
PatKind::Ident(bm, ref path1, _) => {
debug!("PathCollector, visit ident in pat {}: {:?} {:?}",
ast::BindingMode::ByRef(_) => ast::Mutability::Immutable,
ast::BindingMode::ByValue(mt) => mt,
};
- // collect path for either visit_local or visit_arm
- let path = ast::Path::from_ident(path1.span, path1.node);
- self.collected_paths.push((p.id, path, immut));
+ self.collected_idents.push((p.id, path1.node, path1.span, immut));
}
_ => {}
}
sig.text.push_str(" {}");
Ok(sig)
}
- ast::ItemKind::Trait(unsafety, ref generics, ref bounds, _) => {
+ ast::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, _) => {
let mut text = String::new();
+
+ if is_auto == ast::IsAuto::Yes {
+ text.push_str("auto ");
+ }
+
if unsafety == ast::Unsafety::Unsafe {
text.push_str("unsafe ");
}
Ok(sig)
}
- ast::ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
+ ast::ItemKind::AutoImpl(unsafety, ref trait_ref) => {
let mut text = String::new();
if unsafety == ast::Unsafety::Unsafe {
text.push_str("unsafe ");
}
}
- // Return the span for the last ident before a `(` or `<` or '::<' and outside any
- // any brackets, or the last span.
- pub fn sub_span_for_meth_name(&self, span: Span) -> Option<Span> {
- let mut toks = self.retokenise_span(span);
- let mut prev = toks.real_token();
- let mut result = None;
- let mut bracket_count = 0;
- let mut prev_span = None;
- while prev.tok != token::Eof {
- prev_span = None;
- let mut next = toks.real_token();
-
- if (next.tok == token::OpenDelim(token::Paren) || next.tok == token::Lt) &&
- bracket_count == 0 && prev.tok.is_ident() {
- result = Some(prev.sp);
- }
-
- if bracket_count == 0 && next.tok == token::ModSep {
- let old = prev;
- prev = next;
- next = toks.real_token();
- if next.tok == token::Lt && old.tok.is_ident() {
- result = Some(old.sp);
- }
- }
-
- bracket_count += match prev.tok {
- token::OpenDelim(token::Paren) | token::Lt => 1,
- token::CloseDelim(token::Paren) | token::Gt => -1,
- token::BinOp(token::Shr) => -2,
- _ => 0,
- };
-
- if prev.tok.is_ident() && bracket_count == 0 {
- prev_span = Some(prev.sp);
- }
- prev = next;
- }
- result.or(prev_span)
- }
-
// Return the span for the last ident before a `<` and outside any
// angle brackets, or the last span.
pub fn sub_span_for_type_name(&self, span: Span) -> Option<Span> {
}
macro_rules! filter {
- ($util: expr, $span: ident, $parent: expr, None) => {
+ ($util: expr, $span: expr, $parent: expr, None) => {
if $util.filter_generated($span, $parent) {
return None;
}
rustc-demangle = "0.1.4"
rustc = { path = "../librustc" }
rustc_allocator = { path = "../librustc_allocator" }
+rustc_apfloat = { path = "../librustc_apfloat" }
rustc_back = { path = "../librustc_back" }
rustc_const_math = { path = "../librustc_const_math" }
rustc_data_structures = { path = "../librustc_data_structures" }
let canonical = f.replace("-", "_");
let canonical_name = name.replace("-", "_");
- // Look for `.rust-cgu.o` at the end of the filename to conclude
+ // Look for `.rcgu.o` at the end of the filename to conclude
// that this is a Rust-related object file.
fn looks_like_rust(s: &str) -> bool {
let path = Path::new(s);
use rustc::ty::maps::Providers;
use rustc::util::nodemap::FxHashMap;
use rustc_allocator::ALLOCATOR_METHODS;
+use syntax::attr;
pub type ExportedSymbols = FxHashMap<
CrateNum,
None,
SymbolExportLevel::Rust));
}
+
+ // Sort so we get a stable incr. comp. hash.
+ local_crate.sort_unstable_by(|&(ref name1, ..), &(ref name2, ..)| {
+ name1.cmp(name2)
+ });
+
Arc::new(local_crate)
};
}
let special_runtime_crate =
tcx.is_panic_runtime(cnum) || tcx.is_compiler_builtins(cnum);
- let crate_exports = tcx
+ let mut crate_exports: Vec<_> = tcx
.exported_symbol_ids(cnum)
.iter()
.map(|&def_id| {
})
.collect();
+ // Sort so we get a stable incr. comp. hash.
+ crate_exports.sort_unstable_by(|&(ref name1, ..), &(ref name2, ..)| {
+ name1.cmp(name2)
+ });
+
Arc::new(crate_exports)
};
}
fn export_level(tcx: TyCtxt, sym_def_id: DefId) -> SymbolExportLevel {
- if tcx.contains_extern_indicator(sym_def_id) {
+ // We export anything that's not mangled at the "C" layer as it probably has
+ // to do with ABI concerns. We do not, however, apply such treatment to
+ // special symbols in the standard library for various plumbing between
+ // core/std/allocators/etc. For example symbols used to hook up allocation
+ // are not considered for export
+ let is_extern = tcx.contains_extern_indicator(sym_def_id);
+ let std_internal = attr::contains_name(&tcx.get_attrs(sym_def_id),
+ "rustc_std_internal_symbol");
+ if is_extern && !std_internal {
SymbolExportLevel::C
} else {
SymbolExportLevel::Rust
("large", llvm::CodeModel::Large),
];
+pub const TLS_MODEL_ARGS : [(&'static str, llvm::ThreadLocalMode); 4] = [
+ ("global-dynamic", llvm::ThreadLocalMode::GeneralDynamic),
+ ("local-dynamic", llvm::ThreadLocalMode::LocalDynamic),
+ ("initial-exec", llvm::ThreadLocalMode::InitialExec),
+ ("local-exec", llvm::ThreadLocalMode::LocalExec),
+];
+
pub fn llvm_err(handler: &errors::Handler, msg: String) -> FatalError {
match llvm::last_error() {
Some(err) => handler.fatal(&format!("{}: {}", msg, err)),
Some(x) => x.1,
_ => {
sess.err(&format!("{:?} is not a valid code model",
- sess.opts
- .cg
- .code_model));
+ code_model_arg));
sess.abort_if_errors();
bug!();
}
for attr in attrs {
if attr.check_name("thread_local") {
- llvm::set_thread_local(g, true);
+ llvm::set_thread_local_mode(g, ccx.tls_model());
}
}
// symbol and another one doesn't.
for attr in ccx.tcx().get_attrs(def_id).iter() {
if attr.check_name("thread_local") {
- llvm::set_thread_local(g, true);
+ llvm::set_thread_local_mode(g, ccx.tls_model());
}
}
if ccx.use_dll_storage_attrs() && !ccx.tcx().is_foreign_item(def_id) {
debuginfo::create_global_var_metadata(ccx, id, g);
- if attr::contains_name(attrs,
- "thread_local") {
- llvm::set_thread_local(g, true);
+ if attr::contains_name(attrs, "thread_local") {
+ llvm::set_thread_local_mode(g, ccx.tls_model());
}
base::set_link_section(ccx, g, attrs);
tcx: TyCtxt<'a, 'tcx, 'tcx>,
check_overflow: bool,
use_dll_storage_attrs: bool,
+ tls_model: llvm::ThreadLocalMode,
}
/// The local portion of a `CrateContext`. There is one `LocalCrateContext`
Some(x) => x.1,
_ => {
sess.err(&format!("{:?} is not a valid relocation mode",
- sess.opts
- .cg
- .code_model));
+ reloc_model_arg));
+ sess.abort_if_errors();
+ bug!();
+ }
+ }
+}
+
+fn get_tls_model(sess: &Session) -> llvm::ThreadLocalMode {
+ let tls_model_arg = match sess.opts.debugging_opts.tls_model {
+ Some(ref s) => &s[..],
+ None => &sess.target.target.options.tls_model[..],
+ };
+
+ match ::back::write::TLS_MODEL_ARGS.iter().find(
+ |&&arg| arg.0 == tls_model_arg) {
+ Some(x) => x.1,
+ _ => {
+ sess.err(&format!("{:?} is not a valid TLS model",
+ tls_model_arg));
sess.abort_if_errors();
bug!();
}
let check_overflow = tcx.sess.overflow_checks();
+ let tls_model = get_tls_model(&tcx.sess);
+
SharedCrateContext {
tcx,
check_overflow,
use_dll_storage_attrs,
+ tls_model,
}
}
self.shared.use_dll_storage_attrs()
}
+ pub fn tls_model(&self) -> llvm::ThreadLocalMode {
+ self.shared.tls_model
+ }
+
/// Generate a new symbol name with the given prefix. This symbol name must
/// only be used for definitions with `internal` or `private` linkage.
pub fn generate_local_symbol_name(&self, prefix: &str) -> String {
#![feature(custom_attribute)]
#![allow(unused_attributes)]
#![feature(i128_type)]
+#![feature(i128)]
#![feature(libc)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
extern crate owning_ref;
#[macro_use] extern crate rustc;
extern crate rustc_allocator;
+extern crate rustc_apfloat;
extern crate rustc_back;
extern crate rustc_data_structures;
extern crate rustc_incremental;
TerminatorKind::GeneratorDrop |
TerminatorKind::Unreachable |
TerminatorKind::SwitchInt { .. } |
- TerminatorKind::Yield { .. } => {
+ TerminatorKind::Yield { .. } |
+ TerminatorKind::FalseEdges { .. } => {
/* nothing to do */
}
TerminatorKind::Call { cleanup: unwind, .. } |
cleanup);
}
mir::TerminatorKind::GeneratorDrop |
- mir::TerminatorKind::Yield { .. } => bug!("generator ops in trans"),
+ mir::TerminatorKind::Yield { .. } |
+ mir::TerminatorKind::FalseEdges { .. } => bug!("generator ops in trans"),
}
}
use llvm::{self, ValueRef};
use rustc::middle::const_val::{ConstEvalErr, ConstVal, ErrKind};
use rustc_const_math::ConstInt::*;
-use rustc_const_math::{ConstInt, ConstMathErr};
+use rustc_const_math::{ConstInt, ConstMathErr, MAX_F32_PLUS_HALF_ULP};
use rustc::hir::def_id::DefId;
use rustc::infer::TransNormalize;
use rustc::traits;
use rustc::ty::layout::{self, LayoutTyper};
use rustc::ty::cast::{CastTy, IntTy};
use rustc::ty::subst::{Kind, Substs, Subst};
+use rustc_apfloat::{ieee, Float, Status};
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
use {adt, base, machine};
use abi::{self, Abi};
llvm::LLVMConstIntCast(llval, ll_t_out.to_ref(), s)
}
(CastTy::Int(_), CastTy::Float) => {
- if signed {
- llvm::LLVMConstSIToFP(llval, ll_t_out.to_ref())
- } else {
- llvm::LLVMConstUIToFP(llval, ll_t_out.to_ref())
- }
+ cast_const_int_to_float(self.ccx, llval, signed, ll_t_out)
}
(CastTy::Float, CastTy::Float) => {
llvm::LLVMConstFPCast(llval, ll_t_out.to_ref())
}
(CastTy::Float, CastTy::Int(IntTy::I)) => {
- llvm::LLVMConstFPToSI(llval, ll_t_out.to_ref())
+ cast_const_float_to_int(self.ccx, &operand,
+ true, ll_t_out, span)
}
(CastTy::Float, CastTy::Int(_)) => {
- llvm::LLVMConstFPToUI(llval, ll_t_out.to_ref())
+ cast_const_float_to_int(self.ccx, &operand,
+ false, ll_t_out, span)
}
(CastTy::Ptr(_), CastTy::Ptr(_)) |
(CastTy::FnPtr, CastTy::Ptr(_)) |
}
}
+unsafe fn cast_const_float_to_int(ccx: &CrateContext,
+ operand: &Const,
+ signed: bool,
+ int_ty: Type,
+ span: Span) -> ValueRef {
+ let llval = operand.llval;
+ let float_bits = match operand.ty.sty {
+ ty::TyFloat(fty) => fty.bit_width(),
+ _ => bug!("cast_const_float_to_int: operand not a float"),
+ };
+ // Note: this breaks if llval is a complex constant expression rather than a simple constant.
+ // One way that might happen would be if addresses could be turned into integers in constant
+ // expressions, but that doesn't appear to be possible?
+ // In any case, an ICE is better than producing undef.
+ let llval_bits = consts::bitcast(llval, Type::ix(ccx, float_bits as u64));
+ let bits = const_to_opt_u128(llval_bits, false).unwrap_or_else(|| {
+ panic!("could not get bits of constant float {:?}",
+ Value(llval));
+ });
+ let int_width = int_ty.int_width() as usize;
+ // Try to convert, but report an error for overflow and NaN. This matches HIR const eval.
+ let cast_result = match float_bits {
+ 32 if signed => ieee::Single::from_bits(bits).to_i128(int_width).map(|v| v as u128),
+ 64 if signed => ieee::Double::from_bits(bits).to_i128(int_width).map(|v| v as u128),
+ 32 => ieee::Single::from_bits(bits).to_u128(int_width),
+ 64 => ieee::Double::from_bits(bits).to_u128(int_width),
+ n => bug!("unsupported float width {}", n),
+ };
+ if cast_result.status.contains(Status::INVALID_OP) {
+ let err = ConstEvalErr { span: span, kind: ErrKind::CannotCast };
+ err.report(ccx.tcx(), span, "expression");
+ }
+ C_big_integral(int_ty, cast_result.value)
+}
+
+unsafe fn cast_const_int_to_float(ccx: &CrateContext,
+ llval: ValueRef,
+ signed: bool,
+ float_ty: Type) -> ValueRef {
+ // Note: this breaks if llval is a complex constant expression rather than a simple constant.
+ // One way that might happen would be if addresses could be turned into integers in constant
+ // expressions, but that doesn't appear to be possible?
+ // In any case, an ICE is better than producing undef.
+ let value = const_to_opt_u128(llval, signed).unwrap_or_else(|| {
+ panic!("could not get z128 value of constant integer {:?}",
+ Value(llval));
+ });
+ if signed {
+ llvm::LLVMConstSIToFP(llval, float_ty.to_ref())
+ } else if float_ty.float_width() == 32 && value >= MAX_F32_PLUS_HALF_ULP {
+ // We're casting to f32 and the value is > f32::MAX + 0.5 ULP -> round up to infinity.
+ let infinity_bits = C_u32(ccx, ieee::Single::INFINITY.to_bits() as u32);
+ consts::bitcast(infinity_bits, float_ty)
+ } else {
+ llvm::LLVMConstUIToFP(llval, float_ty.to_ref())
+ }
+}
+
impl<'a, 'tcx> MirContext<'a, 'tcx> {
pub fn trans_constant(&mut self,
bcx: &Builder<'a, 'tcx>,
use rustc::mir::tcx::LvalueTy;
use rustc::mir;
use rustc::middle::lang_items::ExchangeMallocFnLangItem;
+use rustc_apfloat::{ieee, Float, Status, Round};
+use rustc_const_math::MAX_F32_PLUS_HALF_ULP;
+use std::{u128, i128};
use base;
use builder::Builder;
use callee;
-use common::{self, val_ty, C_bool, C_i32, C_null, C_usize, C_uint};
+use common::{self, val_ty, C_bool, C_i32, C_u32, C_u64, C_null, C_usize, C_uint, C_big_integral};
+use consts;
use adt;
use machine;
use monomorphize;
bcx.ptrtoint(llval, ll_t_out),
(CastTy::Int(_), CastTy::Ptr(_)) =>
bcx.inttoptr(llval, ll_t_out),
- (CastTy::Int(_), CastTy::Float) if signed =>
- bcx.sitofp(llval, ll_t_out),
(CastTy::Int(_), CastTy::Float) =>
- bcx.uitofp(llval, ll_t_out),
+ cast_int_to_float(&bcx, signed, llval, ll_t_in, ll_t_out),
(CastTy::Float, CastTy::Int(IntTy::I)) =>
- bcx.fptosi(llval, ll_t_out),
+ cast_float_to_int(&bcx, true, llval, ll_t_in, ll_t_out),
(CastTy::Float, CastTy::Int(_)) =>
- bcx.fptoui(llval, ll_t_out),
+ cast_float_to_int(&bcx, false, llval, ll_t_in, ll_t_out),
_ => bug!("unsupported cast: {:?} to {:?}", operand.ty, cast_ty)
};
OperandValue::Immediate(newval)
bcx.ccx.get_intrinsic(&name)
}
+
+fn cast_int_to_float(bcx: &Builder,
+ signed: bool,
+ x: ValueRef,
+ int_ty: Type,
+ float_ty: Type) -> ValueRef {
+ // Most integer types, even i128, fit into [-f32::MAX, f32::MAX] after rounding.
+ // It's only u128 -> f32 that can cause overflows (i.e., should yield infinity).
+ // LLVM's uitofp produces undef in those cases, so we manually check for that case.
+ let is_u128_to_f32 = !signed && int_ty.int_width() == 128 && float_ty.float_width() == 32;
+ if is_u128_to_f32 && bcx.sess().opts.debugging_opts.saturating_float_casts {
+ // All inputs greater or equal to (f32::MAX + 0.5 ULP) are rounded to infinity,
+ // and for everything else LLVM's uitofp works just fine.
+ let max = C_big_integral(int_ty, MAX_F32_PLUS_HALF_ULP);
+ let overflow = bcx.icmp(llvm::IntUGE, x, max);
+ let infinity_bits = C_u32(bcx.ccx, ieee::Single::INFINITY.to_bits() as u32);
+ let infinity = consts::bitcast(infinity_bits, float_ty);
+ bcx.select(overflow, infinity, bcx.uitofp(x, float_ty))
+ } else {
+ if signed {
+ bcx.sitofp(x, float_ty)
+ } else {
+ bcx.uitofp(x, float_ty)
+ }
+ }
+}
+
+fn cast_float_to_int(bcx: &Builder,
+ signed: bool,
+ x: ValueRef,
+ float_ty: Type,
+ int_ty: Type) -> ValueRef {
+ let fptosui_result = if signed {
+ bcx.fptosi(x, int_ty)
+ } else {
+ bcx.fptoui(x, int_ty)
+ };
+
+ if !bcx.sess().opts.debugging_opts.saturating_float_casts {
+ return fptosui_result;
+ }
+ // LLVM's fpto[su]i returns undef when the input x is infinite, NaN, or does not fit into the
+ // destination integer type after rounding towards zero. This `undef` value can cause UB in
+ // safe code (see issue #10184), so we implement a saturating conversion on top of it:
+ // Semantically, the mathematical value of the input is rounded towards zero to the next
+ // mathematical integer, and then the result is clamped into the range of the destination
+ // integer type. Positive and negative infinity are mapped to the maximum and minimum value of
+ // the destination integer type. NaN is mapped to 0.
+ //
+ // Define f_min and f_max as the largest and smallest (finite) floats that are exactly equal to
+ // a value representable in int_ty.
+ // They are exactly equal to int_ty::{MIN,MAX} if float_ty has enough significand bits.
+ // Otherwise, int_ty::MAX must be rounded towards zero, as it is one less than a power of two.
+ // int_ty::MIN, however, is either zero or a negative power of two and is thus exactly
+ // representable. Note that this only works if float_ty's exponent range is sufficently large.
+ // f16 or 256 bit integers would break this property. Right now the smallest float type is f32
+ // with exponents ranging up to 127, which is barely enough for i128::MIN = -2^127.
+ // On the other hand, f_max works even if int_ty::MAX is greater than float_ty::MAX. Because
+ // we're rounding towards zero, we just get float_ty::MAX (which is always an integer).
+ // This already happens today with u128::MAX = 2^128 - 1 > f32::MAX.
+ fn compute_clamp_bounds<F: Float>(signed: bool, int_ty: Type) -> (u128, u128) {
+ let rounded_min = F::from_i128_r(int_min(signed, int_ty), Round::TowardZero);
+ assert_eq!(rounded_min.status, Status::OK);
+ let rounded_max = F::from_u128_r(int_max(signed, int_ty), Round::TowardZero);
+ assert!(rounded_max.value.is_finite());
+ (rounded_min.value.to_bits(), rounded_max.value.to_bits())
+ }
+ fn int_max(signed: bool, int_ty: Type) -> u128 {
+ let shift_amount = 128 - int_ty.int_width();
+ if signed {
+ i128::MAX as u128 >> shift_amount
+ } else {
+ u128::MAX >> shift_amount
+ }
+ }
+ fn int_min(signed: bool, int_ty: Type) -> i128 {
+ if signed {
+ i128::MIN >> (128 - int_ty.int_width())
+ } else {
+ 0
+ }
+ }
+ let float_bits_to_llval = |bits| {
+ let bits_llval = match float_ty.float_width() {
+ 32 => C_u32(bcx.ccx, bits as u32),
+ 64 => C_u64(bcx.ccx, bits as u64),
+ n => bug!("unsupported float width {}", n),
+ };
+ consts::bitcast(bits_llval, float_ty)
+ };
+ let (f_min, f_max) = match float_ty.float_width() {
+ 32 => compute_clamp_bounds::<ieee::Single>(signed, int_ty),
+ 64 => compute_clamp_bounds::<ieee::Double>(signed, int_ty),
+ n => bug!("unsupported float width {}", n),
+ };
+ let f_min = float_bits_to_llval(f_min);
+ let f_max = float_bits_to_llval(f_max);
+ // To implement saturation, we perform the following steps:
+ //
+ // 1. Cast x to an integer with fpto[su]i. This may result in undef.
+ // 2. Compare x to f_min and f_max, and use the comparison results to select:
+ // a) int_ty::MIN if x < f_min or x is NaN
+ // b) int_ty::MAX if x > f_max
+ // c) the result of fpto[su]i otherwise
+ // 3. If x is NaN, return 0.0, otherwise return the result of step 2.
+ //
+ // This avoids resulting undef because values in range [f_min, f_max] by definition fit into the
+ // destination type. It creates an undef temporary, but *producing* undef is not UB. Our use of
+ // undef does not introduce any non-determinism either.
+ // More importantly, the above procedure correctly implements saturating conversion.
+ // Proof (sketch):
+ // If x is NaN, 0 is returned by definition.
+ // Otherwise, x is finite or infinite and thus can be compared with f_min and f_max.
+ // This yields three cases to consider:
+ // (1) if x in [f_min, f_max], the result of fpto[su]i is returned, which agrees with
+ // saturating conversion for inputs in that range.
+ // (2) if x > f_max, then x is larger than int_ty::MAX. This holds even if f_max is rounded
+ // (i.e., if f_max < int_ty::MAX) because in those cases, nextUp(f_max) is already larger
+ // than int_ty::MAX. Because x is larger than int_ty::MAX, the return value of int_ty::MAX
+ // is correct.
+ // (3) if x < f_min, then x is smaller than int_ty::MIN. As shown earlier, f_min exactly equals
+ // int_ty::MIN and therefore the return value of int_ty::MIN is correct.
+ // QED.
+
+ // Step 1 was already performed above.
+
+ // Step 2: We use two comparisons and two selects, with %s1 being the result:
+ // %less_or_nan = fcmp ult %x, %f_min
+ // %greater = fcmp olt %x, %f_max
+ // %s0 = select %less_or_nan, int_ty::MIN, %fptosi_result
+ // %s1 = select %greater, int_ty::MAX, %s0
+ // Note that %less_or_nan uses an *unordered* comparison. This comparison is true if the
+ // operands are not comparable (i.e., if x is NaN). The unordered comparison ensures that s1
+ // becomes int_ty::MIN if x is NaN.
+ // Performance note: Unordered comparison can be lowered to a "flipped" comparison and a
+ // negation, and the negation can be merged into the select. Therefore, it not necessarily any
+ // more expensive than a ordered ("normal") comparison. Whether these optimizations will be
+ // performed is ultimately up to the backend, but at least x86 does perform them.
+ let less_or_nan = bcx.fcmp(llvm::RealULT, x, f_min);
+ let greater = bcx.fcmp(llvm::RealOGT, x, f_max);
+ let int_max = C_big_integral(int_ty, int_max(signed, int_ty));
+ let int_min = C_big_integral(int_ty, int_min(signed, int_ty) as u128);
+ let s0 = bcx.select(less_or_nan, int_min, fptosui_result);
+ let s1 = bcx.select(greater, int_max, s0);
+
+ // Step 3: NaN replacement.
+ // For unsigned types, the above step already yielded int_ty::MIN == 0 if x is NaN.
+ // Therefore we only need to execute this step for signed integer types.
+ if signed {
+ // LLVM has no isNaN predicate, so we use (x == x) instead
+ bcx.select(bcx.fcmp(llvm::RealOEQ, x, x), s1, C_uint(int_ty, 0))
+ } else {
+ s1
+ }
+}
use collector::InliningMap;
use common;
-use rustc::dep_graph::{DepNode, WorkProductId};
+use rustc::dep_graph::WorkProductId;
use rustc::hir::def_id::DefId;
use rustc::hir::map::DefPathData;
use rustc::middle::trans::{Linkage, Visibility};
WorkProductId::from_cgu_name(self.name())
}
- fn work_product_dep_node(&self) -> DepNode {
- self.work_product_id().to_dep_node()
- }
-
fn items_in_deterministic_order<'a>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>)
-> Vec<(TransItem<'tcx>,
cgu1.name().cmp(cgu2.name())
});
- if tcx.sess.opts.enable_dep_node_debug_strs() {
- for cgu in &result {
- let dep_node = cgu.work_product_dep_node();
- tcx.dep_graph.register_dep_node_debug_str(dep_node,
- || cgu.name().to_string());
- }
- }
-
result
}
use rustc_data_structures::bitvec::BitVector;
+use syntax::attr;
+
#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
pub enum TransItemCollectionMode {
Eager,
let mut roots = Vec::new();
{
+ let entry_fn = tcx.sess.entry_fn.borrow().map(|(node_id, _)| {
+ tcx.hir.local_def_id(node_id)
+ });
+
let mut visitor = RootCollector {
tcx,
mode,
+ entry_fn,
output: &mut roots,
};
mir::TerminatorKind::Unreachable |
mir::TerminatorKind::Assert { .. } => {}
mir::TerminatorKind::GeneratorDrop |
- mir::TerminatorKind::Yield { .. } => bug!(),
+ mir::TerminatorKind::Yield { .. } |
+ mir::TerminatorKind::FalseEdges { .. } => bug!(),
}
self.super_terminator_kind(block, kind, location);
tcx: TyCtxt<'a, 'tcx, 'tcx>,
mode: TransItemCollectionMode,
output: &'b mut Vec<TransItem<'tcx>>,
+ entry_fn: Option<DefId>,
}
impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {
hir::ItemUse(..) |
hir::ItemForeignMod(..) |
hir::ItemTy(..) |
- hir::ItemDefaultImpl(..) |
+ hir::ItemAutoImpl(..) |
hir::ItemTrait(..) |
hir::ItemMod(..) => {
// Nothing to do, just keep recursing...
let tcx = self.tcx;
let def_id = tcx.hir.local_def_id(item.id);
- if (self.mode == TransItemCollectionMode::Eager ||
- !tcx.is_const_fn(def_id) || tcx.is_exported_symbol(def_id)) &&
- !item_has_type_parameters(tcx, def_id) {
-
+ if self.is_root(def_id) {
debug!("RootCollector: ItemFn({})",
def_id_to_string(tcx, def_id));
let tcx = self.tcx;
let def_id = tcx.hir.local_def_id(ii.id);
- if (self.mode == TransItemCollectionMode::Eager ||
- !tcx.is_const_fn(def_id) ||
- tcx.is_exported_symbol(def_id)) &&
- !item_has_type_parameters(tcx, def_id) {
+ if self.is_root(def_id) {
debug!("RootCollector: MethodImplItem({})",
def_id_to_string(tcx, def_id));
}
}
+impl<'b, 'a, 'v> RootCollector<'b, 'a, 'v> {
+ fn is_root(&self, def_id: DefId) -> bool {
+ !item_has_type_parameters(self.tcx, def_id) && match self.mode {
+ TransItemCollectionMode::Eager => {
+ true
+ }
+ TransItemCollectionMode::Lazy => {
+ self.entry_fn == Some(def_id) ||
+ self.tcx.is_exported_symbol(def_id) ||
+ attr::contains_name(&self.tcx.get_attrs(def_id),
+ "rustc_std_internal_symbol")
+ }
+ }
+ }
+}
+
fn item_has_type_parameters<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> bool {
let generics = tcx.generics_of(def_id);
generics.parent_types as usize + generics.types.len() > 0
// available to normal end-users.
return true
}
- attr::requests_inline(&instance.def.attrs(tcx)[..])
+ attr::requests_inline(&instance.def.attrs(tcx)[..]) ||
+ tcx.is_const_fn(instance.def.def_id())
}
pub fn is_inline_instance<'a, 'tcx>(
extern crate syntax;
extern crate syntax_pos;
-use rustc::ty::TyCtxt;
+use rustc::ty::{TyCtxt, Instance};
use rustc::hir;
use rustc::hir::def_id::LOCAL_CRATE;
use rustc::hir::map as hir_map;
use rustc::util::nodemap::NodeSet;
-use syntax::attr;
-
pub mod common;
pub mod link;
pub mod collector;
///
/// This list is later used by linkers to determine the set of symbols needed to
/// be exposed from a dynamic library and it's also encoded into the metadata.
-pub fn find_exported_symbols(tcx: TyCtxt) -> NodeSet {
+pub fn find_exported_symbols<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> NodeSet {
tcx.reachable_set(LOCAL_CRATE).0.iter().cloned().filter(|&id| {
// Next, we want to ignore some FFI functions that are not exposed from
// this crate. Reachable FFI functions can be lumped into two
node: hir::ImplItemKind::Method(..), .. }) => {
let def_id = tcx.hir.local_def_id(id);
let generics = tcx.generics_of(def_id);
- let attributes = tcx.get_attrs(def_id);
(generics.parent_types == 0 && generics.types.is_empty()) &&
// Functions marked with #[inline] are only ever translated
// with "internal" linkage and are never exported.
- !attr::requests_inline(&attributes)
+ !common::requests_inline(tcx, &Instance::mono(tcx, def_id))
}
_ => false
## Type collection
-Type "collection" is the process of convering the types found in the
+Type "collection" is the process of converting the types found in the
HIR (`hir::Ty`), which represent the syntactic things that the user
wrote, into the **internal representation** used by the compiler
(`Ty<'tcx>`) -- we also do similar conversions for where-clauses and
bare_fn_ty
}
- pub fn ty_of_closure(&self,
- unsafety: hir::Unsafety,
- decl: &hir::FnDecl,
- abi: abi::Abi,
- expected_sig: Option<ty::FnSig<'tcx>>)
- -> ty::PolyFnSig<'tcx>
- {
- debug!("ty_of_closure(expected_sig={:?})",
- expected_sig);
-
- let input_tys = decl.inputs.iter().enumerate().map(|(i, a)| {
- let expected_arg_ty = expected_sig.as_ref().and_then(|e| {
- // no guarantee that the correct number of expected args
- // were supplied
- if i < e.inputs().len() {
- Some(e.inputs()[i])
- } else {
- None
- }
- });
- self.ty_of_arg(a, expected_arg_ty)
- });
-
- let expected_ret_ty = expected_sig.as_ref().map(|e| e.output());
-
- let output_ty = match decl.output {
- hir::Return(ref output) => {
- if let (&hir::TyInfer, Some(expected_ret_ty)) = (&output.node, expected_ret_ty) {
- self.record_ty(output.hir_id, expected_ret_ty, output.span);
- expected_ret_ty
- } else {
- self.ast_ty_to_ty(&output)
- }
- }
- hir::DefaultReturn(span) => {
- if let Some(expected_ret_ty) = expected_ret_ty {
- expected_ret_ty
- } else {
- self.ty_infer(span)
- }
- }
- };
-
- debug!("ty_of_closure: output_ty={:?}", output_ty);
-
- ty::Binder(self.tcx().mk_fn_sig(
- input_tys,
- output_ty,
- decl.variadic,
- unsafety,
- abi
- ))
- }
-
/// Given the bounds on an object, determines what single region bound (if any) we can
/// use to summarize this type. The basic idea is that we will use the bound the user
/// provided, if they provided one, and otherwise search the supertypes of trait bounds
def_bm: ty::BindingMode) {
let tcx = self.tcx;
- let (substs, kind_name) = match adt_ty.sty {
- ty::TyAdt(adt, substs) => (substs, adt.variant_descr()),
+ let (substs, adt) = match adt_ty.sty {
+ ty::TyAdt(adt, substs) => (substs, adt),
_ => span_bug!(span, "struct pattern is not an ADT")
};
+ let kind_name = adt.variant_descr();
// Index the struct fields' types.
let field_map = variant.fields
self.check_pat_walk(&field.pat, field_ty, def_bm, true);
}
+ // Require `..` if struct has non_exhaustive attribute.
+ if adt.is_struct() && adt.is_non_exhaustive() && !adt.did.is_local() && !etc {
+ span_err!(tcx.sess, span, E0638,
+ "`..` required with {} marked as non-exhaustive",
+ kind_name);
+ }
+
// Report an error if incorrect number of the fields were specified.
if kind_name == "union" {
if fields.len() != 1 {
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
/// Returns the kind of unsize information of t, or None
- /// if t is sized or it is unknown.
- fn pointer_kind(&self, t: Ty<'tcx>, span: Span) -> PointerKind<'tcx> {
+ /// if t is unknown.
+ fn pointer_kind(&self, t: Ty<'tcx>, span: Span) -> Option<PointerKind<'tcx>> {
if self.type_is_known_to_be_sized(t, span) {
- return PointerKind::Thin;
+ return Some(PointerKind::Thin);
}
match t.sty {
- ty::TySlice(_) | ty::TyStr => PointerKind::Length,
+ ty::TySlice(_) | ty::TyStr => Some(PointerKind::Length),
ty::TyDynamic(ref tty, ..) =>
- PointerKind::Vtable(tty.principal().map(|p| p.def_id())),
+ Some(PointerKind::Vtable(tty.principal().map(|p| p.def_id()))),
ty::TyAdt(def, substs) if def.is_struct() => {
// FIXME(arielb1): do some kind of normalization
match def.struct_variant().fields.last() {
- None => PointerKind::Thin,
+ None => Some(PointerKind::Thin),
Some(f) => self.pointer_kind(f.ty(self.tcx, substs), span),
}
}
// Pointers to foreign types are thin, despite being unsized
- ty::TyForeign(..) => PointerKind::Thin,
+ ty::TyForeign(..) => Some(PointerKind::Thin),
// We should really try to normalize here.
- ty::TyProjection(ref pi) => PointerKind::OfProjection(pi),
- ty::TyParam(ref p) => PointerKind::OfParam(p),
+ ty::TyProjection(ref pi) => Some(PointerKind::OfProjection(pi)),
+ ty::TyParam(ref p) => Some(PointerKind::OfParam(p)),
+ // Insufficient type information.
+ ty::TyInfer(_) => None,
_ => panic!(),
}
}
NeedViaThinPtr,
NeedViaInt,
NonScalar,
+ UnknownExprPtrKind,
+ UnknownCastPtrKind,
}
fn make_invalid_casting_error<'a, 'gcx, 'tcx>(sess: &'a Session,
self.expr_ty,
fcx.ty_to_string(self.cast_ty)).emit();
}
+ CastError::UnknownCastPtrKind |
+ CastError::UnknownExprPtrKind => {
+ let unknown_cast_to = match e {
+ CastError::UnknownCastPtrKind => true,
+ CastError::UnknownExprPtrKind => false,
+ _ => bug!(),
+ };
+ let mut err = struct_span_err!(fcx.tcx.sess, self.span, E0641,
+ "cannot cast {} a pointer of an unknown kind",
+ if unknown_cast_to { "to" } else { "from" });
+ err.note("The type information given here is insufficient to check whether \
+ the pointer cast is valid");
+ if unknown_cast_to {
+ err.span_suggestion_short(self.cast_span,
+ "consider giving more type information",
+ String::new());
+ }
+ err.emit();
+ }
}
}
debug!("check_ptr_ptr_cast m_expr={:?} m_cast={:?}", m_expr, m_cast);
// ptr-ptr cast. vtables must match.
- // Cast to thin pointer is OK
+ let expr_kind = fcx.pointer_kind(m_expr.ty, self.span);
let cast_kind = fcx.pointer_kind(m_cast.ty, self.span);
+
+ let cast_kind = match cast_kind {
+ // We can't cast if target pointer kind is unknown
+ None => return Err(CastError::UnknownCastPtrKind),
+ Some(cast_kind) => cast_kind,
+ };
+
+ // Cast to thin pointer is OK
if cast_kind == PointerKind::Thin {
return Ok(CastKind::PtrPtrCast);
}
+ let expr_kind = match expr_kind {
+ // We can't cast to fat pointer if source pointer kind is unknown
+ None => return Err(CastError::UnknownExprPtrKind),
+ Some(expr_kind) => expr_kind,
+ };
+
// thin -> fat? report invalid cast (don't complain about vtable kinds)
- let expr_kind = fcx.pointer_kind(m_expr.ty, self.span);
if expr_kind == PointerKind::Thin {
return Err(CastError::SizedUnsizedCast);
}
-> Result<CastKind, CastError> {
// fptr-ptr cast. must be to thin ptr
- if fcx.pointer_kind(m_cast.ty, self.span) == PointerKind::Thin {
- Ok(CastKind::FnPtrPtrCast)
- } else {
- Err(CastError::IllegalCast)
+ match fcx.pointer_kind(m_cast.ty, self.span) {
+ None => Err(CastError::UnknownCastPtrKind),
+ Some(PointerKind::Thin) => Ok(CastKind::FnPtrPtrCast),
+ _ => Err(CastError::IllegalCast),
}
}
-> Result<CastKind, CastError> {
// ptr-addr cast. must be from thin ptr
- if fcx.pointer_kind(m_expr.ty, self.span) == PointerKind::Thin {
- Ok(CastKind::PtrAddrCast)
- } else {
- Err(CastError::NeedViaThinPtr)
+ match fcx.pointer_kind(m_expr.ty, self.span) {
+ None => Err(CastError::UnknownExprPtrKind),
+ Some(PointerKind::Thin) => Ok(CastKind::PtrAddrCast),
+ _ => Err(CastError::NeedViaThinPtr),
}
}
m_cast: &'tcx ty::TypeAndMut<'tcx>)
-> Result<CastKind, CastError> {
// ptr-addr cast. pointer must be thin.
- if fcx.pointer_kind(m_cast.ty, self.span) == PointerKind::Thin {
- Ok(CastKind::AddrPtrCast)
- } else {
- Err(CastError::IllegalCast)
+ match fcx.pointer_kind(m_cast.ty, self.span) {
+ None => Err(CastError::UnknownCastPtrKind),
+ Some(PointerKind::Thin) => Ok(CastKind::AddrPtrCast),
+ _ => Err(CastError::IllegalCast),
}
}
use super::{check_fn, Expectation, FnCtxt};
use astconv::AstConv;
+use rustc::hir::def_id::DefId;
+use rustc::infer::{InferOk, InferResult};
+use rustc::infer::LateBoundRegionConversionTime;
use rustc::infer::type_variable::TypeVariableOrigin;
use rustc::ty::{self, ToPolyTraitRef, Ty};
use rustc::ty::subst::Substs;
+use rustc::ty::TypeFoldable;
use std::cmp;
use std::iter;
use syntax::abi::Abi;
use rustc::hir;
+struct ClosureSignatures<'tcx> {
+ bound_sig: ty::PolyFnSig<'tcx>,
+ liberated_sig: ty::FnSig<'tcx>,
+}
+
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
- pub fn check_expr_closure(&self,
- expr: &hir::Expr,
- _capture: hir::CaptureClause,
- decl: &'gcx hir::FnDecl,
- body_id: hir::BodyId,
- expected: Expectation<'tcx>)
- -> Ty<'tcx> {
- debug!("check_expr_closure(expr={:?},expected={:?})",
- expr,
- expected);
+ pub fn check_expr_closure(
+ &self,
+ expr: &hir::Expr,
+ _capture: hir::CaptureClause,
+ decl: &'gcx hir::FnDecl,
+ body_id: hir::BodyId,
+ expected: Expectation<'tcx>,
+ ) -> Ty<'tcx> {
+ debug!(
+ "check_expr_closure(expr={:?},expected={:?})",
+ expr,
+ expected
+ );
// It's always helpful for inference if we know the kind of
// closure sooner rather than later, so first examine the expected
self.check_closure(expr, expected_kind, decl, body, expected_sig)
}
- fn check_closure(&self,
- expr: &hir::Expr,
- opt_kind: Option<ty::ClosureKind>,
- decl: &'gcx hir::FnDecl,
- body: &'gcx hir::Body,
- expected_sig: Option<ty::FnSig<'tcx>>)
- -> Ty<'tcx> {
- debug!("check_closure opt_kind={:?} expected_sig={:?}",
- opt_kind,
- expected_sig);
+ fn check_closure(
+ &self,
+ expr: &hir::Expr,
+ opt_kind: Option<ty::ClosureKind>,
+ decl: &'gcx hir::FnDecl,
+ body: &'gcx hir::Body,
+ expected_sig: Option<ty::FnSig<'tcx>>,
+ ) -> Ty<'tcx> {
+ debug!(
+ "check_closure(opt_kind={:?}, expected_sig={:?})",
+ opt_kind,
+ expected_sig
+ );
let expr_def_id = self.tcx.hir.local_def_id(expr.id);
- let sig = AstConv::ty_of_closure(self,
- hir::Unsafety::Normal,
- decl,
- Abi::RustCall,
- expected_sig);
- // `deduce_expectations_from_expected_type` introduces late-bound
- // lifetimes defined elsewhere, which we need to anonymize away.
- let sig = self.tcx.anonymize_late_bound_regions(&sig);
+
+ let ClosureSignatures {
+ bound_sig,
+ liberated_sig,
+ } = self.sig_of_closure(expr_def_id, decl, body, expected_sig);
+
+ debug!("check_closure: ty_of_closure returns {:?}", liberated_sig);
+
+ let interior = check_fn(
+ self,
+ self.param_env,
+ liberated_sig,
+ decl,
+ expr.id,
+ body,
+ true,
+ ).1;
// Create type variables (for now) to represent the transformed
// types of upvars. These will be unified during the upvar
// inference phase (`upvar.rs`).
- let base_substs = Substs::identity_for_item(self.tcx,
- self.tcx.closure_base_def_id(expr_def_id));
- let substs = base_substs.extend_to(self.tcx, expr_def_id,
- |_, _| span_bug!(expr.span, "closure has region param"),
- |_, _| self.infcx.next_ty_var(TypeVariableOrigin::TransformedUpvar(expr.span))
+ let base_substs =
+ Substs::identity_for_item(self.tcx, self.tcx.closure_base_def_id(expr_def_id));
+ let substs = base_substs.extend_to(
+ self.tcx,
+ expr_def_id,
+ |_, _| span_bug!(expr.span, "closure has region param"),
+ |_, _| {
+ self.infcx
+ .next_ty_var(TypeVariableOrigin::TransformedUpvar(expr.span))
+ },
);
-
- let fn_sig = self.liberate_late_bound_regions(expr_def_id, &sig);
- let fn_sig = self.inh.normalize_associated_types_in(body.value.span,
- body.value.id,
- self.param_env,
- &fn_sig);
-
- let interior = check_fn(self, self.param_env, fn_sig, decl, expr.id, body, true).1;
+ let closure_type = self.tcx.mk_closure(expr_def_id, substs);
if let Some(interior) = interior {
- let closure_substs = ty::ClosureSubsts {
- substs: substs,
- };
+ let closure_substs = ty::ClosureSubsts { substs: substs };
return self.tcx.mk_generator(expr_def_id, closure_substs, interior);
}
- let closure_type = self.tcx.mk_closure(expr_def_id, substs);
-
- debug!("check_closure: expr.id={:?} closure_type={:?}", expr.id, closure_type);
+ debug!(
+ "check_closure: expr.id={:?} closure_type={:?}",
+ expr.id,
+ closure_type
+ );
// Tuple up the arguments and insert the resulting function type into
// the `closures` table.
- let sig = sig.map_bound(|sig| self.tcx.mk_fn_sig(
- iter::once(self.tcx.intern_tup(sig.inputs(), false)),
- sig.output(),
- sig.variadic,
- sig.unsafety,
- sig.abi
- ));
-
- debug!("closure for {:?} --> sig={:?} opt_kind={:?}",
- expr_def_id,
- sig,
- opt_kind);
+ let sig = bound_sig.map_bound(|sig| {
+ self.tcx.mk_fn_sig(
+ iter::once(self.tcx.intern_tup(sig.inputs(), false)),
+ sig.output(),
+ sig.variadic,
+ sig.unsafety,
+ sig.abi,
+ )
+ });
+
+ debug!(
+ "check_closure: expr_def_id={:?}, sig={:?}, opt_kind={:?}",
+ expr_def_id,
+ sig,
+ opt_kind
+ );
{
let mut tables = self.tables.borrow_mut();
closure_type
}
- fn deduce_expectations_from_expected_type
- (&self,
- expected_ty: Ty<'tcx>)
- -> (Option<ty::FnSig<'tcx>>, Option<ty::ClosureKind>) {
- debug!("deduce_expectations_from_expected_type(expected_ty={:?})",
- expected_ty);
+ fn deduce_expectations_from_expected_type(
+ &self,
+ expected_ty: Ty<'tcx>,
+ ) -> (Option<ty::FnSig<'tcx>>, Option<ty::ClosureKind>) {
+ debug!(
+ "deduce_expectations_from_expected_type(expected_ty={:?})",
+ expected_ty
+ );
match expected_ty.sty {
ty::TyDynamic(ref object_type, ..) => {
- let sig = object_type.projection_bounds()
+ let sig = object_type
+ .projection_bounds()
.filter_map(|pb| {
let pb = pb.with_self_ty(self.tcx, self.tcx.types.err);
self.deduce_sig_from_projection(&pb)
})
.next();
- let kind = object_type.principal()
+ let kind = object_type
+ .principal()
.and_then(|p| self.tcx.lang_items().fn_trait_kind(p.def_id()));
(sig, kind)
}
}
}
- fn deduce_expectations_from_obligations
- (&self,
- expected_vid: ty::TyVid)
- -> (Option<ty::FnSig<'tcx>>, Option<ty::ClosureKind>) {
+ fn deduce_expectations_from_obligations(
+ &self,
+ expected_vid: ty::TyVid,
+ ) -> (Option<ty::FnSig<'tcx>>, Option<ty::ClosureKind>) {
let fulfillment_cx = self.fulfillment_cx.borrow();
// Here `expected_ty` is known to be a type inference variable.
- let expected_sig = fulfillment_cx.pending_obligations()
+ let expected_sig = fulfillment_cx
+ .pending_obligations()
.iter()
.map(|obligation| &obligation.obligation)
.filter_map(|obligation| {
- debug!("deduce_expectations_from_obligations: obligation.predicate={:?}",
- obligation.predicate);
+ debug!(
+ "deduce_expectations_from_obligations: obligation.predicate={:?}",
+ obligation.predicate
+ );
match obligation.predicate {
// Given a Projection predicate, we can potentially infer
// infer the kind. This can occur if there is a trait-reference
// like `F : Fn<A>`. Note that due to subtyping we could encounter
// many viable options, so pick the most restrictive.
- let expected_kind = fulfillment_cx.pending_obligations()
+ let expected_kind = fulfillment_cx
+ .pending_obligations()
.iter()
.map(|obligation| &obligation.obligation)
.filter_map(|obligation| {
// inference variable.
ty::Predicate::ClosureKind(..) => None,
};
- opt_trait_ref.and_then(|tr| self.self_type_matches_expected_vid(tr, expected_vid))
+ opt_trait_ref
+ .and_then(|tr| self.self_type_matches_expected_vid(tr, expected_vid))
.and_then(|tr| self.tcx.lang_items().fn_trait_kind(tr.def_id()))
})
- .fold(None,
- |best, cur| Some(best.map_or(cur, |best| cmp::min(best, cur))));
+ .fold(None, |best, cur| {
+ Some(best.map_or(cur, |best| cmp::min(best, cur)))
+ });
(expected_sig, expected_kind)
}
/// Given a projection like "<F as Fn(X)>::Result == Y", we can deduce
/// everything we need to know about a closure.
- fn deduce_sig_from_projection(&self,
- projection: &ty::PolyProjectionPredicate<'tcx>)
- -> Option<ty::FnSig<'tcx>> {
+ fn deduce_sig_from_projection(
+ &self,
+ projection: &ty::PolyProjectionPredicate<'tcx>,
+ ) -> Option<ty::FnSig<'tcx>> {
let tcx = self.tcx;
debug!("deduce_sig_from_projection({:?})", projection);
let arg_param_ty = trait_ref.substs().type_at(1);
let arg_param_ty = self.resolve_type_vars_if_possible(&arg_param_ty);
- debug!("deduce_sig_from_projection: arg_param_ty {:?}",
- arg_param_ty);
+ debug!(
+ "deduce_sig_from_projection: arg_param_ty {:?}",
+ arg_param_ty
+ );
let input_tys = match arg_param_ty.sty {
ty::TyTuple(tys, _) => tys.into_iter(),
let ret_param_ty = projection.0.ty;
let ret_param_ty = self.resolve_type_vars_if_possible(&ret_param_ty);
- debug!("deduce_sig_from_projection: ret_param_ty {:?}", ret_param_ty);
+ debug!(
+ "deduce_sig_from_projection: ret_param_ty {:?}",
+ ret_param_ty
+ );
let fn_sig = self.tcx.mk_fn_sig(
input_tys.cloned(),
ret_param_ty,
false,
hir::Unsafety::Normal,
- Abi::Rust
+ Abi::Rust,
);
debug!("deduce_sig_from_projection: fn_sig {:?}", fn_sig);
Some(fn_sig)
}
- fn self_type_matches_expected_vid(&self,
- trait_ref: ty::PolyTraitRef<'tcx>,
- expected_vid: ty::TyVid)
- -> Option<ty::PolyTraitRef<'tcx>> {
+ fn self_type_matches_expected_vid(
+ &self,
+ trait_ref: ty::PolyTraitRef<'tcx>,
+ expected_vid: ty::TyVid,
+ ) -> Option<ty::PolyTraitRef<'tcx>> {
let self_ty = self.shallow_resolve(trait_ref.self_ty());
- debug!("self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?})",
- trait_ref,
- self_ty);
+ debug!(
+ "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?})",
+ trait_ref,
+ self_ty
+ );
match self_ty.sty {
ty::TyInfer(ty::TyVar(v)) if expected_vid == v => Some(trait_ref),
_ => None,
}
}
+
+ fn sig_of_closure(
+ &self,
+ expr_def_id: DefId,
+ decl: &hir::FnDecl,
+ body: &hir::Body,
+ expected_sig: Option<ty::FnSig<'tcx>>,
+ ) -> ClosureSignatures<'tcx> {
+ if let Some(e) = expected_sig {
+ self.sig_of_closure_with_expectation(expr_def_id, decl, body, e)
+ } else {
+ self.sig_of_closure_no_expectation(expr_def_id, decl, body)
+ }
+ }
+
+ /// If there is no expected signature, then we will convert the
+ /// types that the user gave into a signature.
+ fn sig_of_closure_no_expectation(
+ &self,
+ expr_def_id: DefId,
+ decl: &hir::FnDecl,
+ body: &hir::Body,
+ ) -> ClosureSignatures<'tcx> {
+ debug!("sig_of_closure_no_expectation()");
+
+ let bound_sig = self.supplied_sig_of_closure(decl);
+
+ self.closure_sigs(expr_def_id, body, bound_sig)
+ }
+
+ /// Invoked to compute the signature of a closure expression. This
+ /// combines any user-provided type annotations (e.g., `|x: u32|
+ /// -> u32 { .. }`) with the expected signature.
+ ///
+ /// The approach is as follows:
+ ///
+ /// - Let `S` be the (higher-ranked) signature that we derive from the user's annotations.
+ /// - Let `E` be the (higher-ranked) signature that we derive from the expectations, if any.
+ /// - If we have no expectation `E`, then the signature of the closure is `S`.
+ /// - Otherwise, the signature of the closure is E. Moreover:
+ /// - Skolemize the late-bound regions in `E`, yielding `E'`.
+ /// - Instantiate all the late-bound regions bound in the closure within `S`
+ /// with fresh (existential) variables, yielding `S'`
+ /// - Require that `E' = S'`
+ /// - We could use some kind of subtyping relationship here,
+ /// I imagine, but equality is easier and works fine for
+ /// our purposes.
+ ///
+ /// The key intuition here is that the user's types must be valid
+ /// from "the inside" of the closure, but the expectation
+ /// ultimately drives the overall signature.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// fn with_closure<F>(_: F)
+ /// where F: Fn(&u32) -> &u32 { .. }
+ ///
+ /// with_closure(|x: &u32| { ... })
+ /// ```
+ ///
+ /// Here:
+ /// - E would be `fn(&u32) -> &u32`.
+ /// - S would be `fn(&u32) ->
+ /// - E' is `&'!0 u32 -> &'!0 u32`
+ /// - S' is `&'?0 u32 -> ?T`
+ ///
+ /// S' can be unified with E' with `['?0 = '!0, ?T = &'!10 u32]`.
+ ///
+ /// # Arguments
+ ///
+ /// - `expr_def_id`: the def-id of the closure expression
+ /// - `decl`: the HIR declaration of the closure
+ /// - `body`: the body of the closure
+ /// - `expected_sig`: the expected signature (if any). Note that
+ /// this is missing a binder: that is, there may be late-bound
+ /// regions with depth 1, which are bound then by the closure.
+ fn sig_of_closure_with_expectation(
+ &self,
+ expr_def_id: DefId,
+ decl: &hir::FnDecl,
+ body: &hir::Body,
+ expected_sig: ty::FnSig<'tcx>,
+ ) -> ClosureSignatures<'tcx> {
+ debug!(
+ "sig_of_closure_with_expectation(expected_sig={:?})",
+ expected_sig
+ );
+
+ // Watch out for some surprises and just ignore the
+ // expectation if things don't see to match up with what we
+ // expect.
+ if expected_sig.variadic != decl.variadic {
+ return self.sig_of_closure_no_expectation(expr_def_id, decl, body);
+ } else if expected_sig.inputs_and_output.len() != decl.inputs.len() + 1 {
+ // we could probably handle this case more gracefully
+ return self.sig_of_closure_no_expectation(expr_def_id, decl, body);
+ }
+
+ // Create a `PolyFnSig`. Note the oddity that late bound
+ // regions appearing free in `expected_sig` are now bound up
+ // in this binder we are creating.
+ assert!(!expected_sig.has_regions_escaping_depth(1));
+ let bound_sig = ty::Binder(self.tcx.mk_fn_sig(
+ expected_sig.inputs().iter().cloned(),
+ expected_sig.output(),
+ decl.variadic,
+ hir::Unsafety::Normal,
+ Abi::RustCall,
+ ));
+
+ // `deduce_expectations_from_expected_type` introduces
+ // late-bound lifetimes defined elsewhere, which we now
+ // anonymize away, so as not to confuse the user.
+ let bound_sig = self.tcx.anonymize_late_bound_regions(&bound_sig);
+
+ let closure_sigs = self.closure_sigs(expr_def_id, body, bound_sig);
+
+ // Up till this point, we have ignored the annotations that the user
+ // gave. This function will check that they unify successfully.
+ // Along the way, it also writes out entries for types that the user
+ // wrote into our tables, which are then later used by the privacy
+ // check.
+ match self.check_supplied_sig_against_expectation(decl, &closure_sigs) {
+ Ok(infer_ok) => self.register_infer_ok_obligations(infer_ok),
+ Err(_) => return self.sig_of_closure_no_expectation(expr_def_id, decl, body),
+ }
+
+ closure_sigs
+ }
+
+ /// Enforce the user's types against the expectation. See
+ /// `sig_of_closure_with_expectation` for details on the overall
+ /// strategy.
+ fn check_supplied_sig_against_expectation(
+ &self,
+ decl: &hir::FnDecl,
+ expected_sigs: &ClosureSignatures<'tcx>,
+ ) -> InferResult<'tcx, ()> {
+ // Get the signature S that the user gave.
+ //
+ // (See comment on `sig_of_closure_with_expectation` for the
+ // meaning of these letters.)
+ let supplied_sig = self.supplied_sig_of_closure(decl);
+
+ debug!(
+ "check_supplied_sig_against_expectation: supplied_sig={:?}",
+ supplied_sig
+ );
+
+ // FIXME(#45727): As discussed in [this comment][c1], naively
+ // forcing equality here actually results in suboptimal error
+ // messages in some cases. For now, if there would have been
+ // an obvious error, we fallback to declaring the type of the
+ // closure to be the one the user gave, which allows other
+ // error message code to trigger.
+ //
+ // However, I think [there is potential to do even better
+ // here][c2], since in *this* code we have the precise span of
+ // the type parameter in question in hand when we report the
+ // error.
+ //
+ // [c1]: https://github.com/rust-lang/rust/pull/45072#issuecomment-341089706
+ // [c2]: https://github.com/rust-lang/rust/pull/45072#issuecomment-341096796
+ self.infcx.commit_if_ok(|_| {
+ let mut all_obligations = vec![];
+
+ // The liberated version of this signature should be be a subtype
+ // of the liberated form of the expectation.
+ for ((hir_ty, &supplied_ty), expected_ty) in decl.inputs.iter()
+ .zip(*supplied_sig.inputs().skip_binder()) // binder moved to (*) below
+ .zip(expected_sigs.liberated_sig.inputs())
+ // `liberated_sig` is E'.
+ {
+ // Instantiate (this part of..) S to S', i.e., with fresh variables.
+ let (supplied_ty, _) = self.infcx.replace_late_bound_regions_with_fresh_var(
+ hir_ty.span,
+ LateBoundRegionConversionTime::FnCall,
+ &ty::Binder(supplied_ty),
+ ); // recreated from (*) above
+
+ // Check that E' = S'.
+ let cause = &self.misc(hir_ty.span);
+ let InferOk {
+ value: (),
+ obligations,
+ } = self.at(cause, self.param_env)
+ .eq(*expected_ty, supplied_ty)?;
+ all_obligations.extend(obligations);
+ }
+
+ let (supplied_output_ty, _) = self.infcx.replace_late_bound_regions_with_fresh_var(
+ decl.output.span(),
+ LateBoundRegionConversionTime::FnCall,
+ &supplied_sig.output(),
+ );
+ let cause = &self.misc(decl.output.span());
+ let InferOk {
+ value: (),
+ obligations,
+ } = self.at(cause, self.param_env)
+ .eq(expected_sigs.liberated_sig.output(), supplied_output_ty)?;
+ all_obligations.extend(obligations);
+
+ Ok(InferOk {
+ value: (),
+ obligations: all_obligations,
+ })
+ })
+ }
+
+ /// If there is no expected signature, then we will convert the
+ /// types that the user gave into a signature.
+ fn supplied_sig_of_closure(&self, decl: &hir::FnDecl) -> ty::PolyFnSig<'tcx> {
+ let astconv: &AstConv = self;
+
+ // First, convert the types that the user supplied (if any).
+ let supplied_arguments = decl.inputs.iter().map(|a| astconv.ast_ty_to_ty(a));
+ let supplied_return = match decl.output {
+ hir::Return(ref output) => astconv.ast_ty_to_ty(&output),
+ hir::DefaultReturn(_) => astconv.ty_infer(decl.output.span()),
+ };
+
+ let result = ty::Binder(self.tcx.mk_fn_sig(
+ supplied_arguments,
+ supplied_return,
+ decl.variadic,
+ hir::Unsafety::Normal,
+ Abi::RustCall,
+ ));
+
+ debug!("supplied_sig_of_closure: result={:?}", result);
+
+ result
+ }
+
+ fn closure_sigs(
+ &self,
+ expr_def_id: DefId,
+ body: &hir::Body,
+ bound_sig: ty::PolyFnSig<'tcx>,
+ ) -> ClosureSignatures<'tcx> {
+ let liberated_sig = self.liberate_late_bound_regions(expr_def_id, &bound_sig);
+ let liberated_sig = self.inh.normalize_associated_types_in(
+ body.value.span,
+ body.value.id,
+ self.param_env,
+ &liberated_sig,
+ );
+ ClosureSignatures {
+ bound_sig,
+ liberated_sig,
+ }
+ }
}
ty::TySlice(_) => {
let lang_def_id = lang_items.slice_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
+
+ let lang_def_id = lang_items.slice_u8_impl();
+ self.assemble_inherent_impl_for_primitive(lang_def_id);
}
ty::TyRawPtr(ty::TypeAndMut { ty: _, mutbl: hir::MutImmutable }) => {
let lang_def_id = lang_items.const_ptr_impl();
hir::QPath::TypeRelative(ref qself, _) => qself.span
};
+ // Prohibit struct expressions when non exhaustive flag is set.
+ if let ty::TyAdt(adt, _) = struct_ty.sty {
+ if !adt.did.is_local() && adt.is_non_exhaustive() {
+ span_err!(self.tcx.sess, expr.span, E0639,
+ "cannot create non-exhaustive {} using struct expression",
+ adt.variant_descr());
+ }
+ }
+
self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
base_expr.is_none());
if let &Some(ref base_expr) = base_expr {
// FIXME(#27579) what amount of WF checking do we need for neg impls?
let trait_ref = tcx.impl_trait_ref(tcx.hir.local_def_id(item.id)).unwrap();
- if !tcx.trait_has_default_impl(trait_ref.def_id) {
+ if !tcx.trait_is_auto(trait_ref.def_id) {
error_192(tcx, item.span);
}
}
fn check_trait(&mut self, item: &hir::Item) {
let trait_def_id = self.tcx.hir.local_def_id(item.id);
- if self.tcx.trait_has_default_impl(trait_def_id) {
+ if self.tcx.trait_is_auto(trait_def_id) {
self.check_auto_trait(trait_def_id, item.span);
}
"str",
item.span);
}
+ ty::TySlice(slice_item) if slice_item == self.tcx.types.u8 => {
+ self.check_primitive_impl(def_id,
+ lang_items.slice_u8_impl(),
+ "slice_u8",
+ "[u8]",
+ item.span);
+ }
ty::TySlice(_) => {
self.check_primitive_impl(def_id,
lang_items.slice_impl(),
unsafety::check(tcx);
orphan::check(tcx);
- overlap::check_default_impls(tcx);
+ overlap::check_auto_impls(tcx);
// these queries are executed for side-effects (error reporting):
tcx.crate_inherent_impls(LOCAL_CRATE);
// This final impl is legal according to the orpan
// rules, but it invalidates the reasoning from
// `two_foos` above.
- debug!("trait_ref={:?} trait_def_id={:?} trait_has_default_impl={}",
+ debug!("trait_ref={:?} trait_def_id={:?} trait_is_auto={}",
trait_ref,
trait_def_id,
- self.tcx.trait_has_default_impl(trait_def_id));
- if self.tcx.trait_has_default_impl(trait_def_id) &&
+ self.tcx.trait_is_auto(trait_def_id));
+ if self.tcx.trait_is_auto(trait_def_id) &&
!trait_def_id.is_local() {
let self_ty = trait_ref.self_ty();
let opt_self_def_id = match self_ty.sty {
}
}
}
- hir::ItemDefaultImpl(_, ref item_trait_ref) => {
+ hir::ItemAutoImpl(_, ref item_trait_ref) => {
// "Trait" impl
debug!("coherence2::orphan check: default trait impl {}",
self.tcx.hir.node_to_string(item.id));
use rustc::hir;
use rustc::hir::itemlikevisit::ItemLikeVisitor;
-pub fn check_default_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
+pub fn check_auto_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
let mut overlap = OverlapChecker { tcx };
// this secondary walk specifically checks for some other cases,
impl<'cx, 'tcx, 'v> ItemLikeVisitor<'v> for OverlapChecker<'cx, 'tcx> {
fn visit_item(&mut self, item: &'v hir::Item) {
match item.node {
- hir::ItemDefaultImpl(..) => {
- // look for another default impl; note that due to the
+ hir::ItemAutoImpl(..) => {
+ // look for another auto impl; note that due to the
// general orphan/coherence rules, it must always be
// in this crate.
let impl_def_id = self.tcx.hir.local_def_id(item.id);
let trait_ref = self.tcx.impl_trait_ref(impl_def_id).unwrap();
- let prev_id = self.tcx.hir.trait_default_impl(trait_ref.def_id).unwrap();
+ let prev_id = self.tcx.hir.trait_auto_impl(trait_ref.def_id).unwrap();
if prev_id != item.id {
let mut err = struct_span_err!(self.tcx.sess,
self.tcx.span_of_impl(impl_def_id).unwrap(),
E0521,
- "redundant default implementations of trait \
+ "redundant auto implementations of trait \
`{}`:",
trait_ref);
err.span_note(self.tcx
impl<'cx, 'tcx, 'v> ItemLikeVisitor<'v> for UnsafetyChecker<'cx, 'tcx> {
fn visit_item(&mut self, item: &'v hir::Item) {
match item.node {
- hir::ItemDefaultImpl(unsafety, _) => {
+ hir::ItemAutoImpl(unsafety, _) => {
self.check_unsafety_coherence(item, None, unsafety, hir::ImplPolarity::Positive);
}
hir::ItemImpl(unsafety, polarity, _, ref generics, ..) => {
impl_trait_ref,
impl_polarity,
is_foreign_item,
- is_default_impl,
+ is_auto_impl,
..*providers
};
}
ItemEnum(_, ref generics) |
ItemStruct(_, ref generics) |
ItemUnion(_, ref generics) => generics,
- ItemTrait(_, ref generics, ..) => {
+ ItemTrait(_, _, ref generics, ..) => {
// Implied `Self: Trait` and supertrait bounds.
if param_id == item_node_id {
result.predicates.push(ty::TraitRef {
tcx.predicates_of(def_id);
convert_enum_variant_types(tcx, def_id, &enum_definition.variants);
},
- hir::ItemDefaultImpl(..) => {
+ hir::ItemAutoImpl(..) => {
tcx.impl_trait_ref(def_id);
}
hir::ItemImpl(..) => {
};
let (generics, bounds) = match item.node {
- hir::ItemTrait(_, ref generics, ref supertraits, _) => (generics, supertraits),
+ hir::ItemTrait(.., ref generics, ref supertraits, _) => (generics, supertraits),
_ => span_bug!(item.span,
"super_predicates invoked on non-trait"),
};
let item = tcx.hir.expect_item(node_id);
let unsafety = match item.node {
- hir::ItemTrait(unsafety, ..) => unsafety,
+ hir::ItemTrait(_, unsafety, ..) => unsafety,
_ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
};
}
let def_path_hash = tcx.def_path_hash(def_id);
- let has_default_impl = tcx.hir.trait_is_auto(def_id);
+ let is_auto = match item.node {
+ hir::ItemTrait(hir::IsAuto::Yes, ..) => true,
+ _ => tcx.hir.trait_is_auto(def_id),
+ };
let def = ty::TraitDef::new(def_id,
unsafety,
paren_sugar,
- has_default_impl,
+ is_auto,
def_path_hash);
tcx.alloc_trait_def(def)
}
generics
}
- ItemTrait(_, ref generics, ..) => {
+ ItemTrait(_, _, ref generics, ..) => {
// Add in the self type parameter.
//
// Something of a hack: use the node id for the trait, also as
let substs = Substs::identity_for_item(tcx, def_id);
tcx.mk_adt(def, substs)
}
- ItemDefaultImpl(..) |
+ ItemAutoImpl(..) |
ItemTrait(..) |
ItemMod(..) |
ItemForeignMod(..) |
let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
match tcx.hir.expect_item(node_id).node {
- hir::ItemDefaultImpl(_, ref ast_trait_ref) => {
+ hir::ItemAutoImpl(_, ref ast_trait_ref) => {
Some(AstConv::instantiate_mono_trait_ref(&icx,
ast_trait_ref,
tcx.mk_self_type()))
generics
}
- ItemTrait(_, ref generics, .., ref items) => {
+ ItemTrait(_, _, ref generics, .., ref items) => {
is_trait = Some((ty::TraitRef {
def_id,
substs: Substs::identity_for_item(tcx, def_id)
}
}
-fn is_default_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+fn is_auto_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
-> bool {
match tcx.hir.get_if_local(def_id) {
- Some(hir_map::NodeItem(&hir::Item { node: hir::ItemDefaultImpl(..), .. }))
+ Some(hir_map::NodeItem(&hir::Item { node: hir::ItemAutoImpl(..), .. }))
=> true,
Some(_) => false,
- _ => bug!("is_default_impl applied to non-local def-id {:?}", def_id)
+ _ => bug!("is_auto_impl applied to non-local def-id {:?}", def_id)
}
}
This will compile:
-```
+```ignore (ignore auto_trait future compatibility warning)
#![feature(optin_builtin_traits)]
struct Foo;
```
"##,
+E0638: r##"
+This error indicates that the struct or enum must be matched non-exhaustively
+as it has been marked as `non_exhaustive`.
+
+When applied within a crate, downstream users of the crate will need to use the
+`_` pattern when matching enums and use the `..` pattern when matching structs.
+
+For example, in the below example, since the enum is marked as
+`non_exhaustive`, it is required that downstream crates match non-exhaustively
+on it.
+
+```rust,ignore (pseudo-Rust)
+use std::error::Error as StdError;
+
+#[non_exhaustive] pub enum Error {
+ Message(String),
+ Other,
+}
+
+impl StdError for Error {
+ fn description(&self) -> &str {
+ // This will not error, despite being marked as non_exhaustive, as this
+ // enum is defined within the current crate, it can be matched
+ // exhaustively.
+ match *self {
+ Message(ref s) => s,
+ Other => "other or unknown error",
+ }
+ }
+}
+```
+
+An example of matching non-exhaustively on the above enum is provided below:
+
+```rust,ignore (pseudo-Rust)
+use mycrate::Error;
+
+// This will not error as the non_exhaustive Error enum has been matched with a
+// wildcard.
+match error {
+ Message(ref s) => ...,
+ Other => ...,
+ _ => ...,
+}
+```
+
+Similarly, for structs, match with `..` to avoid this error.
+"##,
+
+E0639: r##"
+This error indicates that the struct or enum cannot be instantiated from
+outside of the defining crate as it has been marked as `non_exhaustive` and as
+such more fields/variants may be added in future that could cause adverse side
+effects for this code.
+
+It is recommended that you look for a `new` function or equivalent in the
+crate's documentation.
+"##,
+
}
register_diagnostics! {
// E0372, // coherence not object safe
E0377, // the trait `CoerceUnsized` may only be implemented for a coercion
// between structures with the same definition
- E0521, // redundant default implementations of trait
+ E0521, // redundant auto implementations of trait
E0533, // `{}` does not name a unit variant, unit struct or a constant
// E0563, // cannot determine a type for this `impl Trait`: {} // removed in 6383de15
E0564, // only named lifetimes are allowed in `impl Trait`,
E0627, // yield statement outside of generator literal
E0632, // cannot provide explicit type parameters when `impl Trait` is used in
// argument position.
+ E0641, // cannot cast to/from a pointer with an unknown kind
}
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(conservative_impl_trait)]
+#![feature(match_default_bindings)]
#![feature(never_type)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
use std::mem;
use std::fmt::{self, Write};
use std::ops;
+#[cfg(stage0)]
use std::ascii::AsciiExt;
use syntax::symbol::Symbol;
}
}
- // If this is a defaulted impl, then bail out early here
- if tcx.is_default_impl(did) {
+ // If this is an auto impl, then bail out early here
+ if tcx.is_auto_impl(did) {
return ret.push(clean::Item {
- inner: clean::DefaultImplItem(clean::DefaultImpl {
+ inner: clean::AutoImplItem(clean::AutoImpl {
// FIXME: this should be decoded
unsafety: hir::Unsafety::Normal,
trait_: match associated_trait.as_ref().unwrap().clean(cx) {
PrimitiveItem(PrimitiveType),
AssociatedConstItem(Type, Option<String>),
AssociatedTypeItem(Vec<TyParamBound>, Option<Type>),
- DefaultImplItem(DefaultImpl),
+ AutoImplItem(AutoImpl),
/// An item that has been stripped by a rustdoc pass
StrippedItem(Box<ItemEnum>),
}
}
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
-pub struct DefaultImpl {
+pub struct AutoImpl {
pub unsafety: hir::Unsafety,
pub trait_: Type,
}
-impl Clean<Item> for doctree::DefaultImpl {
+impl Clean<Item> for doctree::AutoImpl {
fn clean(&self, cx: &DocContext) -> Item {
Item {
name: None,
visibility: Some(Public),
stability: None,
deprecation: None,
- inner: DefaultImplItem(DefaultImpl {
+ inner: AutoImplItem(AutoImpl {
unsafety: self.unsafety,
trait_: self.trait_.clean(cx),
}),
pub stab: Option<attr::Stability>,
pub depr: Option<attr::Deprecation>,
pub impls: Vec<Impl>,
- pub def_traits: Vec<DefaultImpl>,
+ pub def_traits: Vec<AutoImpl>,
pub foreigns: Vec<hir::ForeignMod>,
pub macros: Vec<Macro>,
pub is_crate: bool,
pub id: ast::NodeId,
}
-pub struct DefaultImpl {
+pub struct AutoImpl {
pub unsafety: hir::Unsafety,
pub trait_: hir::TraitRef,
pub id: ast::NodeId,
clean::PrimitiveItem(..) => ItemType::Primitive,
clean::AssociatedConstItem(..) => ItemType::AssociatedConst,
clean::AssociatedTypeItem(..) => ItemType::AssociatedType,
- clean::DefaultImplItem(..) => ItemType::Impl,
+ clean::AutoImplItem(..) => ItemType::Impl,
clean::ForeignTypeItem => ItemType::ForeignType,
clean::StrippedItem(..) => unreachable!(),
}
<dd>Switch tab</dd>
<dt>⏎</dt>
<dd>Go to active search result</dd>
- <dt>+</dt>
+ <dt style="width:31px;">+ / -</dt>
<dd>Collapse/expand all sections</dd>
</dl>
</div>
use libc;
use std::slice;
-use std::ascii::AsciiExt;
use std::cell::RefCell;
use std::collections::{HashMap, VecDeque};
use std::default::Default;
//! both occur before the crate is rendered.
pub use self::ExternalLocation::*;
+#[cfg(stage0)]
use std::ascii::AsciiExt;
use std::cell::RefCell;
use std::cmp::Ordering;
// Figure out the id of this impl. This may map to a
// primitive rather than always to a struct/enum.
// Note: matching twice to restrict the lifetime of the `i` borrow.
- let mut dids = vec![];
+ let mut dids = FxHashSet();
if let clean::Item { inner: clean::ImplItem(ref i), .. } = item {
let masked_trait = i.trait_.def_id().map_or(false,
|d| self.masked_crates.contains(&d.krate));
clean::BorrowedRef {
type_: box clean::ResolvedPath { did, .. }, ..
} => {
- dids.push(did);
+ dids.insert(did);
}
ref t => {
let did = t.primitive_type().and_then(|t| {
});
if let Some(did) = did {
- dids.push(did);
+ dids.insert(did);
}
}
}
if let Some(generics) = i.trait_.as_ref().and_then(|t| t.generics()) {
for bound in generics {
if let Some(did) = bound.def_id() {
- dids.push(did);
+ dids.insert(did);
}
}
}
document(w, cx, item)?;
let mut indices = (0..items.len()).filter(|i| {
- if let clean::DefaultImplItem(..) = items[*i].inner {
+ if let clean::AutoImplItem(..) = items[*i].inner {
return false;
}
!items[*i].is_stripped()
if !foreign.is_empty() {
write!(w, "
- <h2 id='foreign-impls' class='section-header'>
+ <h2 id='foreign-impls' class='small-section-header'>
Implementations on Foreign Types<a href='#foreign-impls' class='anchor'></a>
</h2>
")?;
let mut links = HashSet::new();
let ret = v.iter()
.filter_map(|i| if let Some(ref i) = i.inner_impl().trait_ {
- let out = format!("{:#}", i).replace("<", "<").replace(">", ">");
+ let i_display = format!("{:#}", i);
+ let out = Escape(&i_display);
let encoded = small_url_encode(&format!("{:#}", i));
let generated = format!("<a href=\"#impl-{}\">{}</a>", encoded, out);
if !links.contains(&generated) && links.insert(generated.clone()) {
fn sidebar_struct(fmt: &mut fmt::Formatter, it: &clean::Item,
s: &clean::Struct) -> fmt::Result {
let mut sidebar = String::new();
+ let fields = get_struct_fields_name(&s.fields);
- if s.fields.iter()
- .any(|f| if let clean::StructFieldItem(..) = f.inner { true } else { false }) {
+ if !fields.is_empty() {
if let doctree::Plain = s.struct_type {
- sidebar.push_str("<li><a href=\"#fields\">Fields</a></li>");
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#fields\">Fields</a>\
+ <div class=\"sidebar-links\">{}</div>", fields));
}
}
Ok(())
}
+fn extract_for_impl_name(item: &clean::Item) -> Option<(String, String)> {
+ match item.inner {
+ clean::ItemEnum::ImplItem(ref i) => {
+ if let Some(ref trait_) = i.trait_ {
+ Some((format!("{:#}", i.for_), format!("{:#}", trait_)))
+ } else {
+ None
+ }
+ },
+ _ => None,
+ }
+}
+
fn sidebar_trait(fmt: &mut fmt::Formatter, it: &clean::Item,
t: &clean::Trait) -> fmt::Result {
let mut sidebar = String::new();
- let has_types = t.items.iter().any(|m| m.is_associated_type());
- let has_consts = t.items.iter().any(|m| m.is_associated_const());
- let has_required = t.items.iter().any(|m| m.is_ty_method());
- let has_provided = t.items.iter().any(|m| m.is_method());
+ let types = t.items
+ .iter()
+ .filter_map(|m| {
+ match m.name {
+ Some(ref name) if m.is_associated_type() => {
+ Some(format!("<a href=\"#associatedtype.{name}\">{name}</a>",
+ name=name))
+ }
+ _ => None,
+ }
+ })
+ .collect::<String>();
+ let consts = t.items
+ .iter()
+ .filter_map(|m| {
+ match m.name {
+ Some(ref name) if m.is_associated_const() => {
+ Some(format!("<a href=\"#associatedconstant.{name}\">{name}</a>",
+ name=name))
+ }
+ _ => None,
+ }
+ })
+ .collect::<String>();
+ let required = t.items
+ .iter()
+ .filter_map(|m| {
+ match m.name {
+ Some(ref name) if m.is_ty_method() => {
+ Some(format!("<a href=\"#tymethod.{name}\">{name}</a>",
+ name=name))
+ }
+ _ => None,
+ }
+ })
+ .collect::<String>();
+ let provided = t.items
+ .iter()
+ .filter_map(|m| {
+ match m.name {
+ Some(ref name) if m.is_method() => {
+ Some(format!("<a href=\"#method.{name}\">{name}</a>", name=name))
+ }
+ _ => None,
+ }
+ })
+ .collect::<String>();
- if has_types {
- sidebar.push_str("<li><a href=\"#associated-types\">Associated Types</a></li>");
+ if !types.is_empty() {
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#associated-types\">\
+ Associated Types</a><div class=\"sidebar-links\">{}</div>",
+ types));
}
- if has_consts {
- sidebar.push_str("<li><a href=\"#associated-const\">Associated Constants</a></li>");
+ if !consts.is_empty() {
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#associated-const\">\
+ Associated Constants</a><div class=\"sidebar-links\">{}</div>",
+ consts));
}
- if has_required {
- sidebar.push_str("<li><a href=\"#required-methods\">Required Methods</a></li>");
+ if !required.is_empty() {
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#required-methods\">\
+ Required Methods</a><div class=\"sidebar-links\">{}</div>",
+ required));
}
- if has_provided {
- sidebar.push_str("<li><a href=\"#provided-methods\">Provided Methods</a></li>");
+ if !provided.is_empty() {
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#provided-methods\">\
+ Provided Methods</a><div class=\"sidebar-links\">{}</div>",
+ provided));
}
let c = cache();
if let Some(implementors) = c.implementors.get(&it.def_id) {
- if implementors.iter().any(|i| i.impl_.for_.def_id()
- .map_or(false, |d| !c.paths.contains_key(&d)))
- {
- sidebar.push_str("<li><a href=\"#foreign-impls\">\
- Implementations on Foreign Types</a></li>");
- }
- }
-
- sidebar.push_str("<li><a href=\"#implementors\">Implementors</a></li>");
+ let res = implementors.iter()
+ .filter(|i| i.impl_.for_.def_id()
+ .map_or(false, |d| !c.paths.contains_key(&d)))
+ .filter_map(|i| {
+ if let Some(item) = implementor2item(&c, i) {
+ match extract_for_impl_name(&item) {
+ Some((ref name, ref url)) => {
+ Some(format!("<a href=\"#impl-{}\">{}</a>",
+ small_url_encode(url),
+ Escape(name)))
+ }
+ _ => None,
+ }
+ } else {
+ None
+ }
+ })
+ .collect::<String>();
+ if !res.is_empty() {
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#foreign-impls\">\
+ Implementations on Foreign Types</a><div \
+ class=\"sidebar-links\">{}</div>",
+ res));
+ }
+ }
+
+ sidebar.push_str("<a class=\"sidebar-title\" href=\"#implementors\">Implementors</a>");
sidebar.push_str(&sidebar_assoc_items(it));
Ok(())
}
+fn get_struct_fields_name(fields: &[clean::Item]) -> String {
+ fields.iter()
+ .filter(|f| if let clean::StructFieldItem(..) = f.inner {
+ true
+ } else {
+ false
+ })
+ .filter_map(|f| match f.name {
+ Some(ref name) => Some(format!("<a href=\"#structfield.{name}\">\
+ {name}</a>", name=name)),
+ _ => None,
+ })
+ .collect()
+}
+
fn sidebar_union(fmt: &mut fmt::Formatter, it: &clean::Item,
u: &clean::Union) -> fmt::Result {
let mut sidebar = String::new();
+ let fields = get_struct_fields_name(&u.fields);
- if u.fields.iter()
- .any(|f| if let clean::StructFieldItem(..) = f.inner { true } else { false }) {
- sidebar.push_str("<li><a href=\"#fields\">Fields</a></li>");
+ if !fields.is_empty() {
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#fields\">Fields</a>\
+ <div class=\"sidebar-links\">{}</div>", fields));
}
sidebar.push_str(&sidebar_assoc_items(it));
e: &clean::Enum) -> fmt::Result {
let mut sidebar = String::new();
- if !e.variants.is_empty() {
- sidebar.push_str("<li><a href=\"#variants\">Variants</a></li>");
+ let variants = e.variants.iter()
+ .filter_map(|v| match v.name {
+ Some(ref name) => Some(format!("<a href=\"#variant.{name}\">{name}\
+ </a>", name = name)),
+ _ => None,
+ })
+ .collect::<String>();
+ if !variants.is_empty() {
+ sidebar.push_str(&format!("<a class=\"sidebar-title\" href=\"#variants\">Variants</a>\
+ <div class=\"sidebar-links\">{}</div>", variants));
}
sidebar.push_str(&sidebar_assoc_items(it));
ItemType::TyMethod, ItemType::Method, ItemType::StructField, ItemType::Variant,
ItemType::AssociatedType, ItemType::AssociatedConst, ItemType::ForeignType] {
if items.iter().any(|it| {
- if let clean::DefaultImplItem(..) = it.inner {
+ if let clean::AutoImplItem(..) = it.inner {
false
} else {
!it.is_stripped() && it.type_() == myty
break;
case "+":
+ case "-":
ev.preventDefault();
toggleAllDocs();
break;
var valLower = query.query.toLowerCase(),
val = valLower,
typeFilter = itemTypeFromName(query.type),
- results = [],
+ results = {},
split = valLower.split("::");
// remove empty keywords
}
}
+ function min(a, b) {
+ if (a < b) {
+ return a;
+ }
+ return b;
+ }
+
+ function nbElements(obj) {
+ var size = 0, key;
+ for (key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ size += 1;
+ }
+ }
+ return size;
+ }
+
function findArg(obj, val) {
+ var lev_distance = MAX_LEV_DISTANCE + 1;
if (obj && obj.type && obj.type.inputs.length > 0) {
for (var i = 0; i < obj.type.inputs.length; i++) {
if (obj.type.inputs[i].name === val) {
- return true;
+ // No need to check anything else: we found it. Let's just move on.
+ return 0;
+ }
+ lev_distance = min(levenshtein(obj.type.inputs[i].name, val), lev_distance);
+ if (lev_distance === 0) {
+ return 0;
}
}
}
- return false;
+ return lev_distance;
+ }
+
+ function checkReturned(obj, val) {
+ var lev_distance = MAX_LEV_DISTANCE + 1;
+ if (obj && obj.type && obj.type.output) {
+ if (obj.type.output.name.toLowerCase() === val) {
+ return 0;
+ }
+ lev_distance = min(levenshtein(obj.type.output.name, val));
+ if (lev_distance === 0) {
+ return 0;
+ }
+ }
+ return lev_distance;
}
function typePassesFilter(filter, type) {
if ((val.charAt(0) === "\"" || val.charAt(0) === "'") &&
val.charAt(val.length - 1) === val.charAt(0))
{
- val = val.substr(1, val.length - 2);
+ val = val.substr(1, val.length - 2).toLowerCase();
for (var i = 0; i < nSearchWords; ++i) {
+ var ty = searchIndex[i];
if (searchWords[i] === val) {
// filter type: ... queries
if (typePassesFilter(typeFilter, searchIndex[i].ty)) {
- results.push({id: i, index: -1});
+ results[ty.path + ty.name] = {id: i, index: -1};
}
- } else if (findArg(searchIndex[i], val.toLowerCase()) ||
- (searchIndex[i].type &&
- searchIndex[i].type.output &&
- searchIndex[i].type.output.name === val.toLowerCase())) {
+ } else if (findArg(searchIndex[i], val) ||
+ (ty.type &&
+ ty.type.output &&
+ ty.type.output.name === val)) {
if (typePassesFilter(typeFilter, searchIndex[i].ty)) {
- results.push({id: i, index: -1, dontValidate: true});
+ results[ty.path + ty.name] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
}
}
- if (results.length === max) {
+ if (nbElements(results) === max) {
break;
}
}
for (var i = 0; i < nSearchWords; ++i) {
var type = searchIndex[i].type;
+ var ty = searchIndex[i];
if (!type) {
continue;
}
var typeOutput = type.output ? type.output.name : "";
if (output === "*" || output == typeOutput) {
if (input === "*") {
- results.push({id: i, index: -1, dontValidate: true});
+ results[ty.path + ty.name] = {id: i, index: -1, dontValidate: true};
} else {
var allFound = true;
for (var it = 0; allFound === true && it < inputs.length; it++) {
allFound = found;
}
if (allFound === true) {
- results.push({id: i, index: -1, dontValidate: true});
+ results[ty.path + ty.name] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
}
}
}
for (var i = 0; i < split.length; ++i) {
for (var j = 0; j < nSearchWords; ++j) {
var lev_distance;
+ var ty = searchIndex[j];
+ if (!ty) {
+ continue;
+ }
if (searchWords[j].indexOf(split[i]) > -1 ||
searchWords[j].indexOf(val) > -1 ||
searchWords[j].replace(/_/g, "").indexOf(val) > -1)
{
// filter type: ... queries
if (typePassesFilter(typeFilter, searchIndex[j].ty)) {
- results.push({
+ results[ty.path + ty.name] = {
id: j,
index: searchWords[j].replace(/_/g, "").indexOf(val),
lev: 0,
- });
+ };
}
} else if (
- (lev_distance = levenshtein(searchWords[j], val)) <=
- MAX_LEV_DISTANCE) {
+ (lev_distance = levenshtein(searchWords[j], val)) <= MAX_LEV_DISTANCE) {
if (typePassesFilter(typeFilter, searchIndex[j].ty)) {
- results.push({
- id: j,
- index: 0,
- // we want lev results to go lower than others
- lev: lev_distance,
- });
+ if (results[ty.path + ty.name] === undefined ||
+ results[ty.path + ty.name].lev > lev_distance) {
+ results[ty.path + ty.name] = {
+ id: j,
+ index: 0,
+ // we want lev results to go lower than others
+ lev: lev_distance,
+ };
+ }
}
- } else if (findArg(searchIndex[j], val)) {
+ } else if (
+ (lev_distance = findArg(searchIndex[j], val)) <= MAX_LEV_DISTANCE) {
if (typePassesFilter(typeFilter, searchIndex[j].ty)) {
- results.push({
- id: j,
- index: 0,
- // we want lev results to go lower than others
- lev: lev_distance,
- });
+ if (results[ty.path + ty.name] === undefined ||
+ results[ty.path + ty.name].lev > lev_distance) {
+ results[ty.path + ty.name] = {
+ id: j,
+ index: 0,
+ // we want lev results to go lower than others
+ lev: lev_distance,
+ };
+ }
+ }
+ } else if (
+ (lev_distance = checkReturned(searchIndex[j], val)) <=
+ MAX_LEV_DISTANCE) {
+ if (typePassesFilter(typeFilter, searchIndex[j].ty)) {
+ if (results[ty.path + ty.name] === undefined ||
+ results[ty.path + ty.name].lev > lev_distance) {
+ results[ty.path + ty.name] = {
+ id: j,
+ index: 0,
+ // we want lev results to go lower than others
+ lev: lev_distance,
+ };
+ }
}
}
- if (results.length === max) {
+ if (nbElements(results) === max) {
break;
}
}
}
}
+ var ar = [];
+ for (var entry in results) {
+ if (results.hasOwnProperty(entry)) {
+ ar.push(results[entry]);
+ }
+ }
+ results = ar;
var nresults = results.length;
for (var i = 0; i < nresults; ++i) {
results[i].word = searchWords[results[i].id];
return 0;
});
- // remove duplicates, according to the data provided
- for (var i = results.length - 1; i > 0; i -= 1) {
- if (results[i].word === results[i - 1].word &&
- results[i].item.ty === results[i - 1].item.ty &&
- results[i].item.path === results[i - 1].item.path &&
- (results[i].item.parent || {}).name === (results[i - 1].item.parent || {}).name)
- {
- results[i].id = -1;
- }
- }
for (var i = 0; i < results.length; ++i) {
var result = results[i],
name = result.item.name.toLowerCase(),
elems[0].onclick = function() { printTab(0); };
elems[1].onclick = function() { printTab(1); };
elems[2].onclick = function() { printTab(2); };
+ printTab(currentTab);
}
function search(e) {
}
}
if (results['others'].length < maxResults &&
- ((query.search && obj.name.indexOf(query.search)) || added === false)) {
+ ((query.search && obj.name.indexOf(query.search) !== -1) ||
+ added === false)) {
results['others'].push(obj);
}
}
display: block;
margin-top: -1px;
}
-#help dd { margin: 5px 33px; }
+#help dd { margin: 5px 35px; }
#help .infos { padding-left: 0; }
#help h1, #help h2 { margin-top: 0; }
#help > div div {
width: 50%;
float: left;
padding: 20px;
+ padding-left: 17px;
}
.stab {
html_playground_url = "https://play.rust-lang.org/")]
#![deny(warnings)]
+#![feature(ascii_ctype)]
#![feature(rustc_private)]
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(test)]
#![feature(unicode)]
#![feature(vec_remove_item)]
-#![feature(ascii_ctype)]
extern crate arena;
extern crate getopts;
// handled in the `strip-priv-imports` pass
clean::ExternCrateItem(..) | clean::ImportItem(..) => {}
- clean::DefaultImplItem(..) | clean::ImplItem(..) => {}
+ clean::AutoImplItem(..) | clean::ImplItem(..) => {}
// tymethods/macros have no control over privacy
clean::MacroItem(..) | clean::TyMethodItem(..) => {}
let mut prog = String::new();
- // First push any outer attributes from the example, assuming they
- // are intended to be crate attributes.
- prog.push_str(&crate_attrs);
+ if opts.attrs.is_empty() {
+ // If there aren't any attributes supplied by #![doc(test(attr(...)))], then allow some
+ // lints that are commonly triggered in doctests. The crate-level test attributes are
+ // commonly used to make tests fail in case they trigger warnings, so having this there in
+ // that case may cause some tests to pass when they shouldn't have.
+ prog.push_str("#![allow(unused)]\n");
+ }
- // Next, any attributes for other aspects such as lints.
+ // Next, any attributes that came from the crate root via #![doc(test(attr(...)))].
for attr in &opts.attrs {
prog.push_str(&format!("#![{}]\n", attr));
}
+ // Now push any outer attributes from the example, assuming they
+ // are intended to be crate attributes.
+ prog.push_str(&crate_attrs);
+
// Don't inject `extern crate std` because it's already injected by the
// compiler.
if !s.contains("extern crate") && !opts.no_crate_inject && cratename != Some("std") {
};
om.constants.push(s);
},
- hir::ItemTrait(unsafety, ref gen, ref b, ref item_ids) => {
+ hir::ItemTrait(_, unsafety, ref gen, ref b, ref item_ids) => {
let items = item_ids.iter()
.map(|ti| self.cx.tcx.hir.trait_item(ti.id).clone())
.collect();
om.impls.push(i);
}
},
- hir::ItemDefaultImpl(unsafety, ref trait_ref) => {
+ hir::ItemAutoImpl(unsafety, ref trait_ref) => {
// See comment above about ItemImpl.
if !self.inlining {
- let i = DefaultImpl {
+ let i = AutoImpl {
unsafety,
trait_: trait_ref.clone(),
id: item.id,
name = "std"
version = "0.0.0"
build = "build.rs"
+license = "MIT/Apache-2.0"
+repository = "https://github.com/rust-lang/rust.git"
+description = "The Rust Standard Library"
[lib]
name = "std"
/// ```
/// use std::ascii::AsciiExt;
///
-/// assert_eq!("café".to_ascii_uppercase(), "CAFÉ");
-/// assert_eq!("café".to_ascii_uppercase(), "CAFé");
+/// assert_eq!(AsciiExt::to_ascii_uppercase("café"), "CAFÉ");
+/// assert_eq!(AsciiExt::to_ascii_uppercase("café"), "CAFé");
/// ```
///
/// In the first example, the lowercased string is represented `"cafe\u{301}"`
/// Checks if the value is within the ASCII range.
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// use std::ascii::AsciiExt;
- ///
- /// let ascii = 'a';
- /// let non_ascii = '❤';
- /// let int_ascii = 97;
- ///
- /// assert!(ascii.is_ascii());
- /// assert!(!non_ascii.is_ascii());
- /// assert!(int_ascii.is_ascii());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[stable(feature = "rust1", since = "1.0.0")]
fn is_ascii(&self) -> bool;
/// To uppercase ASCII characters in addition to non-ASCII characters, use
/// [`str::to_uppercase`].
///
- /// # Examples
- ///
- /// ```
- /// use std::ascii::AsciiExt;
- ///
- /// let ascii = 'a';
- /// let non_ascii = '❤';
- /// let int_ascii = 97;
+ /// # Note
///
- /// assert_eq!('A', ascii.to_ascii_uppercase());
- /// assert_eq!('❤', non_ascii.to_ascii_uppercase());
- /// assert_eq!(65, int_ascii.to_ascii_uppercase());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
///
/// [`make_ascii_uppercase`]: #tymethod.make_ascii_uppercase
/// [`str::to_uppercase`]: ../primitive.str.html#method.to_uppercase
/// To lowercase ASCII characters in addition to non-ASCII characters, use
/// [`str::to_lowercase`].
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// use std::ascii::AsciiExt;
- ///
- /// let ascii = 'A';
- /// let non_ascii = '❤';
- /// let int_ascii = 65;
- ///
- /// assert_eq!('a', ascii.to_ascii_lowercase());
- /// assert_eq!('❤', non_ascii.to_ascii_lowercase());
- /// assert_eq!(97, int_ascii.to_ascii_lowercase());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
///
/// [`make_ascii_lowercase`]: #tymethod.make_ascii_lowercase
/// [`str::to_lowercase`]: ../primitive.str.html#method.to_lowercase
/// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
/// but without allocating and copying temporaries.
///
- /// # Examples
- ///
- /// ```
- /// use std::ascii::AsciiExt;
- ///
- /// let ascii1 = 'A';
- /// let ascii2 = 'a';
- /// let ascii3 = 'A';
- /// let ascii4 = 'z';
+ /// # Note
///
- /// assert!(ascii1.eq_ignore_ascii_case(&ascii2));
- /// assert!(ascii1.eq_ignore_ascii_case(&ascii3));
- /// assert!(!ascii1.eq_ignore_ascii_case(&ascii4));
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[stable(feature = "rust1", since = "1.0.0")]
fn eq_ignore_ascii_case(&self, other: &Self) -> bool;
/// To return a new uppercased value without modifying the existing one, use
/// [`to_ascii_uppercase`].
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// use std::ascii::AsciiExt;
- ///
- /// let mut ascii = 'a';
- ///
- /// ascii.make_ascii_uppercase();
- ///
- /// assert_eq!('A', ascii);
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
///
/// [`to_ascii_uppercase`]: #tymethod.to_ascii_uppercase
#[stable(feature = "ascii", since = "1.9.0")]
/// To return a new lowercased value without modifying the existing one, use
/// [`to_ascii_lowercase`].
///
- /// # Examples
- ///
- /// ```
- /// use std::ascii::AsciiExt;
+ /// # Note
///
- /// let mut ascii = 'A';
- ///
- /// ascii.make_ascii_lowercase();
- ///
- /// assert_eq!('a', ascii);
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
///
/// [`to_ascii_lowercase`]: #tymethod.to_ascii_lowercase
#[stable(feature = "ascii", since = "1.9.0")]
/// For strings, true if all characters in the string are
/// ASCII alphabetic.
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
- ///
- /// assert!(A.is_ascii_alphabetic());
- /// assert!(G.is_ascii_alphabetic());
- /// assert!(a.is_ascii_alphabetic());
- /// assert!(g.is_ascii_alphabetic());
- /// assert!(!zero.is_ascii_alphabetic());
- /// assert!(!percent.is_ascii_alphabetic());
- /// assert!(!space.is_ascii_alphabetic());
- /// assert!(!lf.is_ascii_alphabetic());
- /// assert!(!esc.is_ascii_alphabetic());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_alphabetic(&self) -> bool { unimplemented!(); }
/// For strings, true if all characters in the string are
/// ASCII uppercase.
///
- /// # Examples
- ///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
+ /// # Note
///
- /// assert!(A.is_ascii_uppercase());
- /// assert!(G.is_ascii_uppercase());
- /// assert!(!a.is_ascii_uppercase());
- /// assert!(!g.is_ascii_uppercase());
- /// assert!(!zero.is_ascii_uppercase());
- /// assert!(!percent.is_ascii_uppercase());
- /// assert!(!space.is_ascii_uppercase());
- /// assert!(!lf.is_ascii_uppercase());
- /// assert!(!esc.is_ascii_uppercase());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_uppercase(&self) -> bool { unimplemented!(); }
/// For strings, true if all characters in the string are
/// ASCII lowercase.
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
- ///
- /// assert!(!A.is_ascii_lowercase());
- /// assert!(!G.is_ascii_lowercase());
- /// assert!(a.is_ascii_lowercase());
- /// assert!(g.is_ascii_lowercase());
- /// assert!(!zero.is_ascii_lowercase());
- /// assert!(!percent.is_ascii_lowercase());
- /// assert!(!space.is_ascii_lowercase());
- /// assert!(!lf.is_ascii_lowercase());
- /// assert!(!esc.is_ascii_lowercase());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_lowercase(&self) -> bool { unimplemented!(); }
/// For strings, true if all characters in the string are
/// ASCII alphanumeric.
///
- /// # Examples
- ///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
+ /// # Note
///
- /// assert!(A.is_ascii_alphanumeric());
- /// assert!(G.is_ascii_alphanumeric());
- /// assert!(a.is_ascii_alphanumeric());
- /// assert!(g.is_ascii_alphanumeric());
- /// assert!(zero.is_ascii_alphanumeric());
- /// assert!(!percent.is_ascii_alphanumeric());
- /// assert!(!space.is_ascii_alphanumeric());
- /// assert!(!lf.is_ascii_alphanumeric());
- /// assert!(!esc.is_ascii_alphanumeric());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_alphanumeric(&self) -> bool { unimplemented!(); }
/// For strings, true if all characters in the string are
/// ASCII digits.
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
- ///
- /// assert!(!A.is_ascii_digit());
- /// assert!(!G.is_ascii_digit());
- /// assert!(!a.is_ascii_digit());
- /// assert!(!g.is_ascii_digit());
- /// assert!(zero.is_ascii_digit());
- /// assert!(!percent.is_ascii_digit());
- /// assert!(!space.is_ascii_digit());
- /// assert!(!lf.is_ascii_digit());
- /// assert!(!esc.is_ascii_digit());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_digit(&self) -> bool { unimplemented!(); }
/// For strings, true if all characters in the string are
/// ASCII hex digits.
///
- /// # Examples
- ///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
+ /// # Note
///
- /// assert!(A.is_ascii_hexdigit());
- /// assert!(!G.is_ascii_hexdigit());
- /// assert!(a.is_ascii_hexdigit());
- /// assert!(!g.is_ascii_hexdigit());
- /// assert!(zero.is_ascii_hexdigit());
- /// assert!(!percent.is_ascii_hexdigit());
- /// assert!(!space.is_ascii_hexdigit());
- /// assert!(!lf.is_ascii_hexdigit());
- /// assert!(!esc.is_ascii_hexdigit());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_hexdigit(&self) -> bool { unimplemented!(); }
/// For strings, true if all characters in the string are
/// ASCII punctuation.
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
- ///
- /// assert!(!A.is_ascii_punctuation());
- /// assert!(!G.is_ascii_punctuation());
- /// assert!(!a.is_ascii_punctuation());
- /// assert!(!g.is_ascii_punctuation());
- /// assert!(!zero.is_ascii_punctuation());
- /// assert!(percent.is_ascii_punctuation());
- /// assert!(!space.is_ascii_punctuation());
- /// assert!(!lf.is_ascii_punctuation());
- /// assert!(!esc.is_ascii_punctuation());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_punctuation(&self) -> bool { unimplemented!(); }
/// For strings, true if all characters in the string are
/// ASCII punctuation.
///
- /// # Examples
- ///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
+ /// # Note
///
- /// assert!(A.is_ascii_graphic());
- /// assert!(G.is_ascii_graphic());
- /// assert!(a.is_ascii_graphic());
- /// assert!(g.is_ascii_graphic());
- /// assert!(zero.is_ascii_graphic());
- /// assert!(percent.is_ascii_graphic());
- /// assert!(!space.is_ascii_graphic());
- /// assert!(!lf.is_ascii_graphic());
- /// assert!(!esc.is_ascii_graphic());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_graphic(&self) -> bool { unimplemented!(); }
/// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
/// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
///
- /// # Examples
+ /// # Note
///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
- ///
- /// assert!(!A.is_ascii_whitespace());
- /// assert!(!G.is_ascii_whitespace());
- /// assert!(!a.is_ascii_whitespace());
- /// assert!(!g.is_ascii_whitespace());
- /// assert!(!zero.is_ascii_whitespace());
- /// assert!(!percent.is_ascii_whitespace());
- /// assert!(space.is_ascii_whitespace());
- /// assert!(lf.is_ascii_whitespace());
- /// assert!(!esc.is_ascii_whitespace());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_whitespace(&self) -> bool { unimplemented!(); }
/// Note that most ASCII whitespace characters are control
/// characters, but SPACE is not.
///
- /// # Examples
- ///
- /// ```
- /// #![feature(ascii_ctype)]
- /// # #![allow(non_snake_case)]
- /// use std::ascii::AsciiExt;
- /// let A = 'A';
- /// let G = 'G';
- /// let a = 'a';
- /// let g = 'g';
- /// let zero = '0';
- /// let percent = '%';
- /// let space = ' ';
- /// let lf = '\n';
- /// let esc = '\u{001b}';
+ /// # Note
///
- /// assert!(!A.is_ascii_control());
- /// assert!(!G.is_ascii_control());
- /// assert!(!a.is_ascii_control());
- /// assert!(!g.is_ascii_control());
- /// assert!(!zero.is_ascii_control());
- /// assert!(!percent.is_ascii_control());
- /// assert!(!space.is_ascii_control());
- /// assert!(lf.is_ascii_control());
- /// assert!(esc.is_ascii_control());
- /// ```
+ /// This method will be deprecated in favor of the identically-named
+ /// inherent methods on `u8`, `char`, `[u8]` and `str`.
#[unstable(feature = "ascii_ctype", issue = "39658")]
fn is_ascii_control(&self) -> bool { unimplemented!(); }
}
+// FIXME(LukasKalbertodt): this impl block can be removed in the future. This is
+// possible once the stage0 compiler is new enough to contain the inherent
+// ascii methods for `[str]`. See FIXME comment further down.
+#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl AsciiExt for str {
type Owned = String;
}
}
+// FIXME(LukasKalbertodt): this impl block can be removed in the future. This is
+// possible once the stage0 compiler is new enough to contain the inherent
+// ascii methods for `[u8]`. See FIXME comment further down.
+#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl AsciiExt for [u8] {
type Owned = Vec<u8>;
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsciiExt for u8 {
- type Owned = u8;
- #[inline]
- fn is_ascii(&self) -> bool { *self & 128 == 0 }
- #[inline]
- fn to_ascii_uppercase(&self) -> u8 { ASCII_UPPERCASE_MAP[*self as usize] }
- #[inline]
- fn to_ascii_lowercase(&self) -> u8 { ASCII_LOWERCASE_MAP[*self as usize] }
- #[inline]
- fn eq_ignore_ascii_case(&self, other: &u8) -> bool {
- self.to_ascii_lowercase() == other.to_ascii_lowercase()
- }
- #[inline]
- fn make_ascii_uppercase(&mut self) { *self = self.to_ascii_uppercase(); }
- #[inline]
- fn make_ascii_lowercase(&mut self) { *self = self.to_ascii_lowercase(); }
+macro_rules! impl_by_delegating {
+ ($ty:ty, $owned:ty) => {
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl AsciiExt for $ty {
+ type Owned = $owned;
- #[inline]
- fn is_ascii_alphabetic(&self) -> bool {
- if *self >= 0x80 { return false; }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- L|Lx|U|Ux => true,
- _ => false
- }
- }
+ #[inline]
+ fn is_ascii(&self) -> bool { self.is_ascii() }
- #[inline]
- fn is_ascii_uppercase(&self) -> bool {
- if *self >= 0x80 { return false }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- U|Ux => true,
- _ => false
- }
- }
+ #[inline]
+ fn to_ascii_uppercase(&self) -> Self::Owned { self.to_ascii_uppercase() }
- #[inline]
- fn is_ascii_lowercase(&self) -> bool {
- if *self >= 0x80 { return false }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- L|Lx => true,
- _ => false
- }
- }
+ #[inline]
+ fn to_ascii_lowercase(&self) -> Self::Owned { self.to_ascii_lowercase() }
- #[inline]
- fn is_ascii_alphanumeric(&self) -> bool {
- if *self >= 0x80 { return false }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- D|L|Lx|U|Ux => true,
- _ => false
- }
- }
+ #[inline]
+ fn eq_ignore_ascii_case(&self, o: &Self) -> bool { self.eq_ignore_ascii_case(o) }
- #[inline]
- fn is_ascii_digit(&self) -> bool {
- if *self >= 0x80 { return false }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- D => true,
- _ => false
- }
- }
+ #[inline]
+ fn make_ascii_uppercase(&mut self) { self.make_ascii_uppercase(); }
- #[inline]
- fn is_ascii_hexdigit(&self) -> bool {
- if *self >= 0x80 { return false }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- D|Lx|Ux => true,
- _ => false
- }
- }
+ #[inline]
+ fn make_ascii_lowercase(&mut self) { self.make_ascii_lowercase(); }
- #[inline]
- fn is_ascii_punctuation(&self) -> bool {
- if *self >= 0x80 { return false }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- P => true,
- _ => false
- }
- }
+ #[inline]
+ fn is_ascii_alphabetic(&self) -> bool { self.is_ascii_alphabetic() }
- #[inline]
- fn is_ascii_graphic(&self) -> bool {
- if *self >= 0x80 { return false; }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- Ux|U|Lx|L|D|P => true,
- _ => false
- }
- }
+ #[inline]
+ fn is_ascii_uppercase(&self) -> bool { self.is_ascii_uppercase() }
- #[inline]
- fn is_ascii_whitespace(&self) -> bool {
- if *self >= 0x80 { return false; }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- Cw|W => true,
- _ => false
- }
- }
-
- #[inline]
- fn is_ascii_control(&self) -> bool {
- if *self >= 0x80 { return false; }
- match ASCII_CHARACTER_CLASS[*self as usize] {
- C|Cw => true,
- _ => false
- }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsciiExt for char {
- type Owned = char;
- #[inline]
- fn is_ascii(&self) -> bool {
- *self as u32 <= 0x7F
- }
+ #[inline]
+ fn is_ascii_lowercase(&self) -> bool { self.is_ascii_lowercase() }
- #[inline]
- fn to_ascii_uppercase(&self) -> char {
- if self.is_ascii() {
- (*self as u8).to_ascii_uppercase() as char
- } else {
- *self
- }
- }
+ #[inline]
+ fn is_ascii_alphanumeric(&self) -> bool { self.is_ascii_alphanumeric() }
- #[inline]
- fn to_ascii_lowercase(&self) -> char {
- if self.is_ascii() {
- (*self as u8).to_ascii_lowercase() as char
- } else {
- *self
- }
- }
+ #[inline]
+ fn is_ascii_digit(&self) -> bool { self.is_ascii_digit() }
- #[inline]
- fn eq_ignore_ascii_case(&self, other: &char) -> bool {
- self.to_ascii_lowercase() == other.to_ascii_lowercase()
- }
+ #[inline]
+ fn is_ascii_hexdigit(&self) -> bool { self.is_ascii_hexdigit() }
- #[inline]
- fn make_ascii_uppercase(&mut self) { *self = self.to_ascii_uppercase(); }
- #[inline]
- fn make_ascii_lowercase(&mut self) { *self = self.to_ascii_lowercase(); }
+ #[inline]
+ fn is_ascii_punctuation(&self) -> bool { self.is_ascii_punctuation() }
- #[inline]
- fn is_ascii_alphabetic(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_alphabetic()
- }
+ #[inline]
+ fn is_ascii_graphic(&self) -> bool { self.is_ascii_graphic() }
- #[inline]
- fn is_ascii_uppercase(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_uppercase()
- }
+ #[inline]
+ fn is_ascii_whitespace(&self) -> bool { self.is_ascii_whitespace() }
- #[inline]
- fn is_ascii_lowercase(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_lowercase()
- }
-
- #[inline]
- fn is_ascii_alphanumeric(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_alphanumeric()
- }
-
- #[inline]
- fn is_ascii_digit(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_digit()
- }
-
- #[inline]
- fn is_ascii_hexdigit(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_hexdigit()
- }
-
- #[inline]
- fn is_ascii_punctuation(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_punctuation()
+ #[inline]
+ fn is_ascii_control(&self) -> bool { self.is_ascii_control() }
+ }
}
+}
- #[inline]
- fn is_ascii_graphic(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_graphic()
- }
+impl_by_delegating!(u8, u8);
+impl_by_delegating!(char, char);
- #[inline]
- fn is_ascii_whitespace(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_whitespace()
- }
+// FIXME(LukasKalbertodt): the macro invocation should replace the impl block
+// for `[u8]` above. But this is not possible until the stage0 compiler is new
+// enough to contain the inherent ascii methods for `[u8]`.
+#[cfg(not(stage0))]
+impl_by_delegating!([u8], Vec<u8>);
- #[inline]
- fn is_ascii_control(&self) -> bool {
- (*self as u32 <= 0x7f) && (*self as u8).is_ascii_control()
- }
-}
+// FIXME(LukasKalbertodt): the macro invocation should replace the impl block
+// for `str` above. But this is not possible until the stage0 compiler is new
+// enough to contain the inherent ascii methods for `str`.
+#[cfg(not(stage0))]
+impl_by_delegating!(str, String);
/// An iterator over the escaped version of a byte.
///
}
-static ASCII_LOWERCASE_MAP: [u8; 256] = [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
- b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
- b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
- b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
- b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
- b'@',
-
- b'a', b'b', b'c', b'd', b'e', b'f', b'g',
- b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
- b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
- b'x', b'y', b'z',
-
- b'[', b'\\', b']', b'^', b'_',
- b'`', b'a', b'b', b'c', b'd', b'e', b'f', b'g',
- b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
- b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
- b'x', b'y', b'z', b'{', b'|', b'}', b'~', 0x7f,
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
- 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
- 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
- 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
- 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
- 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
- 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
- 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
- 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
- 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
- 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
- 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
- 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
- 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
- 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
- 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
-];
-
-static ASCII_UPPERCASE_MAP: [u8; 256] = [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
- b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
- b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
- b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
- b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
- b'@', b'A', b'B', b'C', b'D', b'E', b'F', b'G',
- b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
- b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
- b'X', b'Y', b'Z', b'[', b'\\', b']', b'^', b'_',
- b'`',
-
- b'A', b'B', b'C', b'D', b'E', b'F', b'G',
- b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
- b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
- b'X', b'Y', b'Z',
-
- b'{', b'|', b'}', b'~', 0x7f,
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
- 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
- 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
- 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
- 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
- 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
- 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
- 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
- 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
- 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
- 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
- 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
- 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
- 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
- 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
- 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
-];
-
-enum AsciiCharacterClass {
- C, // control
- Cw, // control whitespace
- W, // whitespace
- D, // digit
- L, // lowercase
- Lx, // lowercase hex digit
- U, // uppercase
- Ux, // uppercase hex digit
- P, // punctuation
-}
-use self::AsciiCharacterClass::*;
-
-static ASCII_CHARACTER_CLASS: [AsciiCharacterClass; 128] = [
-// _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _a _b _c _d _e _f
- C, C, C, C, C, C, C, C, C, Cw,Cw,C, Cw,Cw,C, C, // 0_
- C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, // 1_
- W, P, P, P, P, P, P, P, P, P, P, P, P, P, P, P, // 2_
- D, D, D, D, D, D, D, D, D, D, P, P, P, P, P, P, // 3_
- P, Ux,Ux,Ux,Ux,Ux,Ux,U, U, U, U, U, U, U, U, U, // 4_
- U, U, U, U, U, U, U, U, U, U, U, P, P, P, P, P, // 5_
- P, Lx,Lx,Lx,Lx,Lx,Lx,L, L, L, L, L, L, L, L, L, // 6_
- L, L, L, L, L, L, L, L, L, L, L, P, P, P, P, C, // 7_
-];
-
#[cfg(test)]
mod tests {
- use super::*;
+ //! Note that most of these tests are not testing `AsciiExt` methods, but
+ //! test inherent ascii methods of char, u8, str and [u8]. `AsciiExt` is
+ //! just using those methods, though.
use char::from_u32;
#[test]
/// set to arbitrary text, and may not even exist. This means this property should
/// not be relied upon for security purposes.
///
+/// On Unix systems shell usually expands unquoted arguments with glob patterns
+/// (such as `*` and `?`). On Windows this is not done, and such arguments are
+/// passed as-is.
+///
/// # Panics
///
/// The returned iterator will panic during iteration if any argument to the
#[cfg(not(test))]
#[doc(hidden)]
+#[allow(unused_attributes)]
pub mod __default_lib_allocator {
use super::{System, Layout, Alloc, AllocErr};
use ptr;
// ABI
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_alloc(size: usize,
align: usize,
err: *mut u8) -> *mut u8 {
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_oom(err: *const u8) -> ! {
System.oom((*(err as *const AllocErr)).clone())
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_dealloc(ptr: *mut u8,
size: usize,
align: usize) {
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_usable_size(layout: *const u8,
min: *mut usize,
max: *mut usize) {
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_realloc(ptr: *mut u8,
old_size: usize,
old_align: usize,
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_alloc_zeroed(size: usize,
align: usize,
err: *mut u8) -> *mut u8 {
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_alloc_excess(size: usize,
align: usize,
excess: *mut usize,
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_realloc_excess(ptr: *mut u8,
old_size: usize,
old_align: usize,
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_grow_in_place(ptr: *mut u8,
old_size: usize,
old_align: usize,
}
#[no_mangle]
+ #[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_shrink_in_place(ptr: *mut u8,
old_size: usize,
old_align: usize,
#[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
+ /// Returns `true` if there are no bytes in the internal buffer.
+ ///
+ /// # Examples
+ /// ```
+ /// # #![feature(bufreader_is_empty)]
+ /// use std::io::BufReader;
+ /// use std::io::BufRead;
+ /// use std::fs::File;
+ ///
+ /// # fn foo() -> std::io::Result<()> {
+ /// let f1 = File::open("log.txt")?;
+ /// let mut reader = BufReader::new(f1);
+ /// assert!(reader.is_empty());
+ ///
+ /// if reader.fill_buf()?.len() > 0 {
+ /// assert!(!reader.is_empty());
+ /// }
+ /// # Ok(())
+ /// # }
+ /// ```
+ #[unstable(feature = "bufreader_is_empty", issue = "45323", reason = "recently added")]
+ pub fn is_empty(&self) -> bool {
+ self.pos == self.cap
+ }
+
/// Unwraps this `BufReader`, returning the underlying reader.
///
/// Note that any leftover data in the internal buffer is lost.
#![feature(allow_internal_unstable)]
#![feature(align_offset)]
#![feature(array_error_internals)]
+#![feature(ascii_ctype)]
#![feature(asm)]
#![feature(attr_literals)]
#![feature(box_syntax)]
// * Types like Mutex/RwLock which are explicilty poisoned are unwind safe
// * Our custom AssertUnwindSafe wrapper is indeed unwind safe
#[stable(feature = "catch_unwind", since = "1.9.0")]
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
impl UnwindSafe for .. {}
#[stable(feature = "catch_unwind", since = "1.9.0")]
impl<'a, T: ?Sized> !UnwindSafe for &'a mut T {}
// only thing which doesn't implement it (which then transitively applies to
// everything else).
#[stable(feature = "catch_unwind", since = "1.9.0")]
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
impl RefUnwindSafe for .. {}
#[stable(feature = "catch_unwind", since = "1.9.0")]
impl<T: ?Sized> !RefUnwindSafe for UnsafeCell<T> {}
#![stable(feature = "rust1", since = "1.0.0")]
-use ascii::*;
use borrow::{Borrow, Cow};
use cmp;
use error::Error;
use cell::UnsafeCell;
use fmt;
-use marker;
use mem;
use ops::{Deref, DerefMut};
use ptr;
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: ?Sized> !marker::Send for RwLockReadGuard<'a, T> {}
+impl<'a, T: ?Sized> !Send for RwLockReadGuard<'a, T> {}
+
+#[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
+unsafe impl<'a, T: ?Sized + Sync> Sync for RwLockReadGuard<'a, T> {}
/// RAII structure used to release the exclusive write access of a lock when
/// dropped.
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: ?Sized> !marker::Send for RwLockWriteGuard<'a, T> {}
+impl<'a, T: ?Sized> !Send for RwLockWriteGuard<'a, T> {}
+
+#[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
+unsafe impl<'a, T: ?Sized + Sync> Sync for RwLockWriteGuard<'a, T> {}
impl<T> RwLock<T> {
/// Creates a new instance of an `RwLock<T>` which is unlocked.
use sys_common::{FromInner, AsInner, AsInnerMut};
use sys::platform::fs::MetadataExt as UnixMetadataExt;
-/// Unix-specific extensions to `File`
+/// Unix-specific extensions to [`File`].
+///
+/// [`File`]: ../../../../std/fs/struct.File.html
#[stable(feature = "file_offset", since = "1.15.0")]
pub trait FileExt {
/// Reads a number of bytes starting from a given offset.
// casts and rely on manual lowering to `stat` if the raw type is desired.
#[stable(feature = "metadata_ext", since = "1.1.0")]
pub trait MetadataExt {
+ /// Returns the ID of the device containing the file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let dev_id = meta.dev();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn dev(&self) -> u64;
+ /// Returns the inode number.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let inode = meta.ino();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn ino(&self) -> u64;
+ /// Returns the rights applied to this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let mode = meta.mode();
+ /// let user_has_write_access = mode & 0o200;
+ /// let user_has_read_write_access = mode & 0o600;
+ /// let group_has_read_access = mode & 0o040;
+ /// let others_have_exec_access = mode & 0o001;
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn mode(&self) -> u32;
+ /// Returns the number of hard links pointing to this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nb_hard_links = meta.nlink();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn nlink(&self) -> u64;
+ /// Returns the user ID of the owner of this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let user_id = meta.uid();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn uid(&self) -> u32;
+ /// Returns the group ID of the owner of this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let group_id = meta.gid();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn gid(&self) -> u32;
+ /// Returns the device ID of this file (if it is a special one).
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let device_id = meta.rdev();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn rdev(&self) -> u64;
+ /// Returns the total size of this file in bytes.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let file_size = meta.size();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn size(&self) -> u64;
+ /// Returns the time of the last access to the file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let last_access_time = meta.atime();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn atime(&self) -> i64;
+ /// Returns the time of the last access to the file in nanoseconds.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nano_last_access_time = meta.atime_nsec();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn atime_nsec(&self) -> i64;
+ /// Returns the time of the last modification of the file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let last_modification_time = meta.mtime();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn mtime(&self) -> i64;
+ /// Returns the time of the last modification of the file in nanoseconds.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nano_last_modification_time = meta.mtime_nsec();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn mtime_nsec(&self) -> i64;
+ /// Returns the time of the last status change of the file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let last_status_change_time = meta.ctime();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn ctime(&self) -> i64;
+ /// Returns the time of the last status change of the file in nanoseconds.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nano_last_status_change_time = meta.ctime_nsec();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn ctime_nsec(&self) -> i64;
+ /// Returns the blocksize for filesystem I/O.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let blocksize = meta.blksize();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn blksize(&self) -> u64;
+ /// Returns the number of blocks allocated to the file, in 512-byte units.
+ ///
+ /// Please note that this may be smaller than `st_size / 512` when the file has holes.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let blocks = meta.blocks();
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "metadata_ext", since = "1.1.0")]
fn blocks(&self) -> u64;
}
fn blocks(&self) -> u64 { self.st_blocks() }
}
-/// Add special unix types (block/char device, fifo and socket)
+/// Add support for special unix types (block/char device, fifo and socket).
#[stable(feature = "file_type_ext", since = "1.5.0")]
pub trait FileTypeExt {
/// Returns whether this file type is a block device.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("block_device_file")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_block_device());
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "file_type_ext", since = "1.5.0")]
fn is_block_device(&self) -> bool;
/// Returns whether this file type is a char device.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("char_device_file")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_char_device());
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "file_type_ext", since = "1.5.0")]
fn is_char_device(&self) -> bool;
/// Returns whether this file type is a fifo.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("fifo_file")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_fifo());
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "file_type_ext", since = "1.5.0")]
fn is_fifo(&self) -> bool;
/// Returns whether this file type is a socket.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ ///
+ /// # use std::io;
+ /// # fn f() -> io::Result<()> {
+ /// let meta = fs::metadata("unix.socket")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_socket());
+ /// # Ok(())
+ /// # }
+ /// ```
#[stable(feature = "file_type_ext", since = "1.5.0")]
fn is_socket(&self) -> bool;
}
fn is_socket(&self) -> bool { self.as_inner().is(libc::S_IFSOCK) }
}
-/// Unix-specific extension methods for `fs::DirEntry`
+/// Unix-specific extension methods for [`fs::DirEntry`].
+///
+/// [`fs::DirEntry`]: ../../../../std/fs/struct.DirEntry.html
#[stable(feature = "dir_entry_ext", since = "1.1.0")]
pub trait DirEntryExt {
/// Returns the underlying `d_ino` field in the contained `dirent`
}
#[stable(feature = "dir_builder", since = "1.6.0")]
-/// An extension trait for `fs::DirBuilder` for unix-specific options.
+/// An extension trait for [`fs::DirBuilder`] for unix-specific options.
+///
+/// [`fs::DirBuilder`]: ../../../../std/fs/struct.DirBuilder.html
pub trait DirBuilderExt {
/// Sets the mode to create new directories with. This option defaults to
/// 0o777.
}
}
-#[cfg(target_env = "gnu")]
+#[cfg(all(target_env = "gnu", feature = "backtrace"))]
mod gnu {
use super::*;
}
}
-#[cfg(target_env = "gnu")]
+#[cfg(all(target_env = "gnu", feature = "backtrace"))]
pub use self::gnu::*;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use ascii::*;
-
use path::Prefix;
use ffi::OsStr;
use mem;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use ascii::*;
+use ascii::AsciiExt;
use collections::HashMap;
use collections;
use env::split_paths;
//!
//! Fatal logic errors in Rust cause *thread panic*, during which
//! a thread will unwind the stack, running destructors and freeing
-//! owned resources. Thread panic is unrecoverable from within
-//! the panicking thread (i.e. there is no 'try/catch' in Rust), but
-//! the panic may optionally be detected from a different thread. If
-//! the main thread panics, the application will exit with a non-zero
-//! exit code.
+//! owned resources. While not meant as a 'try/catch' mechanism, panics
+//! in Rust can nonetheless be caught (unless compiling with `panic=abort`) with
+//! [`catch_unwind`](../../std/panic/fn.catch_unwind.html) and recovered
+//! from, or alternatively be resumed with
+//! [`resume_unwind`](../../std/panic/fn.resume_unwind.html). If the panic
+//! is not caught the thread will exit, but the panic may optionally be
+//! detected from a different thread with [`join`]. If the main thread panics
+//! without the panic being caught, the application will exit with a
+//! non-zero exit code.
//!
//! When the main thread of a Rust program terminates, the entire program shuts
//! down, even if other threads are still running. However, this module provides
pub fn to_uppercase(self) -> ToUppercase {
ToUppercase(CaseMappingIter::new(conversions::to_upper(self)))
}
+
+ /// Checks if the value is within the ASCII range.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let ascii = 'a';
+ /// let non_ascii = '❤';
+ ///
+ /// assert!(ascii.is_ascii());
+ /// assert!(!non_ascii.is_ascii());
+ /// ```
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn is_ascii(&self) -> bool {
+ *self as u32 <= 0x7F
+ }
+
+ /// Makes a copy of the value in its ASCII upper case equivalent.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To uppercase the value in-place, use [`make_ascii_uppercase`].
+ ///
+ /// To uppercase ASCII characters in addition to non-ASCII characters, use
+ /// [`to_uppercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let ascii = 'a';
+ /// let non_ascii = '❤';
+ ///
+ /// assert_eq!('A', ascii.to_ascii_uppercase());
+ /// assert_eq!('❤', non_ascii.to_ascii_uppercase());
+ /// ```
+ ///
+ /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase
+ /// [`to_uppercase`]: #method.to_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn to_ascii_uppercase(&self) -> char {
+ if self.is_ascii() {
+ (*self as u8).to_ascii_uppercase() as char
+ } else {
+ *self
+ }
+ }
+
+ /// Makes a copy of the value in its ASCII lower case equivalent.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To lowercase the value in-place, use [`make_ascii_lowercase`].
+ ///
+ /// To lowercase ASCII characters in addition to non-ASCII characters, use
+ /// [`to_lowercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let ascii = 'A';
+ /// let non_ascii = '❤';
+ ///
+ /// assert_eq!('a', ascii.to_ascii_lowercase());
+ /// assert_eq!('❤', non_ascii.to_ascii_lowercase());
+ /// ```
+ ///
+ /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase
+ /// [`to_lowercase`]: #method.to_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn to_ascii_lowercase(&self) -> char {
+ if self.is_ascii() {
+ (*self as u8).to_ascii_lowercase() as char
+ } else {
+ *self
+ }
+ }
+
+ /// Checks that two values are an ASCII case-insensitive match.
+ ///
+ /// Equivalent to `to_ascii_lowercase(a) == to_ascii_lowercase(b)`.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let upper_a = 'A';
+ /// let lower_a = 'a';
+ /// let lower_z = 'z';
+ ///
+ /// assert!(upper_a.eq_ignore_ascii_case(&lower_a));
+ /// assert!(upper_a.eq_ignore_ascii_case(&upper_a));
+ /// assert!(!upper_a.eq_ignore_ascii_case(&lower_z));
+ /// ```
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn eq_ignore_ascii_case(&self, other: &char) -> bool {
+ self.to_ascii_lowercase() == other.to_ascii_lowercase()
+ }
+
+ /// Converts this type to its ASCII upper case equivalent in-place.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new uppercased value without modifying the existing one, use
+ /// [`to_ascii_uppercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let mut ascii = 'a';
+ ///
+ /// ascii.make_ascii_uppercase();
+ ///
+ /// assert_eq!('A', ascii);
+ /// ```
+ ///
+ /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn make_ascii_uppercase(&mut self) {
+ *self = self.to_ascii_uppercase();
+ }
+
+ /// Converts this type to its ASCII lower case equivalent in-place.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
+ /// but non-ASCII letters are unchanged.
+ ///
+ /// To return a new lowercased value without modifying the existing one, use
+ /// [`to_ascii_lowercase`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// let mut ascii = 'A';
+ ///
+ /// ascii.make_ascii_lowercase();
+ ///
+ /// assert_eq!('a', ascii);
+ /// ```
+ ///
+ /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase
+ #[stable(feature = "ascii_methods_on_intrinsics", since = "1.21.0")]
+ #[inline]
+ pub fn make_ascii_lowercase(&mut self) {
+ *self = self.to_ascii_lowercase();
+ }
+
+ /// Checks if the value is an ASCII alphabetic character:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(uppercase_a.is_ascii_alphabetic());
+ /// assert!(uppercase_g.is_ascii_alphabetic());
+ /// assert!(a.is_ascii_alphabetic());
+ /// assert!(g.is_ascii_alphabetic());
+ /// assert!(!zero.is_ascii_alphabetic());
+ /// assert!(!percent.is_ascii_alphabetic());
+ /// assert!(!space.is_ascii_alphabetic());
+ /// assert!(!lf.is_ascii_alphabetic());
+ /// assert!(!esc.is_ascii_alphabetic());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphabetic(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_alphabetic()
+ }
+
+ /// Checks if the value is an ASCII uppercase character:
+ /// U+0041 'A' ... U+005A 'Z'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(uppercase_a.is_ascii_uppercase());
+ /// assert!(uppercase_g.is_ascii_uppercase());
+ /// assert!(!a.is_ascii_uppercase());
+ /// assert!(!g.is_ascii_uppercase());
+ /// assert!(!zero.is_ascii_uppercase());
+ /// assert!(!percent.is_ascii_uppercase());
+ /// assert!(!space.is_ascii_uppercase());
+ /// assert!(!lf.is_ascii_uppercase());
+ /// assert!(!esc.is_ascii_uppercase());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_uppercase(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_uppercase()
+ }
+
+ /// Checks if the value is an ASCII lowercase character:
+ /// U+0061 'a' ... U+007A 'z'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(!uppercase_a.is_ascii_lowercase());
+ /// assert!(!uppercase_g.is_ascii_lowercase());
+ /// assert!(a.is_ascii_lowercase());
+ /// assert!(g.is_ascii_lowercase());
+ /// assert!(!zero.is_ascii_lowercase());
+ /// assert!(!percent.is_ascii_lowercase());
+ /// assert!(!space.is_ascii_lowercase());
+ /// assert!(!lf.is_ascii_lowercase());
+ /// assert!(!esc.is_ascii_lowercase());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_lowercase(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_lowercase()
+ }
+
+ /// Checks if the value is an ASCII alphanumeric character:
+ ///
+ /// - U+0041 'A' ... U+005A 'Z', or
+ /// - U+0061 'a' ... U+007A 'z', or
+ /// - U+0030 '0' ... U+0039 '9'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(uppercase_a.is_ascii_alphanumeric());
+ /// assert!(uppercase_g.is_ascii_alphanumeric());
+ /// assert!(a.is_ascii_alphanumeric());
+ /// assert!(g.is_ascii_alphanumeric());
+ /// assert!(zero.is_ascii_alphanumeric());
+ /// assert!(!percent.is_ascii_alphanumeric());
+ /// assert!(!space.is_ascii_alphanumeric());
+ /// assert!(!lf.is_ascii_alphanumeric());
+ /// assert!(!esc.is_ascii_alphanumeric());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_alphanumeric(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_alphanumeric()
+ }
+
+ /// Checks if the value is an ASCII decimal digit:
+ /// U+0030 '0' ... U+0039 '9'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(!uppercase_a.is_ascii_digit());
+ /// assert!(!uppercase_g.is_ascii_digit());
+ /// assert!(!a.is_ascii_digit());
+ /// assert!(!g.is_ascii_digit());
+ /// assert!(zero.is_ascii_digit());
+ /// assert!(!percent.is_ascii_digit());
+ /// assert!(!space.is_ascii_digit());
+ /// assert!(!lf.is_ascii_digit());
+ /// assert!(!esc.is_ascii_digit());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_digit(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_digit()
+ }
+
+ /// Checks if the value is an ASCII hexadecimal digit:
+ ///
+ /// - U+0030 '0' ... U+0039 '9', or
+ /// - U+0041 'A' ... U+0046 'F', or
+ /// - U+0061 'a' ... U+0066 'f'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(uppercase_a.is_ascii_hexdigit());
+ /// assert!(!uppercase_g.is_ascii_hexdigit());
+ /// assert!(a.is_ascii_hexdigit());
+ /// assert!(!g.is_ascii_hexdigit());
+ /// assert!(zero.is_ascii_hexdigit());
+ /// assert!(!percent.is_ascii_hexdigit());
+ /// assert!(!space.is_ascii_hexdigit());
+ /// assert!(!lf.is_ascii_hexdigit());
+ /// assert!(!esc.is_ascii_hexdigit());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_hexdigit(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_hexdigit()
+ }
+
+ /// Checks if the value is an ASCII punctuation character:
+ ///
+ /// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
+ /// - U+003A ... U+0040 `: ; < = > ? @`, or
+ /// - U+005B ... U+0060 `[ \\ ] ^ _ \``, or
+ /// - U+007B ... U+007E `{ | } ~`
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(!uppercase_a.is_ascii_punctuation());
+ /// assert!(!uppercase_g.is_ascii_punctuation());
+ /// assert!(!a.is_ascii_punctuation());
+ /// assert!(!g.is_ascii_punctuation());
+ /// assert!(!zero.is_ascii_punctuation());
+ /// assert!(percent.is_ascii_punctuation());
+ /// assert!(!space.is_ascii_punctuation());
+ /// assert!(!lf.is_ascii_punctuation());
+ /// assert!(!esc.is_ascii_punctuation());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_punctuation(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_punctuation()
+ }
+
+ /// Checks if the value is an ASCII graphic character:
+ /// U+0021 '@' ... U+007E '~'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(uppercase_a.is_ascii_graphic());
+ /// assert!(uppercase_g.is_ascii_graphic());
+ /// assert!(a.is_ascii_graphic());
+ /// assert!(g.is_ascii_graphic());
+ /// assert!(zero.is_ascii_graphic());
+ /// assert!(percent.is_ascii_graphic());
+ /// assert!(!space.is_ascii_graphic());
+ /// assert!(!lf.is_ascii_graphic());
+ /// assert!(!esc.is_ascii_graphic());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_graphic(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_graphic()
+ }
+
+ /// Checks if the value is an ASCII whitespace character:
+ /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
+ /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
+ ///
+ /// Rust uses the WhatWG Infra Standard's [definition of ASCII
+ /// whitespace][infra-aw]. There are several other definitions in
+ /// wide use. For instance, [the POSIX locale][pct] includes
+ /// U+000B VERTICAL TAB as well as all the above characters,
+ /// but—from the very same specification—[the default rule for
+ /// "field splitting" in the Bourne shell][bfs] considers *only*
+ /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
+ ///
+ /// If you are writing a program that will process an existing
+ /// file format, check what that format's definition of whitespace is
+ /// before using this function.
+ ///
+ /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
+ /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
+ /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(!uppercase_a.is_ascii_whitespace());
+ /// assert!(!uppercase_g.is_ascii_whitespace());
+ /// assert!(!a.is_ascii_whitespace());
+ /// assert!(!g.is_ascii_whitespace());
+ /// assert!(!zero.is_ascii_whitespace());
+ /// assert!(!percent.is_ascii_whitespace());
+ /// assert!(space.is_ascii_whitespace());
+ /// assert!(lf.is_ascii_whitespace());
+ /// assert!(!esc.is_ascii_whitespace());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_whitespace(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_whitespace()
+ }
+
+ /// Checks if the value is an ASCII control character:
+ /// U+0000 NUL ... U+001F UNIT SEPARATOR, or U+007F DELETE.
+ /// Note that most ASCII whitespace characters are control
+ /// characters, but SPACE is not.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ascii_ctype)]
+ ///
+ /// let uppercase_a = 'A';
+ /// let uppercase_g = 'G';
+ /// let a = 'a';
+ /// let g = 'g';
+ /// let zero = '0';
+ /// let percent = '%';
+ /// let space = ' ';
+ /// let lf = '\n';
+ /// let esc: char = 0x1b_u8.into();
+ ///
+ /// assert!(!uppercase_a.is_ascii_control());
+ /// assert!(!uppercase_g.is_ascii_control());
+ /// assert!(!a.is_ascii_control());
+ /// assert!(!g.is_ascii_control());
+ /// assert!(!zero.is_ascii_control());
+ /// assert!(!percent.is_ascii_control());
+ /// assert!(!space.is_ascii_control());
+ /// assert!(lf.is_ascii_control());
+ /// assert!(esc.is_ascii_control());
+ /// ```
+ #[unstable(feature = "ascii_ctype", issue = "39658")]
+ #[inline]
+ pub fn is_ascii_control(&self) -> bool {
+ self.is_ascii() && (*self as u8).is_ascii_control()
+ }
}
/// An iterator that decodes UTF-16 encoded code points from an iterator of `u16`s.
#![deny(warnings)]
#![no_std]
+#![feature(ascii_ctype)]
#![feature(core_char_ext)]
#![feature(str_internals)]
#![feature(decode_utf8)]
}
}
+/// Is the trait definition an auto trait?
+#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub enum IsAuto {
+ Yes,
+ No
+}
+
#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum Unsafety {
Unsafe,
Union(VariantData, Generics),
/// A Trait declaration (`trait` or `pub trait`).
///
- /// E.g. `trait Foo { .. }` or `trait Foo<T> { .. }`
- Trait(Unsafety, Generics, TyParamBounds, Vec<TraitItem>),
+ /// E.g. `trait Foo { .. }`, `trait Foo<T> { .. }` or `auto trait Foo {}`
+ Trait(IsAuto, Unsafety, Generics, TyParamBounds, Vec<TraitItem>),
/// Auto trait implementation.
///
/// E.g. `impl Trait for .. {}` or `impl<T> Trait<T> for .. {}`
- DefaultImpl(Unsafety, TraitRef),
+ AutoImpl(Unsafety, TraitRef),
/// An implementation.
///
/// E.g. `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`
ItemKind::Mac(..) |
ItemKind::MacroDef(..) |
ItemKind::Impl(..) |
- ItemKind::DefaultImpl(..) => "item"
+ ItemKind::AutoImpl(..) => "item"
}
}
}
src_hash: u128,
source_len: usize,
mut file_local_lines: Vec<BytePos>,
- mut file_local_multibyte_chars: Vec<MultiByteChar>)
+ mut file_local_multibyte_chars: Vec<MultiByteChar>,
+ mut file_local_non_narrow_chars: Vec<NonNarrowChar>)
-> Rc<FileMap> {
let start_pos = self.next_start_pos();
let mut files = self.files.borrow_mut();
mbc.pos = mbc.pos + start_pos;
}
+ for swc in &mut file_local_non_narrow_chars {
+ *swc = *swc + start_pos;
+ }
+
let filemap = Rc::new(FileMap {
name: filename,
name_was_remapped,
end_pos,
lines: RefCell::new(file_local_lines),
multibyte_chars: RefCell::new(file_local_multibyte_chars),
+ non_narrow_chars: RefCell::new(file_local_non_narrow_chars),
});
files.push(filemap.clone());
let line = a + 1; // Line numbers start at 1
let linebpos = (*f.lines.borrow())[a];
let linechpos = self.bytepos_to_file_charpos(linebpos);
+ let col = chpos - linechpos;
+
+ let col_display = {
+ let non_narrow_chars = f.non_narrow_chars.borrow();
+ let start_width_idx = non_narrow_chars
+ .binary_search_by_key(&linebpos, |x| x.pos())
+ .unwrap_or_else(|x| x);
+ let end_width_idx = non_narrow_chars
+ .binary_search_by_key(&pos, |x| x.pos())
+ .unwrap_or_else(|x| x);
+ let special_chars = end_width_idx - start_width_idx;
+ let non_narrow: usize =
+ non_narrow_chars[start_width_idx..end_width_idx]
+ .into_iter()
+ .map(|x| x.width())
+ .sum();
+ col.0 - special_chars + non_narrow
+ };
debug!("byte pos {:?} is on the line at byte pos {:?}",
pos, linebpos);
debug!("char pos {:?} is on the line at char pos {:?}",
Loc {
file: f,
line,
- col: chpos - linechpos,
+ col,
+ col_display,
}
}
Err(f) => {
+ let col_display = {
+ let non_narrow_chars = f.non_narrow_chars.borrow();
+ let end_width_idx = non_narrow_chars
+ .binary_search_by_key(&pos, |x| x.pos())
+ .unwrap_or_else(|x| x);
+ let non_narrow: usize =
+ non_narrow_chars[0..end_width_idx]
+ .into_iter()
+ .map(|x| x.width())
+ .sum();
+ chpos.0 - end_width_idx + non_narrow
+ };
Loc {
file: f,
line: 0,
col: chpos,
+ col_display,
}
}
}
use parse::ParseSess;
use symbol::Symbol;
-use std::ascii::AsciiExt;
use std::env;
macro_rules! set {
// allow '|' at beginning of match arms (RFC 1925)
(active, match_beginning_vert, "1.21.0", Some(44101)),
+ // Future-proofing enums/structs with #[non_exhaustive] attribute (RFC 2008)
+ (active, non_exhaustive, "1.22.0", Some(44109)),
+
// Copy/Clone closures (RFC 2132)
(active, clone_closures, "1.22.0", Some(44490)),
(active, copy_closures, "1.22.0", Some(44490)),
not yet settled",
cfg_fn!(structural_match))),
+ // RFC #2008
+ ("non_exhaustive", Whitelisted, Gated(Stability::Unstable,
+ "non_exhaustive",
+ "non exhaustive is an experimental feature",
+ cfg_fn!(non_exhaustive))),
+
("plugin", CrateLevel, Gated(Stability::Unstable,
"plugin",
"compiler plugins are experimental \
"allow_fail attribute is currently unstable",
cfg_fn!(allow_fail))),
+ ("rustc_std_internal_symbol", Whitelisted, Gated(Stability::Unstable,
+ "rustc_attrs",
+ "this is an internal attribute that will \
+ never be stable",
+ cfg_fn!(rustc_attrs))),
+
// Crate level attributes
("crate_name", CrateLevel, Ungated),
("crate_type", CrateLevel, Ungated),
}
}
- ast::ItemKind::DefaultImpl(..) => {
+ ast::ItemKind::AutoImpl(..) => {
gate_feature_post!(&self, optin_builtin_traits,
i.span,
- "default trait implementations are experimental \
+ "auto trait implementations are experimental \
and possibly buggy");
}
}
}
+ ast::ItemKind::Trait(ast::IsAuto::Yes, ..) => {
+ gate_feature_post!(&self, optin_builtin_traits,
+ i.span,
+ "auto traits are experimental and possibly buggy");
+ }
+
ast::ItemKind::MacroDef(ast::MacroDef { legacy: false, .. }) => {
let msg = "`macro` is experimental";
gate_feature_post!(&self, decl_macro, i.span, msg);
let generics = folder.fold_generics(generics);
ItemKind::Union(folder.fold_variant_data(struct_def), generics)
}
- ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
- ItemKind::DefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
+ ItemKind::AutoImpl(unsafety, ref trait_ref) => {
+ ItemKind::AutoImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
}
ItemKind::Impl(unsafety,
polarity,
folder.fold_ty(ty),
impl_items.move_flat_map(|item| folder.fold_impl_item(item)),
),
- ItemKind::Trait(unsafety, generics, bounds, items) => ItemKind::Trait(
+ ItemKind::Trait(is_auto, unsafety, generics, bounds, items) => ItemKind::Trait(
+ is_auto,
unsafety,
folder.fold_generics(generics),
folder.fold_bounds(bounds),
use std::io::{self, Write};
use std::vec;
-use rustc_serialize::json::as_json;
+use rustc_serialize::json::{as_json, as_pretty_json};
pub struct JsonEmitter {
dst: Box<Write + Send>,
registry: Option<Registry>,
cm: Rc<CodeMapper + 'static>,
+ pretty: bool,
}
impl JsonEmitter {
pub fn stderr(registry: Option<Registry>,
- code_map: Rc<CodeMap>) -> JsonEmitter {
+ code_map: Rc<CodeMap>,
+ pretty: bool) -> JsonEmitter {
JsonEmitter {
dst: Box::new(io::stderr()),
registry,
cm: code_map,
+ pretty,
}
}
- pub fn basic() -> JsonEmitter {
+ pub fn basic(pretty: bool) -> JsonEmitter {
let file_path_mapping = FilePathMapping::empty();
- JsonEmitter::stderr(None, Rc::new(CodeMap::new(file_path_mapping)))
+ JsonEmitter::stderr(None, Rc::new(CodeMap::new(file_path_mapping)), pretty)
}
pub fn new(dst: Box<Write + Send>,
registry: Option<Registry>,
- code_map: Rc<CodeMap>) -> JsonEmitter {
+ code_map: Rc<CodeMap>,
+ pretty: bool) -> JsonEmitter {
JsonEmitter {
dst,
registry,
cm: code_map,
+ pretty,
}
}
}
impl Emitter for JsonEmitter {
fn emit(&mut self, db: &DiagnosticBuilder) {
let data = Diagnostic::from_diagnostic_builder(db, self);
- if let Err(e) = writeln!(&mut self.dst, "{}", as_json(&data)) {
+ let result = if self.pretty {
+ writeln!(&mut self.dst, "{}", as_pretty_json(&data))
+ } else {
+ writeln!(&mut self.dst, "{}", as_json(&data))
+ };
+ if let Err(e) = result {
panic!("failed to print diagnostics: {:?}", e);
}
}
spans: Vec<DiagnosticSpan>,
/// Associated diagnostic messages.
children: Vec<Diagnostic>,
- /// The message as rustc would render it. Currently this is only
- /// `Some` for "suggestions", but eventually it will include all
- /// snippets.
+ /// The message as rustc would render it. Currently this is always `None`
rendered: Option<String>,
}
/// Label that should be placed at this location (if any)
label: Option<String>,
/// If we are suggesting a replacement, this will contain text
- /// that should be sliced in atop this span. You may prefer to
- /// load the fully rendered version from the parent `Diagnostic`,
- /// however.
+ /// that should be sliced in atop this span.
suggested_replacement: Option<String>,
/// Macro invocations that created the code at this span, if any.
expansion: Option<Box<DiagnosticSpanMacroExpansion>>,
self.filemap.record_multibyte_char(self.pos, new_ch_len);
}
}
+ self.filemap.record_width(self.pos, new_ch);
} else {
self.ch = None;
self.pos = new_pos;
use ast::{Expr, ExprKind, RangeLimits};
use ast::{Field, FnDecl};
use ast::{ForeignItem, ForeignItemKind, FunctionRetTy};
-use ast::{Ident, ImplItem, Item, ItemKind};
+use ast::{Ident, ImplItem, IsAuto, Item, ItemKind};
use ast::{Lifetime, LifetimeDef, Lit, LitKind, UintTy};
use ast::Local;
use ast::MacStmtStyle;
pub fn eat_to_tokens(&mut self, kets: &[&token::Token]) {
let handler = self.diagnostic();
- self.parse_seq_to_before_tokens(kets,
- SeqSep::none(),
- TokenExpectType::Expect,
- |p| Ok(p.parse_token_tree()),
- |mut e| handler.cancel(&mut e));
+ if let Err(ref mut err) = self.parse_seq_to_before_tokens(kets,
+ SeqSep::none(),
+ TokenExpectType::Expect,
+ |p| Ok(p.parse_token_tree())) {
+ handler.cancel(err);
+ }
}
/// Parse a sequence, including the closing delimiter. The function
-> PResult<'a, Vec<T>> where
F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
- let val = self.parse_seq_to_before_end(ket, sep, f);
+ let val = self.parse_seq_to_before_end(ket, sep, f)?;
self.bump();
Ok(val)
}
ket: &token::Token,
sep: SeqSep,
f: F)
- -> Vec<T>
- where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>
+ -> PResult<'a, Vec<T>>
+ where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>
{
- self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f, |mut e| e.emit())
+ self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f)
}
- // `fe` is an error handler.
- fn parse_seq_to_before_tokens<T, F, Fe>(&mut self,
+ fn parse_seq_to_before_tokens<T, F>(&mut self,
kets: &[&token::Token],
sep: SeqSep,
expect: TokenExpectType,
- mut f: F,
- mut fe: Fe)
- -> Vec<T>
- where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
- Fe: FnMut(DiagnosticBuilder)
+ mut f: F)
+ -> PResult<'a, Vec<T>>
+ where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>
{
let mut first: bool = true;
let mut v = vec![];
if first {
first = false;
} else {
- if let Err(e) = self.expect(t) {
- fe(e);
+ if let Err(mut e) = self.expect(t) {
// Attempt to keep parsing if it was a similar separator
if let Some(ref tokens) = t.similar_tokens() {
if tokens.contains(&self.token) {
self.bump();
}
}
+ e.emit();
// Attempt to keep parsing if it was an omitted separator
match f(self) {
Ok(t) => {
break;
}
- match f(self) {
- Ok(t) => v.push(t),
- Err(e) => {
- fe(e);
- break;
- }
- }
+ let t = f(self)?;
+ v.push(t);
}
- v
+ Ok(v)
}
/// Parse a sequence, including the closing delimiter. The function
F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
self.expect(bra)?;
- let result = self.parse_seq_to_before_end(ket, sep, f);
+ let result = self.parse_seq_to_before_end(ket, sep, f)?;
if self.token == *ket {
self.bump();
}
{
let lo = self.span;
self.expect(bra)?;
- let result = self.parse_seq_to_before_end(ket, sep, f);
+ let result = self.parse_seq_to_before_end(ket, sep, f)?;
let hi = self.span;
self.bump();
Ok(respan(lo.to(hi), result))
};
let span = lo.to(self.prev_span);
- let ty = Ty { node: node, span: span, id: ast::DUMMY_NODE_ID };
+ let ty = Ty { node, span, id: ast::DUMMY_NODE_ID };
// Try to recover from use of `+` with incorrect priority.
self.maybe_recover_from_bad_type_plus(allow_plus, &ty)?;
self.parse_path(style)
}
- fn parse_path_segments(&mut self, segments: &mut Vec<PathSegment>, style: PathStyle,
- enable_warning: bool) -> PResult<'a, ()> {
+ fn parse_path_segments(&mut self,
+ segments: &mut Vec<PathSegment>,
+ style: PathStyle,
+ enable_warning: bool)
+ -> PResult<'a, ()> {
loop {
segments.push(self.parse_path_segment(style, enable_warning)?);
} else {
// `(T, U) -> R`
self.bump(); // `(`
- let inputs = self.parse_seq_to_end(&token::CloseDelim(token::Paren),
- SeqSep::trailing_allowed(token::Comma),
- |p| p.parse_ty())?;
+ let inputs = self.parse_seq_to_before_tokens(
+ &[&token::CloseDelim(token::Paren)],
+ SeqSep::trailing_allowed(token::Comma),
+ TokenExpectType::Expect,
+ |p| p.parse_ty())?;
+ self.bump(); // `)`
let output = if self.eat(&token::RArrow) {
Some(self.parse_ty_no_plus()?)
} else {
// Parse: `for <src_pat> in <src_expr> <src_loop_block>`
let pat = self.parse_pat()?;
- self.expect_keyword(keywords::In)?;
+ if !self.eat_keyword(keywords::In) {
+ let in_span = self.prev_span.between(self.span);
+ let mut err = self.sess.span_diagnostic
+ .struct_span_err(in_span, "missing `in` in `for` loop");
+ err.span_suggestion_short(in_span, "try adding `in` here", " in ".into());
+ err.emit();
+ }
let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
let (iattrs, loop_block) = self.parse_inner_attrs_and_block()?;
attrs.extend(iattrs);
}
/// Parse the RHS of a local variable declaration (e.g. '= 14;')
- fn parse_initializer(&mut self) -> PResult<'a, Option<P<Expr>>> {
+ fn parse_initializer(&mut self
, skip_eq: bool) -> PResult<'a, Option<P<Expr>>> {
if self.check(&token::Eq) {
self.bump();
Ok(Some(self.parse_expr()?))
+ } else if skip_eq {
+ Ok(Some(self.parse_expr()?))
} else {
Ok(None)
}
let lo = self.prev_span;
let pat = self.parse_pat()?;
- let ty = if self.eat(&token::Colon) {
- Some(self.parse_ty()?)
+ let (err, ty) = if self.eat(&token::Colon) {
+ // Save the state of the parser before parsing type normally, in case there is a `:`
+ // instead of an `=` typo.
+ let parser_snapshot_before_type = self.clone();
+ let colon_sp = self.prev_span;
+ match self.parse_ty() {
+ Ok(ty) => (None, Some(ty)),
+ Err(mut err) => {
+ // Rewind to before attempting to parse the type and continue parsing
+ let parser_snapshot_after_type = self.clone();
+ mem::replace(self, parser_snapshot_before_type);
+
+ let snippet = self.sess.codemap().span_to_snippet(pat.span).unwrap();
+ err.span_label(pat.span, format!("while parsing the type for `{}`", snippet));
+ (Some((parser_snapshot_after_type, colon_sp, err)), None)
+ }
+ }
} else {
- None
+ (None, None)
+ };
+ let init = match (self.parse_initializer(err.is_some()), err) {
+ (Ok(init), None) => { // init parsed, ty parsed
+ init
+ }
+ (Ok(init), Some((_, colon_sp, mut err))) => { // init parsed, ty error
+ // Could parse the type as if it were the initializer, it is likely there was a
+ // typo in the code: `:` instead of `=`. Add suggestion and emit the error.
+ err.span_suggestion_short(colon_sp,
+ "use `=` if you meant to assign",
+ "=".to_string());
+ err.emit();
+ // As this was parsed successfuly, continue as if the code has been fixed for the
+ // rest of the file. It will still fail due to the emitted error, but we avoid
+ // extra noise.
+ init
+ }
+ (Err(mut init_err), Some((snapshot, _, ty_err))) => { // init error, ty error
+ init_err.cancel();
+ // Couldn't parse the type nor the initializer, only raise the type error and
+ // return to the parser state before parsing the type as the initializer.
+ // let x: <parse_error>;
+ mem::replace(self, snapshot);
+ return Err(ty_err);
+ }
+ (Err(err), None) => { // init error, ty parsed
+ // Couldn't parse the initializer and we're not attempting to recover a failed
+ // parse of the type, return the error.
+ return Err(err);
+ }
};
- let init = self.parse_initializer()?;
let hi = if self.token == token::Semi {
self.span
} else {
self.look_ahead(1, |t| t.is_ident() && !t.is_reserved_ident())
}
+ fn eat_auto_trait(&mut self) -> bool {
+ if self.token.is_keyword(keywords::Auto)
+ && self.look_ahead(1, |t| t.is_keyword(keywords::Trait))
+ {
+ self.eat_keyword(keywords::Auto) && self.eat_keyword(keywords::Trait)
+ } else {
+ false
+ }
+ }
+
fn is_defaultness(&self) -> bool {
// `pub` is included for better error messages
self.token.is_keyword(keywords::Default) &&
} else if self.eat(&token::Comma) {
let mut fn_inputs = vec![self_arg];
fn_inputs.append(&mut self.parse_seq_to_before_end(
- &token::CloseDelim(token::Paren), sep, parse_arg_fn)
+ &token::CloseDelim(token::Paren), sep, parse_arg_fn)?
);
fn_inputs
} else {
return self.unexpected();
}
} else {
- self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn)
+ self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn)?
};
// Parse closing paren and return type.
&[&token::BinOp(token::Or), &token::OrOr],
SeqSep::trailing_allowed(token::Comma),
TokenExpectType::NoExpect,
- |p| p.parse_fn_block_arg(),
- |mut e| e.emit()
- );
+ |p| p.parse_fn_block_arg()
+ )?;
self.expect_or()?;
args
}
}
/// Parse trait Foo { ... }
- fn parse_item_trait(&mut self, unsafety: Unsafety) -> PResult<'a, ItemInfo> {
+ fn parse_item_trait(&mut self, is_auto: IsAuto, unsafety: Unsafety) -> PResult<'a, ItemInfo> {
let ident = self.parse_ident()?;
let mut tps = self.parse_generics()?;
}
}
}
- Ok((ident, ItemKind::Trait(unsafety, tps, bounds, trait_items), None))
+ Ok((ident, ItemKind::Trait(is_auto, unsafety, tps, bounds, trait_items), None))
}
/// Parses items implementations variants
if opt_trait.is_some() && self.eat(&token::DotDot) {
if generics.is_parameterized() {
- self.span_err(impl_span, "default trait implementations are not \
+ self.span_err(impl_span, "auto trait implementations are not \
allowed to have generics");
}
if let ast::Defaultness::Default = defaultness {
self.span_err(impl_span, "`default impl` is not allowed for \
- default trait implementations");
+ auto trait implementations");
}
self.expect(&token::OpenDelim(token::Brace))?;
self.expect(&token::CloseDelim(token::Brace))?;
Ok((keywords::Invalid.ident(),
- ItemKind::DefaultImpl(unsafety, opt_trait.unwrap()), None))
+ ItemKind::AutoImpl(unsafety, opt_trait.unwrap()), None))
} else {
if opt_trait.is_some() {
ty = self.parse_ty()?;
return Ok(Some(item));
}
if self.check_keyword(keywords::Unsafe) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Trait))
+ (self.look_ahead(1, |t| t.is_keyword(keywords::Trait)) ||
+ self.look_ahead(1, |t| t.is_keyword(keywords::Auto)))
{
// UNSAFE TRAIT ITEM
self.expect_keyword(keywords::Unsafe)?;
- self.expect_keyword(keywords::Trait)?;
+ let is_auto = if self.eat_keyword(keywords::Trait) {
+ IsAuto::No
+ } else {
+ self.eat_auto_trait();
+ IsAuto::Yes
+ };
let (ident, item_, extra_attrs) =
- self.parse_item_trait(ast::Unsafety::Unsafe)?;
+ self.parse_item_trait(is_auto, ast::Unsafety::Unsafe)?;
let prev_span = self.prev_span;
let item = self.mk_item(lo.to(prev_span),
ident,
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.eat_keyword(keywords::Trait) {
+ if self.check_keyword(keywords::Trait)
+ || (self.check_keyword(keywords::Auto)
+ && self.look_ahead(1, |t| t.is_keyword(keywords::Trait)))
+ {
+ let is_auto = if self.eat_keyword(keywords::Trait) {
+ IsAuto::No
+ } else {
+ self.eat_auto_trait();
+ IsAuto::Yes
+ };
// TRAIT ITEM
let (ident, item_, extra_attrs) =
- self.parse_item_trait(ast::Unsafety::Normal)?;
+ self.parse_item_trait(is_auto, ast::Unsafety::Normal)?;
let prev_span = self.prev_span;
let item = self.mk_item(lo.to(prev_span),
ident,
self.head(&visibility_qualified(&item.vis, "union"))?;
self.print_struct(struct_def, generics, item.ident, item.span, true)?;
}
- ast::ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
+ ast::ItemKind::AutoImpl(unsafety, ref trait_ref) => {
self.head("")?;
self.print_visibility(&item.vis)?;
self.print_unsafety(unsafety)?;
}
self.bclose(item.span)?;
}
- ast::ItemKind::Trait(unsafety, ref generics, ref bounds, ref trait_items) => {
+ 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_generics(generics)?;
Fixity::None => (prec + 1, prec + 1),
};
+ let left_prec = match (&lhs.node, op.node) {
+ // These cases need parens: `x as i32 < y` has the parser thinking that `i32 < y` is
+ // the beginning of a path type. It starts trying to parse `x as (i32 < y ...` instead
+ // of `(x as i32) < ...`. We need to convince it _not_ to do that.
+ (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Lt) |
+ (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Shl) => parser::PREC_FORCE_PAREN,
+ _ => left_prec,
+ };
+
self.print_expr_maybe_paren(lhs, left_prec)?;
self.s.space()?;
self.word_space(op.node.to_string())?;
ast::Unsafety::Unsafe => self.word_nbsp("unsafe"),
}
}
+
+ pub fn print_is_auto(&mut self, s: ast::IsAuto) -> io::Result<()> {
+ match s {
+ ast::IsAuto::Yes => self.word_nbsp("auto"),
+ ast::IsAuto::No => Ok(()),
+ }
+ }
}
fn repeat(s: &str, n: usize) -> String { iter::repeat(s).take(n).collect() }
visitor.visit_generics(type_parameters);
visitor.visit_enum_def(enum_definition, type_parameters, item.id, item.span)
}
- ItemKind::DefaultImpl(_, ref trait_ref) => {
+ ItemKind::AutoImpl(_, ref trait_ref) => {
visitor.visit_trait_ref(trait_ref)
}
ItemKind::Impl(_, _, _,
visitor.visit_variant_data(struct_definition, item.ident,
generics, item.id, item.span);
}
- ItemKind::Trait(_, ref generics, ref bounds, ref methods) => {
+ ItemKind::Trait(.., ref generics, ref bounds, ref methods) => {
visitor.visit_generics(generics);
walk_list!(visitor, visit_ty_param_bound, bounds);
walk_list!(visitor, visit_trait_item, methods);
[dependencies]
serialize = { path = "../libserialize" }
rustc_data_structures = { path = "../librustc_data_structures" }
+unicode-width = "0.1.4"
extern crate serialize;
extern crate serialize as rustc_serialize; // used by deriving
+extern crate unicode_width;
+
pub mod hygiene;
pub use hygiene::{SyntaxContext, ExpnInfo, ExpnFormat, NameAndSpan, CompilerDesugaringKind};
pub bytes: usize,
}
+/// Identifies an offset of a non-narrow character in a FileMap
+#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Eq, PartialEq)]
+pub enum NonNarrowChar {
+ /// Represents a zero-width character
+ ZeroWidth(BytePos),
+ /// Represents a wide (fullwidth) character
+ Wide(BytePos),
+}
+
+impl NonNarrowChar {
+ fn new(pos: BytePos, width: usize) -> Self {
+ match width {
+ 0 => NonNarrowChar::ZeroWidth(pos),
+ 2 => NonNarrowChar::Wide(pos),
+ _ => panic!("width {} given for non-narrow character", width),
+ }
+ }
+
+ /// Returns the absolute offset of the character in the CodeMap
+ pub fn pos(&self) -> BytePos {
+ match *self {
+ NonNarrowChar::ZeroWidth(p) |
+ NonNarrowChar::Wide(p) => p,
+ }
+ }
+
+ /// Returns the width of the character, 0 (zero-width) or 2 (wide)
+ pub fn width(&self) -> usize {
+ match *self {
+ NonNarrowChar::ZeroWidth(_) => 0,
+ NonNarrowChar::Wide(_) => 2,
+ }
+ }
+}
+
+impl Add<BytePos> for NonNarrowChar {
+ type Output = Self;
+
+ fn add(self, rhs: BytePos) -> Self {
+ match self {
+ NonNarrowChar::ZeroWidth(pos) => NonNarrowChar::ZeroWidth(pos + rhs),
+ NonNarrowChar::Wide(pos) => NonNarrowChar::Wide(pos + rhs),
+ }
+ }
+}
+
+impl Sub<BytePos> for NonNarrowChar {
+ type Output = Self;
+
+ fn sub(self, rhs: BytePos) -> Self {
+ match self {
+ NonNarrowChar::ZeroWidth(pos) => NonNarrowChar::ZeroWidth(pos - rhs),
+ NonNarrowChar::Wide(pos) => NonNarrowChar::Wide(pos - rhs),
+ }
+ }
+}
+
/// The state of the lazy external source loading mechanism of a FileMap.
#[derive(PartialEq, Eq, Clone)]
pub enum ExternalSource {
pub lines: RefCell<Vec<BytePos>>,
/// Locations of multi-byte characters in the source code
pub multibyte_chars: RefCell<Vec<MultiByteChar>>,
+ /// Width of characters that are not narrow in the source code
+ pub non_narrow_chars: RefCell<Vec<NonNarrowChar>>,
}
impl Encodable for FileMap {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_struct("FileMap", 7, |s| {
+ s.emit_struct("FileMap", 8, |s| {
s.emit_struct_field("name", 0, |s| self.name.encode(s))?;
s.emit_struct_field("name_was_remapped", 1, |s| self.name_was_remapped.encode(s))?;
s.emit_struct_field("src_hash", 6, |s| self.src_hash.encode(s))?;
})?;
s.emit_struct_field("multibyte_chars", 5, |s| {
(*self.multibyte_chars.borrow()).encode(s)
+ })?;
+ s.emit_struct_field("non_narrow_chars", 7, |s| {
+ (*self.non_narrow_chars.borrow()).encode(s)
})
})
}
impl Decodable for FileMap {
fn decode<D: Decoder>(d: &mut D) -> Result<FileMap, D::Error> {
- d.read_struct("FileMap", 6, |d| {
+ d.read_struct("FileMap", 8, |d| {
let name: String = d.read_struct_field("name", 0, |d| Decodable::decode(d))?;
let name_was_remapped: bool =
d.read_struct_field("name_was_remapped", 1, |d| Decodable::decode(d))?;
})?;
let multibyte_chars: Vec<MultiByteChar> =
d.read_struct_field("multibyte_chars", 5, |d| Decodable::decode(d))?;
+ let non_narrow_chars: Vec<NonNarrowChar> =
+ d.read_struct_field("non_narrow_chars", 7, |d| Decodable::decode(d))?;
Ok(FileMap {
name,
name_was_remapped,
src_hash,
external_src: RefCell::new(ExternalSource::AbsentOk),
lines: RefCell::new(lines),
- multibyte_chars: RefCell::new(multibyte_chars)
+ multibyte_chars: RefCell::new(multibyte_chars),
+ non_narrow_chars: RefCell::new(non_narrow_chars)
})
})
}
end_pos: Pos::from_usize(end_pos),
lines: RefCell::new(Vec::new()),
multibyte_chars: RefCell::new(Vec::new()),
+ non_narrow_chars: RefCell::new(Vec::new()),
}
}
self.multibyte_chars.borrow_mut().push(mbc);
}
+ pub fn record_width(&self, pos: BytePos, ch: char) {
+ let width = match ch {
+ '\t' | '\n' =>
+ // Tabs will consume one column.
+ // Make newlines take one column so that displayed spans can point them.
+ 1,
+ ch =>
+ // Assume control characters are zero width.
+ // FIXME: How can we decide between `width` and `width_cjk`?
+ unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0),
+ };
+ // Only record non-narrow characters.
+ if width != 1 {
+ self.non_narrow_chars.borrow_mut().push(NonNarrowChar::new(pos, width));
+ }
+ }
+
pub fn is_real_file(&self) -> bool {
!(self.name.starts_with("<") &&
self.name.ends_with(">"))
/// The (1-based) line number
pub line: usize,
/// The (0-based) column offset
- pub col: CharPos
+ pub col: CharPos,
+ /// The (0-based) column offset when displayed
+ pub col_display: usize,
}
/// A source code location used as the result of lookup_char_pos_adj
const CTXT_INDEX: usize = 2;
// Tag = 0, inline format.
-// -----------------------------------
-// | base 31:8 | len 7:1 | tag 0:0 |
-// -----------------------------------
+// -------------------------------------------------------------
+// | base 31:8 | len 7:1 | ctxt (currently 0 bits) | tag 0:0 |
+// -------------------------------------------------------------
+// Since there are zero bits for ctxt, only SpanData with a 0 SyntaxContext
+// can be inline.
const INLINE_SIZES: [u32; 3] = [24, 7, 0];
const INLINE_OFFSETS: [u32; 3] = [8, 1, 1];
(54, Yield, "yield")
// Weak keywords, have special meaning only in specific contexts.
- (55, Catch, "catch")
- (56, Default, "default")
- (57, Dyn, "dyn")
- (58, StaticLifetime, "'static")
- (59, Union, "union")
+ (55, Auto, "auto")
+ (56, Catch, "catch")
+ (57, Default, "default")
+ (58, Dyn, "dyn")
+ (59, StaticLifetime, "'static")
+ (60, Union, "union")
}
// If an interner exists in TLS, return it. Otherwise, prepare a fresh one.
// When an executable or dylib image is linked, all user code and libraries are
// "sandwiched" between these two object files, so code or data from rsbegin.o
// become first in the respective sections of the image, whereas code and data
-// from rsend.o become the last ones. This effect can be used to place symbols
+// from rsend.o become the last ones. This effect can be used to place symbols
// at the beginning or at the end of a section, as well as to insert any required
// headers or footers.
//
trait Sized {}
#[lang = "sync"]
trait Sync {}
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
impl Sync for .. {}
#[lang = "copy"]
trait Copy {}
#[lang = "freeze"]
trait Freeze {}
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
impl Freeze for .. {}
#[lang = "drop_in_place"]
trait Copy {}
#[lang = "freeze"]
trait Freeze {}
+#[allow(unknown_lints)]
+#[allow(auto_impl)]
impl Freeze for .. {}
#[lang = "drop_in_place"]
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-tidy-linelength
+// compile-flags:-Zprint-trans-items=lazy
+
+// NB: We do not expect *any* translation item to be generated here.
+
+#![feature(const_fn)]
+#![deny(dead_code)]
+#![crate_type = "rlib"]
+
+pub const fn foo(x: u32) -> u32 {
+ x + 0xf00
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-tidy-linelength
+// compile-flags:-Zprint-trans-items=lazy
+
+// NB: We do not expect *any* translation item to be generated here.
+
+#![deny(dead_code)]
+#![crate_type = "rlib"]
+
+#[inline]
+pub fn foo() -> bool {
+ [1, 2] == [3, 4]
+}
+
// compile-flags:-Zinline-in-all-cgus
#![allow(dead_code)]
-#![crate_type="lib"]
+#![crate_type="rlib"]
// aux-build:cgu_extern_drop_glue.rs
extern crate cgu_extern_drop_glue;
struct LocalStruct(cgu_extern_drop_glue::Struct);
-//~ TRANS_ITEM fn extern_drop_glue::user[0] @@ extern_drop_glue[Internal]
-fn user()
+//~ TRANS_ITEM fn extern_drop_glue::user[0] @@ extern_drop_glue[External]
+pub fn user()
{
//~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<extern_drop_glue::LocalStruct[0]> @@ extern_drop_glue[Internal]
let _ = LocalStruct(cgu_extern_drop_glue::Struct(0));
}
-mod mod1 {
+pub mod mod1 {
use cgu_extern_drop_glue;
struct LocalStruct(cgu_extern_drop_glue::Struct);
- //~ TRANS_ITEM fn extern_drop_glue::mod1[0]::user[0] @@ extern_drop_glue-mod1[Internal]
- fn user()
+ //~ TRANS_ITEM fn extern_drop_glue::mod1[0]::user[0] @@ extern_drop_glue-mod1[External]
+ pub fn user()
{
//~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<extern_drop_glue::mod1[0]::LocalStruct[0]> @@ extern_drop_glue-mod1[Internal]
let _ = LocalStruct(cgu_extern_drop_glue::Struct(0));
cgu_explicit_inlining::never_inlined();
}
-mod mod1 {
+pub mod mod1 {
use cgu_explicit_inlining;
- //~ TRANS_ITEM fn inlining_from_extern_crate::mod1[0]::user[0] @@ inlining_from_extern_crate-mod1[Internal]
+ //~ TRANS_ITEM fn inlining_from_extern_crate::mod1[0]::user[0] @@ inlining_from_extern_crate-mod1[External]
pub fn user()
{
cgu_explicit_inlining::inlined();
}
}
-mod mod2 {
+pub mod mod2 {
use cgu_explicit_inlining;
- //~ TRANS_ITEM fn inlining_from_extern_crate::mod2[0]::user[0] @@ inlining_from_extern_crate-mod2[Internal]
+ //~ TRANS_ITEM fn inlining_from_extern_crate::mod2[0]::user[0] @@ inlining_from_extern_crate-mod2[External]
pub fn user()
{
cgu_explicit_inlining::always_inlined();
// compile-flags:-Zinline-in-all-cgus
#![allow(dead_code)]
-#![crate_type="lib"]
+#![crate_type="rlib"]
//~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<local_drop_glue::Struct[0]> @@ local_drop_glue[Internal] local_drop_glue-mod1[Internal]
struct Struct {
_a: Struct
}
-//~ TRANS_ITEM fn local_drop_glue::user[0] @@ local_drop_glue[Internal]
-fn user()
+//~ TRANS_ITEM fn local_drop_glue::user[0] @@ local_drop_glue[External]
+pub fn user()
{
let _ = Outer {
_a: Struct {
};
}
-mod mod1
+pub mod mod1
{
use super::Struct;
_b: (u32, Struct),
}
- //~ TRANS_ITEM fn local_drop_glue::mod1[0]::user[0] @@ local_drop_glue-mod1[Internal]
- fn user()
+ //~ TRANS_ITEM fn local_drop_glue::mod1[0]::user[0] @@ local_drop_glue-mod1[External]
+ pub fn user()
{
let _ = Struct2 {
_a: Struct { _a: 0 },
}
}
-mod user1 {
+pub mod user1 {
use super::inline;
- //~ TRANS_ITEM fn local_inlining_but_not_all::user1[0]::foo[0] @@ local_inlining_but_not_all-user1[Internal]
- fn foo() {
+ //~ TRANS_ITEM fn local_inlining_but_not_all::user1[0]::foo[0] @@ local_inlining_but_not_all-user1[External]
+ pub fn foo() {
inline::inlined_function();
}
}
-mod user2 {
+pub mod user2 {
use super::inline;
- //~ TRANS_ITEM fn local_inlining_but_not_all::user2[0]::bar[0] @@ local_inlining_but_not_all-user2[Internal]
- fn bar() {
+ //~ TRANS_ITEM fn local_inlining_but_not_all::user2[0]::bar[0] @@ local_inlining_but_not_all-user2[External]
+ pub fn bar() {
inline::inlined_function();
}
}
-mod non_user {
+pub mod non_user {
- //~ TRANS_ITEM fn local_inlining_but_not_all::non_user[0]::baz[0] @@ local_inlining_but_not_all-non_user[Internal]
- fn baz() {
+ //~ TRANS_ITEM fn local_inlining_but_not_all::non_user[0]::baz[0] @@ local_inlining_but_not_all-non_user[External]
+ pub fn baz() {
}
}
}
}
-mod user1 {
+pub mod user1 {
use super::inline;
- //~ TRANS_ITEM fn local_inlining::user1[0]::foo[0] @@ local_inlining-user1[Internal]
- fn foo() {
+ //~ TRANS_ITEM fn local_inlining::user1[0]::foo[0] @@ local_inlining-user1[External]
+ pub fn foo() {
inline::inlined_function();
}
}
-mod user2 {
+pub mod user2 {
use super::inline;
- //~ TRANS_ITEM fn local_inlining::user2[0]::bar[0] @@ local_inlining-user2[Internal]
- fn bar() {
+ //~ TRANS_ITEM fn local_inlining::user2[0]::bar[0] @@ local_inlining-user2[External]
+ pub fn bar() {
inline::inlined_function();
}
}
-mod non_user {
+pub mod non_user {
- //~ TRANS_ITEM fn local_inlining::non_user[0]::baz[0] @@ local_inlining-non_user[Internal]
- fn baz() {
+ //~ TRANS_ITEM fn local_inlining::non_user[0]::baz[0] @@ local_inlining-non_user[External]
+ pub fn baz() {
}
}
// compile-flags:-Zinline-in-all-cgus
#![allow(dead_code)]
-#![crate_type="lib"]
+#![crate_type="rlib"]
mod inline {
}
}
-mod indirect_user {
+pub mod indirect_user {
use super::direct_user;
- //~ TRANS_ITEM fn local_transitive_inlining::indirect_user[0]::bar[0] @@ local_transitive_inlining-indirect_user[Internal]
- fn bar() {
+ //~ TRANS_ITEM fn local_transitive_inlining::indirect_user[0]::bar[0] @@ local_transitive_inlining-indirect_user[External]
+ pub fn bar() {
direct_user::foo();
}
}
-mod non_user {
+pub mod non_user {
- //~ TRANS_ITEM fn local_transitive_inlining::non_user[0]::baz[0] @@ local_transitive_inlining-non_user[Internal]
- fn baz() {
+ //~ TRANS_ITEM fn local_transitive_inlining::non_user[0]::baz[0] @@ local_transitive_inlining-non_user[External]
+ pub fn baz() {
}
}
// incremental compilation
// compile-flags:-Zprint-trans-items=lazy -Zincremental=tmp/partitioning-tests/statics
-#![crate_type="lib"]
+#![crate_type="rlib"]
//~ TRANS_ITEM static statics::FOO[0] @@ statics[Internal]
static FOO: u32 = 0;
//~ TRANS_ITEM static statics::BAR[0] @@ statics[Internal]
static BAR: u32 = 0;
-//~ TRANS_ITEM fn statics::function[0] @@ statics[Internal]
-fn function() {
+//~ TRANS_ITEM fn statics::function[0] @@ statics[External]
+pub fn function() {
//~ TRANS_ITEM static statics::function[0]::FOO[0] @@ statics[Internal]
static FOO: u32 = 0;
static BAR: u32 = 0;
}
-mod mod1 {
+pub mod mod1 {
//~ TRANS_ITEM static statics::mod1[0]::FOO[0] @@ statics-mod1[Internal]
static FOO: u32 = 0;
//~ TRANS_ITEM static statics::mod1[0]::BAR[0] @@ statics-mod1[Internal]
static BAR: u32 = 0;
- //~ TRANS_ITEM fn statics::mod1[0]::function[0] @@ statics-mod1[Internal]
- fn function() {
+ //~ TRANS_ITEM fn statics::mod1[0]::function[0] @@ statics-mod1[External]
+ pub fn function() {
//~ TRANS_ITEM static statics::mod1[0]::function[0]::FOO[0] @@ statics-mod1[Internal]
static FOO: u32 = 0;
// Hack to get the correct size for the length part in slices
// CHECK: @helper([[USIZE:i[0-9]+]] %arg0)
#[no_mangle]
-fn helper(_: usize) {
+pub fn helper(_: usize) {
}
// CHECK-LABEL: @no_op_slice_adjustment
#![crate_type = "lib"]
-mod tests {
+pub mod tests {
// CHECK: @f1(i32 inreg %arg0, i32 inreg %arg1, i32 %arg2)
#[no_mangle]
- extern "fastcall" fn f1(_: i32, _: i32, _: i32) {}
+ pub extern "fastcall" fn f1(_: i32, _: i32, _: i32) {}
// CHECK: @f2(i32* inreg %arg0, i32* inreg %arg1, i32* %arg2)
#[no_mangle]
- extern "fastcall" fn f2(_: *const i32, _: *const i32, _: *const i32) {}
+ pub extern "fastcall" fn f2(_: *const i32, _: *const i32, _: *const i32) {}
// CHECK: @f3(float %arg0, i32 inreg %arg1, i32 inreg %arg2, i32 %arg3)
#[no_mangle]
- extern "fastcall" fn f3(_: f32, _: i32, _: i32, _: i32) {}
+ pub extern "fastcall" fn f3(_: f32, _: i32, _: i32, _: i32) {}
// CHECK: @f4(i32 inreg %arg0, float %arg1, i32 inreg %arg2, i32 %arg3)
#[no_mangle]
- extern "fastcall" fn f4(_: i32, _: f32, _: i32, _: i32) {}
+ pub extern "fastcall" fn f4(_: i32, _: f32, _: i32, _: i32) {}
// CHECK: @f5(i64 %arg0, i32 %arg1)
#[no_mangle]
- extern "fastcall" fn f5(_: i64, _: i32) {}
+ pub extern "fastcall" fn f5(_: i64, _: i32) {}
// CHECK: @f6(i1 inreg zeroext %arg0, i32 inreg %arg1, i32 %arg2)
#[no_mangle]
- extern "fastcall" fn f6(_: bool, _: i32, _: i32) {}
+ pub extern "fastcall" fn f6(_: bool, _: i32, _: i32) {}
}
// Hack to get the correct size for the length part in slices
// CHECK: @helper([[USIZE:i[0-9]+]] %arg0)
#[no_mangle]
-fn helper(_: usize) {
+pub fn helper(_: usize) {
}
// CHECK: @slice(i8* noalias nonnull readonly %arg0.ptr, [[USIZE]] %arg0.meta)
// FIXME #25759 This should also have `nocapture`
#[no_mangle]
-fn slice(_: &[u8]) {
+pub fn slice(_: &[u8]) {
}
// CHECK: @mutable_slice(i8* nonnull %arg0.ptr, [[USIZE]] %arg0.meta)
// FIXME #25759 This should also have `nocapture`
// ... there's this LLVM bug that forces us to not use noalias, see #29485
#[no_mangle]
-fn mutable_slice(_: &mut [u8]) {
+pub fn mutable_slice(_: &mut [u8]) {
}
// CHECK: @unsafe_slice(%UnsafeInner* nonnull %arg0.ptr, [[USIZE]] %arg0.meta)
// CHECK: @str(i8* noalias nonnull readonly %arg0.ptr, [[USIZE]] %arg0.meta)
// FIXME #25759 This should also have `nocapture`
#[no_mangle]
-fn str(_: &[u8]) {
+pub fn str(_: &[u8]) {
}
// CHECK: @trait_borrow({}* nonnull, {}* noalias nonnull readonly)
// FIXME #25759 This should also have `nocapture`
#[no_mangle]
-fn trait_borrow(_: &Drop) {
+pub fn trait_borrow(_: &Drop) {
}
// CHECK: @trait_box({}* noalias nonnull, {}* noalias nonnull readonly)
#[no_mangle]
-fn trait_box(_: Box<Drop>) {
+pub fn trait_box(_: Box<Drop>) {
}
// CHECK: { i16*, [[USIZE]] } @return_slice(i16* noalias nonnull readonly %x.ptr, [[USIZE]] %x.meta)
#[no_mangle]
-fn return_slice(x: &[u16]) -> &[u16] {
+pub fn return_slice(x: &[u16]) -> &[u16] {
x
}
// CHECK-LABEL: @mir
// CHECK-NOT: store{{.*}}undef
#[no_mangle]
-fn mir() {
+pub fn mir() {
let x = Zst { phantom: PhantomData };
let y = (x, 0);
drop(y);
#![feature(naked_functions)]
// CHECK: Function Attrs: naked uwtable
-// CHECK-NEXT: define internal void @naked_empty()
+// CHECK-NEXT: define void @naked_empty()
#[no_mangle]
#[naked]
-fn naked_empty() {
+pub fn naked_empty() {
// CHECK-NEXT: {{.+}}:
// CHECK-NEXT: ret void
}
// CHECK: Function Attrs: naked uwtable
#[no_mangle]
#[naked]
-// CHECK-NEXT: define internal void @naked_with_args(i{{[0-9]+}})
-fn naked_with_args(a: isize) {
+// CHECK-NEXT: define void @naked_with_args(i{{[0-9]+}})
+pub fn naked_with_args(a: isize) {
// CHECK-NEXT: {{.+}}:
// CHECK-NEXT: %a = alloca i{{[0-9]+}}
&a; // keep variable in an alloca
}
// CHECK: Function Attrs: naked uwtable
-// CHECK-NEXT: define internal i{{[0-9]+}} @naked_with_return()
+// CHECK-NEXT: define i{{[0-9]+}} @naked_with_return()
#[no_mangle]
#[naked]
-fn naked_with_return() -> isize {
+pub fn naked_with_return() -> isize {
// CHECK-NEXT: {{.+}}:
// CHECK-NEXT: ret i{{[0-9]+}} 0
0
}
// CHECK: Function Attrs: naked uwtable
-// CHECK-NEXT: define internal i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+}})
+// CHECK-NEXT: define i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+}})
#[no_mangle]
#[naked]
-fn naked_with_args_and_return(a: isize) -> isize {
+pub fn naked_with_args_and_return(a: isize) -> isize {
// CHECK-NEXT: {{.+}}:
// CHECK-NEXT: %a = alloca i{{[0-9]+}}
&a; // keep variable in an alloca
}
// CHECK: Function Attrs: naked uwtable
-// CHECK-NEXT: define internal void @naked_recursive()
+// CHECK-NEXT: define void @naked_recursive()
#[no_mangle]
#[naked]
-fn naked_recursive() {
+pub fn naked_recursive() {
// CHECK-NEXT: {{.+}}:
// CHECK-NEXT: call void @naked_empty()
// Hack to get the correct size for the length part in slices
// CHECK: @helper([[USIZE:i[0-9]+]] %arg0)
#[no_mangle]
-fn helper(_: usize) {
+pub fn helper(_: usize) {
}
// CHECK-LABEL: @ref_dst
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: -C no-prepopulate-passes
+
+// This file tests that we don't generate any code for saturation if
+// -Z saturating-float-casts is not enabled.
+
+#![crate_type = "lib"]
+#![feature(i128_type)]
+
+// CHECK-LABEL: @f32_to_u32
+#[no_mangle]
+pub fn f32_to_u32(x: f32) -> u32 {
+ // CHECK: fptoui
+ // CHECK-NOT: fcmp
+ // CHECK-NOT: icmp
+ // CHECK-NOT: select
+ x as u32
+}
+
+// CHECK-LABEL: @f32_to_i32
+#[no_mangle]
+pub fn f32_to_i32(x: f32) -> i32 {
+ // CHECK: fptosi
+ // CHECK-NOT: fcmp
+ // CHECK-NOT: icmp
+ // CHECK-NOT: select
+ x as i32
+}
+
+#[no_mangle]
+pub fn f64_to_u8(x: f32) -> u16 {
+ // CHECK-NOT: fcmp
+ // CHECK-NOT: icmp
+ // CHECK-NOT: select
+ x as u16
+}
+
+// CHECK-LABEL: @i32_to_f64
+#[no_mangle]
+pub fn i32_to_f64(x: i32) -> f64 {
+ // CHECK: sitofp
+ // CHECK-NOT: fcmp
+ // CHECK-NOT: icmp
+ // CHECK-NOT: select
+ x as f64
+}
+
+// CHECK-LABEL: @u128_to_f32
+#[no_mangle]
+pub fn u128_to_f32(x: u128) -> f32 {
+ // CHECK: uitofp
+ // CHECK-NOT: fcmp
+ // CHECK-NOT: icmp
+ // CHECK-NOT: select
+ x as f32
+}
#[inline()] //~ ERROR E0534
pub fn something() {}
-fn main() {}
+fn main() {
+ something();
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(optin_builtin_traits)]
+
+trait Foo {}
+impl Foo for .. {}
+//~^ ERROR The form `impl Foo for .. {}` will be removed, please use `auto trait Foo {}`
+//~^^ WARN this was previously accepted by the compiler
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(optin_builtin_traits)]
+
+auto trait Generic<T> {}
+//~^ ERROR auto traits cannot have generics
+//~^^ traits with auto impls (`e.g. impl Trait for ..`) can not have type parameters
+auto trait Bound : Copy {}
+//~^ ERROR auto traits cannot have super traits
+//~^^ traits with auto impls (`e.g. impl Trait for ..`) cannot have predicates
+auto trait MyTrait { fn foo() {} }
+//~^ ERROR auto traits cannot contain items
+//~^^ traits with default impls (`e.g. impl Trait for ..`) must have no methods or associated items
+fn main() {}
#![crate_type = "rlib"]
pub trait DefaultedTrait { }
+#[allow(auto_impl)]
impl DefaultedTrait for .. { }
pub struct Something<T> { t: T }
#![feature(repr_simd, platform_intrinsics, core_intrinsics)]
#![allow(warnings)]
+#![crate_type = "rlib"]
// Bad monomorphizations could previously cause LLVM asserts even though the
// error was caught in the compiler.
use std::intrinsics;
#[derive(Copy, Clone)]
-struct Foo(i64);
+pub struct Foo(i64);
-unsafe fn test_cttz(v: Foo) -> Foo {
+pub unsafe fn test_cttz(v: Foo) -> Foo {
intrinsics::cttz(v)
//~^ ERROR `cttz` intrinsic: expected basic integer type, found `Foo`
}
-unsafe fn test_fadd_fast(a: Foo, b: Foo) -> Foo {
+pub unsafe fn test_fadd_fast(a: Foo, b: Foo) -> Foo {
intrinsics::fadd_fast(a, b)
//~^ ERROR `fadd_fast` intrinsic: expected basic float type, found `Foo`
}
-unsafe fn test_simd_add(a: Foo, b: Foo) -> Foo {
+pub unsafe fn test_simd_add(a: Foo, b: Foo) -> Foo {
simd_add(a, b)
//~^ ERROR `simd_add` intrinsic: expected SIMD input type, found non-SIMD `Foo`
}
-
-fn main() {}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+//compile-flags: -Z emit-end-regions -Z borrowck-mir
+
+fn foo(_:String) {}
+
+fn main()
+{
+ let my_str = "hello".to_owned();
+ match Some(42) {
+ Some(_) if { drop(my_str); false } => {}
+ Some(_) => {}
+ None => { foo(my_str); } //~ ERROR (Mir) [E0381]
+ }
+}
// revisions: ast mir
//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+enum Foo {
+ A(i32),
+ B
+}
+
+fn match_enum() {
+ let mut foo = Foo::B;
+ let p = &mut foo;
+ let _ = match foo {
+ Foo::B => 1, //[mir]~ ERROR (Mir) [E0503]
+ _ => 2,
+ Foo::A(x) => x //[ast]~ ERROR [E0503]
+ //[mir]~^ ERROR (Ast) [E0503]
+ //[mir]~| ERROR (Mir) [E0503]
+ };
+}
+
+
fn main() {
let mut x = 1;
let _x = &mut x;
--- /dev/null
+See `src/test/run-pass/closure-expected-type`.
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// must-compile-successfully
+
+#![feature(underscore_lifetimes)]
+#![allow(warnings)]
+
+type Different<'a, 'b> = &'a mut (&'a (), &'b ());
+type Same<'a> = Different<'a, 'a>;
+
+fn with_closure_expecting_different<F>(_: F)
+ where F: for<'a, 'b> FnOnce(Different<'a, 'b>)
+{
+}
+
+fn with_closure_expecting_different_anon<F>(_: F)
+ where F: FnOnce(Different<'_, '_>)
+{
+}
+
+fn supplying_nothing_expecting_anon() {
+ with_closure_expecting_different_anon(|x: Different| {
+ })
+}
+
+fn supplying_nothing_expecting_named() {
+ with_closure_expecting_different(|x: Different| {
+ })
+}
+
+fn supplying_underscore_expecting_anon() {
+ with_closure_expecting_different_anon(|x: Different<'_, '_>| {
+ })
+}
+
+fn supplying_underscore_expecting_named() {
+ with_closure_expecting_different(|x: Different<'_, '_>| {
+ })
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(underscore_lifetimes)]
+
+fn with_closure_expecting_fn_with_free_region<F>(_: F)
+ where F: for<'a> FnOnce(fn(&'a u32), &i32)
+{
+}
+
+fn with_closure_expecting_fn_with_bound_region<F>(_: F)
+ where F: FnOnce(fn(&u32), &i32)
+{
+}
+
+fn expect_free_supply_free_from_fn<'x>(x: &'x u32) {
+ // Here, the type given for `'x` "obscures" a region from the
+ // expected signature that is bound at closure level.
+ with_closure_expecting_fn_with_free_region(|x: fn(&'x u32), y| {});
+ //~^ ERROR mismatched types
+ //~| ERROR mismatched types
+}
+
+fn expect_free_supply_free_from_closure() {
+ // A variant on the previous test. Here, the region `'a` will be
+ // bound at the closure level, just as is expected, so no error
+ // results.
+ type Foo<'a> = fn(&'a u32);
+ with_closure_expecting_fn_with_free_region(|_x: Foo<'_>, y| {});
+}
+
+fn expect_free_supply_bound() {
+ // Here, we are given a function whose region is bound at closure level,
+ // but we expect one bound in the argument. Error results.
+ with_closure_expecting_fn_with_free_region(|x: fn(&u32), y| {});
+ //~^ ERROR type mismatch in closure arguments
+}
+
+fn expect_bound_supply_free_from_fn<'x>(x: &'x u32) {
+ // Here, we are given a `fn(&u32)` but we expect a `fn(&'x
+ // u32)`. In principle, this could be ok, but we demand equality.
+ with_closure_expecting_fn_with_bound_region(|x: fn(&'x u32), y| {});
+ //~^ ERROR type mismatch in closure arguments
+}
+
+fn expect_bound_supply_free_from_closure() {
+ // A variant on the previous test. Here, the region `'a` will be
+ // bound at the closure level, but we expect something bound at
+ // the argument level.
+ type Foo<'a> = fn(&'a u32);
+ with_closure_expecting_fn_with_bound_region(|_x: Foo<'_>, y| {});
+ //~^ ERROR type mismatch in closure arguments
+}
+
+fn expect_bound_supply_bound<'x>(x: &'x u32) {
+ // No error in this case. The supplied type supplies the bound
+ // regions, and hence we are able to figure out the type of `y`
+ // from the expected type
+ with_closure_expecting_fn_with_bound_region(|x: for<'z> fn(&'z u32), y| {
+ });
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn with_closure<F, A>(_: F)
+ where F: FnOnce(A, A)
+{
+}
+
+fn a() {
+ with_closure(|x: u32, y| {
+ // We deduce type of `y` from `x`.
+ });
+}
+
+fn b() {
+ // Here we take the supplied types, resulting in an error later on.
+ with_closure(|x: u32, y: i32| {
+ //~^ ERROR type mismatch in closure arguments
+ });
+}
+
+fn c() {
+ with_closure(|x, y: i32| {
+ // We deduce type of `x` from `y`.
+ });
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// must-compile-successfully
+
+fn with_closure<F, A>(_: F)
+ where F: FnOnce(A, &u32)
+{
+}
+
+fn foo() {
+ // This version works; we infer `A` to be `u32`, and take the type
+ // of `y` to be `&u32`.
+ with_closure(|x: u32, y| {});
+}
+
+fn bar() {
+ // This version also works.
+ with_closure(|x: &u32, y| {});
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// must-compile-successfully
+
+fn with_closure<F, A>(_: F)
+ where F: FnOnce(A, &u32)
+{
+}
+
+fn foo() {
+ // This version works; we infer `A` to be `u32`, and take the type
+ // of `y` to be `&u32`.
+ with_closure(|x: u32, y| {});
+}
+
+fn bar<'x>(x: &'x u32) {
+ // Same.
+ with_closure(|x: &'x u32, y| {});
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(warnings)]
+
+fn closure_expecting_bound<F>(_: F)
+ where F: FnOnce(&u32)
+{
+}
+
+fn closure_expecting_free<'a, F>(_: F)
+ where F: FnOnce(&'a u32)
+{
+}
+
+fn expect_bound_supply_nothing() {
+ // Because `x` is inferred to have a bound region, we cannot allow
+ // it to escape into `f`:
+ let mut f: Option<&u32> = None;
+ closure_expecting_bound(|x| {
+ f = Some(x); //~ ERROR E0495
+ });
+}
+
+fn expect_bound_supply_bound() {
+ // Because `x` is inferred to have a bound region, we cannot allow
+ // it to escape into `f`, even with an explicit type annotation on
+ // closure:
+ let mut f: Option<&u32> = None;
+ closure_expecting_bound(|x: &u32| {
+ f = Some(x); //~ ERROR E0495
+ });
+}
+
+fn expect_bound_supply_named<'x>() {
+ let mut f: Option<&u32> = None;
+
+ // Here we give a type annotation that `x` should be free. We get
+ // an error because of that.
+ closure_expecting_bound(|x: &'x u32| {
+ //~^ ERROR mismatched types
+ //~| ERROR mismatched types
+
+ // And we still cannot let `x` escape into `f`.
+ f = Some(x);
+ //~^ ERROR cannot infer
+ });
+}
+
+fn expect_free_supply_nothing() {
+ let mut f: Option<&u32> = None;
+ closure_expecting_free(|x| f = Some(x)); // OK
+}
+
+fn expect_free_supply_bound() {
+ let mut f: Option<&u32> = None;
+
+ // Here, even though the annotation `&u32` could be seen as being
+ // bound in the closure, we permit it to be defined as a free
+ // region (which is inferred to something in the fn body).
+ closure_expecting_free(|x: &u32| f = Some(x)); // OK
+}
+
+fn expect_free_supply_named<'x>() {
+ let mut f: Option<&u32> = None;
+
+ // Here, even though the annotation `&u32` could be seen as being
+ // bound in the closure, we permit it to be defined as a free
+ // region (which is inferred to something in the fn body).
+ closure_expecting_free(|x: &'x u32| f = Some(x)); // OK
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn with_closure<F, A, B>(_: F)
+ where F: FnOnce(A, B)
+{
+}
+
+fn a() {
+ // Type of `y` is unconstrained.
+ with_closure(|x: u32, y| {}); //~ ERROR E0282
+}
+
+fn b() {
+ with_closure(|x: u32, y: u32| {}); // OK
+}
+
+fn c() {
+ with_closure(|x: u32, y: u32| {}); // OK
+}
+
+fn main() { }
trait MyTrait { fn foo() {} }
+#[allow(auto_impl)]
impl MyTrait for .. {}
-//~^ ERROR redundant default implementations of trait `MyTrait`
+//~^ ERROR redundant auto implementations of trait `MyTrait`
+#[allow(auto_impl)]
impl MyTrait for .. {}
trait MySafeTrait {}
+#[allow(auto_impl)]
unsafe impl MySafeTrait for .. {}
//~^ ERROR implementing the trait `MySafeTrait` is not unsafe
unsafe trait MyUnsafeTrait {}
+#[allow(auto_impl)]
impl MyUnsafeTrait for .. {}
//~^ ERROR the trait `MyUnsafeTrait` requires an `unsafe impl` declaration
#![crate_type="rlib"]
#![allow(warnings)]
-mod a {
+pub mod a {
#[no_mangle]
pub extern fn fail() {
}
}
-mod b {
+pub mod b {
#[no_mangle]
pub extern fn fail() {
//~^ symbol `fail` is already defined
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//#![feature(non_exhaustive)]
+
+#[non_exhaustive] //~ERROR non exhaustive is an experimental feature (see issue #44109)
+pub enum NonExhaustiveEnum {
+ Unit,
+ Tuple(u32),
+ Struct { field: u32 }
+}
+
+fn main() { }
fn dummy(&self) {}
}
+auto trait AutoDummyTrait {}
+//~^ ERROR auto traits are experimental and possibly buggy
+
+#[allow(auto_impl)]
impl DummyTrait for .. {}
-//~^ ERROR default trait implementations are experimental and possibly buggy
+//~^ ERROR auto trait implementations are experimental and possibly buggy
impl !DummyTrait for DummyStruct {}
//~^ ERROR negative trait bounds are not yet fully implemented; use marker types for now
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(i128_type)]
+#![allow(const_err)] // this test is only about hard errors
+
+use std::{f32, f64};
+
+// Forces evaluation of constants, triggering hard error
+fn force<T>(_: T) {}
+
+fn main() {
+ { const X: u16 = -1. as u16; force(X); } //~ ERROR constant evaluation error
+ { const X: u128 = -100. as u128; force(X); } //~ ERROR constant evaluation error
+
+ { const X: i8 = f32::NAN as i8; force(X); } //~ ERROR constant evaluation error
+ { const X: i32 = f32::NAN as i32; force(X); } //~ ERROR constant evaluation error
+ { const X: u64 = f32::NAN as u64; force(X); } //~ ERROR constant evaluation error
+ { const X: u128 = f32::NAN as u128; force(X); } //~ ERROR constant evaluation error
+
+ { const X: i8 = f32::INFINITY as i8; force(X); } //~ ERROR constant evaluation error
+ { const X: u32 = f32::INFINITY as u32; force(X); } //~ ERROR constant evaluation error
+ { const X: i128 = f32::INFINITY as i128; force(X); } //~ ERROR constant evaluation error
+ { const X: u128 = f32::INFINITY as u128; force(X); } //~ ERROR constant evaluation error
+
+ { const X: u8 = f32::NEG_INFINITY as u8; force(X); } //~ ERROR constant evaluation error
+ { const X: u16 = f32::NEG_INFINITY as u16; force(X); } //~ ERROR constant evaluation error
+ { const X: i64 = f32::NEG_INFINITY as i64; force(X); } //~ ERROR constant evaluation error
+ { const X: i128 = f32::NEG_INFINITY as i128; force(X); } //~ ERROR constant evaluation error
+
+ { const X: i8 = f64::NAN as i8; force(X); } //~ ERROR constant evaluation error
+ { const X: i32 = f64::NAN as i32; force(X); } //~ ERROR constant evaluation error
+ { const X: u64 = f64::NAN as u64; force(X); } //~ ERROR constant evaluation error
+ { const X: u128 = f64::NAN as u128; force(X); } //~ ERROR constant evaluation error
+
+ { const X: i8 = f64::INFINITY as i8; force(X); } //~ ERROR constant evaluation error
+ { const X: u32 = f64::INFINITY as u32; force(X); } //~ ERROR constant evaluation error
+ { const X: i128 = f64::INFINITY as i128; force(X); } //~ ERROR constant evaluation error
+ { const X: u128 = f64::INFINITY as u128; force(X); } //~ ERROR constant evaluation error
+
+ { const X: u8 = f64::NEG_INFINITY as u8; force(X); } //~ ERROR constant evaluation error
+ { const X: u16 = f64::NEG_INFINITY as u16; force(X); } //~ ERROR constant evaluation error
+ { const X: i64 = f64::NEG_INFINITY as i64; force(X); } //~ ERROR constant evaluation error
+ { const X: i128 = f64::NEG_INFINITY as i128; force(X); } //~ ERROR constant evaluation error
+
+ { const X: u8 = 256. as u8; force(X); } //~ ERROR constant evaluation error
+ { const X: i8 = -129. as i8; force(X); } //~ ERROR constant evaluation error
+ { const X: i8 = 128. as i8; force(X); } //~ ERROR constant evaluation error
+ { const X: i32 = 2147483648. as i32; force(X); } //~ ERROR constant evaluation error
+ { const X: i32 = -2147483904. as i32; force(X); } //~ ERROR constant evaluation error
+ { const X: u32 = 4294967296. as u32; force(X); } //~ ERROR constant evaluation error
+ { const X: u128 = 1e40 as u128; force(X); } //~ ERROR constant evaluation error
+ { const X: i128 = 1e40 as i128; force(X); } //~ ERROR constant evaluation error
+}
\ No newline at end of file
fn c() {
}
-fn main() {}
+fn main() {
+ a();
+ b();
+ c();
+}
#![recursion_limit = "20"]
#![type_length_limit = "20000000"]
+#![crate_type = "rlib"]
#[derive(Clone)]
struct A (B);
pub fn matches() {
A(B::Variant1).matches(&(|| ()))
}
-
-fn main() {}
type Output;
}
+#[allow(auto_impl)]
unsafe impl Trait for .. {}
fn call_method<T: Trait>(x: T) {}
}
}
+#[allow(auto_impl)]
unsafe impl Trait for .. {}
fn call_method<T: Trait>(x: T) {
#![feature(core_intrinsics)]
#![allow(warnings)]
+#![crate_type = "rlib"]
use std::intrinsics;
#[derive(Copy, Clone)]
-struct Foo(i64);
-type Bar = &'static Fn();
-type Quux = [u8; 100];
+pub struct Foo(i64);
+pub type Bar = &'static Fn();
+pub type Quux = [u8; 100];
-unsafe fn test_bool_load(p: &mut bool, v: bool) {
+pub unsafe fn test_bool_load(p: &mut bool, v: bool) {
intrinsics::atomic_load(p);
//~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `bool`
}
-unsafe fn test_bool_store(p: &mut bool, v: bool) {
+pub unsafe fn test_bool_store(p: &mut bool, v: bool) {
intrinsics::atomic_store(p, v);
//~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `bool`
}
-unsafe fn test_bool_xchg(p: &mut bool, v: bool) {
+pub unsafe fn test_bool_xchg(p: &mut bool, v: bool) {
intrinsics::atomic_xchg(p, v);
//~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `bool`
}
-unsafe fn test_bool_cxchg(p: &mut bool, v: bool) {
+pub unsafe fn test_bool_cxchg(p: &mut bool, v: bool) {
intrinsics::atomic_cxchg(p, v, v);
//~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `bool`
}
-unsafe fn test_Foo_load(p: &mut Foo, v: Foo) {
+pub unsafe fn test_Foo_load(p: &mut Foo, v: Foo) {
intrinsics::atomic_load(p);
//~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `Foo`
}
-unsafe fn test_Foo_store(p: &mut Foo, v: Foo) {
+pub unsafe fn test_Foo_store(p: &mut Foo, v: Foo) {
intrinsics::atomic_store(p, v);
//~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `Foo`
}
-unsafe fn test_Foo_xchg(p: &mut Foo, v: Foo) {
+pub unsafe fn test_Foo_xchg(p: &mut Foo, v: Foo) {
intrinsics::atomic_xchg(p, v);
//~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `Foo`
}
-unsafe fn test_Foo_cxchg(p: &mut Foo, v: Foo) {
+pub unsafe fn test_Foo_cxchg(p: &mut Foo, v: Foo) {
intrinsics::atomic_cxchg(p, v, v);
//~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `Foo`
}
-unsafe fn test_Bar_load(p: &mut Bar, v: Bar) {
+pub unsafe fn test_Bar_load(p: &mut Bar, v: Bar) {
intrinsics::atomic_load(p);
//~^ ERROR expected basic integer type, found `&std::ops::Fn()`
}
-unsafe fn test_Bar_store(p: &mut Bar, v: Bar) {
+pub unsafe fn test_Bar_store(p: &mut Bar, v: Bar) {
intrinsics::atomic_store(p, v);
//~^ ERROR expected basic integer type, found `&std::ops::Fn()`
}
-unsafe fn test_Bar_xchg(p: &mut Bar, v: Bar) {
+pub unsafe fn test_Bar_xchg(p: &mut Bar, v: Bar) {
intrinsics::atomic_xchg(p, v);
//~^ ERROR expected basic integer type, found `&std::ops::Fn()`
}
-unsafe fn test_Bar_cxchg(p: &mut Bar, v: Bar) {
+pub unsafe fn test_Bar_cxchg(p: &mut Bar, v: Bar) {
intrinsics::atomic_cxchg(p, v, v);
//~^ ERROR expected basic integer type, found `&std::ops::Fn()`
}
-unsafe fn test_Quux_load(p: &mut Quux, v: Quux) {
+pub unsafe fn test_Quux_load(p: &mut Quux, v: Quux) {
intrinsics::atomic_load(p);
//~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `[u8; 100]`
}
-unsafe fn test_Quux_store(p: &mut Quux, v: Quux) {
+pub unsafe fn test_Quux_store(p: &mut Quux, v: Quux) {
intrinsics::atomic_store(p, v);
//~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `[u8; 100]`
}
-unsafe fn test_Quux_xchg(p: &mut Quux, v: Quux) {
+pub unsafe fn test_Quux_xchg(p: &mut Quux, v: Quux) {
intrinsics::atomic_xchg(p, v);
//~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `[u8; 100]`
}
-unsafe fn test_Quux_cxchg(p: &mut Quux, v: Quux) {
+pub unsafe fn test_Quux_cxchg(p: &mut Quux, v: Quux) {
intrinsics::atomic_cxchg(p, v, v);
//~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `[u8; 100]`
}
-
-fn main() {}
unsafe trait Zen {}
+#[allow(auto_impl)]
unsafe impl Zen for .. {}
unsafe impl<'a, T: 'a> Zen for &'a T where T: Sync {}
}
struct Ts(pub u8);
+#[allow(auto_impl)]
pub impl MarkerTr for .. {} //~ ERROR unnecessary visibility qualifier
pub impl Tr for S { //~ ERROR unnecessary visibility qualifier
pub fn f() {} //~ ERROR unnecessary visibility qualifier
}
struct Ts(pub u8);
+ #[allow(auto_impl)]
pub impl MarkerTr for .. {} //~ ERROR unnecessary visibility qualifier
pub impl Tr for S { //~ ERROR unnecessary visibility qualifier
pub fn f() {} //~ ERROR unnecessary visibility qualifier
}
struct Ts(pub u8);
+ #[allow(auto_impl)]
pub impl MarkerTr for .. {} //~ ERROR unnecessary visibility qualifier
pub impl Tr for S { //~ ERROR unnecessary visibility qualifier
pub fn f() {} //~ ERROR unnecessary visibility qualifier
}
fn take1<'a>(p: parameterized1) -> parameterized1<'a> { p }
-//~^ ERROR mismatched types
+//~^ ERROR explicit lifetime required in the type of `p`
fn take3(p: not_parameterized1) -> not_parameterized1 { p }
fn take4(p: not_parameterized2) -> not_parameterized2 { p }
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_type = "rlib"]
+#![feature(non_exhaustive)]
+
+#[non_exhaustive]
+pub enum NonExhaustiveEnum {
+ Unit,
+ Tuple(u32),
+ Struct { field: u32 }
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(non_exhaustive)]
+
+#[non_exhaustive]
+pub struct NormalStruct {
+ pub first_field: u16,
+ pub second_field: u16,
+}
+
+#[non_exhaustive]
+pub struct UnitStruct;
+
+#[non_exhaustive]
+pub struct TupleStruct(pub u16, pub u16);
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub struct FunctionalRecord {
+ pub first_field: u16,
+ pub second_field: u16,
+ pub third_field: bool
+}
+
+impl Default for FunctionalRecord {
+ fn default() -> FunctionalRecord {
+ FunctionalRecord { first_field: 640, second_field: 480, third_field: false }
+ }
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_type = "rlib"]
+#![feature(non_exhaustive)]
+
+pub enum NonExhaustiveVariants {
+ #[non_exhaustive] Unit,
+ #[non_exhaustive] Tuple(u32),
+ #[non_exhaustive] Struct { field: u32 }
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:enums.rs
+extern crate enums;
+
+use enums::NonExhaustiveEnum;
+
+fn main() {
+ let enum_unit = NonExhaustiveEnum::Unit;
+
+ match enum_unit {
+ //~^ ERROR non-exhaustive patterns: `_` not covered [E0004]
+ NonExhaustiveEnum::Unit => "first",
+ NonExhaustiveEnum::Tuple(_) => "second",
+ NonExhaustiveEnum::Struct { .. } => "third"
+ };
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:structs.rs
+extern crate structs;
+
+use structs::{NormalStruct, UnitStruct, TupleStruct, FunctionalRecord};
+
+fn main() {
+ let fr = FunctionalRecord {
+ //~^ ERROR cannot create non-exhaustive struct
+ first_field: 1920,
+ second_field: 1080,
+ ..FunctionalRecord::default()
+ };
+
+ let ns = NormalStruct { first_field: 640, second_field: 480 };
+ //~^ ERROR cannot create non-exhaustive struct
+
+ let NormalStruct { first_field, second_field } = ns;
+ //~^ ERROR `..` required with struct marked as non-exhaustive
+
+ let ts = TupleStruct(640, 480);
+ //~^ ERROR expected function, found struct `TupleStruct` [E0423]
+
+ let ts_explicit = structs::TupleStruct(640, 480);
+ //~^ ERROR tuple struct `TupleStruct` is private [E0603]
+
+ let TupleStruct { 0: first_field, 1: second_field } = ts;
+ //~^ ERROR `..` required with struct marked as non-exhaustive
+
+ let us = UnitStruct;
+ //~^ ERROR expected value, found struct `UnitStruct` [E0423]
+
+ let us_explicit = structs::UnitStruct;
+ //~^ ERROR unit struct `UnitStruct` is private [E0603]
+
+ let UnitStruct { } = us;
+ //~^ ERROR `..` required with struct marked as non-exhaustive
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:variants.rs
+extern crate variants;
+
+use variants::NonExhaustiveVariants;
+
+/*
+ * The initial implementation of #[non_exhaustive] (RFC 2008) does not include support for
+ * variants. See issue #44109 and PR 45394.
+ */
+// ignore-test
+
+fn main() {
+ let variant_struct = NonExhaustiveVariants::Struct { field: 640 };
+ //~^ ERROR cannot create non-exhaustive variant
+
+ let variant_tuple = NonExhaustiveVariants::Tuple { 0: 640 };
+ //~^ ERROR cannot create non-exhaustive variant
+
+ match variant_struct {
+ NonExhaustiveVariants::Unit => "",
+ NonExhaustiveVariants::Tuple(fe_tpl) => "",
+ //~^ ERROR `..` required with variant marked as non-exhaustive
+ NonExhaustiveVariants::Struct { field } => ""
+ //~^ ERROR `..` required with variant marked as non-exhaustive
+ };
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(non_exhaustive)]
+
+/*
+ * The initial implementation of #[non_exhaustive] (RFC 2008) does not include support for
+ * variants. See issue #44109 and PR 45394.
+ */
+
+pub enum NonExhaustiveVariants {
+ #[non_exhaustive] Unit,
+ //~^ ERROR #[non_exhaustive] is not yet supported on variants
+ #[non_exhaustive] Tuple(u32),
+ //~^ ERROR #[non_exhaustive] is not yet supported on variants
+ #[non_exhaustive] Struct { field: u32 }
+ //~^ ERROR #[non_exhaustive] is not yet supported on variants
+}
+
+fn main() { }
fn g(&self::S: &S) {}
fn h(&mut self::S: &mut S) {}
fn i(&'a self::S: &S) {} //~ ERROR unexpected lifetime `'a` in pattern
- //~^ ERROR expected one of `)` or `mut`, found `'a`
}
fn main() {}
trait Foo {}
+#[allow(auto_impl)]
default impl Foo for .. {}
-//~^ ERROR `default impl` is not allowed for default trait implementations
+//~^ ERROR `default impl` is not allowed for auto trait implementations
fn main() {}
trait Foo {}
+#[allow(auto_impl)]
impl Foo for .. {}
impl<T> Foo for T {}
trait Bar {}
+#[allow(auto_impl)]
impl Bar for .. {}
impl<T> !Bar for T {}
#![feature(optin_builtin_traits)]
-trait MyDefaultImpl {}
+trait MyAutoImpl {}
-impl<T> MyDefaultImpl for .. {}
-//~^ ERROR default trait implementations are not allowed to have generics
+#[allow(auto_impl)]
+impl<T> MyAutoImpl for .. {}
+//~^ ERROR auto trait implementations are not allowed to have generics
fn main() {}
#![feature(optin_builtin_traits)]
trait Magic: Copy {} //~ ERROR E0568
+#[allow(auto_impl)]
impl Magic for .. {}
fn copy<T: Magic>(x: T) -> (T, T) { (x, x) }
#![feature(optin_builtin_traits)]
trait Magic : Sized where Option<Self> : Magic {} //~ ERROR E0568
+#[allow(auto_impl)]
impl Magic for .. {}
impl<T:Magic> Magic for T {}
#![feature(optin_builtin_traits)]
trait Magic: Copy {} //~ ERROR E0568
+#[allow(auto_impl)]
impl Magic for .. {}
impl<T:Magic> Magic for T {}
#![feature(optin_builtin_traits)]
trait Magic<T> {} //~ ERROR E0567
+#[allow(auto_impl)]
impl Magic<isize> for .. {}
trait MyTrait {}
+#[allow(auto_impl)]
impl MyTrait for .. {}
struct MyS;
trait MyTrait {}
+#[allow(auto_impl)]
impl MyTrait for .. {}
impl<T> !MyTrait for *mut T {}
trait MyTrait {}
+#[allow(auto_impl)]
impl MyTrait for .. {}
unsafe trait MyUnsafeTrait {}
+#[allow(auto_impl)]
unsafe impl MyUnsafeTrait for .. {}
struct ThisImplsTrait;
#![feature(optin_builtin_traits)]
+#[allow(auto_impl)]
impl Copy for .. {} //~ ERROR E0318
//~^ NOTE `Copy` trait not defined in this crate
fn main() {}
#![feature(optin_builtin_traits)]
trait Defaulted { }
+#[allow(auto_impl)]
impl Defaulted for .. { }
impl<'a,T:Signed> Defaulted for &'a T { }
impl<'a,T:Signed> Defaulted for &'a mut T { }
// crate. This should not cause anything we use to be invalidated.
// Regression test for #36168.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
// aux-build:point.rs
+// must-compile-successfully
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
+#![crate_type = "rlib"]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_free_fn", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_free_fn", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="cfail2")]
extern crate point;
/// A fn item that calls (public) methods on `Point` from the same impl
-mod fn_calls_methods_in_same_impl {
+pub mod fn_calls_methods_in_same_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let x = Point { x: 2.0, y: 2.0 };
x.distance_from_origin();
}
/// A fn item that calls (public) methods on `Point` from another impl
-mod fn_calls_free_fn {
+pub mod fn_calls_free_fn {
use point::{self, Point};
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let x = Point { x: 2.0, y: 2.0 };
point::distance_squared(&x);
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn make_origin() -> Point {
Point { x: 2.0, y: 2.0 }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
// Fns with that type used only in their body are also recompiled, but
// their callers are not.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
+// must-compile-successfully
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
+#![crate_type = "rlib"]
// These are expected to require translation.
-#![rustc_partition_translated(module="struct_point-point", cfg="rpass2")]
-#![rustc_partition_translated(module="struct_point-fn_with_type_in_sig", cfg="rpass2")]
-#![rustc_partition_translated(module="struct_point-call_fn_with_type_in_sig", cfg="rpass2")]
-#![rustc_partition_translated(module="struct_point-fn_with_type_in_body", cfg="rpass2")]
-#![rustc_partition_translated(module="struct_point-fn_make_struct", cfg="rpass2")]
-#![rustc_partition_translated(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_translated(module="struct_point-fn_write_field", cfg="rpass2")]
-
-#![rustc_partition_reused(module="struct_point-call_fn_with_type_in_body", cfg="rpass2")]
-
-mod point {
- #[cfg(rpass1)]
+#![rustc_partition_translated(module="struct_point-point", cfg="cfail2")]
+#![rustc_partition_translated(module="struct_point-fn_with_type_in_sig", cfg="cfail2")]
+#![rustc_partition_translated(module="struct_point-call_fn_with_type_in_sig", cfg="cfail2")]
+#![rustc_partition_translated(module="struct_point-fn_with_type_in_body", cfg="cfail2")]
+#![rustc_partition_translated(module="struct_point-fn_make_struct", cfg="cfail2")]
+#![rustc_partition_translated(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_translated(module="struct_point-fn_write_field", cfg="cfail2")]
+
+#![rustc_partition_reused(module="struct_point-call_fn_with_type_in_body", cfg="cfail2")]
+
+pub mod point {
+ #[cfg(cfail1)]
pub struct Point {
pub x: f32,
pub y: f32,
}
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
pub struct Point {
pub x: f32,
pub y: f32,
impl Point {
pub fn origin() -> Point {
- #[cfg(rpass1)]
+ #[cfg(cfail1)]
return Point { x: 0.0, y: 0.0 };
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
return Point { x: 0.0, y: 0.0, z: 0.0 };
}
pub fn total(&self) -> f32 {
- #[cfg(rpass1)]
+ #[cfg(cfail1)]
return self.x + self.y;
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
return self.x + self.y + self.z;
}
/// sufficiently "private", we might not need to type-check again.
/// Rebuilding is probably always necessary since the layout may be
/// affected.
-mod fn_with_type_in_sig {
+pub mod fn_with_type_in_sig {
use point::Point;
- #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+ #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
pub fn boop(p: Option<&Point>) -> f32 {
p.map(|p| p.total()).unwrap_or(0.0)
}
/// sufficiently "private", we might not need to type-check again.
/// Rebuilding is probably always necessary since the layout may be
/// affected.
-mod call_fn_with_type_in_sig {
+pub mod call_fn_with_type_in_sig {
use fn_with_type_in_sig;
- #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+ #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
pub fn bip() -> f32 {
fn_with_type_in_sig::boop(None)
}
/// sufficiently "private", we might not need to type-check again.
/// Rebuilding is probably always necessary since the layout may be
/// affected.
-mod fn_with_type_in_body {
+pub mod fn_with_type_in_body {
use point::Point;
- #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+ #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
pub fn boop() -> f32 {
Point::origin().total()
}
/// body. In this case, the effects of the change should be contained
/// to Y; X should not have to be rebuilt, nor should it need to be
/// typechecked again.
-mod call_fn_with_type_in_body {
+pub mod call_fn_with_type_in_body {
use fn_with_type_in_body;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn bip() -> f32 {
fn_with_type_in_body::boop()
}
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+ #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
pub fn make_origin(p: Point) -> Point {
Point { ..p }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+ #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+ #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
// Test where we change the body of a private method in an impl.
// We then test what sort of functions must be rebuilt as a result.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
+// must-compile-successfully
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
+#![crate_type = "rlib"]
-#![rustc_partition_translated(module="struct_point-point", cfg="rpass2")]
+#![rustc_partition_translated(module="struct_point-point", cfg="cfail2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="cfail2")]
-mod point {
+pub mod point {
pub struct Point {
pub x: f32,
pub y: f32,
}
fn distance_squared(this: &Point) -> f32 {
- #[cfg(rpass1)]
+ #[cfg(cfail1)]
return this.x + this.y;
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
return this.x * this.x + this.y * this.y;
}
}
/// A fn item that calls (public) methods on `Point` from the same impl which changed
-mod fn_calls_methods_in_same_impl {
+pub mod fn_calls_methods_in_same_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let x = Point { x: 2.0, y: 2.0 };
x.distance_from_origin();
}
/// A fn item that calls (public) methods on `Point` from another impl
-mod fn_calls_methods_in_another_impl {
+pub mod fn_calls_methods_in_another_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let mut x = Point { x: 2.0, y: 2.0 };
x.translate(3.0, 3.0);
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn make_origin() -> Point {
Point { x: 2.0, y: 2.0 }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
}
fn distance_squared(this: &Point) -> f32 {
- #[cfg(rpass1)]
+ #[cfg(cfail1)]
return this.x + this.y;
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
return this.x * this.x + this.y * this.y;
}
// Test where we change the body of a private method in an impl.
// We then test what sort of functions must be rebuilt as a result.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
// aux-build:point.rs
+// must-compile-successfully
+#![crate_type = "rlib"]
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="cfail2")]
extern crate point;
/// A fn item that calls (public) methods on `Point` from the same impl which changed
-mod fn_calls_methods_in_same_impl {
+pub mod fn_calls_methods_in_same_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let x = Point { x: 2.0, y: 2.0 };
x.distance_from_origin();
}
/// A fn item that calls (public) methods on `Point` from another impl
-mod fn_calls_methods_in_another_impl {
+pub mod fn_calls_methods_in_another_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let mut x = Point { x: 2.0, y: 2.0 };
x.translate(3.0, 3.0);
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn make_origin() -> Point {
Point { x: 2.0, y: 2.0 }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
// Test where we change the body of a private method in an impl.
// We then test what sort of functions must be rebuilt as a result.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
+// must-compile-successfully
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
+#![crate_type = "rlib"]
-#![rustc_partition_translated(module="struct_point-point", cfg="rpass2")]
+#![rustc_partition_translated(module="struct_point-point", cfg="cfail2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="cfail2")]
-mod point {
+pub mod point {
pub struct Point {
pub x: f32,
pub y: f32,
}
impl Point {
- fn distance_squared(&self) -> f32 {
- #[cfg(rpass1)]
+ pub fn distance_squared(&self) -> f32 {
+ #[cfg(cfail1)]
return self.x + self.y;
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
return self.x * self.x + self.y * self.y;
}
}
/// A fn item that calls (public) methods on `Point` from the same impl which changed
-mod fn_calls_methods_in_same_impl {
+pub mod fn_calls_methods_in_same_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let x = Point { x: 2.0, y: 2.0 };
x.distance_from_origin();
}
/// A fn item that calls (public) methods on `Point` from another impl
-mod fn_calls_methods_in_another_impl {
+pub mod fn_calls_methods_in_another_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let mut x = Point { x: 2.0, y: 2.0 };
x.translate(3.0, 3.0);
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn make_origin() -> Point {
Point { x: 2.0, y: 2.0 }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
impl Point {
fn distance_squared(&self) -> f32 {
- #[cfg(rpass1)]
+ #[cfg(cfail1)]
return self.x + self.y;
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
return self.x * self.x + self.y * self.y;
}
// Test where we change the body of a private method in an impl.
// We then test what sort of functions must be rebuilt as a result.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
// aux-build:point.rs
+// must-compile-successfully
+#![crate_type = "rlib"]
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
-#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="cfail2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_same_impl", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_methods_in_another_impl", cfg="cfail2")]
extern crate point;
/// A fn item that calls (public) methods on `Point` from the same impl which changed
-mod fn_calls_methods_in_same_impl {
+pub mod fn_calls_methods_in_same_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let x = Point { x: 2.0, y: 2.0 };
x.distance_from_origin();
}
/// A fn item that calls (public) methods on `Point` from another impl
-mod fn_calls_methods_in_another_impl {
+pub mod fn_calls_methods_in_another_impl {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn dirty() {
let mut x = Point { x: 2.0, y: 2.0 };
x.translate(3.0, 3.0);
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn make_origin() -> Point {
Point { x: 2.0, y: 2.0 }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
// Test where we change the body of a public, inherent method.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
+// must-compile-successfully
+#![crate_type = "rlib"]
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
-#![rustc_partition_translated(module="struct_point-point", cfg="rpass2")]
+#![rustc_partition_translated(module="struct_point-point", cfg="cfail2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_changed_method", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_another_method", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_changed_method", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_another_method", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="cfail2")]
-mod point {
+pub mod point {
pub struct Point {
pub x: f32,
pub y: f32,
impl Point {
pub fn distance_from_origin(&self) -> f32 {
- #[cfg(rpass1)]
+ #[cfg(cfail1)]
return self.x * self.x + self.y * self.y;
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
return (self.x * self.x + self.y * self.y).sqrt();
}
}
/// A fn item that calls the method on `Point` which changed
-mod fn_calls_changed_method {
+pub mod fn_calls_changed_method {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let p = Point { x: 2.0, y: 2.0 };
p.distance_from_origin();
}
/// A fn item that calls a method on `Point` which did not change
-mod fn_calls_another_method {
+pub mod fn_calls_another_method {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let p = Point { x: 2.0, y: 2.0 };
p.x();
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn make_origin() -> Point {
Point { x: 2.0, y: 2.0 }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
// Test where we change the *signature* of a public, inherent method.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// compile-flags: -Z query-dep-graph
+// must-compile-successfully
+#![crate_type = "rlib"]
#![feature(rustc_attrs)]
#![feature(stmt_expr_attributes)]
#![allow(dead_code)]
// These are expected to require translation.
-#![rustc_partition_translated(module="struct_point-point", cfg="rpass2")]
-#![rustc_partition_translated(module="struct_point-fn_calls_changed_method", cfg="rpass2")]
+#![rustc_partition_translated(module="struct_point-point", cfg="cfail2")]
+#![rustc_partition_translated(module="struct_point-fn_calls_changed_method", cfg="cfail2")]
-#![rustc_partition_reused(module="struct_point-fn_calls_another_method", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="rpass2")]
-#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="rpass2")]
+#![rustc_partition_reused(module="struct_point-fn_calls_another_method", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_make_struct", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_read_field", cfg="cfail2")]
+#![rustc_partition_reused(module="struct_point-fn_write_field", cfg="cfail2")]
-mod point {
+pub mod point {
pub struct Point {
pub x: f32,
pub y: f32,
}
impl Point {
- #[cfg(rpass1)]
+ #[cfg(cfail1)]
pub fn distance_from_point(&self, p: Option<Point>) -> f32 {
let p = p.unwrap_or(Point { x: 0.0, y: 0.0 });
let x_diff = self.x - p.x;
return x_diff * x_diff + y_diff * y_diff;
}
- #[cfg(rpass2)]
+ #[cfg(cfail2)]
pub fn distance_from_point(&self, p: Option<&Point>) -> f32 {
const ORIGIN: &Point = &Point { x: 0.0, y: 0.0 };
let p = p.unwrap_or(ORIGIN);
}
/// A fn item that calls the method that was changed
-mod fn_calls_changed_method {
+pub mod fn_calls_changed_method {
use point::Point;
- #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+ #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let p = Point { x: 2.0, y: 2.0 };
p.distance_from_point(None);
}
/// A fn item that calls a method that was not changed
-mod fn_calls_another_method {
+pub mod fn_calls_another_method {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn check() {
let p = Point { x: 2.0, y: 2.0 };
p.x();
}
/// A fn item that makes an instance of `Point` but does not invoke methods
-mod fn_make_struct {
+pub mod fn_make_struct {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn make_origin() -> Point {
Point { x: 2.0, y: 2.0 }
}
}
/// A fn item that reads fields from `Point` but does not invoke methods
-mod fn_read_field {
+pub mod fn_read_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn get_x(p: Point) -> f32 {
p.x
}
}
/// A fn item that writes to a field of `Point` but does not invoke methods
-mod fn_write_field {
+pub mod fn_write_field {
use point::Point;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
pub fn inc_x(p: &mut Point) {
p.x += 1.0;
}
}
-
-fn main() {
-}
}
// Change UFCS Callee Indirectly -----------------------------------------------
-mod change_ufcs_callee_indirectly {
+pub mod change_ufcs_callee_indirectly {
#[cfg(cfail1)]
use super::Struct as Struct;
#[cfg(not(cfail1))]
#![crate_type="rlib"]
-enum Enum {
+pub enum Enum {
Struct {
x: i32,
y: i64,
// Change field value (struct-like) -----------------------------------------
#[cfg(cfail1)]
-fn change_field_value_struct_like() -> Enum {
+pub fn change_field_value_struct_like() -> Enum {
Enum::Struct {
x: 0,
y: 1,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_field_value_struct_like() -> Enum {
+pub fn change_field_value_struct_like() -> Enum {
Enum::Struct {
x: 0,
y: 2,
// Change field order (struct-like) -----------------------------------------
#[cfg(cfail1)]
-fn change_field_order_struct_like() -> Enum {
+pub fn change_field_order_struct_like() -> Enum {
Enum::Struct {
x: 3,
y: 4,
#[rustc_metadata_clean(cfg="cfail3")]
// FIXME(michaelwoerister):Interesting. I would have thought that that changes the MIR. And it
// would if it were not all constants
-fn change_field_order_struct_like() -> Enum {
+pub fn change_field_order_struct_like() -> Enum {
Enum::Struct {
y: 4,
x: 3,
}
-enum Enum2 {
+pub enum Enum2 {
Struct {
x: i8,
y: i8,
// Change constructor path (struct-like) ------------------------------------
#[cfg(cfail1)]
-fn change_constructor_path_struct_like() {
+pub fn change_constructor_path_struct_like() {
let _ = Enum::Struct {
x: 0,
y: 1,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_path_struct_like() {
+pub fn change_constructor_path_struct_like() {
let _ = Enum2::Struct {
x: 0,
y: 1,
// Change variant (regular struct) ------------------------------------
#[cfg(cfail1)]
-fn change_constructor_variant_struct_like() {
+pub fn change_constructor_variant_struct_like() {
let _ = Enum2::Struct {
x: 0,
y: 1,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_variant_struct_like() {
+pub fn change_constructor_variant_struct_like() {
let _ = Enum2::Struct2 {
x: 0,
y: 1,
// Change constructor path indirectly (struct-like) -------------------------
-mod change_constructor_path_indirectly_struct_like {
+pub mod change_constructor_path_indirectly_struct_like {
#[cfg(cfail1)]
use super::Enum as TheEnum;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_dirty(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> TheEnum {
+ pub fn function() -> TheEnum {
TheEnum::Struct {
x: 0,
y: 1,
// Change constructor variant indirectly (struct-like) ---------------------------
-mod change_constructor_variant_indirectly_struct_like {
+pub mod change_constructor_variant_indirectly_struct_like {
use super::Enum2;
#[cfg(cfail1)]
use super::Enum2::Struct as Variant;
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> Enum2 {
+ pub fn function() -> Enum2 {
Variant {
x: 0,
y: 1,
// Change field value (tuple-like) -------------------------------------------
#[cfg(cfail1)]
-fn change_field_value_tuple_like() -> Enum {
+pub fn change_field_value_tuple_like() -> Enum {
Enum::Tuple(0, 1, 2)
}
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_field_value_tuple_like() -> Enum {
+pub fn change_field_value_tuple_like() -> Enum {
Enum::Tuple(0, 1, 3)
}
// Change constructor path (tuple-like) --------------------------------------
#[cfg(cfail1)]
-fn change_constructor_path_tuple_like() {
+pub fn change_constructor_path_tuple_like() {
let _ = Enum::Tuple(0, 1, 2);
}
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_path_tuple_like() {
+pub fn change_constructor_path_tuple_like() {
let _ = Enum2::Tuple(0, 1, 2);
}
// Change constructor variant (tuple-like) --------------------------------------
#[cfg(cfail1)]
-fn change_constructor_variant_tuple_like() {
+pub fn change_constructor_variant_tuple_like() {
let _ = Enum2::Tuple(0, 1, 2);
}
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_variant_tuple_like() {
+pub fn change_constructor_variant_tuple_like() {
let _ = Enum2::Tuple2(0, 1, 2);
}
// Change constructor path indirectly (tuple-like) ---------------------------
-mod change_constructor_path_indirectly_tuple_like {
+pub mod change_constructor_path_indirectly_tuple_like {
#[cfg(cfail1)]
use super::Enum as TheEnum;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_dirty(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> TheEnum {
+ pub fn function() -> TheEnum {
TheEnum::Tuple(0, 1, 2)
}
}
// Change constructor variant indirectly (tuple-like) ---------------------------
-mod change_constructor_variant_indirectly_tuple_like {
+pub mod change_constructor_variant_indirectly_tuple_like {
use super::Enum2;
#[cfg(cfail1)]
use super::Enum2::Tuple as Variant;
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> Enum2 {
+ pub fn function() -> Enum2 {
Variant(0, 1, 2)
}
}
-enum Clike {
+pub enum Clike {
A,
B,
C
}
-enum Clike2 {
+pub enum Clike2 {
B,
C,
D
// Change constructor path (C-like) --------------------------------------
#[cfg(cfail1)]
-fn change_constructor_path_c_like() {
+pub fn change_constructor_path_c_like() {
let _ = Clike::B;
}
#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_path_c_like() {
+pub fn change_constructor_path_c_like() {
let _ = Clike2::B;
}
// Change constructor variant (C-like) --------------------------------------
#[cfg(cfail1)]
-fn change_constructor_variant_c_like() {
+pub fn change_constructor_variant_c_like() {
let _ = Clike::A;
}
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_variant_c_like() {
+pub fn change_constructor_variant_c_like() {
let _ = Clike::C;
}
// Change constructor path indirectly (C-like) ---------------------------
-mod change_constructor_path_indirectly_c_like {
+pub mod change_constructor_path_indirectly_c_like {
#[cfg(cfail1)]
use super::Clike as TheEnum;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_dirty(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> TheEnum {
+ pub fn function() -> TheEnum {
TheEnum::B
}
}
// Change constructor variant indirectly (C-like) ---------------------------
-mod change_constructor_variant_indirectly_c_like {
+pub mod change_constructor_variant_indirectly_c_like {
use super::Clike;
#[cfg(cfail1)]
use super::Clike::A as Variant;
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> Clike {
+ pub fn function() -> Clike {
Variant
}
}
#![feature(rustc_attrs)]
#![crate_type="rlib"]
-struct Foo;
+pub struct Foo;
// Change Method Name -----------------------------------------------------------
#[cfg(cfail1)]
#[rustc_metadata_clean(cfg="cfail3")]
pub fn add_trait_bound_to_impl_parameter(&self) { }
}
+
+
+// Force instantiation of some fns so we can check their hash.
+pub fn instantiation_root() {
+ Foo::method_privacy();
+
+ #[cfg(cfail1)]
+ {
+ Bar(0u32).change_impl_self_type();
+ }
+
+ #[cfg(not(cfail1))]
+ {
+ Bar(0u64).change_impl_self_type();
+ }
+}
}
+// shift left ------------------------------------------------------------------
+#[cfg(cfail1)]
+pub fn shift_left(val: i32, shift: usize) -> i32 {
+ val << shift
+}
+
+#[cfg(not(cfail1))]
+#[rustc_clean(label="Hir", cfg="cfail2")]
+#[rustc_clean(label="Hir", cfg="cfail3")]
+#[rustc_dirty(label="HirBody", cfg="cfail2")]
+#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_metadata_clean(cfg="cfail2")]
+#[rustc_metadata_clean(cfg="cfail3")]
+pub fn shift_left(val: i32, shift: usize) -> i32 {
+ val << shift
+}
+
+
+// shift right ------------------------------------------------------------------
+#[cfg(cfail1)]
+pub fn shift_right(val: i32, shift: usize) -> i32 {
+ val >> shift
+}
+
+#[cfg(not(cfail1))]
+#[rustc_clean(label="Hir", cfg="cfail2")]
+#[rustc_clean(label="Hir", cfg="cfail3")]
+#[rustc_dirty(label="HirBody", cfg="cfail2")]
+#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_metadata_clean(cfg="cfail2")]
+#[rustc_metadata_clean(cfg="cfail3")]
+pub fn shift_right(val: i32, shift: usize) -> i32 {
+ val >> shift
+}
+
// THE FOLLOWING ITEMS SHOULD NOT BE INFLUENCED BY THEIR SOURCE LOCATION
// bitwise ---------------------------------------------------------------------
#[cfg(cfail1)]
pub fn bitwise(val: i32) -> i32 {
- !val & 0x101010101 | 0x45689 ^ 0x2372382 << 1 >> 1
+ !val & 0x101010101 | 0x45689 ^ 0x2372382
}
#[cfg(not(cfail1))]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
pub fn bitwise(val: i32) -> i32 {
- !val & 0x101010101 | 0x45689 ^ 0x2372382 << 1 >> 1
+ !val & 0x101010101 | 0x45689 ^ 0x2372382
}
#![crate_type="rlib"]
-struct RegularStruct {
+pub struct RegularStruct {
x: i32,
y: i64,
z: i16,
// Change field value (regular struct) -----------------------------------------
#[cfg(cfail1)]
-fn change_field_value_regular_struct() -> RegularStruct {
+pub fn change_field_value_regular_struct() -> RegularStruct {
RegularStruct {
x: 0,
y: 1,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_field_value_regular_struct() -> RegularStruct {
+pub fn change_field_value_regular_struct() -> RegularStruct {
RegularStruct {
x: 0,
y: 2,
// Change field order (regular struct) -----------------------------------------
#[cfg(cfail1)]
-fn change_field_order_regular_struct() -> RegularStruct {
+pub fn change_field_order_regular_struct() -> RegularStruct {
RegularStruct {
x: 3,
y: 4,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_field_order_regular_struct() -> RegularStruct {
+pub fn change_field_order_regular_struct() -> RegularStruct {
RegularStruct {
y: 4,
x: 3,
// Add field (regular struct) --------------------------------------------------
#[cfg(cfail1)]
-fn add_field_regular_struct() -> RegularStruct {
+pub fn add_field_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
x: 3,
y: 4,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn add_field_regular_struct() -> RegularStruct {
+pub fn add_field_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
x: 3,
y: 4,
// Change field label (regular struct) -----------------------------------------
#[cfg(cfail1)]
-fn change_field_label_regular_struct() -> RegularStruct {
+pub fn change_field_label_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
x: 3,
y: 4,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_field_label_regular_struct() -> RegularStruct {
+pub fn change_field_label_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
x: 3,
y: 4,
-struct RegularStruct2 {
+pub struct RegularStruct2 {
x: i8,
y: i8,
z: i8,
// Change constructor path (regular struct) ------------------------------------
#[cfg(cfail1)]
-fn change_constructor_path_regular_struct() {
+pub fn change_constructor_path_regular_struct() {
let _ = RegularStruct {
x: 0,
y: 1,
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_path_regular_struct() {
+pub fn change_constructor_path_regular_struct() {
let _ = RegularStruct2 {
x: 0,
y: 1,
// Change constructor path indirectly (regular struct) -------------------------
-mod change_constructor_path_indirectly_regular_struct {
+pub mod change_constructor_path_indirectly_regular_struct {
#[cfg(cfail1)]
use super::RegularStruct as Struct;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_dirty(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> Struct {
+ pub fn function() -> Struct {
Struct {
x: 0,
y: 1,
-struct TupleStruct(i32, i64, i16);
+pub struct TupleStruct(i32, i64, i16);
// Change field value (tuple struct) -------------------------------------------
#[cfg(cfail1)]
-fn change_field_value_tuple_struct() -> TupleStruct {
+pub fn change_field_value_tuple_struct() -> TupleStruct {
TupleStruct(0, 1, 2)
}
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_field_value_tuple_struct() -> TupleStruct {
+pub fn change_field_value_tuple_struct() -> TupleStruct {
TupleStruct(0, 1, 3)
}
-struct TupleStruct2(u16, u16, u16);
+pub struct TupleStruct2(u16, u16, u16);
// Change constructor path (tuple struct) --------------------------------------
#[cfg(cfail1)]
-fn change_constructor_path_tuple_struct() {
+pub fn change_constructor_path_tuple_struct() {
let _ = TupleStruct(0, 1, 2);
}
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-fn change_constructor_path_tuple_struct() {
+pub fn change_constructor_path_tuple_struct() {
let _ = TupleStruct2(0, 1, 2);
}
// Change constructor path indirectly (tuple struct) ---------------------------
-mod change_constructor_path_indirectly_tuple_struct {
+pub mod change_constructor_path_indirectly_tuple_struct {
#[cfg(cfail1)]
use super::TupleStruct as Struct;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail3")]
#[rustc_metadata_dirty(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
- fn function() -> Struct {
+ pub fn function() -> Struct {
Struct(0, 1, 2)
}
}
// Add default implementation to method -------------------------------------------
#[cfg(cfail1)]
-trait TraitAddMethodDefaultImplementation {
+trait TraitAddMethodAutoImplementation {
fn method();
}
#[rustc_clean(label="Hir", cfg="cfail3")]
#[rustc_metadata_clean(cfg="cfail2")]
#[rustc_metadata_clean(cfg="cfail3")]
-trait TraitAddMethodDefaultImplementation {
+trait TraitAddMethodAutoImplementation {
#[rustc_dirty(label="Hir", cfg="cfail2")]
#[rustc_clean(label="Hir", cfg="cfail3")]
#[rustc_metadata_dirty(cfg="cfail2")]
// Check that the hash of `foo` doesn't change just because we ordered
// the nested items (or even added new ones).
-// revisions: rpass1 rpass2
+// revisions: cfail1 cfail2
+// must-compile-successfully
+#![crate_type = "rlib"]
#![feature(rustc_attrs)]
-#[cfg(rpass1)]
-fn foo() {
- fn bar() { }
- fn baz() { }
+#[cfg(cfail1)]
+pub fn foo() {
+ pub fn bar() { }
+ pub fn baz() { }
}
-#[cfg(rpass2)]
-#[rustc_clean(label="Hir", cfg="rpass2")]
-#[rustc_clean(label="HirBody", cfg="rpass2")]
-fn foo() {
- #[rustc_clean(label="Hir", cfg="rpass2")]
- #[rustc_clean(label="HirBody", cfg="rpass2")]
- fn baz() { } // order is different...
+#[cfg(cfail2)]
+#[rustc_clean(label="Hir", cfg="cfail2")]
+#[rustc_dirty(label="HirBody", cfg="cfail2")]
+pub fn foo() {
+ #[rustc_clean(label="Hir", cfg="cfail2")]
+ #[rustc_clean(label="HirBody", cfg="cfail2")]
+ pub fn baz() { } // order is different...
- #[rustc_clean(label="Hir", cfg="rpass2")]
- #[rustc_clean(label="HirBody", cfg="rpass2")]
- fn bar() { } // but that doesn't matter.
+ #[rustc_clean(label="Hir", cfg="cfail2")]
+ #[rustc_clean(label="HirBody", cfg="cfail2")]
+ pub fn bar() { } // but that doesn't matter.
- fn bap() { } // neither does adding a new item
+ pub fn bap() { } // neither does adding a new item
}
-
-fn main() { }
mod mod1 {
pub fn some_fn() {
- let _ = 1;
- }
+ #[cfg(rpass2)]
+ {}
- #[cfg(rpass2)]
- fn _some_other_fn() {
+ let _ = 1;
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: rpass1 rpass2
+// revisions: cfail1 cfail2
// compile-flags: -Z query-dep-graph
+// must-compile-successfully
#![allow(warnings)]
#![feature(rustc_attrs)]
-#![rustc_partition_reused(module="krate_inherent-x", cfg="rpass2")]
+#![rustc_partition_reused(module="krate_inherent-x", cfg="cfail2")]
+#![crate_type = "rlib"]
-fn main() { }
-
-mod x {
- struct Foo;
+pub mod x {
+ pub struct Foo;
impl Foo {
- fn foo(&self) { }
+ pub fn foo(&self) { }
}
- fn method() {
+ pub fn method() {
let x: Foo = Foo;
x.foo(); // inherent methods used to add an edge from Krate
}
}
-#[cfg(rpass1)]
-fn bar() { } // remove this unrelated fn in rpass2, which should not affect `x::method`
+#[cfg(cfail1)]
+pub fn bar() { } // remove this unrelated fn in cfail2, which should not affect `x::method`
#![rustc_partition_reused(module="krate_inlined-x", cfg="rpass2")]
fn main() {
+ x::method();
+
#[cfg(rpass2)]
()
}
mod x {
- fn method() {
+ pub fn method() {
// use some methods that require inlining HIR from another crate:
let mut v = vec![];
v.push(1);
// This test case makes sure that the compiler doesn't crash due to a failing
// table lookup when a source file is removed.
-// revisions:rpass1 rpass2
+// revisions:cfail1 cfail2
// Note that we specify -g so that the FileMaps actually get referenced by the
// incr. comp. cache:
// compile-flags: -Z query-dep-graph -g
+// must-compile-successfully
-#[cfg(rpass1)]
+#![crate_type= "rlib"]
+
+#[cfg(cfail1)]
mod auxiliary;
-#[cfg(rpass1)]
-fn main() {
+#[cfg(cfail1)]
+pub fn foo() {
auxiliary::print_hello();
}
-#[cfg(rpass2)]
-fn main() {
+#[cfg(cfail2)]
+pub fn foo() {
println!("hello");
}
// revisions:rpass1 rpass2
// compile-flags: -Z query-dep-graph -g
-#![rustc_partition_reused(module="spans_in_type_debuginfo", cfg="rpass2")]
#![rustc_partition_reused(module="spans_in_type_debuginfo-structs", cfg="rpass2")]
#![rustc_partition_reused(module="spans_in_type_debuginfo-enums", cfg="rpass2")]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: rpass1 rpass2
+// revisions: cfail1 cfail2
// compile-flags: -Z query-dep-graph
+// must-compile-successfully
#![allow(warnings)]
#![feature(rustc_attrs)]
+#![crate_type = "rlib"]
// Here the only thing which changes is the string constant in `x`.
// Therefore, the compiler deduces (correctly) that typeck is not
// needed even for callers of `x`.
-fn main() { }
-mod x {
- #[cfg(rpass1)]
+pub mod x {
+ #[cfg(cfail1)]
pub fn x() {
println!("{}", "1");
}
- #[cfg(rpass2)]
- #[rustc_dirty(label="HirBody", cfg="rpass2")]
- #[rustc_dirty(label="MirOptimized", cfg="rpass2")]
+ #[cfg(cfail2)]
+ #[rustc_dirty(label="HirBody", cfg="cfail2")]
+ #[rustc_dirty(label="MirOptimized", cfg="cfail2")]
pub fn x() {
println!("{}", "2");
}
}
-mod y {
+pub mod y {
use x;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
- #[rustc_clean(label="MirOptimized", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
+ #[rustc_clean(label="MirOptimized", cfg="cfail2")]
pub fn y() {
x::x();
}
}
-mod z {
+pub mod z {
use y;
- #[rustc_clean(label="TypeckTables", cfg="rpass2")]
- #[rustc_clean(label="MirOptimized", cfg="rpass2")]
+ #[rustc_clean(label="TypeckTables", cfg="cfail2")]
+ #[rustc_clean(label="MirOptimized", cfg="cfail2")]
pub fn z() {
y::y();
}
y
}
-fn main() { }
+fn main() {
+ // Make sure the function actually gets instantiated.
+ test(0);
+}
// END RUST SOURCE
// START rustc.node4.CopyPropagation.before.mir
Baz { x: a, y: 0.0, z: false }
}
-fn main() {}
+fn main() {
+ // Make sure the function actually gets instantiated.
+ bar(0);
+}
// END RUST SOURCE
// START rustc.node13.Deaggregator.before.mir
}
}
-fn main() {}
+fn main() {
+ // Make sure the function actually gets instantiated.
+ test1(false, 0);
+}
// END RUST SOURCE
// START rustc.node12.Deaggregator.before.mir
[Foo::A(x), Foo::A(x)]
}
-fn main() { }
+fn main() {
+ // Make sure the function actually gets instantiated.
+ test(0);
+}
// END RUST SOURCE
// START rustc.node10.Deaggregator.before.mir
let x = S.other(S.id());
}
+// no_mangle to make sure this gets instantiated even in an executable.
+#[no_mangle]
pub fn test() {
let u = S;
let mut v = S;
--- /dev/null
+// Copyright 2012-2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: -Z emit-end-regions -Z borrowck-mir
+
+fn guard() -> bool {
+ false
+}
+
+fn guard2(_:i32) -> bool {
+ true
+}
+
+// no_mangle to make sure this gets instantiated even in an executable.
+#[no_mangle]
+pub fn full_tested_match() {
+ let _ = match Some(42) {
+ Some(x) if guard() => (1, x),
+ Some(y) => (2, y),
+ None => (3, 3),
+ };
+}
+
+// no_mangle to make sure this gets instantiated even in an executable.
+#[no_mangle]
+pub fn full_tested_match2() {
+ let _ = match Some(42) {
+ Some(x) if guard() => (1, x),
+ None => (3, 3),
+ Some(y) => (2, y),
+ };
+}
+
+fn main() {
+ let _ = match Some(1) {
+ Some(_w) if guard() => 1,
+ _x => 2,
+ Some(y) if guard2(y) => 3,
+ _z => 4,
+ };
+}
+
+// END RUST SOURCE
+//
+// START rustc.node17.SimplifyBranches-initial.before.mir
+// bb0: {
+// ...
+// _2 = std::option::Option<i32>::Some(const 42i32,);
+// _5 = discriminant(_2);
+// switchInt(_5) -> [0isize: bb5, otherwise: bb3];
+// }
+// bb1: { // arm1
+// StorageLive(_7);
+// _7 = _3;
+// _1 = (const 1i32, _7);
+// StorageDead(_7);
+// goto -> bb11;
+// }
+// bb2: { // binding3(empty) and arm3
+// _1 = (const 3i32, const 3i32);
+// goto -> bb11;
+// }
+// bb3: {
+// falseEdges -> [real: bb7, imaginary: bb4]; //pre_binding1
+// }
+// bb4: {
+// falseEdges -> [real: bb10, imaginary: bb5]; //pre_binding2
+// }
+// bb5: {
+// falseEdges -> [real: bb2, imaginary: bb6]; //pre_binding3
+// }
+// bb6: {
+// unreachable;
+// }
+// bb7: { // binding1 and guard
+// StorageLive(_3);
+// _3 = ((_2 as Some).0: i32);
+// StorageLive(_6);
+// _6 = const guard() -> bb8;
+// }
+// bb8: { // end of guard
+// switchInt(_6) -> [0u8: bb9, otherwise: bb1];
+// }
+// bb9: { // to pre_binding2
+// falseEdges -> [real: bb4, imaginary: bb4];
+// }
+// bb10: { // bindingNoLandingPads.before.mir2 and arm2
+// StorageLive(_4);
+// _4 = ((_2 as Some).0: i32);
+// StorageLive(_8);
+// _8 = _4;
+// _1 = (const 2i32, _8);
+// StorageDead(_8);
+// goto -> bb11;
+// }
+// bb11: {
+// ...
+// return;
+// }
+// END rustc.node17.SimplifyBranches-initial.before.mir
+//
+// START rustc.node42.SimplifyBranches-initial.before.mir
+// bb0: {
+// ...
+// _2 = std::option::Option<i32>::Some(const 42i32,);
+// _5 = discriminant(_2);
+// switchInt(_5) -> [0isize: bb4, otherwise: bb3];
+// }
+// bb1: { // arm1
+// StorageLive(_7);
+// _7 = _3;
+// _1 = (const 1i32, _7);
+// StorageDead(_7);
+// goto -> bb11;
+// }
+// bb2: { // binding3(empty) and arm3
+// _1 = (const 3i32, const 3i32);
+// goto -> bb11;
+// }
+// bb3: {
+// falseEdges -> [real: bb7, imaginary: bb4]; //pre_binding1
+// }
+// bb4: {
+// falseEdges -> [real: bb2, imaginary: bb5]; //pre_binding2
+// }
+// bb5: {
+// falseEdges -> [real: bb10, imaginary: bb6]; //pre_binding3
+// }
+// bb6: {
+// unreachable;
+// }
+// bb7: { // binding1 and guard
+// StorageLive(_3);
+// _3 = ((_2 as Some).0: i32);
+// StorageLive(_6);
+// _6 = const guard() -> bb8;
+// }
+// bb8: { // end of guard
+// switchInt(_6) -> [0u8: bb9, otherwise: bb1];
+// }
+// bb9: { // to pre_binding2
+// falseEdges -> [real: bb5, imaginary: bb4];
+// }
+// bb10: { // binding2 and arm2
+// StorageLive(_4);
+// _4 = ((_2 as Some).0: i32);
+// StorageLive(_8);
+// _8 = _4;
+// _1 = (const 2i32, _8);
+// StorageDead(_8);
+// goto -> bb11;
+// }
+// bb11: {
+// ...
+// return;
+// }
+// END rustc.node42.SimplifyBranches-initial.before.mir
+//
+// START rustc.node67.SimplifyBranches-initial.before.mir
+// bb0: {
+// ...
+// _2 = std::option::Option<i32>::Some(const 1i32,);
+// _7 = discriminant(_2);
+// switchInt(_7) -> [1isize: bb3, otherwise: bb4];
+// }
+// bb1: { // arm1
+// _1 = const 1i32;
+// goto -> bb16;
+// }
+// bb2: { // arm3
+// _1 = const 3i32;
+// goto -> bb16;
+// }
+//
+// bb3: {
+// falseEdges -> [real: bb8, imaginary: bb4]; //pre_binding1
+// }
+// bb4: {
+// falseEdges -> [real: bb11, imaginary: bb5]; //pre_binding2
+// }
+// bb5: {
+// falseEdges -> [real: bb12, imaginary: bb6]; //pre_binding3
+// }
+// bb6: {
+// falseEdges -> [real: bb15, imaginary: bb7]; //pre_binding4
+// }
+// bb7: {
+// unreachable;
+// }
+// bb8: { // binding1: Some(w) if guard()
+// StorageLive(_3);
+// _3 = ((_2 as Some).0: i32);
+// StorageLive(_8);
+// _8 = const guard() -> bb9;
+// }
+// bb9: { //end of guard
+// switchInt(_8) -> [0u8: bb10, otherwise: bb1];
+// }
+// bb10: { // to pre_binding2
+// falseEdges -> [real: bb4, imaginary: bb4];
+// }
+// bb11: { // binding2 & arm2
+// StorageLive(_4);
+// _4 = _2;
+// _1 = const 2i32;
+// goto -> bb16;
+// }
+// bb12: { // binding3: Some(y) if guard2(y)
+// StorageLive(_5);
+// _5 = ((_2 as Some).0: i32);
+// StorageLive(_10);
+// StorageLive(_11);
+// _11 = _5;
+// _10 = const guard2(_11) -> bb13;
+// }
+// bb13: { // end of guard2
+// StorageDead(_11);
+// switchInt(_10) -> [0u8: bb14, otherwise: bb2];
+// }
+// bb14: { // to pre_binding4
+// falseEdges -> [real: bb6, imaginary: bb6];
+// }
+// bb15: { // binding4 & arm4
+// StorageLive(_6);
+// _6 = _2;
+// _1 = const 4i32;
+// goto -> bb16;
+// }
+// bb16: {
+// ...
+// return;
+// }
+// END rustc.node67.SimplifyBranches-initial.before.mir
--- /dev/null
+// Copyright 2012-2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Basic test for named lifetime translation. Check that we
+// instantiate the types that appear in function arguments with
+// suitable variables and that we setup the outlives relationship
+// between R0 and R1 properly.
+
+// compile-flags:-Znll -Zverbose
+// ^^^^^^^^^ force compiler to dump more region information
+// ignore-tidy-linelength
+
+#![allow(warnings)]
+
+fn use_x<'a, 'b: 'a, 'c>(w: &'a mut i32, x: &'b u32, y: &'a u32, z: &'c u32) -> bool { true }
+
+fn main() {
+}
+
+// END RUST SOURCE
+// START rustc.node4.nll.0.mir
+// | '_#0r: {bb0[0], bb0[1], '_#0r}
+// | '_#1r: {bb0[0], bb0[1], '_#0r, '_#1r}
+// | '_#2r: {bb0[0], bb0[1], '_#2r}
+// ...
+// fn use_x(_1: &'_#0r mut i32, _2: &'_#1r u32, _3: &'_#0r u32, _4: &'_#2r u32) -> bool {
+// END rustc.node4.nll.0.mir
// fn main::{{closure}}(_1: &ReErased [closure@NodeId(50)], _2: &ReErased mut i32) -> i32 {
// ...
// bb0: {
-// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(50)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]);
+// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(50)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
// StorageLive(_3);
// Validate(Suspend(ReScope(Remainder(BlockRemainder { block: ItemLocalId(22), first_statement_index: 0 }))), [(*_2): i32]);
// _3 = &ReErased (*_2);
// fn main::{{closure}}(_1: &ReErased [closure@NodeId(60)], _2: &ReErased mut i32) -> bool {
// ...
// bb0: {
-// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]);
-// Validate(Release, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]);
+// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
+// Validate(Release, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
// StorageLive(_3);
// ...
// _0 = const write_42(_3) -> bb1;
// fn main::{{closure}}(_1: &ReErased [closure@NodeId(46)], _2: &ReErased mut i32) -> bool {
// ...
// bb0: {
-// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(46)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrAnon(1)) mut i32]);
+// Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(46)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
// StorageLive(_3);
// StorageLive(_4);
// Validate(Suspend(ReScope(Node(ItemLocalId(9)))), [(*_2): i32]);
impl S {
fn f(*, a: u8) -> u8 {} //~ ERROR expected pattern, found `*`
- //~^ ERROR expected one of `)`, `-`, `box`, `false`, `mut`, `ref`, or `true`, found `*`
}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(optin_builtin_traits)]
+
+// pp-exact
+
+auto trait MyTrait { }
+
+unsafe auto trait UnsafeMyTrait { }
+
+pub fn main() { }
--- /dev/null
+#![feature(prelude_import)]
+#![no_std]
+#[prelude_import]
+use std::prelude::v1::*;
+#[macro_use]
+extern crate std as std;
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-compare-only
+// pretty-mode:expanded
+// pp-exact:cast-lt.pp
+
+macro_rules! negative(( $ e : expr ) => { $ e < 0 });
+
+fn main() { (1 as i32) < 0; }
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-compare-only
+// pretty-mode:expanded
+// pp-exact:cast-lt.pp
+
+macro_rules! negative {
+ ($e:expr) => { $e < 0 }
+}
+
+fn main() {
+ negative!(1 as i32);
+}
+
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(optin_builtin_traits)]
-
-// pp-exact
-
-trait MyTrait { }
-
-impl MyTrait for .. { }
-
-pub fn main() { }
--- /dev/null
+# Test that allocator-related symbols don't show up as exported from a cdylib as
+# they're internal to Rust and not part of the public ABI.
+
+-include ../tools.mk
+
+ifdef IS_MSVC
+all:
+ true
+else
+all:
+ $(RUSTC) foo.rs
+ nm -g "$(call DYLIB,foo)"
+ nm -g "$(call DYLIB,foo)" | grep -vq __rdl_
+ nm -g "$(call DYLIB,foo)" | grep -vq __rde_
+ nm -g "$(call DYLIB,foo)" | grep -vq __rg_
+ nm -g "$(call DYLIB,foo)" | grep -vq __rust_
+endif
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_type = "cdylib"]
+
+#[no_mangle]
+pub extern fn foo() -> u32 {
+ 3
+}
all:
$(RUSTC) -C extra-filename=bar foo.rs -C save-temps
- rm $(TMPDIR)/foobar.foo0.rust-cgu.o
+ rm $(TMPDIR)/foobar.foo0.rcgu.o
rm $(TMPDIR)/$(call BIN,foobar)
fn inner() -> u32 {
8675309
}
+ inner();
}
extern "C" fn outer_foreign<T>() {
fn inner() -> u32 {
11235813
}
+ inner();
}
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+
+
fn magic_fn() -> usize {
1234
}
}
}
-fn main() { }
+fn main() {
+ magic_fn();
+ a::magic_fn();
+ b::magic_fn();
+}
#[lang = "freeze"]
trait Freeze {}
+#[allow(auto_impl)]
impl Freeze for .. {}
trait Foo { fn dummy(&self) { } }
impl Foo for usize {}
-pub fn dummy() {
+#[no_mangle]
+pub extern "C" fn dummy() {
// force the vtable to be created
let _x = &1usize as &Foo;
}
Def { id: id }
}
}
+
+#[no_mangle]
+pub fn user() {
+ let _ = Def::new(0);
+}
#[lang = "freeze"]
trait Freeze {}
+#[allow(auto_impl)]
impl Freeze for .. {}
#[lang="start"]
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+macro_rules! auto {
+ () => (struct S;)
+}
+
+auto!();
+
+fn auto() {}
+
+fn main() {
+ auto();
+ let auto = 10;
+ auto;
+ auto as u8;
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(optin_builtin_traits)]
+
+auto trait Auto {}
+// Redundant but accepted until we remove it.
+#[allow(auto_impl)]
+impl Auto for .. {}
+
+unsafe auto trait AutoUnsafe {}
+
+impl !Auto for bool {}
+impl !AutoUnsafe for bool {}
+
+struct AutoBool(bool);
+
+impl Auto for AutoBool {}
+unsafe impl AutoUnsafe for AutoBool {}
+
+fn take_auto<T: Auto>(_: T) {}
+fn take_auto_unsafe<T: AutoUnsafe>(_: T) {}
+
+fn main() {
+ take_auto(0);
+ take_auto(AutoBool(true));
+ take_auto_unsafe(0);
+ take_auto_unsafe(AutoBool(true));
+}
--- /dev/null
+Some tests targeted at how we deduce the types of closure arguments.
+This process is a result of some heuristics aimed at combining the
+*expected type* we have with the *actual types* that we get from
+inputs. This investigation was kicked off by #38714, which revealed
+some pretty deep flaws in the ad-hoc way that we were doing things
+before.
+
+See also `src/test/compile-fail/closure-expected-type`.
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn with_closure<A, F>(_: F)
+ where F: FnOnce(Vec<A>, A)
+{
+}
+
+fn expect_free_supply_free<'x>(x: &'x u32) {
+ with_closure(|mut x: Vec<_>, y| {
+ // Shows that the call to `x.push()` is influencing type of `y`...
+ x.push(22_u32);
+
+ // ...since we now know the type of `y` and can resolve the method call.
+ y.wrapping_add(1);
+ });
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct UsizeRef<'a> {
+ a: &'a usize
+}
+
+type RefTo = Box<for<'r> Fn(&'r Vec<usize>) -> UsizeRef<'r>>;
+
+fn ref_to<'a>(vec: &'a Vec<usize>) -> UsizeRef<'a> {
+ UsizeRef{ a: &vec[0]}
+}
+
+fn main() {
+ // Regression test: this was causing ICEs; it should compile.
+ let a: RefTo = Box::new(|vec: &Vec<usize>| {
+ UsizeRef{ a: &vec[0] }
+ });
+}
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn with_closure<F, R>(f: F) -> Result<char, R>
+ where F: FnOnce(&char) -> Result<char, R>,
+{
+ f(&'a')
+}
+
+fn main() {
+ // Test that supplying the `-> Result<char, ()>` manually here
+ // (which is needed to constrain `R`) still allows us to figure
+ // out that the type of `x` is `&'a char` where `'a` is bound in
+ // the closure (if we didn't, we'd get a type-error because
+ // `with_closure` requires a bound region).
+ //
+ // This pattern was found in the wild.
+ let z = with_closure(|x| -> Result<char, ()> { Ok(*x) });
+ assert_eq!(z.unwrap(), 'a');
+
+ // It also works with `_`:
+ let z = with_closure(|x: _| -> Result<char, ()> { Ok(*x) });
+ assert_eq!(z.unwrap(), 'a');
+
+ // It also works with `&_`:
+ let z = with_closure(|x: &_| -> Result<char, ()> { Ok(*x) });
+ assert_eq!(z.unwrap(), 'a');
+}
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn with_closure<F>(f: F) -> u32
+ where F: FnOnce(&u32, &u32) -> u32
+{
+ f(&22, &44)
+}
+
+fn main() {
+ let z = with_closure(|x, y| x + y).wrapping_add(1);
+ assert_eq!(z, 22 + 44 + 1);
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This test deserializes an enum in-place by transmuting to a union that
+// should have the same layout, and manipulating the tag and payloads
+// independently. This verifies that `repr(some_int)` has a stable representation,
+// and that we don't miscompile these kinds of manipulations.
+
+use std::time::Duration;
+use std::mem;
+
+#[repr(u8)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+enum MyEnum {
+ A(u32), // Single primitive value
+ B { x: u8, y: i16 }, // Composite, and the offset of `y` depends on tag being internal
+ C, // Empty
+ D(Option<u32>), // Contains an enum
+ E(Duration), // Contains a struct
+}
+
+#[allow(non_snake_case)]
+#[repr(C)]
+union MyEnumRepr {
+ A: MyEnumVariantA,
+ B: MyEnumVariantB,
+ C: MyEnumVariantC,
+ D: MyEnumVariantD,
+ E: MyEnumVariantE,
+}
+
+#[repr(u8)] #[derive(Copy, Clone)] enum MyEnumTag { A, B, C, D, E }
+#[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantA(MyEnumTag, u32);
+#[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantB { tag: MyEnumTag, x: u8, y: i16 }
+#[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantC(MyEnumTag);
+#[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantD(MyEnumTag, Option<u32>);
+#[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantE(MyEnumTag, Duration);
+
+fn main() {
+ let result: Vec<Result<MyEnum, ()>> = vec![
+ Ok(MyEnum::A(17)),
+ Ok(MyEnum::B { x: 206, y: 1145 }),
+ Ok(MyEnum::C),
+ Err(()),
+ Ok(MyEnum::D(Some(407))),
+ Ok(MyEnum::D(None)),
+ Ok(MyEnum::E(Duration::from_secs(100))),
+ Err(()),
+ ];
+
+ // Binary serialized version of the above (little-endian)
+ let input: Vec<u8> = vec![
+ 0, 17, 0, 0, 0,
+ 1, 206, 121, 4,
+ 2,
+ 8, /* invalid tag value */
+ 3, 0, 151, 1, 0, 0,
+ 3, 1,
+ 4, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, /* incomplete value */
+ ];
+
+ let mut output = vec![];
+ let mut buf = &input[..];
+
+ unsafe {
+ // This should be safe, because we don't match on it unless it's fully formed,
+ // and it doesn't have a destructor.
+ let mut dest: MyEnum = mem::uninitialized();
+ while buf.len() > 0 {
+ match parse_my_enum(&mut dest, &mut buf) {
+ Ok(()) => output.push(Ok(dest)),
+ Err(()) => output.push(Err(())),
+ }
+ }
+ }
+
+ assert_eq!(output, result);
+}
+
+fn parse_my_enum<'a>(dest: &'a mut MyEnum, buf: &mut &[u8]) -> Result<(), ()> {
+ unsafe {
+ // Should be correct to do this transmute.
+ let dest: &'a mut MyEnumRepr = mem::transmute(dest);
+ let tag = read_u8(buf)?;
+
+ dest.A.0 = match tag {
+ 0 => MyEnumTag::A,
+ 1 => MyEnumTag::B,
+ 2 => MyEnumTag::C,
+ 3 => MyEnumTag::D,
+ 4 => MyEnumTag::E,
+ _ => return Err(()),
+ };
+
+ match dest.B.tag {
+ MyEnumTag::A => {
+ dest.A.1 = read_u32_le(buf)?;
+ }
+ MyEnumTag::B => {
+ dest.B.x = read_u8(buf)?;
+ dest.B.y = read_u16_le(buf)? as i16;
+ }
+ MyEnumTag::C => {
+ /* do nothing */
+ }
+ MyEnumTag::D => {
+ let is_some = read_u8(buf)? == 0;
+ if is_some {
+ dest.D.1 = Some(read_u32_le(buf)?);
+ } else {
+ dest.D.1 = None;
+ }
+ }
+ MyEnumTag::E => {
+ let secs = read_u64_le(buf)?;
+ let nanos = read_u32_le(buf)?;
+ dest.E.1 = Duration::new(secs, nanos);
+ }
+ }
+ Ok(())
+ }
+}
+
+
+
+// reader helpers
+
+fn read_u64_le(buf: &mut &[u8]) -> Result<u64, ()> {
+ if buf.len() < 8 { return Err(()) }
+ let val = (buf[0] as u64) << 0
+ | (buf[1] as u64) << 8
+ | (buf[2] as u64) << 16
+ | (buf[3] as u64) << 24
+ | (buf[4] as u64) << 32
+ | (buf[5] as u64) << 40
+ | (buf[6] as u64) << 48
+ | (buf[7] as u64) << 56;
+ *buf = &buf[8..];
+ Ok(val)
+}
+
+fn read_u32_le(buf: &mut &[u8]) -> Result<u32, ()> {
+ if buf.len() < 4 { return Err(()) }
+ let val = (buf[0] as u32) << 0
+ | (buf[1] as u32) << 8
+ | (buf[2] as u32) << 16
+ | (buf[3] as u32) << 24;
+ *buf = &buf[4..];
+ Ok(val)
+}
+
+fn read_u16_le(buf: &mut &[u8]) -> Result<u16, ()> {
+ if buf.len() < 2 { return Err(()) }
+ let val = (buf[0] as u16) << 0
+ | (buf[1] as u16) << 8;
+ *buf = &buf[2..];
+ Ok(val)
+}
+
+fn read_u8(buf: &mut &[u8]) -> Result<u8, ()> {
+ if buf.len() < 1 { return Err(()) }
+ let val = buf[0];
+ *buf = &buf[1..];
+ Ok(val)
+}
#![feature(optin_builtin_traits)]
trait NotSame {}
+#[allow(auto_impl)]
impl NotSame for .. {}
impl<A> !NotSame for (A, A) {}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags:--test -g
+
+use std::{env, panic, fs};
+
+#[cfg(target_os = "macos")]
+#[test]
+fn simple_test() {
+ // Find our dSYM and replace the DWARF binary with an empty file
+ let mut dsym_path = env::current_exe().unwrap();
+ let executable_name = dsym_path.file_name().unwrap().to_str().unwrap().to_string();
+ assert!(dsym_path.pop()); // Pop executable
+ dsym_path.push(format!("{}.dSYM/Contents/Resources/DWARF/{0}", executable_name));
+ {
+ let file = fs::OpenOptions::new().read(false).write(true).truncate(true).create(false)
+ .open(&dsym_path).unwrap();
+ }
+
+ env::set_var("RUST_BACKTRACE", "1");
+
+ // We don't need to die of panic, just trigger a backtrace
+ let _ = panic::catch_unwind(|| {
+ assert!(false);
+ });
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags:-Zmir-opt-level=2
+
+trait Array {
+ type Item;
+}
+
+fn foo<A: Array>() {
+ let _: *mut A::Item = std::ptr::null_mut();
+}
+
+struct Foo;
+impl Array for Foo { type Item = i32; }
+
+fn main() {
+ foo::<Foo>();
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: -C debug_assertions=yes
+
+#![feature(i128_type)]
+
+use std::panic;
+
+fn main() {
+ macro_rules! overflow_test {
+ ($t:ident) => (
+ let r = panic::catch_unwind(|| {
+ ($t::max_value()).next_power_of_two()
+ });
+ assert!(r.is_err());
+
+ let r = panic::catch_unwind(|| {
+ (($t::max_value() >> 1) + 2).next_power_of_two()
+ });
+ assert!(r.is_err());
+ )
+ }
+ overflow_test!(u8);
+ overflow_test!(u16);
+ overflow_test!(u32);
+ overflow_test!(u64);
+ overflow_test!(u128);
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: -C debug_assertions=no
+
+#![feature(i128_type)]
+
+fn main() {
+ for i in 129..256 {
+ assert_eq!((i as u8).next_power_of_two(), 0);
+ }
+
+ assert_eq!(((1u16 << 15) + 1).next_power_of_two(), 0);
+ assert_eq!(((1u32 << 31) + 1).next_power_of_two(), 0);
+ assert_eq!(((1u64 << 63) + 1).next_power_of_two(), 0);
+ assert_eq!(((1u128 << 127) + 1).next_power_of_two(), 0);
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_type = "rlib"]
+#![feature(non_exhaustive)]
+
+#[non_exhaustive]
+pub enum NonExhaustiveEnum {
+ Unit,
+ Tuple(u32),
+ Struct { field: u32 }
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(non_exhaustive)]
+
+#[non_exhaustive]
+pub struct NormalStruct {
+ pub first_field: u16,
+ pub second_field: u16,
+}
+
+#[non_exhaustive]
+pub struct UnitStruct;
+
+#[non_exhaustive]
+pub struct TupleStruct (pub u16, pub u16);
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_type = "rlib"]
+#![feature(non_exhaustive)]
+
+pub enum NonExhaustiveVariants {
+ #[non_exhaustive] Unit,
+ #[non_exhaustive] Tuple(u32),
+ #[non_exhaustive] Struct { field: u32 }
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:enums.rs
+extern crate enums;
+
+// ignore-pretty issue #37199
+
+use enums::NonExhaustiveEnum;
+
+fn main() {
+ let enum_unit = NonExhaustiveEnum::Unit;
+
+ match enum_unit {
+ NonExhaustiveEnum::Unit => 1,
+ NonExhaustiveEnum::Tuple(_) => 2,
+ // This particular arm tests that a enum marked as non-exhaustive
+ // will not error if its variants are matched exhaustively.
+ NonExhaustiveEnum::Struct { field } => field,
+ _ => 0 // no error with wildcard
+ };
+
+ match enum_unit {
+ _ => "no error with only wildcard"
+ };
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(non_exhaustive)]
+
+#[non_exhaustive]
+pub enum NonExhaustiveEnum {
+ Unit,
+ Tuple(u32),
+ Struct { field: u32 }
+}
+
+fn main() {
+ let enum_unit = NonExhaustiveEnum::Unit;
+
+ match enum_unit {
+ NonExhaustiveEnum::Unit => "first",
+ NonExhaustiveEnum::Tuple(_) => "second",
+ NonExhaustiveEnum::Struct { .. } => "third",
+ };
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:structs.rs
+extern crate structs;
+
+use structs::{NormalStruct, UnitStruct, TupleStruct};
+
+// We only test matching here as we cannot create non-exhaustive
+// structs from another crate. ie. they'll never pass in run-pass tests.
+
+fn match_structs(ns: NormalStruct, ts: TupleStruct, us: UnitStruct) {
+ let NormalStruct { first_field, second_field, .. } = ns;
+
+ let TupleStruct { 0: first, 1: second, .. } = ts;
+
+ let UnitStruct { .. } = us;
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(non_exhaustive)]
+
+#[non_exhaustive]
+pub struct NormalStruct {
+ pub first_field: u16,
+ pub second_field: u16,
+}
+
+#[non_exhaustive]
+pub struct UnitStruct;
+
+#[non_exhaustive]
+pub struct TupleStruct (pub u16, pub u16);
+
+fn main() {
+ let ns = NormalStruct { first_field: 640, second_field: 480 };
+
+ let NormalStruct { first_field, second_field } = ns;
+
+ let ts = TupleStruct { 0: 340, 1: 480 };
+ let ts_constructor = TupleStruct(340, 480);
+
+ let TupleStruct { 0: first, 1: second } = ts;
+ let TupleStruct(first, second) = ts_constructor;
+
+ let us = UnitStruct {};
+ let us_constructor = UnitStruct;
+
+ let UnitStruct { } = us;
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:variants.rs
+extern crate variants;
+
+use variants::NonExhaustiveVariants;
+
+/*
+ * The initial implementation of #[non_exhaustive] (RFC 2008) does not include support for
+ * variants. See issue #44109 and PR 45394.
+ */
+// ignore-test
+
+fn main() {
+ let variant_tuple = NonExhaustiveVariants::Tuple { 0: 340 };
+ let variant_struct = NonExhaustiveVariants::Struct { field: 340 };
+
+ match variant_struct {
+ NonExhaustiveVariants::Unit => "",
+ NonExhaustiveVariants::Struct { field, .. } => "",
+ NonExhaustiveVariants::Tuple(fe_tpl, ..) => ""
+ };
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(non_exhaustive)]
+
+/*
+ * The initial implementation of #[non_exhaustive] (RFC 2008) does not include support for
+ * variants. See issue #44109 and PR 45394.
+ */
+// ignore-test
+
+pub enum NonExhaustiveVariants {
+ #[non_exhaustive] Unit,
+ #[non_exhaustive] Tuple(u32),
+ #[non_exhaustive] Struct { field: u32 }
+}
+
+fn main() {
+ let variant_tuple = NonExhaustiveVariants::Tuple(340);
+ let variant_struct = NonExhaustiveVariants::Struct { field: 340 };
+
+ match variant_tuple {
+ NonExhaustiveVariants::Unit => "",
+ NonExhaustiveVariants::Tuple(fe_tpl) => "",
+ NonExhaustiveVariants::Struct { field } => ""
+ };
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: -Z saturating-float-casts
+
+#![feature(test, i128, i128_type, stmt_expr_attributes)]
+#![deny(overflowing_literals)]
+extern crate test;
+
+use std::{f32, f64};
+use std::{u8, i8, u16, i16, u32, i32, u64, i64};
+#[cfg(not(target_os="emscripten"))]
+use std::{u128, i128};
+use test::black_box;
+
+macro_rules! test {
+ ($val:expr, $src_ty:ident -> $dest_ty:ident, $expected:expr) => (
+ // black_box disables constant evaluation to test run-time conversions:
+ assert_eq!(black_box::<$src_ty>($val) as $dest_ty, $expected,
+ "run-time {} -> {}", stringify!($src_ty), stringify!($dest_ty));
+ );
+
+ ($fval:expr, f* -> $ity:ident, $ival:expr) => (
+ test!($fval, f32 -> $ity, $ival);
+ test!($fval, f64 -> $ity, $ival);
+ )
+}
+
+// This macro tests const eval in addition to run-time evaluation.
+// If and when saturating casts are adopted, this macro should be merged with test!() to ensure
+// that run-time and const eval agree on inputs that currently trigger a const eval error.
+macro_rules! test_c {
+ ($val:expr, $src_ty:ident -> $dest_ty:ident, $expected:expr) => ({
+ test!($val, $src_ty -> $dest_ty, $expected);
+ {
+ const X: $src_ty = $val;
+ const Y: $dest_ty = X as $dest_ty;
+ assert_eq!(Y, $expected,
+ "const eval {} -> {}", stringify!($src_ty), stringify!($dest_ty));
+ }
+ });
+
+ ($fval:expr, f* -> $ity:ident, $ival:expr) => (
+ test!($fval, f32 -> $ity, $ival);
+ test!($fval, f64 -> $ity, $ival);
+ )
+}
+
+macro_rules! common_fptoi_tests {
+ ($fty:ident -> $($ity:ident)+) => ({ $(
+ test!($fty::NAN, $fty -> $ity, 0);
+ test!($fty::INFINITY, $fty -> $ity, $ity::MAX);
+ test!($fty::NEG_INFINITY, $fty -> $ity, $ity::MIN);
+ // These two tests are not solely float->int tests, in particular the latter relies on
+ // `u128::MAX as f32` not being UB. But that's okay, since this file tests int->float
+ // as well, the test is just slightly misplaced.
+ test!($ity::MIN as $fty, $fty -> $ity, $ity::MIN);
+ test!($ity::MAX as $fty, $fty -> $ity, $ity::MAX);
+ test_c!(0., $fty -> $ity, 0);
+ test_c!($fty::MIN_POSITIVE, $fty -> $ity, 0);
+ test!(-0.9, $fty -> $ity, 0);
+ test_c!(1., $fty -> $ity, 1);
+ test_c!(42., $fty -> $ity, 42);
+ )+ });
+
+ (f* -> $($ity:ident)+) => ({
+ common_fptoi_tests!(f32 -> $($ity)+);
+ common_fptoi_tests!(f64 -> $($ity)+);
+ })
+}
+
+macro_rules! fptoui_tests {
+ ($fty: ident -> $($ity: ident)+) => ({ $(
+ test!(-0., $fty -> $ity, 0);
+ test!(-$fty::MIN_POSITIVE, $fty -> $ity, 0);
+ test!(-0.99999994, $fty -> $ity, 0);
+ test!(-1., $fty -> $ity, 0);
+ test!(-100., $fty -> $ity, 0);
+ test!(#[allow(overflowing_literals)] -1e50, $fty -> $ity, 0);
+ test!(#[allow(overflowing_literals)] -1e130, $fty -> $ity, 0);
+ )+ });
+
+ (f* -> $($ity:ident)+) => ({
+ fptoui_tests!(f32 -> $($ity)+);
+ fptoui_tests!(f64 -> $($ity)+);
+ })
+}
+
+pub fn main() {
+ common_fptoi_tests!(f* -> i8 i16 i32 i64 u8 u16 u32 u64);
+ fptoui_tests!(f* -> u8 u16 u32 u64);
+ // FIXME emscripten does not support i128
+ #[cfg(not(target_os="emscripten"))] {
+ common_fptoi_tests!(f* -> i128 u128);
+ fptoui_tests!(f* -> u128);
+ }
+
+ // The following tests cover edge cases for some integer types.
+
+ // # u8
+ test_c!(254., f* -> u8, 254);
+ test!(256., f* -> u8, 255);
+
+ // # i8
+ test_c!(-127., f* -> i8, -127);
+ test!(-129., f* -> i8, -128);
+ test_c!(126., f* -> i8, 126);
+ test!(128., f* -> i8, 127);
+
+ // # i32
+ // -2147483648. is i32::MIN (exactly)
+ test_c!(-2147483648., f* -> i32, i32::MIN);
+ // 2147483648. is i32::MAX rounded up
+ test!(2147483648., f32 -> i32, 2147483647);
+ // With 24 significand bits, floats with magnitude in [2^30 + 1, 2^31] are rounded to
+ // multiples of 2^7. Therefore, nextDown(round(i32::MAX)) is 2^31 - 128:
+ test_c!(2147483520., f32 -> i32, 2147483520);
+ // Similarly, nextUp(i32::MIN) is i32::MIN + 2^8 and nextDown(i32::MIN) is i32::MIN - 2^7
+ test!(-2147483904., f* -> i32, i32::MIN);
+ test_c!(-2147483520., f* -> i32, -2147483520);
+
+ // # u32
+ // round(MAX) and nextUp(round(MAX))
+ test_c!(4294967040., f* -> u32, 4294967040);
+ test!(4294967296., f* -> u32, 4294967295);
+
+ // # u128
+ #[cfg(not(target_os="emscripten"))]
+ {
+ // float->int:
+ test_c!(f32::MAX, f32 -> u128, 0xffffff00000000000000000000000000);
+ // nextDown(f32::MAX) = 2^128 - 2 * 2^104
+ const SECOND_LARGEST_F32: f32 = 340282326356119256160033759537265639424.;
+ test_c!(SECOND_LARGEST_F32, f32 -> u128, 0xfffffe00000000000000000000000000);
+
+ // int->float:
+ // f32::MAX - 0.5 ULP and smaller should be rounded down
+ test_c!(0xfffffe00000000000000000000000000, u128 -> f32, SECOND_LARGEST_F32);
+ test_c!(0xfffffe7fffffffffffffffffffffffff, u128 -> f32, SECOND_LARGEST_F32);
+ test_c!(0xfffffe80000000000000000000000000, u128 -> f32, SECOND_LARGEST_F32);
+ // numbers within < 0.5 ULP of f32::MAX it should be rounded to f32::MAX
+ test_c!(0xfffffe80000000000000000000000001, u128 -> f32, f32::MAX);
+ test_c!(0xfffffeffffffffffffffffffffffffff, u128 -> f32, f32::MAX);
+ test_c!(0xffffff00000000000000000000000000, u128 -> f32, f32::MAX);
+ test_c!(0xffffff00000000000000000000000001, u128 -> f32, f32::MAX);
+ test_c!(0xffffff7fffffffffffffffffffffffff, u128 -> f32, f32::MAX);
+ // f32::MAX + 0.5 ULP and greater should be rounded to infinity
+ test_c!(0xffffff80000000000000000000000000, u128 -> f32, f32::INFINITY);
+ test_c!(0xffffff80000000f00000000000000000, u128 -> f32, f32::INFINITY);
+ test_c!(0xffffff87ffffffffffffffff00000001, u128 -> f32, f32::INFINITY);
+
+ // u128->f64 should not be affected by the u128->f32 checks
+ test_c!(0xffffff80000000000000000000000000, u128 -> f64,
+ 340282356779733661637539395458142568448.0);
+ test_c!(u128::MAX, u128 -> f64, 340282366920938463463374607431768211455.0);
+ }
+}
pub trait Bar {}
+ #[allow(auto_impl)]
impl Bar for .. {}
pub trait Foo {
pub trait AnOibit {}
+#[allow(auto_impl)]
impl AnOibit for .. {}
pub trait AnOibit {}
+#[allow(auto_impl)]
impl AnOibit for .. {}
pub struct Foo<T> { field: T }
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "foo"]
+
+pub trait Bar<T, U> {}
+
+// @has 'foo/struct.Foo1.html'
+pub struct Foo1;
+// @count - '//*[@class="impl"]' 1
+// @has - '//*[@class="impl"]' "impl Bar<Foo1, &'static Foo1> for Foo1"
+impl Bar<Foo1, &'static Foo1> for Foo1 {}
+
+// @has 'foo/struct.Foo2.html'
+pub struct Foo2;
+// @count - '//*[@class="impl"]' 1
+// @has - '//*[@class="impl"]' "impl Bar<&'static Foo2, Foo2> for u8"
+impl Bar<&'static Foo2, Foo2> for u8 {}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-tidy-linelength
+
+#![crate_name = "foo"]
+
+// @has foo/struct.Foo.html
+// @has - '//*[@class="sidebar-links"]/a' 'super_long_name'
+// @has - '//*[@class="sidebar-links"]/a' 'Disp'
+pub struct Foo(usize);
+
+impl Foo {
+ pub fn super_long_name() {}
+}
+
+pub trait Disp {
+ fn disp_trait_method();
+}
+
+impl Disp for Foo {
+ fn disp_trait_method() {}
+}
pub fn dummy() {}
// ensure that `extern crate foo;` was inserted into code snips automatically:
-// @matches foo/index.html '//a[@class="test-arrow"][@href="https://example.com/?code=extern%20crate%20foo%3B%0Afn%20main()%20%7B%0Ause%20foo%3A%3Adummy%3B%0Adummy()%3B%0A%7D"]' "Run"
+// @matches foo/index.html '//a[@class="test-arrow"][@href="https://example.com/?code=%23!%5Ballow(unused)%5D%0Aextern%20crate%20foo%3B%0Afn%20main()%20%7B%0Ause%20foo%3A%3Adummy%3B%0Adummy()%3B%0A%7D"]' "Run"
//! }
//! ```
-// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=fn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D%0A"]' "Run"
-// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=fn%20main()%20%7B%0Aprintln!(%22Hello%2C%20world!%22)%3B%0A%7D"]' "Run"
-// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Bfeature(something)%5D%0A%0Afn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D%0A&version=nightly"]' "Run"
+// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D%0A"]' "Run"
+// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Aprintln!(%22Hello%2C%20world!%22)%3B%0A%7D"]' "Run"
+// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0A%23!%5Bfeature(something)%5D%0A%0Afn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D%0A&version=nightly"]' "Run"
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "foo"]
+
+// @has foo/trait.Foo.html
+// @has - '//*[@class="sidebar-title"][@href="#required-methods"]' 'Required Methods'
+// @has - '//*[@class="sidebar-links"]/a' 'bar'
+// @has - '//*[@class="sidebar-title"][@href="#provided-methods"]' 'Provided Methods'
+// @has - '//*[@class="sidebar-links"]/a' 'foo'
+// @has - '//*[@class="sidebar-title"][@href="#associated-const"]' 'Associated Constants'
+// @has - '//*[@class="sidebar-links"]/a' 'BAR'
+// @has - '//*[@class="sidebar-title"][@href="#associated-types"]' 'Associated Types'
+// @has - '//*[@class="sidebar-links"]/a' 'Output'
+pub trait Foo {
+ const BAR: u32 = 0;
+ type Output: ?Sized;
+
+ fn foo() {}
+ fn bar() -> Self::Output;
+}
+
+// @has foo/struct.Bar.html
+// @has - '//*[@class="sidebar-title"][@href="#fields"]' 'Fields'
+// @has - '//*[@class="sidebar-links"]/a[@href="#structfield.f"]' 'f'
+// @has - '//*[@class="sidebar-links"]/a[@href="#structfield.u"]' 'u'
+// @!has - '//*[@class="sidebar-links"]/a' 'w'
+pub struct Bar {
+ pub f: u32,
+ pub u: u32,
+ w: u32,
+}
+
+// @has foo/enum.En.html
+// @has - '//*[@class="sidebar-title"][@href="#variants"]' 'Variants'
+// @has - '//*[@class="sidebar-links"]/a' 'foo'
+// @has - '//*[@class="sidebar-links"]/a' 'bar'
+pub enum En {
+ foo,
+ bar,
+}
+
+// @has foo/union.MyUnion.html
+// @has - '//*[@class="sidebar-title"][@href="#fields"]' 'Fields'
+// @has - '//*[@class="sidebar-links"]/a[@href="#structfield.f1"]' 'f1'
+// @has - '//*[@class="sidebar-links"]/a[@href="#structfield.f2"]' 'f2'
+// @!has - '//*[@class="sidebar-links"]/a' 'w'
+pub union MyUnion {
+ pub f1: u32,
+ pub f2: f32,
+ w: u32,
+}
--> $DIR/unicode.rs:11:8
|
11 | extern "路濫狼á́́" fn foo() {}
- | ^^^^^^^^
+ | ^^^^^^^^^
error: aborting due to previous error
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(non_ascii_idents)]
+
+fn main() {
+ let _ = ("a̐éö̲", 0u7);
+ let _ = ("아あ", 1i42);
+ let _ = a̐é;
+}
--- /dev/null
+error: invalid width `7` for integer literal
+ --> $DIR/unicode_2.rs:14:25
+ |
+14 | let _ = ("a̐éö̲", 0u7);
+ | ^^^
+ |
+ = help: valid widths are 8, 16, 32, 64 and 128
+
+error: invalid width `42` for integer literal
+ --> $DIR/unicode_2.rs:15:20
+ |
+15 | let _ = ("아あ", 1i42);
+ | ^^^^
+ |
+ = help: valid widths are 8, 16, 32, 64 and 128
+
+error[E0425]: cannot find value `a̐é` in this scope
+ --> $DIR/unicode_2.rs:16:13
+ |
+16 | let _ = a̐é;
+ | ^^ not found in this scope
+
+error: aborting due to 3 previous errors
+
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let s = "ZͨA͑ͦ͒͋ͤ͑̚L̄͑͋Ĝͨͥ̿͒̽̈́Oͥ͛ͭ!̏"; while true { break; }
+ println!("{}", s);
+}
--- /dev/null
+warning: denote infinite loops with `loop { ... }`
+ --> $DIR/unicode_3.rs:12:45
+ |
+12 | let s = "ZͨA͑ͦ͒͋ͤ͑̚L̄͑͋Ĝͨͥ̿͒̽̈́Oͥ͛ͭ!̏"; while true { break; }
+ | ----------^^^^^^^^^^^
+ | |
+ | help: use `loop`
+ |
+ = note: #[warn(while_true)] on by default
+
- .escape_debug()
- .escape_default()
- .escape_unicode()
- - .to_lowercase()
- - .to_uppercase()
+ - .to_ascii_lowercase()
+ - .to_ascii_uppercase()
error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:23:10
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ for i 0..2 {
+ }
+}
+
--- /dev/null
+error: missing `in` in `for` loop
+ --> $DIR/issue-40782.rs:12:10
+ |
+12 | for i 0..2 {
+ | ^ help: try adding `in` here
+
+error: aborting due to previous error
+
--> $DIR/issue-44078.rs:12:8
|
12 | "😊"";
- | ________^
+ | _________^
13 | | }
| |__^
18 | foo!(true);
| ^^^^ expecting a type here because of type ascription
-error: expected one of `!`, `&&`, `&`, `(`, `*`, `.`, `;`, `<`, `?`, `[`, `_`, `dyn`, `extern`, `fn`, `for`, `impl`, `unsafe`, `}`, an operator, or lifetime, found `true`
- --> $DIR/issue-44406.rs:18:10
- |
-13 | bar(baz: $rest)
- | - expected one of 20 possible tokens here
-...
-18 | foo!(true);
- | ^^^^ unexpected token
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+fn main() {
+ let x: *const _ = 0 as _;
+
+ let x: *const _ = 0 as *const _;
+ let y: Option<*const fmt::Debug> = Some(x) as _;
+
+ let x = 0 as *const i32 as *const _ as *mut _;
+}
--- /dev/null
+error[E0641]: cannot cast to a pointer of an unknown kind
+ --> $DIR/issue-45730.rs:13:23
+ |
+13 | let x: *const _ = 0 as _;
+ | ^^^^^-
+ | |
+ | help: consider giving more type information
+ |
+ = note: The type information given here is insufficient to check whether the pointer cast is valid
+
+error[E0641]: cannot cast to a pointer of an unknown kind
+ --> $DIR/issue-45730.rs:15:23
+ |
+15 | let x: *const _ = 0 as *const _;
+ | ^^^^^--------
+ | |
+ | help: consider giving more type information
+ |
+ = note: The type information given here is insufficient to check whether the pointer cast is valid
+
+error[E0641]: cannot cast to a pointer of an unknown kind
+ --> $DIR/issue-45730.rs:18:13
+ |
+18 | let x = 0 as *const i32 as *const _ as *mut _;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------
+ | |
+ | help: consider giving more type information
+ |
+ = note: The type information given here is insufficient to check whether the pointer cast is valid
+
+error: aborting due to 3 previous errors
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[derive(Clone)]
+enum Foo<'a> {
+ Bar(&'a str),
+}
+
+impl<'a> Foo<'a> {
+ fn bar(&self, other: Foo) -> Foo<'a> {
+ match *self {
+ Foo::Bar(s) => {
+ if s == "test" {
+ other
+ } else {
+ self.clone()
+ }
+ }
+ }
+ }
+}
+
+fn main() { }
--- /dev/null
+error[E0621]: explicit lifetime required in the type of `other`
+ --> $DIR/ex1-return-one-existing-name-early-bound-in-struct.rs:21:21
+ |
+17 | fn bar(&self, other: Foo) -> Foo<'a> {
+ | ----- consider changing the type of `other` to `Foo<'a>`
+...
+21 | other
+ | ^^^^^ lifetime `'a` required
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+trait Foo<'a> {}
+impl<'a, T> Foo<'a> for T {}
+
+fn baz<'a, 'b, T>(x: &mut Vec<&'a T>, y: &T)
+ where i32: Foo<'a>,
+ u32: Foo<'b>
+{
+ x.push(y);
+}
+fn main() {
+let x = baz;
+}
--- /dev/null
+error[E0621]: explicit lifetime required in the type of `y`
+ --> $DIR/ex2a-push-one-existing-name-early-bound.rs:17:12
+ |
+13 | fn baz<'a, 'b, T>(x: &mut Vec<&'a T>, y: &T)
+ | - consider changing the type of `y` to `&'a T`
+...
+17 | x.push(y);
+ | ^ lifetime `'a` required
+
+error: aborting due to previous error
+
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-trait Foo<'a> {}
-impl<'a, T> Foo<'a> for T {}
-
-fn baz<'a, 'b, T>(x: &mut Vec<&'a T>, y: &T)
- where i32: Foo<'a>,
- u32: Foo<'b>
-{
- x.push(y);
-}
-fn main() {
-let x = baz;
-}
+++ /dev/null
-error[E0623]: lifetime mismatch
- --> $DIR/ex3-both-anon-regions-earlybound-regions.rs:17:12
- |
-13 | fn baz<'a, 'b, T>(x: &mut Vec<&'a T>, y: &T)
- | ----- -- these two types are declared with different lifetimes...
-...
-17 | x.push(y);
- | ^ ...but data from `y` flows into `x` here
-
-error: aborting due to previous error
-
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This is just like unreachable_pub.rs, but without the
+// `crate_visibility_modifier` feature (so that we can test the suggestions to
+// use `pub(crate)` that are given when that feature is off, as opposed to the
+// suggestions to use `crate` given when it is on). When that feature becomes
+// stable, this test can be deleted.
+
+#![feature(macro_vis_matcher)]
+
+#![allow(unused)]
+#![warn(unreachable_pub)]
+
+mod private_mod {
+ // non-leaked `pub` items in private module should be linted
+ pub use std::fmt;
+
+ pub struct Hydrogen {
+ // `pub` struct fields, too
+ pub neutrons: usize,
+ // (... but not more-restricted fields)
+ pub(crate) electrons: usize
+ }
+ impl Hydrogen {
+ // impls, too
+ pub fn count_neutrons(&self) -> usize { self.neutrons }
+ pub(crate) fn count_electrons(&self) -> usize { self.electrons }
+ }
+
+ pub enum Helium {}
+ pub union Lithium { c1: usize, c2: u8 }
+ pub fn beryllium() {}
+ pub trait Boron {}
+ pub const CARBON: usize = 1;
+ pub static NITROGEN: usize = 2;
+ pub type Oxygen = bool;
+
+ macro_rules! define_empty_struct_with_visibility {
+ ($visibility: vis, $name: ident) => { $visibility struct $name {} }
+ }
+ define_empty_struct_with_visibility!(pub, Fluorine);
+
+ extern {
+ pub fn catalyze() -> bool;
+ }
+
+ // items leaked through signatures (see `get_neon` below) are OK
+ pub struct Neon {}
+
+ // crate-visible items are OK
+ pub(crate) struct Sodium {}
+}
+
+pub mod public_mod {
+ // module is public: these are OK, too
+ pub struct Magnesium {}
+ pub(crate) struct Aluminum {}
+}
+
+pub fn get_neon() -> private_mod::Neon {
+ private_mod::Neon {}
+}
+
+fn main() {
+ let _ = get_neon();
+}
--- /dev/null
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:24:5
+ |
+24 | pub use std::fmt;
+ | ---^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+note: lint level defined here
+ --> $DIR/unreachable_pub-pub_crate.rs:20:9
+ |
+20 | #![warn(unreachable_pub)]
+ | ^^^^^^^^^^^^^^^
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:26:5
+ |
+26 | pub struct Hydrogen {
+ | ---^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` field
+ --> $DIR/unreachable_pub-pub_crate.rs:28:9
+ |
+28 | pub neutrons: usize,
+ | ---^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:34:9
+ |
+34 | pub fn count_neutrons(&self) -> usize { self.neutrons }
+ | ---^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:38:5
+ |
+38 | pub enum Helium {}
+ | ---^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:39:5
+ |
+39 | pub union Lithium { c1: usize, c2: u8 }
+ | ---^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:40:5
+ |
+40 | pub fn beryllium() {}
+ | ---^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:41:5
+ |
+41 | pub trait Boron {}
+ | ---^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:42:5
+ |
+42 | pub const CARBON: usize = 1;
+ | ---^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:43:5
+ |
+43 | pub static NITROGEN: usize = 2;
+ | ---^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:44:5
+ |
+44 | pub type Oxygen = bool;
+ | ---^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:47:47
+ |
+47 | ($visibility: vis, $name: ident) => { $visibility struct $name {} }
+ | -----------^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+48 | }
+49 | define_empty_struct_with_visibility!(pub, Fluorine);
+ | ---------------------------------------------------- in this macro invocation
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub-pub_crate.rs:52:9
+ |
+52 | pub fn catalyze() -> bool;
+ | ---^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `pub(crate)`
+ |
+ = help: or consider exporting it for use by other crates
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(crate_visibility_modifier)]
+#![feature(macro_vis_matcher)]
+
+#![allow(unused)]
+#![warn(unreachable_pub)]
+
+mod private_mod {
+ // non-leaked `pub` items in private module should be linted
+ pub use std::fmt;
+
+ pub struct Hydrogen {
+ // `pub` struct fields, too
+ pub neutrons: usize,
+ // (... but not more-restricted fields)
+ crate electrons: usize
+ }
+ impl Hydrogen {
+ // impls, too
+ pub fn count_neutrons(&self) -> usize { self.neutrons }
+ crate fn count_electrons(&self) -> usize { self.electrons }
+ }
+
+ pub enum Helium {}
+ pub union Lithium { c1: usize, c2: u8 }
+ pub fn beryllium() {}
+ pub trait Boron {}
+ pub const CARBON: usize = 1;
+ pub static NITROGEN: usize = 2;
+ pub type Oxygen = bool;
+
+ macro_rules! define_empty_struct_with_visibility {
+ ($visibility: vis, $name: ident) => { $visibility struct $name {} }
+ }
+ define_empty_struct_with_visibility!(pub, Fluorine);
+
+ extern {
+ pub fn catalyze() -> bool;
+ }
+
+ // items leaked through signatures (see `get_neon` below) are OK
+ pub struct Neon {}
+
+ // crate-visible items are OK
+ crate struct Sodium {}
+}
+
+pub mod public_mod {
+ // module is public: these are OK, too
+ pub struct Magnesium {}
+ crate struct Aluminum {}
+}
+
+pub fn get_neon() -> private_mod::Neon {
+ private_mod::Neon {}
+}
+
+fn main() {
+ let _ = get_neon();
+}
--- /dev/null
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:19:5
+ |
+19 | pub use std::fmt;
+ | ---^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+note: lint level defined here
+ --> $DIR/unreachable_pub.rs:15:9
+ |
+15 | #![warn(unreachable_pub)]
+ | ^^^^^^^^^^^^^^^
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:21:5
+ |
+21 | pub struct Hydrogen {
+ | ---^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` field
+ --> $DIR/unreachable_pub.rs:23:9
+ |
+23 | pub neutrons: usize,
+ | ---^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:29:9
+ |
+29 | pub fn count_neutrons(&self) -> usize { self.neutrons }
+ | ---^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:33:5
+ |
+33 | pub enum Helium {}
+ | ---^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:34:5
+ |
+34 | pub union Lithium { c1: usize, c2: u8 }
+ | ---^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:35:5
+ |
+35 | pub fn beryllium() {}
+ | ---^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:36:5
+ |
+36 | pub trait Boron {}
+ | ---^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:37:5
+ |
+37 | pub const CARBON: usize = 1;
+ | ---^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:38:5
+ |
+38 | pub static NITROGEN: usize = 2;
+ | ---^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:39:5
+ |
+39 | pub type Oxygen = bool;
+ | ---^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:42:47
+ |
+42 | ($visibility: vis, $name: ident) => { $visibility struct $name {} }
+ | -----------^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+43 | }
+44 | define_empty_struct_with_visibility!(pub, Fluorine);
+ | ---------------------------------------------------- in this macro invocation
+ |
+ = help: or consider exporting it for use by other crates
+
+warning: unreachable `pub` item
+ --> $DIR/unreachable_pub.rs:47:9
+ |
+47 | pub fn catalyze() -> bool;
+ | ---^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | help: consider restricting its visibility: `crate`
+ |
+ = help: or consider exporting it for use by other crates
+
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: --error-format json
+// compile-flags: --error-format pretty-json -Zunstable-options
// The output for humans should just highlight the whole span without showing
// the suggested replacement, but we also want to test that suggested
-{"message":"unnecessary parentheses around assigned value","code":{"code":"unused_parens","explanation":null},"level":"warning","spans":[{"file_name":"$DIR/unused_parens_json_suggestion.rs","byte_start":1001,"byte_end":1014,"line_start":24,"line_end":24,"column_start":14,"column_end":27,"is_primary":true,"text":[{"text":" let _a = (1 / (2 + 3));","highlight_start":14,"highlight_end":27}],"label":null,"suggested_replacement":null,"expansion":null}],"children":[{"message":"lint level defined here","code":null,"level":"note","spans":[{"file_name":"$DIR/unused_parens_json_suggestion.rs","byte_start":847,"byte_end":860,"line_start":19,"line_end":19,"column_start":9,"column_end":22,"is_primary":true,"text":[{"text":"#![warn(unused_parens)]","highlight_start":9,"highlight_end":22}],"label":null,"suggested_replacement":null,"expansion":null}],"children":[],"rendered":null},{"message":"remove these parentheses","code":null,"level":"help","spans":[{"file_name":"$DIR/unused_parens_json_suggestion.rs","byte_start":1001,"byte_end":1014,"line_start":24,"line_end":24,"column_start":14,"column_end":27,"is_primary":true,"text":[{"text":" let _a = (1 / (2 + 3));","highlight_start":14,"highlight_end":27}],"label":null,"suggested_replacement":"1 / (2 + 3)","expansion":null}],"children":[],"rendered":null}],"rendered":null}
+{
+ "message": "unnecessary parentheses around assigned value",
+ "code": {
+ "code": "unused_parens",
+ "explanation": null
+ },
+ "level": "warning",
+ "spans": [
+ {
+ "file_name": "$DIR/unused_parens_json_suggestion.rs",
+ "byte_start": 1027,
+ "byte_end": 1040,
+ "line_start": 24,
+ "line_end": 24,
+ "column_start": 14,
+ "column_end": 27,
+ "is_primary": true,
+ "text": [
+ {
+ "text": " let _a = (1 / (2 + 3));",
+ "highlight_start": 14,
+ "highlight_end": 27
+ }
+ ],
+ "label": null,
+ "suggested_replacement": null,
+ "expansion": null
+ }
+ ],
+ "children": [
+ {
+ "message": "lint level defined here",
+ "code": null,
+ "level": "note",
+ "spans": [
+ {
+ "file_name": "$DIR/unused_parens_json_suggestion.rs",
+ "byte_start": 873,
+ "byte_end": 886,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 9,
+ "column_end": 22,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "#![warn(unused_parens)]",
+ "highlight_start": 9,
+ "highlight_end": 22
+ }
+ ],
+ "label": null,
+ "suggested_replacement": null,
+ "expansion": null
+ }
+ ],
+ "children": [],
+ "rendered": null
+ },
+ {
+ "message": "remove these parentheses",
+ "code": null,
+ "level": "help",
+ "spans": [
+ {
+ "file_name": "$DIR/unused_parens_json_suggestion.rs",
+ "byte_start": 1027,
+ "byte_end": 1040,
+ "line_start": 24,
+ "line_end": 24,
+ "column_start": 14,
+ "column_end": 27,
+ "is_primary": true,
+ "text": [
+ {
+ "text": " let _a = (1 / (2 + 3));",
+ "highlight_start": 14,
+ "highlight_end": 27
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "1 / (2 + 3)",
+ "expansion": null
+ }
+ ],
+ "children": [],
+ "rendered": null
+ }
+ ],
+ "rendered": null
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: --error-format json
+// compile-flags: --error-format pretty-json -Zunstable-options
// The output for humans should just highlight the whole span without showing
// the suggested replacement, but we also want to test that suggested
-{"message":"cannot find type `Iter` in this scope","code":{"code":"E0412","explanation":"/nThe type name used is not in scope./n/nErroneous code examples:/n/n```compile_fail,E0412/nimpl Something {} // error: type name `Something` is not in scope/n/n// or:/n/ntrait Foo {/n fn bar(N); // error: type name `N` is not in scope/n}/n/n// or:/n/nfn foo(x: T) {} // type name `T` is not in scope/n```/n/nTo fix this error, please verify you didn't misspell the type name, you did/ndeclare it or imported it into the scope. Examples:/n/n```/nstruct Something;/n/nimpl Something {} // ok!/n/n// or:/n/ntrait Foo {/n type N;/n/n fn bar(_: Self::N); // ok!/n}/n/n// or:/n/nfn foo<T>(x: T) {} // ok!/n```/n/nAnother case that causes this error is when a type is imported into a parent/nmodule. To fix this, you can follow the suggestion and use File directly or/n`use super::File;` which will import the types from the parent namespace. An/nexample that causes this error is below:/n/n```compile_fail,E0412/nuse std::fs::File;/n/nmod foo {/n fn some_function(f: File) {}/n}/n```/n/n```/nuse std::fs::File;/n/nmod foo {/n // either/n use super::File;/n // or/n // use std::fs::File;/n fn foo(f: File) {}/n}/n# fn main() {} // don't insert it for us; that'll break imports/n```/n"},"level":"error","spans":[{"file_name":"$DIR/use_suggestion_json.rs","byte_start":862,"byte_end":866,"line_start":20,"line_end":20,"column_start":12,"column_end":16,"is_primary":true,"text":[{"text":" let x: Iter;","highlight_start":12,"highlight_end":16}],"label":"not found in this scope","suggested_replacement":null,"expansion":null}],"children":[{"message":"possible candidates are found in other modules, you can import them into scope","code":null,"level":"help","spans":[{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::collections::binary_heap::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::collections::btree_map::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::collections::btree_set::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::collections::hash_map::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::collections::hash_set::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::collections::linked_list::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::collections::vec_deque::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::option::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::path::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::result::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::slice::Iter;/n/n","expansion":null},{"file_name":"$DIR/use_suggestion_json.rs","byte_start":839,"byte_end":839,"line_start":19,"line_end":19,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"fn main() {","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"use std::sync::mpsc::Iter;/n/n","expansion":null}],"children":[],"rendered":null}],"rendered":null}
-{"message":"aborting due to previous error","code":null,"level":"error","spans":[],"children":[],"rendered":null}
+{
+ "message": "cannot find type `Iter` in this scope",
+ "code": {
+ "code": "E0412",
+ "explanation": "/nThe type name used is not in scope./n/nErroneous code examples:/n/n```compile_fail,E0412/nimpl Something {} // error: type name `Something` is not in scope/n/n// or:/n/ntrait Foo {/n fn bar(N); // error: type name `N` is not in scope/n}/n/n// or:/n/nfn foo(x: T) {} // type name `T` is not in scope/n```/n/nTo fix this error, please verify you didn't misspell the type name, you did/ndeclare it or imported it into the scope. Examples:/n/n```/nstruct Something;/n/nimpl Something {} // ok!/n/n// or:/n/ntrait Foo {/n type N;/n/n fn bar(_: Self::N); // ok!/n}/n/n// or:/n/nfn foo<T>(x: T) {} // ok!/n```/n/nAnother case that causes this error is when a type is imported into a parent/nmodule. To fix this, you can follow the suggestion and use File directly or/n`use super::File;` which will import the types from the parent namespace. An/nexample that causes this error is below:/n/n```compile_fail,E0412/nuse std::fs::File;/n/nmod foo {/n fn some_function(f: File) {}/n}/n```/n/n```/nuse std::fs::File;/n/nmod foo {/n // either/n use super::File;/n // or/n // use std::fs::File;/n fn foo(f: File) {}/n}/n# fn main() {} // don't insert it for us; that'll break imports/n```/n"
+ },
+ "level": "error",
+ "spans": [
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 888,
+ "byte_end": 892,
+ "line_start": 20,
+ "line_end": 20,
+ "column_start": 12,
+ "column_end": 16,
+ "is_primary": true,
+ "text": [
+ {
+ "text": " let x: Iter;",
+ "highlight_start": 12,
+ "highlight_end": 16
+ }
+ ],
+ "label": "not found in this scope",
+ "suggested_replacement": null,
+ "expansion": null
+ }
+ ],
+ "children": [
+ {
+ "message": "possible candidates are found in other modules, you can import them into scope",
+ "code": null,
+ "level": "help",
+ "spans": [
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::collections::binary_heap::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::collections::btree_map::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::collections::btree_set::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::collections::hash_map::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::collections::hash_set::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::collections::linked_list::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::collections::vec_deque::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::option::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::path::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::result::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::slice::Iter;/n/n",
+ "expansion": null
+ },
+ {
+ "file_name": "$DIR/use_suggestion_json.rs",
+ "byte_start": 865,
+ "byte_end": 865,
+ "line_start": 19,
+ "line_end": 19,
+ "column_start": 1,
+ "column_end": 1,
+ "is_primary": true,
+ "text": [
+ {
+ "text": "fn main() {",
+ "highlight_start": 1,
+ "highlight_end": 1
+ }
+ ],
+ "label": null,
+ "suggested_replacement": "use std::sync::mpsc::Iter;/n/n",
+ "expansion": null
+ }
+ ],
+ "children": [],
+ "rendered": null
+ }
+ ],
+ "rendered": null
+}
+{
+ "message": "aborting due to previous error",
+ "code": null,
+ "level": "error",
+ "spans": [],
+ "children": [],
+ "rendered": null
+}
| |
| expected closure that takes 2 arguments
-error: non-reference pattern used to match a reference (see issue #42640)
- --> $DIR/closure-arg-count.rs:17:24
- |
-17 | [1, 2, 3].sort_by(|(tuple, tuple2)| panic!());
- | ^^^^^^^^^^^^^^^ help: consider using: `&(tuple, tuple2)`
- |
- = help: add #![feature(match_default_bindings)] to the crate attributes to enable
-
-error[E0308]: mismatched types
- --> $DIR/closure-arg-count.rs:17:24
- |
-17 | [1, 2, 3].sort_by(|(tuple, tuple2)| panic!());
- | ^^^^^^^^^^^^^^^ expected integral variable, found tuple
- |
- = note: expected type `{integer}`
- found type `(_, _)`
-
error[E0593]: closure is expected to take 2 arguments, but it takes 1 argument
--> $DIR/closure-arg-count.rs:17:15
|
| |
| expected closure that takes a single 2-tuple as argument
-error: aborting due to 9 previous errors
+error: aborting due to 7 previous errors
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Basic test for free regions in the NLL code. This test ought to
+// report an error due to a reborrowing constraint. Right now, we get
+// a variety of errors from the older, AST-based machinery (notably
+// borrowck), and then we get the NLL error at the end.
+
+// compile-flags:-Znll
+
+fn foo<'a, 'b>(x: &'a u32, y: &'b u32) -> &'b u32 {
+ &*x
+}
+
+fn main() { }
--- /dev/null
+warning: not reporting region error due to -Znll
+ --> $DIR/named-region-basic.rs:19:5
+ |
+19 | &*x
+ | ^^^
+
+error[E0597]: `*x` does not live long enough
+ --> $DIR/named-region-basic.rs:19:6
+ |
+19 | &*x
+ | ^^ does not live long enough
+ |
+ = note: borrowed value must be valid for the static lifetime...
+note: ...but borrowed value is only valid for the lifetime 'a as defined on the function body at 18:1
+ --> $DIR/named-region-basic.rs:18:1
+ |
+18 | / fn foo<'a, 'b>(x: &'a u32, y: &'b u32) -> &'b u32 {
+19 | | &*x
+20 | | }
+ | |_^
+
+error: free region `'a` does not outlive `'b`
+ --> $DIR/named-region-basic.rs:19:5
+ |
+19 | &*x
+ | ^^^
+
+error: aborting due to 2 previous errors
+
14 | foo(bar(;
| ^
-error: expected one of `)`, `,`, `.`, `<`, `?`, `break`, `continue`, `false`, `for`, `if`, `loop`, `match`, `move`, `return`, `true`, `unsafe`, `while`, `yield`, or an operator, found `;`
- --> $DIR/token-error-correct.rs:14:13
- |
-14 | foo(bar(;
- | ^ expected one of 19 possible tokens here
-
error: expected expression, found `)`
--> $DIR/token-error-correct.rs:23:1
|
23 | }
| ^
-error[E0425]: cannot find function `foo` in this scope
- --> $DIR/token-error-correct.rs:14:5
- |
-14 | foo(bar(;
- | ^^^ not found in this scope
-
-error[E0425]: cannot find function `bar` in this scope
- --> $DIR/token-error-correct.rs:14:9
- |
-14 | foo(bar(;
- | ^^^ not found in this scope
-
-error: aborting due to 7 previous errors
+error: aborting due to 4 previous errors
#[inline(unknown)] //~ ERROR E0535
pub fn something() {}
-fn main() {}
+fn main() {
+ something();
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let x: Vec::with_capacity(10, 20);
+}
--- /dev/null
+error: expected type, found `10`
+ --> $DIR/type-ascription-instead-of-initializer.rs:12:31
+ |
+12 | let x: Vec::with_capacity(10, 20);
+ | -- ^^
+ | ||
+ | |help: use `=` if you meant to assign
+ | while parsing the type for `x`
+
+error[E0061]: this function takes 1 parameter but 2 parameters were supplied
+ --> $DIR/type-ascription-instead-of-initializer.rs:12:31
+ |
+12 | let x: Vec::with_capacity(10, 20);
+ | ^^^^^^ expected 1 parameter
+
+error: aborting due to 2 previous errors
+
-Subproject commit 859c2305b5d7ff820d7f7af158bbca999cbd8bf3
+Subproject commit b83550edc300e3d80dd16d0440123ffc1ad77bb9
let status = command
// Disable rust-lang/cargo's cross-compile tests
.env("CFG_DISABLE_CROSS_TESTS", "1")
+ // Relax #![deny(warnings)] in some crates
+ .env("RUSTFLAGS", "--cap-lints warn")
.current_dir(crate_path)
.status()
.expect("");
MirOpt,
}
+impl Mode {
+ pub fn disambiguator(self) -> &'static str {
+ // Run-pass and pretty run-pass tests could run concurrently, and if they do,
+ // they need to keep their output segregated. Same is true for debuginfo tests that
+ // can be run both on gdb and lldb.
+ match self {
+ Pretty => ".pretty",
+ DebugInfoGdb => ".gdb",
+ DebugInfoLldb => ".lldb",
+ _ => "",
+ }
+ }
+}
+
impl FromStr for Mode {
type Err = ();
fn from_str(s: &str) -> Result<Mode, ()> {
if let Some(ref incremental_dir) = self.props.incremental_dir {
rustc.args(&["-Z", &format!("incremental={}", incremental_dir.display())]);
+ rustc.args(&["-Z", "incremental-verify-ich"]);
}
match self.config.mode {
fn aux_output_dir_name(&self) -> PathBuf {
let f = self.output_base_name();
let mut fname = f.file_name().unwrap().to_os_string();
- fname.push(&format!(".{}.libaux", self.config.mode));
+ fname.push(&format!("{}.aux", self.config.mode.disambiguator()));
f.with_file_name(&fname)
}
output_file.push(test_name);
debug!("comparing the contests of: {:?}", output_file);
debug!("with: {:?}", expected_content);
+ if !output_file.exists() {
+ panic!("Output file `{}` from test does not exist",
+ output_file.into_os_string().to_string_lossy());
+ }
self.check_mir_test_timestamp(test_name, &output_file);
let mut dumped_file = fs::File::open(output_file.clone()).unwrap();
// We expect each non-empty line to appear consecutively, non-consecutive lines
// must be separated by at least one Elision
+ let mut start_block_line = None;
while let Some(dumped_line) = dumped_lines.next() {
match expected_lines.next() {
- Some(&ExpectedLine::Text(expected_line)) =>
+ Some(&ExpectedLine::Text(expected_line)) => {
+ let normalized_expected_line = normalize_mir_line(expected_line);
+ if normalized_expected_line.contains(":{") {
+ start_block_line = Some(expected_line);
+ }
+
if !compare(expected_line, dumped_line) {
+ error!("{:?}", start_block_line);
error(expected_line,
- format!("Mismatch in lines\nExpected Line: {:?}", dumped_line));
- },
+ format!("Mismatch in lines\nCurrnt block: {}\nExpected Line: {:?}",
+ start_block_line.unwrap_or("None"), dumped_line));
+ }
+ },
Some(&ExpectedLine::Elision) => {
// skip any number of elisions in a row.
while let Some(&&ExpectedLine::Elision) = expected_lines.peek() {
fn normalize_output(&self, output: &str, custom_rules: &[(String, String)]) -> String {
let parent_dir = self.testpaths.file.parent().unwrap();
let cflags = self.props.compile_flags.join(" ");
- let parent_dir_str = if cflags.contains("--error-format json") {
+ let parent_dir_str = if cflags.contains("--error-format json")
+ || cflags.contains("--error-format pretty-json") {
parent_dir.display().to_string().replace("\\", "\\\\")
} else {
parent_dir.display().to_string()
-Subproject commit 48fd42fe92175ce93a5b67f78c195254ee94493d
+Subproject commit 9ad92e134ff56df52481cf19dc3da14b9e735061
-Subproject commit cf0d494dda7447bacaab743a70c47e28bea55c6f
+Subproject commit 51b03c3aaf5e69afbb7508e566c5da2bf0bc3662
projects / rust.git / commitdiff