Auto merge of #62452 - Centril:rollup-5jww3h7, r=Centril
Rollup of 5 pull requests Successful merges: - #60081 (Refactor unicode.py script) - #61862 (Make the Weak::{into,as}_raw methods) - #62243 (Improve documentation for built-in macros) - #62422 (Remove some uses of mem::uninitialized) - #62436 (normalize use of backticks/lowercase in compiler messages for librustc_mir) Failed merges: r? @ghost
This commit is contained in:
bors
commit
b0bd5f236d
64 changed files with 1725 additions and 682 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -36,6 +36,7 @@ __pycache__/
|
|||
/src/libcore/unicode/Scripts.txt
|
||||
/src/libcore/unicode/SpecialCasing.txt
|
||||
/src/libcore/unicode/UnicodeData.txt
|
||||
/src/libcore/unicode/downloaded
|
||||
/stage[0-9]+/
|
||||
/target
|
||||
target/
|
||||
|
|
|
|||
|
|
@ -1291,26 +1291,26 @@ impl<T> Weak<T> {
|
|||
/// ```
|
||||
/// #![feature(weak_into_raw)]
|
||||
///
|
||||
/// use std::rc::{Rc, Weak};
|
||||
/// use std::rc::Rc;
|
||||
/// use std::ptr;
|
||||
///
|
||||
/// let strong = Rc::new("hello".to_owned());
|
||||
/// let weak = Rc::downgrade(&strong);
|
||||
/// // Both point to the same object
|
||||
/// assert!(ptr::eq(&*strong, Weak::as_raw(&weak)));
|
||||
/// assert!(ptr::eq(&*strong, weak.as_raw()));
|
||||
/// // The strong here keeps it alive, so we can still access the object.
|
||||
/// assert_eq!("hello", unsafe { &*Weak::as_raw(&weak) });
|
||||
/// assert_eq!("hello", unsafe { &*weak.as_raw() });
|
||||
///
|
||||
/// drop(strong);
|
||||
/// // But not any more. We can do Weak::as_raw(&weak), but accessing the pointer would lead to
|
||||
/// // But not any more. We can do weak.as_raw(), but accessing the pointer would lead to
|
||||
/// // undefined behaviour.
|
||||
/// // assert_eq!("hello", unsafe { &*Weak::as_raw(&weak) });
|
||||
/// // assert_eq!("hello", unsafe { &*weak.as_raw() });
|
||||
/// ```
|
||||
///
|
||||
/// [`null`]: ../../std/ptr/fn.null.html
|
||||
#[unstable(feature = "weak_into_raw", issue = "60728")]
|
||||
pub fn as_raw(this: &Self) -> *const T {
|
||||
match this.inner() {
|
||||
pub fn as_raw(&self) -> *const T {
|
||||
match self.inner() {
|
||||
None => ptr::null(),
|
||||
Some(inner) => {
|
||||
let offset = data_offset_sized::<T>();
|
||||
|
|
@ -1341,7 +1341,7 @@ impl<T> Weak<T> {
|
|||
///
|
||||
/// let strong = Rc::new("hello".to_owned());
|
||||
/// let weak = Rc::downgrade(&strong);
|
||||
/// let raw = Weak::into_raw(weak);
|
||||
/// let raw = weak.into_raw();
|
||||
///
|
||||
/// assert_eq!(1, Rc::weak_count(&strong));
|
||||
/// assert_eq!("hello", unsafe { &*raw });
|
||||
|
|
@ -1353,9 +1353,9 @@ impl<T> Weak<T> {
|
|||
/// [`from_raw`]: struct.Weak.html#method.from_raw
|
||||
/// [`as_raw`]: struct.Weak.html#method.as_raw
|
||||
#[unstable(feature = "weak_into_raw", issue = "60728")]
|
||||
pub fn into_raw(this: Self) -> *const T {
|
||||
let result = Self::as_raw(&this);
|
||||
mem::forget(this);
|
||||
pub fn into_raw(self) -> *const T {
|
||||
let result = self.as_raw();
|
||||
mem::forget(self);
|
||||
result
|
||||
}
|
||||
|
||||
|
|
@ -1382,18 +1382,18 @@ impl<T> Weak<T> {
|
|||
///
|
||||
/// let strong = Rc::new("hello".to_owned());
|
||||
///
|
||||
/// let raw_1 = Weak::into_raw(Rc::downgrade(&strong));
|
||||
/// let raw_2 = Weak::into_raw(Rc::downgrade(&strong));
|
||||
/// let raw_1 = Rc::downgrade(&strong).into_raw();
|
||||
/// let raw_2 = Rc::downgrade(&strong).into_raw();
|
||||
///
|
||||
/// assert_eq!(2, Rc::weak_count(&strong));
|
||||
///
|
||||
/// assert_eq!("hello", &*Weak::upgrade(&unsafe { Weak::from_raw(raw_1) }).unwrap());
|
||||
/// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap());
|
||||
/// assert_eq!(1, Rc::weak_count(&strong));
|
||||
///
|
||||
/// drop(strong);
|
||||
///
|
||||
/// // Decrement the last weak count.
|
||||
/// assert!(Weak::upgrade(&unsafe { Weak::from_raw(raw_2) }).is_none());
|
||||
/// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());
|
||||
/// ```
|
||||
///
|
||||
/// [`null`]: ../../std/ptr/fn.null.html
|
||||
|
|
|
|||
|
|
@ -1080,26 +1080,26 @@ impl<T> Weak<T> {
|
|||
/// ```
|
||||
/// #![feature(weak_into_raw)]
|
||||
///
|
||||
/// use std::sync::{Arc, Weak};
|
||||
/// use std::sync::Arc;
|
||||
/// use std::ptr;
|
||||
///
|
||||
/// let strong = Arc::new("hello".to_owned());
|
||||
/// let weak = Arc::downgrade(&strong);
|
||||
/// // Both point to the same object
|
||||
/// assert!(ptr::eq(&*strong, Weak::as_raw(&weak)));
|
||||
/// assert!(ptr::eq(&*strong, weak.as_raw()));
|
||||
/// // The strong here keeps it alive, so we can still access the object.
|
||||
/// assert_eq!("hello", unsafe { &*Weak::as_raw(&weak) });
|
||||
/// assert_eq!("hello", unsafe { &*weak.as_raw() });
|
||||
///
|
||||
/// drop(strong);
|
||||
/// // But not any more. We can do Weak::as_raw(&weak), but accessing the pointer would lead to
|
||||
/// // But not any more. We can do weak.as_raw(), but accessing the pointer would lead to
|
||||
/// // undefined behaviour.
|
||||
/// // assert_eq!("hello", unsafe { &*Weak::as_raw(&weak) });
|
||||
/// // assert_eq!("hello", unsafe { &*weak.as_raw() });
|
||||
/// ```
|
||||
///
|
||||
/// [`null`]: ../../std/ptr/fn.null.html
|
||||
#[unstable(feature = "weak_into_raw", issue = "60728")]
|
||||
pub fn as_raw(this: &Self) -> *const T {
|
||||
match this.inner() {
|
||||
pub fn as_raw(&self) -> *const T {
|
||||
match self.inner() {
|
||||
None => ptr::null(),
|
||||
Some(inner) => {
|
||||
let offset = data_offset_sized::<T>();
|
||||
|
|
@ -1130,7 +1130,7 @@ impl<T> Weak<T> {
|
|||
///
|
||||
/// let strong = Arc::new("hello".to_owned());
|
||||
/// let weak = Arc::downgrade(&strong);
|
||||
/// let raw = Weak::into_raw(weak);
|
||||
/// let raw = weak.into_raw();
|
||||
///
|
||||
/// assert_eq!(1, Arc::weak_count(&strong));
|
||||
/// assert_eq!("hello", unsafe { &*raw });
|
||||
|
|
@ -1142,9 +1142,9 @@ impl<T> Weak<T> {
|
|||
/// [`from_raw`]: struct.Weak.html#method.from_raw
|
||||
/// [`as_raw`]: struct.Weak.html#method.as_raw
|
||||
#[unstable(feature = "weak_into_raw", issue = "60728")]
|
||||
pub fn into_raw(this: Self) -> *const T {
|
||||
let result = Self::as_raw(&this);
|
||||
mem::forget(this);
|
||||
pub fn into_raw(self) -> *const T {
|
||||
let result = self.as_raw();
|
||||
mem::forget(self);
|
||||
result
|
||||
}
|
||||
|
||||
|
|
@ -1172,18 +1172,18 @@ impl<T> Weak<T> {
|
|||
///
|
||||
/// let strong = Arc::new("hello".to_owned());
|
||||
///
|
||||
/// let raw_1 = Weak::into_raw(Arc::downgrade(&strong));
|
||||
/// let raw_2 = Weak::into_raw(Arc::downgrade(&strong));
|
||||
/// let raw_1 = Arc::downgrade(&strong).into_raw();
|
||||
/// let raw_2 = Arc::downgrade(&strong).into_raw();
|
||||
///
|
||||
/// assert_eq!(2, Arc::weak_count(&strong));
|
||||
///
|
||||
/// assert_eq!("hello", &*Weak::upgrade(&unsafe { Weak::from_raw(raw_1) }).unwrap());
|
||||
/// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap());
|
||||
/// assert_eq!(1, Arc::weak_count(&strong));
|
||||
///
|
||||
/// drop(strong);
|
||||
///
|
||||
/// // Decrement the last weak count.
|
||||
/// assert!(Weak::upgrade(&unsafe { Weak::from_raw(raw_2) }).is_none());
|
||||
/// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());
|
||||
/// ```
|
||||
///
|
||||
/// [`null`]: ../../std/ptr/fn.null.html
|
||||
|
|
|
|||
|
|
@ -75,6 +75,7 @@
|
|||
#![feature(const_fn)]
|
||||
#![feature(const_fn_union)]
|
||||
#![feature(custom_inner_attributes)]
|
||||
#![feature(decl_macro)]
|
||||
#![feature(doc_cfg)]
|
||||
#![feature(doc_spotlight)]
|
||||
#![feature(extern_types)]
|
||||
|
|
|
|||
|
|
@ -642,183 +642,720 @@ macro_rules! uninitialized_array {
|
|||
/// These macros do not have any corresponding definition with a `macro_rules!`
|
||||
/// macro, but are documented here. Their implementations can be found hardcoded
|
||||
/// into libsyntax itself.
|
||||
///
|
||||
/// For more information, see documentation for `std`'s macros.
|
||||
#[cfg(rustdoc)]
|
||||
mod builtin {
|
||||
|
||||
/// Causes compilation to fail with the given error message when encountered.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::compile_error!`].
|
||||
/// This macro should be used when a crate uses a conditional compilation strategy to provide
|
||||
/// better error messages for erroneous conditions. It's the compiler-level form of [`panic!`],
|
||||
/// which emits an error at *runtime*, rather than during compilation.
|
||||
///
|
||||
/// [`std::compile_error!`]: ../std/macro.compile_error.html
|
||||
/// # Examples
|
||||
///
|
||||
/// Two such examples are macros and `#[cfg]` environments.
|
||||
///
|
||||
/// Emit better compiler error if a macro is passed invalid values. Without the final branch,
|
||||
/// the compiler would still emit an error, but the error's message would not mention the two
|
||||
/// valid values.
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// macro_rules! give_me_foo_or_bar {
|
||||
/// (foo) => {};
|
||||
/// (bar) => {};
|
||||
/// ($x:ident) => {
|
||||
/// compile_error!("This macro only accepts `foo` or `bar`");
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// give_me_foo_or_bar!(neither);
|
||||
/// // ^ will fail at compile time with message "This macro only accepts `foo` or `bar`"
|
||||
/// ```
|
||||
///
|
||||
/// Emit compiler error if one of a number of features isn't available.
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// #[cfg(not(any(feature = "foo", feature = "bar")))]
|
||||
/// compile_error!("Either feature \"foo\" or \"bar\" must be enabled for this crate.");
|
||||
/// ```
|
||||
///
|
||||
/// [`panic!`]: ../std/macro.panic.html
|
||||
#[stable(feature = "compile_error_macro", since = "1.20.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! compile_error {
|
||||
($msg:expr) => ({ /* compiler built-in */ });
|
||||
($msg:expr,) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro compile_error {
|
||||
($msg:expr) => ({ /* compiler built-in */ }),
|
||||
($msg:expr,) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Constructs parameters for the other string-formatting macros.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::format_args!`].
|
||||
/// This macro functions by taking a formatting string literal containing
|
||||
/// `{}` for each additional argument passed. `format_args!` prepares the
|
||||
/// additional parameters to ensure the output can be interpreted as a string
|
||||
/// and canonicalizes the arguments into a single type. Any value that implements
|
||||
/// the [`Display`] trait can be passed to `format_args!`, as can any
|
||||
/// [`Debug`] implementation be passed to a `{:?}` within the formatting string.
|
||||
///
|
||||
/// [`std::format_args!`]: ../std/macro.format_args.html
|
||||
/// This macro produces a value of type [`fmt::Arguments`]. This value can be
|
||||
/// passed to the macros within [`std::fmt`] for performing useful redirection.
|
||||
/// All other formatting macros ([`format!`], [`write!`], [`println!`], etc) are
|
||||
/// proxied through this one. `format_args!`, unlike its derived macros, avoids
|
||||
/// heap allocations.
|
||||
///
|
||||
/// You can use the [`fmt::Arguments`] value that `format_args!` returns
|
||||
/// in `Debug` and `Display` contexts as seen below. The example also shows
|
||||
/// that `Debug` and `Display` format to the same thing: the interpolated
|
||||
/// format string in `format_args!`.
|
||||
///
|
||||
/// ```rust
|
||||
/// let debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));
|
||||
/// let display = format!("{}", format_args!("{} foo {:?}", 1, 2));
|
||||
/// assert_eq!("1 foo 2", display);
|
||||
/// assert_eq!(display, debug);
|
||||
/// ```
|
||||
///
|
||||
/// For more information, see the documentation in [`std::fmt`].
|
||||
///
|
||||
/// [`Display`]: ../std/fmt/trait.Display.html
|
||||
/// [`Debug`]: ../std/fmt/trait.Debug.html
|
||||
/// [`fmt::Arguments`]: ../std/fmt/struct.Arguments.html
|
||||
/// [`std::fmt`]: ../std/fmt/index.html
|
||||
/// [`format!`]: ../std/macro.format.html
|
||||
/// [`write!`]: ../std/macro.write.html
|
||||
/// [`println!`]: ../std/macro.println.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::fmt;
|
||||
///
|
||||
/// let s = fmt::format(format_args!("hello {}", "world"));
|
||||
/// assert_eq!(s, format!("hello {}", "world"));
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! format_args {
|
||||
($fmt:expr) => ({ /* compiler built-in */ });
|
||||
($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ });
|
||||
#[allow_internal_unstable(fmt_internals)]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro format_args {
|
||||
($fmt:expr) => ({ /* compiler built-in */ }),
|
||||
($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Same as `format_args`, but adds a newline in the end.
|
||||
#[unstable(feature = "format_args_nl", issue = "0",
|
||||
reason = "`format_args_nl` is only for internal \
|
||||
language use and is subject to change")]
|
||||
#[allow_internal_unstable(fmt_internals)]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro format_args_nl {
|
||||
($fmt:expr) => ({ /* compiler built-in */ }),
|
||||
($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Inspects an environment variable at compile time.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::env!`].
|
||||
/// This macro will expand to the value of the named environment variable at
|
||||
/// compile time, yielding an expression of type `&'static str`.
|
||||
///
|
||||
/// [`std::env!`]: ../std/macro.env.html
|
||||
/// If the environment variable is not defined, then a compilation error
|
||||
/// will be emitted. To not emit a compile error, use the [`option_env!`]
|
||||
/// macro instead.
|
||||
///
|
||||
/// [`option_env!`]: ../std/macro.option_env.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let path: &'static str = env!("PATH");
|
||||
/// println!("the $PATH variable at the time of compiling was: {}", path);
|
||||
/// ```
|
||||
///
|
||||
/// You can customize the error message by passing a string as the second
|
||||
/// parameter:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// let doc: &'static str = env!("documentation", "what's that?!");
|
||||
/// ```
|
||||
///
|
||||
/// If the `documentation` environment variable is not defined, you'll get
|
||||
/// the following error:
|
||||
///
|
||||
/// ```text
|
||||
/// error: what's that?!
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! env {
|
||||
($name:expr) => ({ /* compiler built-in */ });
|
||||
($name:expr,) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro env {
|
||||
($name:expr) => ({ /* compiler built-in */ }),
|
||||
($name:expr,) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Optionally inspects an environment variable at compile time.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::option_env!`].
|
||||
/// If the named environment variable is present at compile time, this will
|
||||
/// expand into an expression of type `Option<&'static str>` whose value is
|
||||
/// `Some` of the value of the environment variable. If the environment
|
||||
/// variable is not present, then this will expand to `None`. See
|
||||
/// [`Option<T>`][option] for more information on this type.
|
||||
///
|
||||
/// [`std::option_env!`]: ../std/macro.option_env.html
|
||||
/// A compile time error is never emitted when using this macro regardless
|
||||
/// of whether the environment variable is present or not.
|
||||
///
|
||||
/// [option]: ../std/option/enum.Option.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let key: Option<&'static str> = option_env!("SECRET_KEY");
|
||||
/// println!("the secret key might be: {:?}", key);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! option_env {
|
||||
($name:expr) => ({ /* compiler built-in */ });
|
||||
($name:expr,) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro option_env {
|
||||
($name:expr) => ({ /* compiler built-in */ }),
|
||||
($name:expr,) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Concatenates identifiers into one identifier.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::concat_idents!`].
|
||||
/// This macro takes any number of comma-separated identifiers, and
|
||||
/// concatenates them all into one, yielding an expression which is a new
|
||||
/// identifier. Note that hygiene makes it such that this macro cannot
|
||||
/// capture local variables. Also, as a general rule, macros are only
|
||||
/// allowed in item, statement or expression position. That means while
|
||||
/// you may use this macro for referring to existing variables, functions or
|
||||
/// modules etc, you cannot define a new one with it.
|
||||
///
|
||||
/// [`std::concat_idents!`]: ../std/macro.concat_idents.html
|
||||
#[unstable(feature = "concat_idents_macro", issue = "29599")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! concat_idents {
|
||||
($($e:ident),+) => ({ /* compiler built-in */ });
|
||||
($($e:ident,)+) => ({ /* compiler built-in */ });
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(concat_idents)]
|
||||
///
|
||||
/// # fn main() {
|
||||
/// fn foobar() -> u32 { 23 }
|
||||
///
|
||||
/// let f = concat_idents!(foo, bar);
|
||||
/// println!("{}", f());
|
||||
///
|
||||
/// // fn concat_idents!(new, fun, name) { } // not usable in this way!
|
||||
/// # }
|
||||
/// ```
|
||||
#[unstable(feature = "concat_idents", issue = "29599",
|
||||
reason = "`concat_idents` is not stable enough for use and is subject to change")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro concat_idents {
|
||||
($($e:ident),+) => ({ /* compiler built-in */ }),
|
||||
($($e:ident,)+) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Concatenates literals into a static string slice.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::concat!`].
|
||||
/// This macro takes any number of comma-separated literals, yielding an
|
||||
/// expression of type `&'static str` which represents all of the literals
|
||||
/// concatenated left-to-right.
|
||||
///
|
||||
/// [`std::concat!`]: ../std/macro.concat.html
|
||||
/// Integer and floating point literals are stringified in order to be
|
||||
/// concatenated.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let s = concat!("test", 10, 'b', true);
|
||||
/// assert_eq!(s, "test10btrue");
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! concat {
|
||||
($($e:expr),*) => ({ /* compiler built-in */ });
|
||||
($($e:expr,)*) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro concat {
|
||||
($($e:expr),*) => ({ /* compiler built-in */ }),
|
||||
($($e:expr,)*) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Expands to the line number on which it was invoked.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::line!`].
|
||||
/// With [`column!`] and [`file!`], these macros provide debugging information for
|
||||
/// developers about the location within the source.
|
||||
///
|
||||
/// [`std::line!`]: ../std/macro.line.html
|
||||
/// The expanded expression has type `u32` and is 1-based, so the first line
|
||||
/// in each file evaluates to 1, the second to 2, etc. This is consistent
|
||||
/// with error messages by common compilers or popular editors.
|
||||
/// The returned line is *not necessarily* the line of the `line!` invocation itself,
|
||||
/// but rather the first macro invocation leading up to the invocation
|
||||
/// of the `line!` macro.
|
||||
///
|
||||
/// [`column!`]: macro.column.html
|
||||
/// [`file!`]: macro.file.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let current_line = line!();
|
||||
/// println!("defined on line: {}", current_line);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! line { () => ({ /* compiler built-in */ }) }
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro line() { /* compiler built-in */ }
|
||||
|
||||
/// Expands to the column number on which it was invoked.
|
||||
/// Expands to the column number at which it was invoked.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::column!`].
|
||||
/// With [`line!`] and [`file!`], these macros provide debugging information for
|
||||
/// developers about the location within the source.
|
||||
///
|
||||
/// [`std::column!`]: ../std/macro.column.html
|
||||
/// The expanded expression has type `u32` and is 1-based, so the first column
|
||||
/// in each line evaluates to 1, the second to 2, etc. This is consistent
|
||||
/// with error messages by common compilers or popular editors.
|
||||
/// The returned column is *not necessarily* the line of the `column!` invocation itself,
|
||||
/// but rather the first macro invocation leading up to the invocation
|
||||
/// of the `column!` macro.
|
||||
///
|
||||
/// [`line!`]: macro.line.html
|
||||
/// [`file!`]: macro.file.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let current_col = column!();
|
||||
/// println!("defined on column: {}", current_col);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! column { () => ({ /* compiler built-in */ }) }
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro column() { /* compiler built-in */ }
|
||||
|
||||
/// Expands to the file name from which it was invoked.
|
||||
/// Same as `column`, but less likely to be shadowed.
|
||||
#[unstable(feature = "__rust_unstable_column", issue = "0",
|
||||
reason = "internal implementation detail of the `column` macro")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro __rust_unstable_column() { /* compiler built-in */ }
|
||||
|
||||
/// Expands to the file name in which it was invoked.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::file!`].
|
||||
/// With [`line!`] and [`column!`], these macros provide debugging information for
|
||||
/// developers about the location within the source.
|
||||
///
|
||||
/// [`std::file!`]: ../std/macro.file.html
|
||||
///
|
||||
/// The expanded expression has type `&'static str`, and the returned file
|
||||
/// is not the invocation of the `file!` macro itself, but rather the
|
||||
/// first macro invocation leading up to the invocation of the `file!`
|
||||
/// macro.
|
||||
///
|
||||
/// [`line!`]: macro.line.html
|
||||
/// [`column!`]: macro.column.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let this_file = file!();
|
||||
/// println!("defined in file: {}", this_file);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! file { () => ({ /* compiler built-in */ }) }
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro file() { /* compiler built-in */ }
|
||||
|
||||
/// Stringifies its arguments.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::stringify!`].
|
||||
/// This macro will yield an expression of type `&'static str` which is the
|
||||
/// stringification of all the tokens passed to the macro. No restrictions
|
||||
/// are placed on the syntax of the macro invocation itself.
|
||||
///
|
||||
/// [`std::stringify!`]: ../std/macro.stringify.html
|
||||
/// Note that the expanded results of the input tokens may change in the
|
||||
/// future. You should be careful if you rely on the output.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let one_plus_one = stringify!(1 + 1);
|
||||
/// assert_eq!(one_plus_one, "1 + 1");
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! stringify { ($($t:tt)*) => ({ /* compiler built-in */ }) }
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro stringify($($t:tt)*) { /* compiler built-in */ }
|
||||
|
||||
/// Includes a utf8-encoded file as a string.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::include_str!`].
|
||||
/// The file is located relative to the current file. (similarly to how
|
||||
/// modules are found)
|
||||
///
|
||||
/// [`std::include_str!`]: ../std/macro.include_str.html
|
||||
/// This macro will yield an expression of type `&'static str` which is the
|
||||
/// contents of the file.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Assume there are two files in the same directory with the following
|
||||
/// contents:
|
||||
///
|
||||
/// File 'spanish.in':
|
||||
///
|
||||
/// ```text
|
||||
/// adiós
|
||||
/// ```
|
||||
///
|
||||
/// File 'main.rs':
|
||||
///
|
||||
/// ```ignore (cannot-doctest-external-file-dependency)
|
||||
/// fn main() {
|
||||
/// let my_str = include_str!("spanish.in");
|
||||
/// assert_eq!(my_str, "adiós\n");
|
||||
/// print!("{}", my_str);
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Compiling 'main.rs' and running the resulting binary will print "adiós".
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! include_str {
|
||||
($file:expr) => ({ /* compiler built-in */ });
|
||||
($file:expr,) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro include_str {
|
||||
($file:expr) => ({ /* compiler built-in */ }),
|
||||
($file:expr,) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Includes a file as a reference to a byte array.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::include_bytes!`].
|
||||
/// The file is located relative to the current file. (similarly to how
|
||||
/// modules are found)
|
||||
///
|
||||
/// [`std::include_bytes!`]: ../std/macro.include_bytes.html
|
||||
/// This macro will yield an expression of type `&'static [u8; N]` which is
|
||||
/// the contents of the file.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Assume there are two files in the same directory with the following
|
||||
/// contents:
|
||||
///
|
||||
/// File 'spanish.in':
|
||||
///
|
||||
/// ```text
|
||||
/// adiós
|
||||
/// ```
|
||||
///
|
||||
/// File 'main.rs':
|
||||
///
|
||||
/// ```ignore (cannot-doctest-external-file-dependency)
|
||||
/// fn main() {
|
||||
/// let bytes = include_bytes!("spanish.in");
|
||||
/// assert_eq!(bytes, b"adi\xc3\xb3s\n");
|
||||
/// print!("{}", String::from_utf8_lossy(bytes));
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Compiling 'main.rs' and running the resulting binary will print "adiós".
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! include_bytes {
|
||||
($file:expr) => ({ /* compiler built-in */ });
|
||||
($file:expr,) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro include_bytes {
|
||||
($file:expr) => ({ /* compiler built-in */ }),
|
||||
($file:expr,) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Expands to a string that represents the current module path.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::module_path!`].
|
||||
/// The current module path can be thought of as the hierarchy of modules
|
||||
/// leading back up to the crate root. The first component of the path
|
||||
/// returned is the name of the crate currently being compiled.
|
||||
///
|
||||
/// [`std::module_path!`]: ../std/macro.module_path.html
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// mod test {
|
||||
/// pub fn foo() {
|
||||
/// assert!(module_path!().ends_with("test"));
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// test::foo();
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! module_path { () => ({ /* compiler built-in */ }) }
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro module_path() { /* compiler built-in */ }
|
||||
|
||||
/// Evaluates boolean combinations of configuration flags, at compile-time.
|
||||
/// Evaluates boolean combinations of configuration flags at compile-time.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::cfg!`].
|
||||
/// In addition to the `#[cfg]` attribute, this macro is provided to allow
|
||||
/// boolean expression evaluation of configuration flags. This frequently
|
||||
/// leads to less duplicated code.
|
||||
///
|
||||
/// [`std::cfg!`]: ../std/macro.cfg.html
|
||||
/// The syntax given to this macro is the same syntax as the [`cfg`]
|
||||
/// attribute.
|
||||
///
|
||||
/// [`cfg`]: ../reference/conditional-compilation.html#the-cfg-attribute
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let my_directory = if cfg!(windows) {
|
||||
/// "windows-specific-directory"
|
||||
/// } else {
|
||||
/// "unix-directory"
|
||||
/// };
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! cfg { ($($cfg:tt)*) => ({ /* compiler built-in */ }) }
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro cfg($($cfg:tt)*) { /* compiler built-in */ }
|
||||
|
||||
/// Parses a file as an expression or an item according to the context.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::include!`].
|
||||
/// The file is located relative to the current file (similarly to how
|
||||
/// modules are found).
|
||||
///
|
||||
/// [`std::include!`]: ../std/macro.include.html
|
||||
/// Using this macro is often a bad idea, because if the file is
|
||||
/// parsed as an expression, it is going to be placed in the
|
||||
/// surrounding code unhygienically. This could result in variables
|
||||
/// or functions being different from what the file expected if
|
||||
/// there are variables or functions that have the same name in
|
||||
/// the current file.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Assume there are two files in the same directory with the following
|
||||
/// contents:
|
||||
///
|
||||
/// File 'monkeys.in':
|
||||
///
|
||||
/// ```ignore (only-for-syntax-highlight)
|
||||
/// ['🙈', '🙊', '🙉']
|
||||
/// .iter()
|
||||
/// .cycle()
|
||||
/// .take(6)
|
||||
/// .collect::<String>()
|
||||
/// ```
|
||||
///
|
||||
/// File 'main.rs':
|
||||
///
|
||||
/// ```ignore (cannot-doctest-external-file-dependency)
|
||||
/// fn main() {
|
||||
/// let my_string = include!("monkeys.in");
|
||||
/// assert_eq!("🙈🙊🙉🙈🙊🙉", my_string);
|
||||
/// println!("{}", my_string);
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Compiling 'main.rs' and running the resulting binary will print
|
||||
/// "🙈🙊🙉🙈🙊🙉".
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
macro_rules! include {
|
||||
($file:expr) => ({ /* compiler built-in */ });
|
||||
($file:expr,) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro include {
|
||||
($file:expr) => ({ /* compiler built-in */ }),
|
||||
($file:expr,) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Asserts that a boolean expression is `true` at runtime.
|
||||
///
|
||||
/// For more information, see the documentation for [`std::assert!`].
|
||||
/// This will invoke the [`panic!`] macro if the provided expression cannot be
|
||||
/// evaluated to `true` at runtime.
|
||||
///
|
||||
/// [`std::assert!`]: ../std/macro.assert.html
|
||||
#[rustc_doc_only_macro]
|
||||
/// # Uses
|
||||
///
|
||||
/// Assertions are always checked in both debug and release builds, and cannot
|
||||
/// be disabled. See [`debug_assert!`] for assertions that are not enabled in
|
||||
/// release builds by default.
|
||||
///
|
||||
/// Unsafe code relies on `assert!` to enforce run-time invariants that, if
|
||||
/// violated could lead to unsafety.
|
||||
///
|
||||
/// Other use-cases of `assert!` include testing and enforcing run-time
|
||||
/// invariants in safe code (whose violation cannot result in unsafety).
|
||||
///
|
||||
/// # Custom Messages
|
||||
///
|
||||
/// This macro has a second form, where a custom panic message can
|
||||
/// be provided with or without arguments for formatting. See [`std::fmt`]
|
||||
/// for syntax for this form.
|
||||
///
|
||||
/// [`panic!`]: macro.panic.html
|
||||
/// [`debug_assert!`]: macro.debug_assert.html
|
||||
/// [`std::fmt`]: ../std/fmt/index.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// // the panic message for these assertions is the stringified value of the
|
||||
/// // expression given.
|
||||
/// assert!(true);
|
||||
///
|
||||
/// fn some_computation() -> bool { true } // a very simple function
|
||||
///
|
||||
/// assert!(some_computation());
|
||||
///
|
||||
/// // assert with a custom message
|
||||
/// let x = true;
|
||||
/// assert!(x, "x wasn't true!");
|
||||
///
|
||||
/// let a = 3; let b = 27;
|
||||
/// assert!(a + b == 30, "a = {}, b = {}", a, b);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
macro_rules! assert {
|
||||
($cond:expr) => ({ /* compiler built-in */ });
|
||||
($cond:expr,) => ({ /* compiler built-in */ });
|
||||
($cond:expr, $($arg:tt)+) => ({ /* compiler built-in */ });
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro assert {
|
||||
($cond:expr) => ({ /* compiler built-in */ }),
|
||||
($cond:expr,) => ({ /* compiler built-in */ }),
|
||||
($cond:expr, $($arg:tt)+) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Inline assembly.
|
||||
#[unstable(feature = "asm", issue = "29722",
|
||||
reason = "inline assembly is not stable enough for use and is subject to change")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro asm("assembly template"
|
||||
: $("output"(operand),)*
|
||||
: $("input"(operand),)*
|
||||
: $("clobbers",)*
|
||||
: $("options",)*) { /* compiler built-in */ }
|
||||
|
||||
/// Module-level inline assembly.
|
||||
#[unstable(feature = "global_asm", issue = "35119",
|
||||
reason = "`global_asm!` is not stable enough for use and is subject to change")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro global_asm("assembly") { /* compiler built-in */ }
|
||||
|
||||
/// Prints passed tokens into the standard output.
|
||||
#[unstable(feature = "log_syntax", issue = "29598",
|
||||
reason = "`log_syntax!` is not stable enough for use and is subject to change")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro log_syntax($($arg:tt)*) { /* compiler built-in */ }
|
||||
|
||||
/// Enables or disables tracing functionality used for debugging other macros.
|
||||
#[unstable(feature = "trace_macros", issue = "29598",
|
||||
reason = "`trace_macros` is not stable enough for use and is subject to change")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro trace_macros {
|
||||
(true) => ({ /* compiler built-in */ }),
|
||||
(false) => ({ /* compiler built-in */ })
|
||||
}
|
||||
|
||||
/// Attribute macro applied to a function to turn it into a unit test.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro test($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Attribute macro applied to a function to turn it into a benchmark test.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro bench($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// An implementation detail of the `#[test]` and `#[bench]` macros.
|
||||
#[unstable(feature = "custom_test_frameworks", issue = "50297",
|
||||
reason = "custom test frameworks are an unstable feature")]
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro test_case($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `Clone`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
|
||||
pub macro Clone($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `Copy`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
|
||||
pub macro Copy($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `Debug`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro Debug($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Unstable implementation detail of the `rustc` compiler, do not use.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_deprecated(
|
||||
since = "1.0.0",
|
||||
reason = "derive(Decodable) is deprecated in favor of derive(RustcDecodable)",
|
||||
suggestion = "RustcDecodable",
|
||||
)]
|
||||
#[allow_internal_unstable(core_intrinsics, libstd_sys_internals)]
|
||||
pub macro Decodable($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `Default`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro Default($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Unstable implementation detail of the `rustc` compiler, do not use.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_deprecated(
|
||||
since = "1.0.0",
|
||||
reason = "derive(Encodable) is deprecated in favor of derive(RustcEncodable)",
|
||||
suggestion = "RustcEncodable",
|
||||
)]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro Encodable($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `Eq`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics, derive_eq)]
|
||||
pub macro Eq($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `Hash`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro Hash($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `Ord`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro Ord($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `PartialEq`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro PartialEq($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Derive macro generating an impl of the trait `PartialOrd`.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro PartialOrd($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Unstable implementation detail of the `rustc` compiler, do not use.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics, libstd_sys_internals)]
|
||||
pub macro RustcDecodable($item:item) { /* compiler built-in */ }
|
||||
|
||||
/// Unstable implementation detail of the `rustc` compiler, do not use.
|
||||
#[rustc_builtin_macro]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable(core_intrinsics)]
|
||||
pub macro RustcEncodable($item:item) { /* compiler built-in */ }
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -4010,7 +4010,7 @@ impl<'a> LoweringContext<'a> {
|
|||
let attrs = self.lower_attrs(&i.attrs);
|
||||
if let ItemKind::MacroDef(ref def) = i.node {
|
||||
if !def.legacy || attr::contains_name(&i.attrs, sym::macro_export) ||
|
||||
attr::contains_name(&i.attrs, sym::rustc_doc_only_macro) {
|
||||
attr::contains_name(&i.attrs, sym::rustc_builtin_macro) {
|
||||
let body = self.lower_token_stream(def.stream());
|
||||
let hir_id = self.lower_node_id(i.id);
|
||||
self.exported_macros.push(hir::MacroDef {
|
||||
|
|
|
|||
|
|
@ -170,8 +170,7 @@ impl CodegenCx<'ll, 'tcx> {
|
|||
pub fn const_get_real(&self, v: &'ll Value) -> Option<(f64, bool)> {
|
||||
unsafe {
|
||||
if self.is_const_real(v) {
|
||||
#[allow(deprecated)]
|
||||
let mut loses_info: llvm::Bool = ::std::mem::uninitialized();
|
||||
let mut loses_info: llvm::Bool = 0;
|
||||
let r = llvm::LLVMConstRealGetDouble(v, &mut loses_info);
|
||||
let loses_info = if loses_info == 1 { true } else { false };
|
||||
Some((r, loses_info))
|
||||
|
|
|
|||
|
|
@ -1465,7 +1465,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
|
|||
.map(|b| GuardFrameLocal::new(b.var_id, b.binding_mode))
|
||||
.collect(),
|
||||
};
|
||||
debug!("Entering guard building context: {:?}", guard_frame);
|
||||
debug!("entering guard building context: {:?}", guard_frame);
|
||||
self.guard_context.push(guard_frame);
|
||||
|
||||
let re_erased = tcx.lifetimes.re_erased;
|
||||
|
|
|
|||
|
|
@ -577,7 +577,7 @@ fn check_legality_of_move_bindings(
|
|||
"cannot bind by-move into a pattern guard");
|
||||
err.span_label(p.span, "moves value into pattern guard");
|
||||
if cx.tcx.sess.opts.unstable_features.is_nightly_build() {
|
||||
err.help("add #![feature(bind_by_move_pattern_guards)] to the \
|
||||
err.help("add `#![feature(bind_by_move_pattern_guards)]` to the \
|
||||
crate attributes to enable");
|
||||
}
|
||||
err.emit();
|
||||
|
|
@ -664,7 +664,7 @@ impl<'a, 'tcx> Delegate<'tcx> for MutationChecker<'a, 'tcx> {
|
|||
"cannot mutably borrow in a pattern guard");
|
||||
err.span_label(span, "borrowed mutably in pattern guard");
|
||||
if self.cx.tcx.sess.opts.unstable_features.is_nightly_build() {
|
||||
err.help("add #![feature(bind_by_move_pattern_guards)] to the \
|
||||
err.help("add `#![feature(bind_by_move_pattern_guards)]` to the \
|
||||
crate attributes to enable");
|
||||
}
|
||||
err.emit();
|
||||
|
|
|
|||
|
|
@ -351,7 +351,7 @@ where
|
|||
if field >= len {
|
||||
// This can be violated because this runs during promotion on code where the
|
||||
// type system has not yet ensured that such things don't happen.
|
||||
debug!("Tried to access element {} of array/slice with length {}", field, len);
|
||||
debug!("tried to access element {} of array/slice with length {}", field, len);
|
||||
return err!(BoundsCheck { len, index: field });
|
||||
}
|
||||
stride * field
|
||||
|
|
|
|||
|
|
@ -289,7 +289,7 @@ pub fn collect_crate_mono_items(
|
|||
collect_roots(tcx, mode)
|
||||
});
|
||||
|
||||
debug!("Building mono item graph, beginning at roots");
|
||||
debug!("building mono item graph, beginning at roots");
|
||||
|
||||
let mut visited = MTLock::new(FxHashSet::default());
|
||||
let mut inlining_map = MTLock::new(InliningMap::new());
|
||||
|
|
@ -316,7 +316,7 @@ pub fn collect_crate_mono_items(
|
|||
// Find all non-generic items by walking the HIR. These items serve as roots to
|
||||
// start monomorphizing from.
|
||||
fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionMode) -> Vec<MonoItem<'_>> {
|
||||
debug!("Collecting roots");
|
||||
debug!("collecting roots");
|
||||
let mut roots = Vec::new();
|
||||
|
||||
{
|
||||
|
|
|
|||
|
|
@ -552,10 +552,10 @@ fn unsafe_derive_on_repr_packed(tcx: TyCtxt<'_>, def_id: DefId) {
|
|||
// FIXME: when we make this a hard error, this should have its
|
||||
// own error code.
|
||||
let message = if tcx.generics_of(def_id).own_requires_monomorphization() {
|
||||
"#[derive] can't be used on a #[repr(packed)] struct with \
|
||||
"`#[derive]` can't be used on a `#[repr(packed)]` struct with \
|
||||
type or const parameters (error E0133)".to_string()
|
||||
} else {
|
||||
"#[derive] can't be used on a #[repr(packed)] struct that \
|
||||
"`#[derive]` can't be used on a `#[repr(packed)]` struct that \
|
||||
does not derive Copy (error E0133)".to_string()
|
||||
};
|
||||
tcx.lint_hir(SAFE_PACKED_BORROWS,
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ impl MirPass for CopyPropagation {
|
|||
|
||||
let mut changed = false;
|
||||
for dest_local in body.local_decls.indices() {
|
||||
debug!("Considering destination local: {:?}", dest_local);
|
||||
debug!("considering destination local: {:?}", dest_local);
|
||||
|
||||
let action;
|
||||
let location;
|
||||
|
|
@ -159,7 +159,7 @@ fn eliminate_self_assignments(
|
|||
} else {
|
||||
continue;
|
||||
}
|
||||
debug!("Deleting a self-assignment for {:?}", dest_local);
|
||||
debug!("deleting a self-assignment for {:?}", dest_local);
|
||||
body.make_statement_nop(location);
|
||||
changed = true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ impl Inliner<'tcx> {
|
|||
|
||||
// Simplify if we inlined anything.
|
||||
if changed {
|
||||
debug!("Running simplify cfg on {:?}", self.source);
|
||||
debug!("running simplify cfg on {:?}", self.source);
|
||||
CfgSimplifier::new(caller_body).simplify();
|
||||
remove_dead_blocks(caller_body);
|
||||
}
|
||||
|
|
@ -247,7 +247,7 @@ impl Inliner<'tcx> {
|
|||
// need to check for first.
|
||||
attr::InlineAttr::Always => true,
|
||||
attr::InlineAttr::Never => {
|
||||
debug!("#[inline(never)] present - not inlining");
|
||||
debug!("`#[inline(never)]` present - not inlining");
|
||||
return false
|
||||
}
|
||||
attr::InlineAttr::Hint => true,
|
||||
|
|
@ -397,7 +397,7 @@ impl Inliner<'tcx> {
|
|||
match terminator.kind {
|
||||
// FIXME: Handle inlining of diverging calls
|
||||
TerminatorKind::Call { args, destination: Some(destination), cleanup, .. } => {
|
||||
debug!("Inlined {:?} into {:?}", callsite.callee, self.source);
|
||||
debug!("inlined {:?} into {:?}", callsite.callee, self.source);
|
||||
|
||||
let mut local_map = IndexVec::with_capacity(callee_body.local_decls.len());
|
||||
let mut scope_map = IndexVec::with_capacity(callee_body.source_scopes.len());
|
||||
|
|
@ -456,7 +456,7 @@ impl Inliner<'tcx> {
|
|||
}
|
||||
|
||||
let dest = if dest_needs_borrow(&destination.0) {
|
||||
debug!("Creating temp for return destination");
|
||||
debug!("creating temp for return destination");
|
||||
let dest = Rvalue::Ref(
|
||||
self.tcx.lifetimes.re_erased,
|
||||
BorrowKind::Mut { allow_two_phase_borrow: false },
|
||||
|
|
@ -610,7 +610,7 @@ impl Inliner<'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
debug!("Creating temp for argument {:?}", arg);
|
||||
debug!("creating temp for argument {:?}", arg);
|
||||
// Otherwise, create a temporary for the arg
|
||||
let arg = Rvalue::Use(arg);
|
||||
|
||||
|
|
@ -659,7 +659,7 @@ struct Integrator<'a, 'tcx> {
|
|||
impl<'a, 'tcx> Integrator<'a, 'tcx> {
|
||||
fn update_target(&self, tgt: BasicBlock) -> BasicBlock {
|
||||
let new = BasicBlock::new(tgt.index() + self.block_idx);
|
||||
debug!("Updating target `{:?}`, new: `{:?}`", tgt, new);
|
||||
debug!("updating target `{:?}`, new: `{:?}`", tgt, new);
|
||||
new
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ pub struct InstCombineVisitor<'tcx> {
|
|||
impl<'tcx> MutVisitor<'tcx> for InstCombineVisitor<'tcx> {
|
||||
fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>, location: Location) {
|
||||
if self.optimizations.and_stars.remove(&location) {
|
||||
debug!("Replacing `&*`: {:?}", rvalue);
|
||||
debug!("replacing `&*`: {:?}", rvalue);
|
||||
let new_place = match *rvalue {
|
||||
Rvalue::Ref(_, _, Place::Projection(ref mut projection)) => {
|
||||
// Replace with dummy
|
||||
|
|
@ -51,7 +51,7 @@ impl<'tcx> MutVisitor<'tcx> for InstCombineVisitor<'tcx> {
|
|||
}
|
||||
|
||||
if let Some(constant) = self.optimizations.arrays_lengths.remove(&location) {
|
||||
debug!("Replacing `Len([_; N])`: {:?}", rvalue);
|
||||
debug!("replacing `Len([_; N])`: {:?}", rvalue);
|
||||
*rvalue = Rvalue::Use(Operand::Constant(box constant));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1545,7 +1545,7 @@ impl MirPass for QualifyAndPromoteConstants {
|
|||
diag.note("for more information, see issue \
|
||||
https://github.com/rust-lang/rust/issues/57563");
|
||||
diag.help(
|
||||
"add #![feature(const_fn)] to the crate attributes to enable",
|
||||
"add `#![feature(const_fn)]` to the crate attributes to enable",
|
||||
);
|
||||
diag.emit();
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ use rustc_data_structures::fx::FxHashSet;
|
|||
use syntax::ast::Ident;
|
||||
use syntax::attr;
|
||||
use syntax::symbol::{kw, sym};
|
||||
use syntax_pos::hygiene::Transparency;
|
||||
use syntax_pos::Span;
|
||||
|
||||
use std::{cmp, fmt, mem};
|
||||
|
|
@ -743,7 +744,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
|
|||
}
|
||||
|
||||
fn visit_macro_def(&mut self, md: &'tcx hir::MacroDef) {
|
||||
if md.legacy {
|
||||
if attr::find_transparency(&md.attrs, md.legacy).0 != Transparency::Opaque {
|
||||
self.update(md.hir_id, Some(AccessLevel::Public));
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -770,19 +770,25 @@ impl<'a> Resolver<'a> {
|
|||
}
|
||||
|
||||
pub fn get_macro(&mut self, res: Res) -> Lrc<SyntaxExtension> {
|
||||
self.opt_get_macro(res).expect("expected `DefKind::Macro` or `Res::NonMacroAttr`")
|
||||
}
|
||||
|
||||
crate fn opt_get_macro(&mut self, res: Res) -> Option<Lrc<SyntaxExtension>> {
|
||||
let def_id = match res {
|
||||
Res::Def(DefKind::Macro(MacroKind::ProcMacroStub), _) =>
|
||||
return Some(self.non_macro_attr(true)), // some dummy extension
|
||||
Res::Def(DefKind::Macro(..), def_id) => def_id,
|
||||
Res::NonMacroAttr(attr_kind) =>
|
||||
return self.non_macro_attr(attr_kind == NonMacroAttrKind::Tool),
|
||||
_ => panic!("expected `DefKind::Macro` or `Res::NonMacroAttr`"),
|
||||
return Some(self.non_macro_attr(attr_kind == NonMacroAttrKind::Tool)),
|
||||
_ => return None,
|
||||
};
|
||||
if let Some(ext) = self.macro_map.get(&def_id) {
|
||||
return ext.clone();
|
||||
return Some(ext.clone());
|
||||
}
|
||||
|
||||
let macro_def = match self.cstore.load_macro_untracked(def_id, &self.session) {
|
||||
LoadedMacro::MacroDef(macro_def) => macro_def,
|
||||
LoadedMacro::ProcMacro(ext) => return ext,
|
||||
LoadedMacro::ProcMacro(ext) => return Some(ext),
|
||||
};
|
||||
|
||||
let ext = Lrc::new(macro_rules::compile(&self.session.parse_sess,
|
||||
|
|
@ -790,7 +796,7 @@ impl<'a> Resolver<'a> {
|
|||
¯o_def,
|
||||
self.cstore.crate_edition_untracked(def_id.krate)));
|
||||
self.macro_map.insert(def_id, ext.clone());
|
||||
ext
|
||||
Some(ext)
|
||||
}
|
||||
|
||||
/// Ensures that the reduced graph rooted at the given external module
|
||||
|
|
|
|||
|
|
@ -1106,6 +1106,19 @@ impl<'a> Resolver<'a> {
|
|||
});
|
||||
}
|
||||
|
||||
crate fn check_reserved_macro_name(&mut self, ident: Ident, res: Res) {
|
||||
// Reserve some names that are not quite covered by the general check
|
||||
// performed on `Resolver::builtin_attrs`.
|
||||
if ident.name == sym::cfg || ident.name == sym::cfg_attr || ident.name == sym::derive {
|
||||
let macro_kind = self.opt_get_macro(res).map(|ext| ext.macro_kind());
|
||||
if macro_kind.is_some() && sub_namespace_match(macro_kind, Some(MacroKind::Attr)) {
|
||||
self.session.span_err(
|
||||
ident.span, &format!("name `{}` is reserved in attribute namespace", ident)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn define_macro(&mut self,
|
||||
item: &ast::Item,
|
||||
expansion: Mark,
|
||||
|
|
@ -1117,13 +1130,14 @@ impl<'a> Resolver<'a> {
|
|||
let ext = Lrc::new(macro_rules::compile(&self.session.parse_sess,
|
||||
&self.session.features_untracked(),
|
||||
item, self.session.edition()));
|
||||
let macro_kind = ext.macro_kind();
|
||||
let res = Res::Def(DefKind::Macro(macro_kind), def_id);
|
||||
self.macro_map.insert(def_id, ext);
|
||||
|
||||
let def = match item.node { ast::ItemKind::MacroDef(ref def) => def, _ => unreachable!() };
|
||||
if def.legacy {
|
||||
let ident = ident.modern();
|
||||
self.macro_names.insert(ident);
|
||||
let res = Res::Def(DefKind::Macro(MacroKind::Bang), def_id);
|
||||
let is_macro_export = attr::contains_name(&item.attrs, sym::macro_export);
|
||||
let vis = if is_macro_export {
|
||||
ty::Visibility::Public
|
||||
|
|
@ -1142,14 +1156,11 @@ impl<'a> Resolver<'a> {
|
|||
self.define(module, ident, MacroNS,
|
||||
(res, vis, item.span, expansion, IsMacroExport));
|
||||
} else {
|
||||
if !attr::contains_name(&item.attrs, sym::rustc_doc_only_macro) {
|
||||
self.check_reserved_macro_name(ident, MacroNS);
|
||||
}
|
||||
self.check_reserved_macro_name(ident, res);
|
||||
self.unused_macros.insert(def_id);
|
||||
}
|
||||
} else {
|
||||
let module = self.current_module;
|
||||
let res = Res::Def(DefKind::Macro(MacroKind::Bang), def_id);
|
||||
let vis = self.resolve_visibility(&item.vis);
|
||||
if vis != ty::Visibility::Public {
|
||||
self.unused_macros.insert(def_id);
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ use rustc::{bug, span_bug};
|
|||
use syntax::ast::{self, Ident, Name, NodeId, CRATE_NODE_ID};
|
||||
use syntax::ext::base::Determinacy::{self, Determined, Undetermined};
|
||||
use syntax::ext::hygiene::Mark;
|
||||
use syntax::symbol::{kw, sym};
|
||||
use syntax::symbol::kw;
|
||||
use syntax::util::lev_distance::find_best_match_for_name;
|
||||
use syntax::{struct_span_err, unwrap_or};
|
||||
use syntax_pos::{MultiSpan, Span};
|
||||
|
|
@ -492,17 +492,6 @@ impl<'a> Resolver<'a> {
|
|||
})
|
||||
}
|
||||
|
||||
crate fn check_reserved_macro_name(&self, ident: Ident, ns: Namespace) {
|
||||
// Reserve some names that are not quite covered by the general check
|
||||
// performed on `Resolver::builtin_attrs`.
|
||||
if ns == MacroNS &&
|
||||
(ident.name == sym::cfg || ident.name == sym::cfg_attr ||
|
||||
ident.name == sym::derive) {
|
||||
self.session.span_err(ident.span,
|
||||
&format!("name `{}` is reserved in macro namespace", ident));
|
||||
}
|
||||
}
|
||||
|
||||
// Define the name or return the existing binding if there is a collision.
|
||||
pub fn try_define(&mut self,
|
||||
module: Module<'a>,
|
||||
|
|
@ -510,17 +499,18 @@ impl<'a> Resolver<'a> {
|
|||
ns: Namespace,
|
||||
binding: &'a NameBinding<'a>)
|
||||
-> Result<(), &'a NameBinding<'a>> {
|
||||
self.check_reserved_macro_name(ident, ns);
|
||||
let res = binding.res();
|
||||
self.check_reserved_macro_name(ident, res);
|
||||
self.set_binding_parent_module(binding, module);
|
||||
self.update_resolution(module, ident, ns, |this, resolution| {
|
||||
if let Some(old_binding) = resolution.binding {
|
||||
if binding.res() == Res::Err {
|
||||
if res == Res::Err {
|
||||
// Do not override real bindings with `Res::Err`s from error recovery.
|
||||
return Ok(());
|
||||
}
|
||||
match (old_binding.is_glob_import(), binding.is_glob_import()) {
|
||||
(true, true) => {
|
||||
if binding.res() != old_binding.res() {
|
||||
if res != old_binding.res() {
|
||||
resolution.binding = Some(this.ambiguity(AmbiguityKind::GlobVsGlob,
|
||||
old_binding, binding));
|
||||
} else if !old_binding.vis.is_at_least(binding.vis, &*this) {
|
||||
|
|
|
|||
|
|
@ -410,7 +410,7 @@ mod builtin {
|
|||
///
|
||||
/// [`panic!`]: ../std/macro.panic.html
|
||||
#[stable(feature = "compile_error_macro", since = "1.20.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! compile_error {
|
||||
($msg:expr) => ({ /* compiler built-in */ });
|
||||
($msg:expr,) => ({ /* compiler built-in */ });
|
||||
|
|
@ -462,7 +462,7 @@ mod builtin {
|
|||
/// assert_eq!(s, format!("hello {}", "world"));
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! format_args {
|
||||
($fmt:expr) => ({ /* compiler built-in */ });
|
||||
($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ });
|
||||
|
|
@ -500,7 +500,7 @@ mod builtin {
|
|||
/// error: what's that?!
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! env {
|
||||
($name:expr) => ({ /* compiler built-in */ });
|
||||
($name:expr,) => ({ /* compiler built-in */ });
|
||||
|
|
@ -526,7 +526,7 @@ mod builtin {
|
|||
/// println!("the secret key might be: {:?}", key);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! option_env {
|
||||
($name:expr) => ({ /* compiler built-in */ });
|
||||
($name:expr,) => ({ /* compiler built-in */ });
|
||||
|
|
@ -557,7 +557,7 @@ mod builtin {
|
|||
/// # }
|
||||
/// ```
|
||||
#[unstable(feature = "concat_idents_macro", issue = "29599")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! concat_idents {
|
||||
($($e:ident),+) => ({ /* compiler built-in */ });
|
||||
($($e:ident,)+) => ({ /* compiler built-in */ });
|
||||
|
|
@ -579,7 +579,7 @@ mod builtin {
|
|||
/// assert_eq!(s, "test10btrue");
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! concat {
|
||||
($($e:expr),*) => ({ /* compiler built-in */ });
|
||||
($($e:expr,)*) => ({ /* compiler built-in */ });
|
||||
|
|
@ -607,7 +607,7 @@ mod builtin {
|
|||
/// println!("defined on line: {}", current_line);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! line { () => ({ /* compiler built-in */ }) }
|
||||
|
||||
/// Expands to the column number at which it was invoked.
|
||||
|
|
@ -632,7 +632,7 @@ mod builtin {
|
|||
/// println!("defined on column: {}", current_col);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! column { () => ({ /* compiler built-in */ }) }
|
||||
|
||||
/// Expands to the file name in which it was invoked.
|
||||
|
|
@ -656,7 +656,7 @@ mod builtin {
|
|||
/// println!("defined in file: {}", this_file);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! file { () => ({ /* compiler built-in */ }) }
|
||||
|
||||
/// Stringifies its arguments.
|
||||
|
|
@ -675,7 +675,7 @@ mod builtin {
|
|||
/// assert_eq!(one_plus_one, "1 + 1");
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! stringify { ($($t:tt)*) => ({ /* compiler built-in */ }) }
|
||||
|
||||
/// Includes a utf8-encoded file as a string.
|
||||
|
|
@ -709,7 +709,7 @@ mod builtin {
|
|||
///
|
||||
/// Compiling 'main.rs' and running the resulting binary will print "adiós".
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! include_str {
|
||||
($file:expr) => ({ /* compiler built-in */ });
|
||||
($file:expr,) => ({ /* compiler built-in */ });
|
||||
|
|
@ -746,7 +746,7 @@ mod builtin {
|
|||
///
|
||||
/// Compiling 'main.rs' and running the resulting binary will print "adiós".
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! include_bytes {
|
||||
($file:expr) => ({ /* compiler built-in */ });
|
||||
($file:expr,) => ({ /* compiler built-in */ });
|
||||
|
|
@ -770,7 +770,7 @@ mod builtin {
|
|||
/// test::foo();
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! module_path { () => ({ /* compiler built-in */ }) }
|
||||
|
||||
/// Evaluates boolean combinations of configuration flags at compile-time.
|
||||
|
|
@ -794,7 +794,7 @@ mod builtin {
|
|||
/// };
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! cfg { ($($cfg:tt)*) => ({ /* compiler built-in */ }) }
|
||||
|
||||
/// Parses a file as an expression or an item according to the context.
|
||||
|
|
@ -837,7 +837,7 @@ mod builtin {
|
|||
/// Compiling 'main.rs' and running the resulting binary will print
|
||||
/// "🙈🙊🙉🙈🙊🙉".
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! include {
|
||||
($file:expr) => ({ /* compiler built-in */ });
|
||||
($file:expr,) => ({ /* compiler built-in */ });
|
||||
|
|
@ -889,7 +889,7 @@ mod builtin {
|
|||
/// assert!(a + b == 30, "a = {}, b = {}", a, b);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_doc_only_macro]
|
||||
#[rustc_builtin_macro]
|
||||
macro_rules! assert {
|
||||
($cond:expr) => ({ /* compiler built-in */ });
|
||||
($cond:expr,) => ({ /* compiler built-in */ });
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ use crate::feature_gate::{Features, GatedCfg};
|
|||
use crate::parse::ParseSess;
|
||||
|
||||
use errors::{Applicability, Handler};
|
||||
use syntax_pos::hygiene::Transparency;
|
||||
use syntax_pos::{symbol::Symbol, symbol::sym, Span};
|
||||
|
||||
use super::{mark_used, MetaItemKind};
|
||||
|
|
@ -854,3 +855,35 @@ fn int_type_of_word(s: Symbol) -> Option<IntType> {
|
|||
_ => None
|
||||
}
|
||||
}
|
||||
|
||||
pub enum TransparencyError {
|
||||
UnknownTransparency(Symbol, Span),
|
||||
MultipleTransparencyAttrs(Span, Span),
|
||||
}
|
||||
|
||||
pub fn find_transparency(
|
||||
attrs: &[Attribute], is_legacy: bool
|
||||
) -> (Transparency, Option<TransparencyError>) {
|
||||
let mut transparency = None;
|
||||
let mut error = None;
|
||||
for attr in attrs {
|
||||
if attr.check_name(sym::rustc_macro_transparency) {
|
||||
if let Some((_, old_span)) = transparency {
|
||||
error = Some(TransparencyError::MultipleTransparencyAttrs(old_span, attr.span));
|
||||
break;
|
||||
} else if let Some(value) = attr.value_str() {
|
||||
transparency = Some((match &*value.as_str() {
|
||||
"transparent" => Transparency::Transparent,
|
||||
"semitransparent" => Transparency::SemiTransparent,
|
||||
"opaque" => Transparency::Opaque,
|
||||
_ => {
|
||||
error = Some(TransparencyError::UnknownTransparency(value, attr.span));
|
||||
continue;
|
||||
}
|
||||
}, attr.span));
|
||||
}
|
||||
}
|
||||
}
|
||||
let fallback = if is_legacy { Transparency::SemiTransparent } else { Transparency::Opaque };
|
||||
(transparency.map_or(fallback, |t| t.0), error)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,11 +2,7 @@
|
|||
|
||||
mod builtin;
|
||||
|
||||
pub use builtin::{
|
||||
cfg_matches, contains_feature_attr, eval_condition, find_crate_name, find_deprecation,
|
||||
find_repr_attrs, find_stability, find_unwind_attr, Deprecation, InlineAttr, OptimizeAttr,
|
||||
IntType, ReprAttr, RustcDeprecation, Stability, StabilityLevel, UnwindAttr,
|
||||
};
|
||||
pub use builtin::*;
|
||||
pub use IntType::*;
|
||||
pub use ReprAttr::*;
|
||||
pub use StabilityLevel::*;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ use crate::edition::Edition;
|
|||
use crate::ext::base::{DummyResult, ExtCtxt, MacResult, TTMacroExpander};
|
||||
use crate::ext::base::{SyntaxExtension, SyntaxExtensionKind};
|
||||
use crate::ext::expand::{AstFragment, AstFragmentKind};
|
||||
use crate::ext::hygiene::Transparency;
|
||||
use crate::ext::tt::macro_parser::{parse, parse_failure_msg};
|
||||
use crate::ext::tt::macro_parser::{Error, Failure, Success};
|
||||
use crate::ext::tt::macro_parser::{MatchedNonterminal, MatchedSeq};
|
||||
|
|
@ -15,7 +14,7 @@ use crate::parse::token::{self, NtTT, Token};
|
|||
use crate::parse::{Directory, ParseSess};
|
||||
use crate::symbol::{kw, sym, Symbol};
|
||||
use crate::tokenstream::{DelimSpan, TokenStream, TokenTree};
|
||||
use crate::{ast, attr};
|
||||
use crate::{ast, attr, attr::TransparencyError};
|
||||
|
||||
use errors::FatalError;
|
||||
use log::debug;
|
||||
|
|
@ -380,13 +379,19 @@ pub fn compile(
|
|||
let expander: Box<_> =
|
||||
Box::new(MacroRulesMacroExpander { name: def.ident, lhses, rhses, valid });
|
||||
|
||||
let default_transparency = if attr::contains_name(&def.attrs, sym::rustc_transparent_macro) {
|
||||
Transparency::Transparent
|
||||
} else if body.legacy {
|
||||
Transparency::SemiTransparent
|
||||
} else {
|
||||
Transparency::Opaque
|
||||
};
|
||||
let (default_transparency, transparency_error) =
|
||||
attr::find_transparency(&def.attrs, body.legacy);
|
||||
match transparency_error {
|
||||
Some(TransparencyError::UnknownTransparency(value, span)) =>
|
||||
sess.span_diagnostic.span_err(
|
||||
span, &format!("unknown macro transparency: `{}`", value)
|
||||
),
|
||||
Some(TransparencyError::MultipleTransparencyAttrs(old_span, new_span)) =>
|
||||
sess.span_diagnostic.span_err(
|
||||
vec![old_span, new_span], "multiple macro transparency attributes"
|
||||
),
|
||||
None => {}
|
||||
}
|
||||
|
||||
let allow_internal_unstable =
|
||||
attr::find_by_name(&def.attrs, sym::allow_internal_unstable).map(|attr| {
|
||||
|
|
|
|||
|
|
@ -245,7 +245,7 @@ declare_features! (
|
|||
(active, allocator_internals, "1.20.0", None, None),
|
||||
|
||||
// Allows using the `format_args_nl` macro.
|
||||
(active, format_args_nl, "1.29.0", None, None),
|
||||
(active, format_args_nl, "1.29.0", Some(0), None),
|
||||
|
||||
// no-tracking-issue-end
|
||||
|
||||
|
|
@ -1313,7 +1313,9 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
|
|||
"the `#[rustc_test_marker]` attribute \
|
||||
is used internally to track tests",
|
||||
cfg_fn!(rustc_attrs))),
|
||||
(sym::rustc_transparent_macro, Whitelisted, template!(Word), Gated(Stability::Unstable,
|
||||
(sym::rustc_macro_transparency, Whitelisted, template!(NameValueStr:
|
||||
"transparent|semitransparent|opaque"),
|
||||
Gated(Stability::Unstable,
|
||||
sym::rustc_attrs,
|
||||
"used internally for testing macro hygiene",
|
||||
cfg_fn!(rustc_attrs))),
|
||||
|
|
@ -1374,7 +1376,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
|
|||
"internal implementation detail",
|
||||
cfg_fn!(rustc_attrs))),
|
||||
|
||||
(sym::rustc_doc_only_macro, Whitelisted, template!(Word), Gated(Stability::Unstable,
|
||||
(sym::rustc_builtin_macro, Whitelisted, template!(Word), Gated(Stability::Unstable,
|
||||
sym::rustc_attrs,
|
||||
"internal implementation detail",
|
||||
cfg_fn!(rustc_attrs))),
|
||||
|
|
|
|||
|
|
@ -537,6 +537,7 @@ symbols! {
|
|||
rustc_allow_const_fn_ptr,
|
||||
rustc_args_required_const,
|
||||
rustc_attrs,
|
||||
rustc_builtin_macro,
|
||||
rustc_clean,
|
||||
rustc_const_unstable,
|
||||
rustc_conversion_suggestion,
|
||||
|
|
@ -545,7 +546,6 @@ symbols! {
|
|||
rustc_deprecated,
|
||||
rustc_diagnostic_macros,
|
||||
rustc_dirty,
|
||||
rustc_doc_only_macro,
|
||||
rustc_dummy,
|
||||
rustc_dump_env_program_clauses,
|
||||
rustc_dump_program_clauses,
|
||||
|
|
@ -557,6 +557,7 @@ symbols! {
|
|||
rustc_layout,
|
||||
rustc_layout_scalar_valid_range_end,
|
||||
rustc_layout_scalar_valid_range_start,
|
||||
rustc_macro_transparency,
|
||||
rustc_mir,
|
||||
rustc_nonnull_optimization_guaranteed,
|
||||
rustc_object_lifetime_default,
|
||||
|
|
@ -579,7 +580,6 @@ symbols! {
|
|||
rustc_synthetic,
|
||||
rustc_test_marker,
|
||||
rustc_then_this_would_need,
|
||||
rustc_transparent_macro,
|
||||
rustc_variance,
|
||||
rustdoc,
|
||||
rust_eh_personality,
|
||||
|
|
|
|||
|
|
@ -2,8 +2,6 @@
|
|||
|
||||
// FIXME (#13400): this is only a tiny fraction of the Windows console api
|
||||
|
||||
extern crate libc;
|
||||
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
|
|
@ -20,19 +18,36 @@ pub struct WinConsole<T> {
|
|||
background: color::Color,
|
||||
}
|
||||
|
||||
type SHORT = i16;
|
||||
type WORD = u16;
|
||||
type DWORD = u32;
|
||||
type BOOL = i32;
|
||||
type HANDLE = *mut u8;
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
#[repr(C)]
|
||||
struct SMALL_RECT {
|
||||
Left: SHORT,
|
||||
Top: SHORT,
|
||||
Right: SHORT,
|
||||
Bottom: SHORT,
|
||||
}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
#[repr(C)]
|
||||
struct COORD {
|
||||
X: SHORT,
|
||||
Y: SHORT,
|
||||
}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
#[repr(C)]
|
||||
struct CONSOLE_SCREEN_BUFFER_INFO {
|
||||
dwSize: [libc::c_short; 2],
|
||||
dwCursorPosition: [libc::c_short; 2],
|
||||
dwSize: COORD,
|
||||
dwCursorPosition: COORD,
|
||||
wAttributes: WORD,
|
||||
srWindow: [libc::c_short; 4],
|
||||
dwMaximumWindowSize: [libc::c_short; 2],
|
||||
srWindow: SMALL_RECT,
|
||||
dwMaximumWindowSize: COORD,
|
||||
}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
|
|
@ -105,12 +120,17 @@ impl<T: Write + Send + 'static> WinConsole<T> {
|
|||
|
||||
/// Returns `None` whenever the terminal cannot be created for some reason.
|
||||
pub fn new(out: T) -> io::Result<WinConsole<T>> {
|
||||
use std::mem::MaybeUninit;
|
||||
|
||||
let fg;
|
||||
let bg;
|
||||
unsafe {
|
||||
#[allow(deprecated)]
|
||||
let mut buffer_info = ::std::mem::uninitialized();
|
||||
if GetConsoleScreenBufferInfo(GetStdHandle(-11i32 as DWORD), &mut buffer_info) != 0 {
|
||||
let mut buffer_info = MaybeUninit::<CONSOLE_SCREEN_BUFFER_INFO>::uninit();
|
||||
if GetConsoleScreenBufferInfo(
|
||||
GetStdHandle(-11i32 as DWORD),
|
||||
buffer_info.as_mut_ptr()
|
||||
) != 0 {
|
||||
let buffer_info = buffer_info.assume_init() ;
|
||||
fg = bits_to_color(buffer_info.wAttributes);
|
||||
bg = bits_to_color(buffer_info.wAttributes >> 4);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ error[E0008]: cannot bind by-move into a pattern guard
|
|||
LL | Some(z) if z.recv().unwrap() => { panic!() },
|
||||
| ^ moves value into pattern guard
|
||||
|
|
||||
= help: add #![feature(bind_by_move_pattern_guards)] to the crate attributes to enable
|
||||
= help: add `#![feature(bind_by_move_pattern_guards)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ error[E0301]: cannot mutably borrow in a pattern guard
|
|||
LL | Enum::A(_) if { let y = &mut x; *y = Enum::B(false); false } => 1,
|
||||
| ^ borrowed mutably in pattern guard
|
||||
|
|
||||
= help: add #![feature(bind_by_move_pattern_guards)] to the crate attributes to enable
|
||||
= help: add `#![feature(bind_by_move_pattern_guards)]` to the crate attributes to enable
|
||||
|
||||
error[E0302]: cannot assign in a pattern guard
|
||||
--> $DIR/borrowck-mutate-in-guard.rs:15:41
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ error[E0301]: cannot mutably borrow in a pattern guard
|
|||
LL | Enum::A(_) if { let y = &mut x; *y = Enum::B(false); false } => 1,
|
||||
| ^ borrowed mutably in pattern guard
|
||||
|
|
||||
= help: add #![feature(bind_by_move_pattern_guards)] to the crate attributes to enable
|
||||
= help: add `#![feature(bind_by_move_pattern_guards)]` to the crate attributes to enable
|
||||
|
||||
error[E0302]: cannot assign in a pattern guard
|
||||
--> $DIR/borrowck-mutate-in-guard.rs:15:41
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ LL | a + b
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0381]: use of possibly uninitialized variable: `a`
|
||||
--> $DIR/const_let_refutable.rs:4:5
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ LL | a + b
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
warning[E0381]: use of possibly uninitialized variable: `a`
|
||||
--> $DIR/const_let_refutable.rs:4:5
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | const fn error(_: fn()) {}
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | vec![1, 2, 3]
|
|||
| ^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
|
||||
|
||||
error: aborting due to previous error
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | const fn unsize(x: &[u8; 3]) -> &[u8] { x }
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/cast_errors.rs:5:23
|
||||
|
|
@ -14,7 +14,7 @@ LL | const fn closure() -> fn() { || {} }
|
|||
| ^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/cast_errors.rs:8:5
|
||||
|
|
@ -23,7 +23,7 @@ LL | (|| {}) as fn();
|
|||
| ^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/cast_errors.rs:11:28
|
||||
|
|
@ -32,7 +32,7 @@ LL | const fn reify(f: fn()) -> unsafe fn() { f }
|
|||
| ^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/cast_errors.rs:13:21
|
||||
|
|
@ -41,7 +41,7 @@ LL | const fn reify2() { main as unsafe fn(); }
|
|||
| ^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 5 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | const fn cmp(x: fn(), y: fn()) -> bool {
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | loop {}
|
|||
| ^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ LL | const fn get_mut(&mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0493]: destructors cannot be evaluated at compile-time
|
||||
--> $DIR/min_const_fn.rs:44:28
|
||||
|
|
@ -26,7 +26,7 @@ LL | const fn get_mut_lt(&'a mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0493]: destructors cannot be evaluated at compile-time
|
||||
--> $DIR/min_const_fn.rs:51:27
|
||||
|
|
@ -41,7 +41,7 @@ LL | const fn get_mut_s(&mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: mutable references in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:58:39
|
||||
|
|
@ -50,7 +50,7 @@ LL | const fn get_mut_sq(&mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:76:16
|
||||
|
|
@ -59,7 +59,7 @@ LL | const fn foo11<T: std::fmt::Display>(t: T) -> T { t }
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:78:18
|
||||
|
|
@ -68,7 +68,7 @@ LL | const fn foo11_2<T: Send>(t: T) -> T { t }
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:80:33
|
||||
|
|
@ -77,7 +77,7 @@ LL | const fn foo19(f: f32) -> f32 { f * 2.0 }
|
|||
| ^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:82:35
|
||||
|
|
@ -86,7 +86,7 @@ LL | const fn foo19_2(f: f32) -> f32 { 2.0 - f }
|
|||
| ^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int and `bool` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:84:35
|
||||
|
|
@ -95,7 +95,7 @@ LL | const fn foo19_3(f: f32) -> f32 { -f }
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:86:43
|
||||
|
|
@ -104,7 +104,7 @@ LL | const fn foo19_4(f: f32, g: f32) -> f32 { f / g }
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: cannot access `static` items in const fn
|
||||
--> $DIR/min_const_fn.rs:90:27
|
||||
|
|
@ -113,7 +113,7 @@ LL | const fn foo25() -> u32 { BAR }
|
|||
| ^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: cannot access `static` items in const fn
|
||||
--> $DIR/min_const_fn.rs:91:36
|
||||
|
|
@ -122,7 +122,7 @@ LL | const fn foo26() -> &'static u32 { &BAR }
|
|||
| ^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:92:42
|
||||
|
|
@ -131,7 +131,7 @@ LL | const fn foo30(x: *const u32) -> usize { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:94:63
|
||||
|
|
@ -140,7 +140,7 @@ LL | const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:96:42
|
||||
|
|
@ -149,7 +149,7 @@ LL | const fn foo30_2(x: *mut u32) -> usize { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:98:63
|
||||
|
|
@ -158,7 +158,7 @@ LL | const fn foo30_2_with_unsafe(x: *mut u32) -> usize { unsafe { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops and conditional expressions are not stable in const fn
|
||||
--> $DIR/min_const_fn.rs:100:38
|
||||
|
|
@ -167,7 +167,7 @@ LL | const fn foo30_4(b: bool) -> usize { if b { 1 } else { 42 } }
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops are not allowed in const fn
|
||||
--> $DIR/min_const_fn.rs:102:29
|
||||
|
|
@ -176,7 +176,7 @@ LL | const fn foo30_5(b: bool) { while b { } }
|
|||
| ^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops and conditional expressions are not stable in const fn
|
||||
--> $DIR/min_const_fn.rs:105:44
|
||||
|
|
@ -185,7 +185,7 @@ LL | const fn foo36(a: bool, b: bool) -> bool { a && b }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops and conditional expressions are not stable in const fn
|
||||
--> $DIR/min_const_fn.rs:107:44
|
||||
|
|
@ -194,7 +194,7 @@ LL | const fn foo37(a: bool, b: bool) -> bool { a || b }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: mutable references in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:109:14
|
||||
|
|
@ -203,7 +203,7 @@ LL | const fn inc(x: &mut i32) { *x += 1 }
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:114:6
|
||||
|
|
@ -212,7 +212,7 @@ LL | impl<T: std::fmt::Debug> Foo<T> {
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:119:6
|
||||
|
|
@ -221,7 +221,7 @@ LL | impl<T: std::fmt::Debug + Sized> Foo<T> {
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:124:6
|
||||
|
|
@ -230,7 +230,7 @@ LL | impl<T: Sync + Sized> Foo<T> {
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: `impl Trait` in const fn is unstable
|
||||
--> $DIR/min_const_fn.rs:130:24
|
||||
|
|
@ -239,7 +239,7 @@ LL | const fn no_rpit2() -> AlanTuring<impl std::fmt::Debug> { AlanTuring(0) }
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:132:34
|
||||
|
|
@ -248,7 +248,7 @@ LL | const fn no_apit2(_x: AlanTuring<impl std::fmt::Debug>) {}
|
|||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:134:22
|
||||
|
|
@ -257,7 +257,7 @@ LL | const fn no_apit(_x: impl std::fmt::Debug) {}
|
|||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: `impl Trait` in const fn is unstable
|
||||
--> $DIR/min_const_fn.rs:135:23
|
||||
|
|
@ -266,7 +266,7 @@ LL | const fn no_rpit() -> impl std::fmt::Debug {}
|
|||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:136:23
|
||||
|
|
@ -275,7 +275,7 @@ LL | const fn no_dyn_trait(_x: &dyn std::fmt::Debug) {}
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:137:32
|
||||
|
|
@ -284,7 +284,7 @@ LL | const fn no_dyn_trait_ret() -> &'static dyn std::fmt::Debug { &() }
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0515]: cannot return reference to temporary value
|
||||
--> $DIR/min_const_fn.rs:137:63
|
||||
|
|
@ -302,7 +302,7 @@ LL | const fn really_no_traits_i_mean_it() { (&() as &dyn std::fmt::Debug, ()).1
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:148:21
|
||||
|
|
@ -311,7 +311,7 @@ LL | const fn no_fn_ptrs(_x: fn()) {}
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:150:27
|
||||
|
|
@ -320,7 +320,7 @@ LL | const fn no_fn_ptrs2() -> fn() { fn foo() {} foo }
|
|||
| ^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 37 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ LL | const fn get_mut(&mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0493]: destructors cannot be evaluated at compile-time
|
||||
--> $DIR/min_const_fn.rs:44:28
|
||||
|
|
@ -26,7 +26,7 @@ LL | const fn get_mut_lt(&'a mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0493]: destructors cannot be evaluated at compile-time
|
||||
--> $DIR/min_const_fn.rs:51:27
|
||||
|
|
@ -41,7 +41,7 @@ LL | const fn get_mut_s(&mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: mutable references in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:58:39
|
||||
|
|
@ -50,7 +50,7 @@ LL | const fn get_mut_sq(&mut self) -> &mut T { &mut self.0 }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:76:16
|
||||
|
|
@ -59,7 +59,7 @@ LL | const fn foo11<T: std::fmt::Display>(t: T) -> T { t }
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:78:18
|
||||
|
|
@ -68,7 +68,7 @@ LL | const fn foo11_2<T: Send>(t: T) -> T { t }
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:80:33
|
||||
|
|
@ -77,7 +77,7 @@ LL | const fn foo19(f: f32) -> f32 { f * 2.0 }
|
|||
| ^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:82:35
|
||||
|
|
@ -86,7 +86,7 @@ LL | const fn foo19_2(f: f32) -> f32 { 2.0 - f }
|
|||
| ^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int and `bool` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:84:35
|
||||
|
|
@ -95,7 +95,7 @@ LL | const fn foo19_3(f: f32) -> f32 { -f }
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_fn.rs:86:43
|
||||
|
|
@ -104,7 +104,7 @@ LL | const fn foo19_4(f: f32, g: f32) -> f32 { f / g }
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: cannot access `static` items in const fn
|
||||
--> $DIR/min_const_fn.rs:90:27
|
||||
|
|
@ -113,7 +113,7 @@ LL | const fn foo25() -> u32 { BAR }
|
|||
| ^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: cannot access `static` items in const fn
|
||||
--> $DIR/min_const_fn.rs:91:36
|
||||
|
|
@ -122,7 +122,7 @@ LL | const fn foo26() -> &'static u32 { &BAR }
|
|||
| ^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:92:42
|
||||
|
|
@ -131,7 +131,7 @@ LL | const fn foo30(x: *const u32) -> usize { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:94:63
|
||||
|
|
@ -140,7 +140,7 @@ LL | const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:96:42
|
||||
|
|
@ -149,7 +149,7 @@ LL | const fn foo30_2(x: *mut u32) -> usize { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: casting pointers to ints is unstable in const fn
|
||||
--> $DIR/min_const_fn.rs:98:63
|
||||
|
|
@ -158,7 +158,7 @@ LL | const fn foo30_2_with_unsafe(x: *mut u32) -> usize { unsafe { x as usize }
|
|||
| ^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops and conditional expressions are not stable in const fn
|
||||
--> $DIR/min_const_fn.rs:100:38
|
||||
|
|
@ -167,7 +167,7 @@ LL | const fn foo30_4(b: bool) -> usize { if b { 1 } else { 42 } }
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops are not allowed in const fn
|
||||
--> $DIR/min_const_fn.rs:102:29
|
||||
|
|
@ -176,7 +176,7 @@ LL | const fn foo30_5(b: bool) { while b { } }
|
|||
| ^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops and conditional expressions are not stable in const fn
|
||||
--> $DIR/min_const_fn.rs:105:44
|
||||
|
|
@ -185,7 +185,7 @@ LL | const fn foo36(a: bool, b: bool) -> bool { a && b }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: loops and conditional expressions are not stable in const fn
|
||||
--> $DIR/min_const_fn.rs:107:44
|
||||
|
|
@ -194,7 +194,7 @@ LL | const fn foo37(a: bool, b: bool) -> bool { a || b }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: mutable references in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:109:14
|
||||
|
|
@ -203,7 +203,7 @@ LL | const fn inc(x: &mut i32) { *x += 1 }
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:114:6
|
||||
|
|
@ -212,7 +212,7 @@ LL | impl<T: std::fmt::Debug> Foo<T> {
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:119:6
|
||||
|
|
@ -221,7 +221,7 @@ LL | impl<T: std::fmt::Debug + Sized> Foo<T> {
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:124:6
|
||||
|
|
@ -230,7 +230,7 @@ LL | impl<T: Sync + Sized> Foo<T> {
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: `impl Trait` in const fn is unstable
|
||||
--> $DIR/min_const_fn.rs:130:24
|
||||
|
|
@ -239,7 +239,7 @@ LL | const fn no_rpit2() -> AlanTuring<impl std::fmt::Debug> { AlanTuring(0) }
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:132:34
|
||||
|
|
@ -248,7 +248,7 @@ LL | const fn no_apit2(_x: AlanTuring<impl std::fmt::Debug>) {}
|
|||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:134:22
|
||||
|
|
@ -257,7 +257,7 @@ LL | const fn no_apit(_x: impl std::fmt::Debug) {}
|
|||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: `impl Trait` in const fn is unstable
|
||||
--> $DIR/min_const_fn.rs:135:23
|
||||
|
|
@ -266,7 +266,7 @@ LL | const fn no_rpit() -> impl std::fmt::Debug {}
|
|||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:136:23
|
||||
|
|
@ -275,7 +275,7 @@ LL | const fn no_dyn_trait(_x: &dyn std::fmt::Debug) {}
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn.rs:137:32
|
||||
|
|
@ -284,7 +284,7 @@ LL | const fn no_dyn_trait_ret() -> &'static dyn std::fmt::Debug { &() }
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
warning[E0515]: cannot return reference to temporary value
|
||||
--> $DIR/min_const_fn.rs:137:63
|
||||
|
|
@ -306,7 +306,7 @@ LL | const fn really_no_traits_i_mean_it() { (&() as &dyn std::fmt::Debug, ()).1
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:148:21
|
||||
|
|
@ -315,7 +315,7 @@ LL | const fn no_fn_ptrs(_x: fn()) {}
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/min_const_fn.rs:150:27
|
||||
|
|
@ -324,7 +324,7 @@ LL | const fn no_fn_ptrs2() -> fn() { fn foo() {} foo }
|
|||
| ^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 36 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | x.0.field;
|
|||
| ^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn_dyn.rs:12:66
|
||||
|
|
@ -14,7 +14,7 @@ LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasDyn { field: &0 }) }
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0716]: temporary value dropped while borrowed
|
||||
--> $DIR/min_const_fn_dyn.rs:12:67
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | x.0.field;
|
|||
| ^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable
|
||||
--> $DIR/min_const_fn_dyn.rs:12:66
|
||||
|
|
@ -14,7 +14,7 @@ LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasDyn { field: &0 }) }
|
|||
| ^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
warning[E0716]: temporary value dropped while borrowed
|
||||
--> $DIR/min_const_fn_dyn.rs:12:67
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | x.0.field;
|
|||
| ^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: function pointers in const fn are unstable
|
||||
--> $DIR/min_const_fn_fn_ptr.rs:14:59
|
||||
|
|
@ -14,7 +14,7 @@ LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasPtr { field }) }
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | const fn bar() -> u32 { foo() }
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: can only call other `const fn` within a `const fn`, but `const foo2` is not stable as `const fn`
|
||||
--> $DIR/min_const_fn_libstd_stability.rs:22:26
|
||||
|
|
@ -14,7 +14,7 @@ LL | const fn bar2() -> u32 { foo2() }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_fn_libstd_stability.rs:26:26
|
||||
|
|
@ -23,7 +23,7 @@ LL | const fn bar3() -> u32 { (5f32 + 6f32) as u32 }
|
|||
| ^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: can only call other `const fn` within a `const fn`, but `const foo2_gated` is not stable as `const fn`
|
||||
--> $DIR/min_const_fn_libstd_stability.rs:34:32
|
||||
|
|
@ -32,7 +32,7 @@ LL | const fn bar2_gated() -> u32 { foo2_gated() }
|
|||
| ^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 4 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | const unsafe fn bar() -> u32 { unsafe { foo() } }
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: can only call other `const fn` within a `const fn`, but `const foo2` is not stable as `const fn`
|
||||
--> $DIR/min_const_unsafe_fn_libstd_stability.rs:22:42
|
||||
|
|
@ -14,7 +14,7 @@ LL | const unsafe fn bar2() -> u32 { unsafe { foo2() } }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: only int, `bool` and `char` operations are stable in const fn
|
||||
--> $DIR/min_const_unsafe_fn_libstd_stability.rs:26:33
|
||||
|
|
@ -23,7 +23,7 @@ LL | const unsafe fn bar3() -> u32 { (5f32 + 6f32) as u32 }
|
|||
| ^^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: can only call other `const fn` within a `const fn`, but `const foo2_gated` is not stable as `const fn`
|
||||
--> $DIR/min_const_unsafe_fn_libstd_stability.rs:34:48
|
||||
|
|
@ -32,7 +32,7 @@ LL | const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }
|
|||
| ^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 4 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | const unsafe fn bar() -> u32 { foo() }
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: can only call other `const fn` within a `const fn`, but `const foo2` is not stable as `const fn`
|
||||
--> $DIR/min_const_unsafe_fn_libstd_stability2.rs:22:33
|
||||
|
|
@ -14,7 +14,7 @@ LL | const unsafe fn bar2() -> u32 { foo2() }
|
|||
| ^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: can only call other `const fn` within a `const fn`, but `const foo2_gated` is not stable as `const fn`
|
||||
--> $DIR/min_const_unsafe_fn_libstd_stability2.rs:30:39
|
||||
|
|
@ -23,7 +23,7 @@ LL | const unsafe fn bar2_gated() -> u32 { foo2_gated() }
|
|||
| ^^^^^^^^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 3 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | let b = &mut a;
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: mutable references in const fn are unstable
|
||||
--> $DIR/mutable_borrow.rs:12:13
|
||||
|
|
@ -14,7 +14,7 @@ LL | let b = &mut a;
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ LL | match *self {
|
|||
| ^^^^^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to 3 previous errors
|
||||
|
||||
|
|
|
|||
|
|
@ -6,15 +6,15 @@
|
|||
// not be aligned.
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Eq)]
|
||||
//~^ ERROR #[derive] can't be used
|
||||
//~^ ERROR `#[derive]` can't be used
|
||||
//~| hard error
|
||||
//~^^^ ERROR #[derive] can't be used
|
||||
//~^^^ ERROR `#[derive]` can't be used
|
||||
//~| hard error
|
||||
#[repr(packed)]
|
||||
pub struct Foo<T>(T, T, T);
|
||||
|
||||
#[derive(PartialEq, Eq)]
|
||||
//~^ ERROR #[derive] can't be used
|
||||
//~^ ERROR `#[derive]` can't be used
|
||||
//~| hard error
|
||||
#[repr(packed)]
|
||||
pub struct Bar(u32, u32, u32);
|
||||
|
|
@ -23,7 +23,7 @@ pub struct Bar(u32, u32, u32);
|
|||
struct Y(usize);
|
||||
|
||||
#[derive(PartialEq)]
|
||||
//~^ ERROR #[derive] can't be used
|
||||
//~^ ERROR `#[derive]` can't be used
|
||||
//~| hard error
|
||||
#[repr(packed)]
|
||||
struct X(Y);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
error: #[derive] can't be used on a #[repr(packed)] struct with type or const parameters (error E0133)
|
||||
error: `#[derive]` can't be used on a `#[repr(packed)]` struct with type or const parameters (error E0133)
|
||||
--> $DIR/deriving-with-repr-packed.rs:8:16
|
||||
|
|
||||
LL | #[derive(Copy, Clone, PartialEq, Eq)]
|
||||
|
|
@ -12,7 +12,7 @@ LL | #![deny(safe_packed_borrows)]
|
|||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
|
||||
|
||||
error: #[derive] can't be used on a #[repr(packed)] struct with type or const parameters (error E0133)
|
||||
error: `#[derive]` can't be used on a `#[repr(packed)]` struct with type or const parameters (error E0133)
|
||||
--> $DIR/deriving-with-repr-packed.rs:8:23
|
||||
|
|
||||
LL | #[derive(Copy, Clone, PartialEq, Eq)]
|
||||
|
|
@ -21,7 +21,7 @@ LL | #[derive(Copy, Clone, PartialEq, Eq)]
|
|||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
|
||||
|
||||
error: #[derive] can't be used on a #[repr(packed)] struct that does not derive Copy (error E0133)
|
||||
error: `#[derive]` can't be used on a `#[repr(packed)]` struct that does not derive Copy (error E0133)
|
||||
--> $DIR/deriving-with-repr-packed.rs:16:10
|
||||
|
|
||||
LL | #[derive(PartialEq, Eq)]
|
||||
|
|
@ -30,7 +30,7 @@ LL | #[derive(PartialEq, Eq)]
|
|||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
|
||||
|
||||
error: #[derive] can't be used on a #[repr(packed)] struct that does not derive Copy (error E0133)
|
||||
error: `#[derive]` can't be used on a `#[repr(packed)]` struct that does not derive Copy (error E0133)
|
||||
--> $DIR/deriving-with-repr-packed.rs:25:10
|
||||
|
|
||||
LL | #[derive(PartialEq)]
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ error[E0008]: cannot bind by-move into a pattern guard
|
|||
LL | Some(s) if s.len() == 0 => {},
|
||||
| ^ moves value into pattern guard
|
||||
|
|
||||
= help: add #![feature(bind_by_move_pattern_guards)] to the crate attributes to enable
|
||||
= help: add `#![feature(bind_by_move_pattern_guards)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ error[E0301]: cannot mutably borrow in a pattern guard
|
|||
LL | option if option.take().is_none() => {},
|
||||
| ^^^^^^ borrowed mutably in pattern guard
|
||||
|
|
||||
= help: add #![feature(bind_by_move_pattern_guards)] to the crate attributes to enable
|
||||
= help: add `#![feature(bind_by_move_pattern_guards)]` to the crate attributes to enable
|
||||
|
||||
error[E0596]: cannot borrow `option` as mutable, as it is immutable for the pattern guard
|
||||
--> $DIR/E0301.rs:4:19
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#![feature(decl_macro, rustc_attrs)]
|
||||
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
pub macro dollar_crate() {
|
||||
let s = $crate::S;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ macro genmod($FromOutside: ident, $Outer: ident) {
|
|||
}
|
||||
}
|
||||
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro genmod_transparent() {
|
||||
type A = FromOutside;
|
||||
struct Outer;
|
||||
|
|
|
|||
31
src/test/ui/hygiene/rustc-macro-transparency.rs
Normal file
31
src/test/ui/hygiene/rustc-macro-transparency.rs
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
#![feature(decl_macro, rustc_attrs)]
|
||||
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro transparent() {
|
||||
struct Transparent;
|
||||
let transparent = 0;
|
||||
}
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
macro semitransparent() {
|
||||
struct SemiTransparent;
|
||||
let semitransparent = 0;
|
||||
}
|
||||
#[rustc_macro_transparency = "opaque"]
|
||||
macro opaque() {
|
||||
struct Opaque;
|
||||
let opaque = 0;
|
||||
}
|
||||
|
||||
fn main() {
|
||||
transparent!();
|
||||
semitransparent!();
|
||||
opaque!();
|
||||
|
||||
Transparent; // OK
|
||||
SemiTransparent; // OK
|
||||
Opaque; //~ ERROR cannot find value `Opaque` in this scope
|
||||
|
||||
transparent; // OK
|
||||
semitransparent; //~ ERROR cannot find value `semitransparent` in this scope
|
||||
opaque; //~ ERROR cannot find value `opaque` in this scope
|
||||
}
|
||||
21
src/test/ui/hygiene/rustc-macro-transparency.stderr
Normal file
21
src/test/ui/hygiene/rustc-macro-transparency.stderr
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
error[E0425]: cannot find value `Opaque` in this scope
|
||||
--> $DIR/rustc-macro-transparency.rs:26:5
|
||||
|
|
||||
LL | Opaque;
|
||||
| ^^^^^^ help: a local variable with a similar name exists: `opaque`
|
||||
|
||||
error[E0425]: cannot find value `semitransparent` in this scope
|
||||
--> $DIR/rustc-macro-transparency.rs:29:5
|
||||
|
|
||||
LL | semitransparent;
|
||||
| ^^^^^^^^^^^^^^^ not found in this scope
|
||||
|
||||
error[E0425]: cannot find value `opaque` in this scope
|
||||
--> $DIR/rustc-macro-transparency.rs:30:5
|
||||
|
|
||||
LL | opaque;
|
||||
| ^^^^^^ not found in this scope
|
||||
|
||||
error: aborting due to 3 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0425`.
|
||||
|
|
@ -5,12 +5,12 @@
|
|||
|
||||
extern crate transparent_basic;
|
||||
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro binding() {
|
||||
let x = 10;
|
||||
}
|
||||
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro label() {
|
||||
break 'label
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | let x = || t;
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -80,17 +80,17 @@
|
|||
struct Right;
|
||||
// struct Wrong; // not defined
|
||||
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro include() {
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_outer() {
|
||||
macro m() { Wrong }
|
||||
}
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_inner() {
|
||||
macro m() { Right }
|
||||
}
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_invoc() {
|
||||
m!()
|
||||
}
|
||||
|
|
@ -100,7 +100,7 @@ macro include() {
|
|||
fn check1() {
|
||||
macro m() {}
|
||||
{
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_gen_inner_invoc() {
|
||||
gen_inner!();
|
||||
m!(); //~ ERROR `m` is ambiguous
|
||||
|
|
@ -112,7 +112,7 @@ macro include() {
|
|||
fn check5() {
|
||||
macro m() { Wrong }
|
||||
{
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_inner_invoc() {
|
||||
macro m() { Right }
|
||||
m!(); // OK
|
||||
|
|
@ -124,7 +124,7 @@ macro include() {
|
|||
fn check9() {
|
||||
macro m() { Wrong }
|
||||
{
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_inner_gen_invoc() {
|
||||
macro m() { Right }
|
||||
gen_invoc!(); // OK
|
||||
|
|
@ -145,7 +145,7 @@ macro include() {
|
|||
macro m() {}
|
||||
{
|
||||
gen_inner!();
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous
|
||||
gen_invoc!();
|
||||
}
|
||||
|
|
@ -186,7 +186,7 @@ macro include() {
|
|||
fn check52() {
|
||||
gen_outer!();
|
||||
{
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_gen_inner_invoc() {
|
||||
gen_inner!();
|
||||
m!(); //~ ERROR `m` is ambiguous
|
||||
|
|
@ -198,7 +198,7 @@ macro include() {
|
|||
fn check56() {
|
||||
gen_outer!();
|
||||
{
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_inner_invoc() {
|
||||
macro m() { Right }
|
||||
m!(); // OK
|
||||
|
|
@ -218,7 +218,7 @@ macro include() {
|
|||
fn check60() {
|
||||
gen_outer!();
|
||||
{
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_inner_gen_invoc() {
|
||||
macro m() { Right }
|
||||
gen_invoc!(); // OK
|
||||
|
|
@ -231,7 +231,7 @@ macro include() {
|
|||
gen_outer!();
|
||||
{
|
||||
gen_inner!();
|
||||
#[rustc_transparent_macro]
|
||||
#[rustc_macro_transparency = "transparent"]
|
||||
macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous
|
||||
gen_invoc!();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,18 +8,18 @@ use proc_macro::*;
|
|||
|
||||
#[proc_macro_attribute]
|
||||
pub fn cfg(_: TokenStream, input: TokenStream) -> TokenStream {
|
||||
//~^ ERROR name `cfg` is reserved in macro namespace
|
||||
//~^ ERROR name `cfg` is reserved in attribute namespace
|
||||
input
|
||||
}
|
||||
|
||||
#[proc_macro_attribute]
|
||||
pub fn cfg_attr(_: TokenStream, input: TokenStream) -> TokenStream {
|
||||
//~^ ERROR name `cfg_attr` is reserved in macro namespace
|
||||
//~^ ERROR name `cfg_attr` is reserved in attribute namespace
|
||||
input
|
||||
}
|
||||
|
||||
#[proc_macro_attribute]
|
||||
pub fn derive(_: TokenStream, input: TokenStream) -> TokenStream {
|
||||
//~^ ERROR name `derive` is reserved in macro namespace
|
||||
//~^ ERROR name `derive` is reserved in attribute namespace
|
||||
input
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,16 +1,16 @@
|
|||
error: name `cfg` is reserved in macro namespace
|
||||
error: name `cfg` is reserved in attribute namespace
|
||||
--> $DIR/reserved-macro-names.rs:10:8
|
||||
|
|
||||
LL | pub fn cfg(_: TokenStream, input: TokenStream) -> TokenStream {
|
||||
| ^^^
|
||||
|
||||
error: name `cfg_attr` is reserved in macro namespace
|
||||
error: name `cfg_attr` is reserved in attribute namespace
|
||||
--> $DIR/reserved-macro-names.rs:16:8
|
||||
|
|
||||
LL | pub fn cfg_attr(_: TokenStream, input: TokenStream) -> TokenStream {
|
||||
| ^^^^^^^^
|
||||
|
||||
error: name `derive` is reserved in macro namespace
|
||||
error: name `derive` is reserved in attribute namespace
|
||||
--> $DIR/reserved-macro-names.rs:22:8
|
||||
|
|
||||
LL | pub fn derive(_: TokenStream, input: TokenStream) -> TokenStream {
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ error[E0008]: cannot bind by-move into a pattern guard
|
|||
LL | A { a: v } if *v == 42 => v,
|
||||
| ^ moves value into pattern guard
|
||||
|
|
||||
= help: add #![feature(bind_by_move_pattern_guards)] to the crate attributes to enable
|
||||
= help: add `#![feature(bind_by_move_pattern_guards)]` to the crate attributes to enable
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | let y = &mut x.0;
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0723]: mutable references in const fn are unstable
|
||||
--> $DIR/ranged_ints2_const.rs:18:9
|
||||
|
|
@ -14,7 +14,7 @@ LL | let y = unsafe { &mut x.0 };
|
|||
| ^
|
||||
|
|
||||
= note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
|
||||
= help: add #![feature(const_fn)] to the crate attributes to enable
|
||||
= help: add `#![feature(const_fn)]` to the crate attributes to enable
|
||||
|
||||
error[E0133]: mutation of layout constrained field is unsafe and requires unsafe function or block
|
||||
--> $DIR/ranged_ints2_const.rs:11:13
|
||||
|
|
|
|||
|
|
@ -13,7 +13,8 @@ pub fn check(path: &Path, bad: &mut bool) {
|
|||
&mut |entry, contents| {
|
||||
let subpath = entry.path();
|
||||
if let Some("rs") = subpath.extension().and_then(|e| e.to_str()) {
|
||||
if contents.contains("#[test]") {
|
||||
let contents = contents.trim();
|
||||
if !contents.starts_with("//") && contents.contains("#[test]") {
|
||||
tidy_error!(
|
||||
bad,
|
||||
"{} contains #[test]; libcore tests must be placed inside \
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue