nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 08:13:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #131466 - matthiaskrgr:rollup-3qtz83x, r=matthiaskrgr

Browse Source 
Rollup of 7 pull requests

Successful merges:

 - #123951 (Reserve guarded string literals (RFC 3593))
 - #130827 (Library: Rename "object safe" to "dyn compatible")
 - #131383 (Add docs about slicing slices at the ends)
 - #131403 (Fix needless_lifetimes in rustc_serialize)
 - #131417 (Fix methods alignment on mobile)
 - #131449 (Decouple WASIp2 sockets from WasiFd)
 - #131462 (Mention allocation errors for `open_buffered`)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-10-10 01:12:11 +00:00
commit df1b5d3cc2
38 changed files with 1647 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
compiler/rustc_lexer/src/lib.rs
View File

@ -104,6 +104,12 @@ pub enum TokenKind {
/// for emoji identifier recovery, as those are not meant to be ever accepted.
InvalidPrefix,
/// Guarded string literal prefix: `#"` or `##`.
///
/// Used for reserving "guarded strings" (RFC 3598) in edition 2024.
/// Split into the component tokens on older editions.
GuardedStrPrefix,
/// Examples: `12u8`, `1.0e-40`, `b"123"`. Note that `_` is an invalid
/// suffix, but may be present here on string and float literals. Users of
/// this type will need to check for and reject that case.
@ -191,30 +197,41 @@ pub enum DocStyle {
/// `rustc_ast::ast::LitKind`).
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum LiteralKind {
/// "12_u8", "0o100", "0b120i99", "1f32".
/// `12_u8`, `0o100`, `0b120i99`, `1f32`.
Int { base: Base, empty_int: bool },
/// "12.34f32", "1e3", but not "1f32".
/// `12.34f32`, `1e3`, but not `1f32`.
Float { base: Base, empty_exponent: bool },
/// "'a'", "'\\'", "'''", "';"
/// `'a'`, `'\\'`, `'''`, `';`
Char { terminated: bool },
/// "b'a'", "b'\\'", "b'''", "b';"
/// `b'a'`, `b'\\'`, `b'''`, `b';`
Byte { terminated: bool },
/// ""abc"", ""abc"
/// `"abc"`, `"abc`
Str { terminated: bool },
/// "b"abc"", "b"abc"
/// `b"abc"`, `b"abc`
ByteStr { terminated: bool },
/// `c"abc"`, `c"abc`
CStr { terminated: bool },
/// "r"abc"", "r#"abc"#", "r####"ab"###"c"####", "r#"a". `None` indicates
/// `r"abc"`, `r#"abc"#`, `r####"ab"###"c"####`, `r#"a`. `None` indicates
/// an invalid literal.
RawStr { n_hashes: Option<u8> },
/// "br"abc"", "br#"abc"#", "br####"ab"###"c"####", "br#"a". `None`
/// `br"abc"`, `br#"abc"#`, `br####"ab"###"c"####`, `br#"a`. `None`
/// indicates an invalid literal.
RawByteStr { n_hashes: Option<u8> },
/// `cr"abc"`, "cr#"abc"#", `cr#"a`. `None` indicates an invalid literal.
RawCStr { n_hashes: Option<u8> },
}
/// `#"abc"#`, `##"a"` (fewer closing), or even `#"a` (unterminated).
///
/// Can capture fewer closing hashes than starting hashes,
/// for more efficient lexing and better backwards diagnostics.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct GuardedStr {
pub n_hashes: u32,
pub terminated: bool,
pub token_len: u32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum RawStrError {
/// Non `#` characters exist between `r` and `"`, e.g. `r##~"abcde"##`
@ -403,6 +420,12 @@ impl Cursor<'_> {
TokenKind::Literal { kind: literal_kind, suffix_start }
}
// Guarded string literal prefix: `#"` or `##`
'#' if matches!(self.first(), '"' | '#') => {
self.bump();
TokenKind::GuardedStrPrefix
}
// One-symbol tokens.
';' => Semi,
',' => Comma,
@ -780,6 +803,60 @@ impl Cursor<'_> {
false
}
/// Attempt to lex for a guarded string literal.
///
/// Used by `rustc_parse::lexer` to lex for guarded strings
/// conditionally based on edition.
///
/// Note: this will not reset the `Cursor` when a
/// guarded string is not found. It is the caller's
/// responsibility to do so.
pub fn guarded_double_quoted_string(&mut self) -> Option<GuardedStr> {
debug_assert!(self.prev() != '#');
let mut n_start_hashes: u32 = 0;
while self.first() == '#' {
n_start_hashes += 1;
self.bump();
}
if self.first() != '"' {
return None;
}
self.bump();
debug_assert!(self.prev() == '"');
// Lex the string itself as a normal string literal
// so we can recover that for older editions later.
let terminated = self.double_quoted_string();
if !terminated {
let token_len = self.pos_within_token();
self.reset_pos_within_token();
return Some(GuardedStr { n_hashes: n_start_hashes, terminated: false, token_len });
}
// Consume closing '#' symbols.
// Note that this will not consume extra trailing `#` characters:
// `###"abcde"####` is lexed as a `GuardedStr { n_end_hashes: 3, .. }`
// followed by a `#` token.
let mut n_end_hashes = 0;
while self.first() == '#' && n_end_hashes < n_start_hashes {
n_end_hashes += 1;
self.bump();
}
// Reserved syntax, always an error, so it doesn't matter if
// `n_start_hashes != n_end_hashes`.
self.eat_literal_suffix();
let token_len = self.pos_within_token();
self.reset_pos_within_token();
Some(GuardedStr { n_hashes: n_start_hashes, terminated: true, token_len })
}
/// Eats the double-quoted string and returns `n_hashes` and an error if encountered.
fn raw_double_quoted_string(&mut self, prefix_len: u32) -> Result<u8, RawStrError> {
// Wrap the actual function to handle the error with too many hashes.

3
compiler/rustc_lint/messages.ftl
View File

@ -740,6 +740,9 @@ lint_reserved_prefix = prefix `{$prefix}` is unknown
.label = unknown prefix
.suggestion = insert whitespace here to avoid this being parsed as a prefix in Rust 2021
lint_reserved_string = will be parsed as a guarded string in Rust 2024
.suggestion = insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
lint_shadowed_into_iter =
this method call resolves to `<&{$target} as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to `<{$target} as IntoIterator>::into_iter` in Rust {$edition}
.use_iter_suggestion = use `.iter()` instead of `.into_iter()` to avoid ambiguity

3
compiler/rustc_lint/src/context/diagnostics.rs
View File

@ -176,6 +176,9 @@ pub(super) fn decorate_lint(sess: &Session, diagnostic: BuiltinLintDiag, diag: &
lints::RawPrefix { label: label_span, suggestion: label_span.shrink_to_hi() }
.decorate_lint(diag);
}
BuiltinLintDiag::ReservedString(suggestion) => {
lints::ReservedString { suggestion }.decorate_lint(diag);
}
BuiltinLintDiag::UnusedBuiltinAttribute { attr_name, macro_name, invoc_span } => {
lints::UnusedBuiltinAttribute { invoc_span, attr_name, macro_name }.decorate_lint(diag);
}

7
compiler/rustc_lint/src/lints.rs
View File

@ -3053,3 +3053,10 @@ pub(crate) enum MutRefSugg {
#[derive(LintDiagnostic)]
#[diag(lint_unqualified_local_imports)]
pub(crate) struct UnqualifiedLocalImportsDiag {}
#[derive(LintDiagnostic)]
#[diag(lint_reserved_string)]
pub(crate) struct ReservedString {
#[suggestion(code = " ", applicability = "machine-applicable")]
pub suggestion: Span,
}

41
compiler/rustc_lint_defs/src/builtin.rs
View File

@ -92,6 +92,7 @@ declare_lint_pass! {
RUST_2021_INCOMPATIBLE_OR_PATTERNS,
RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
RUST_2021_PRELUDE_COLLISIONS,
RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
RUST_2024_INCOMPATIBLE_PAT,
RUST_2024_PRELUDE_COLLISIONS,
SELF_CONSTRUCTOR_FROM_OUTER_ITEM,
@ -4996,3 +4997,43 @@ declare_lint! {
Warn,
"detects pointer to integer transmutes in const functions and associated constants",
}
declare_lint! {
/// The `rust_2024_guarded_string_incompatible_syntax` lint detects `#` tokens
/// that will be parsed as part of a guarded string literal in Rust 2024.
///
/// ### Example
///
/// ```rust,edition2021,compile_fail
/// #![deny(rust_2024_guarded_string_incompatible_syntax)]
///
/// macro_rules! m {
/// (# $x:expr #) => ();
/// (# $x:expr) => ();
/// }
///
/// m!(#"hey"#);
/// m!(#"hello");
/// ```
///
/// {{produces}}
///
/// ### Explanation
///
/// Prior to Rust 2024, `#"hey"#` is three tokens: the first `#`
/// followed by the string literal `"hey"` then the final `#`.
/// In Rust 2024, the whole sequence is considered a single token.
///
/// This lint suggests to add whitespace between the leading `#`
/// and the string to keep them separated in Rust 2024.
// Allow this lint -- rustdoc doesn't yet support threading edition into this lint's parser.
#[allow(rustdoc::invalid_rust_codeblocks)]
pub RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
Allow,
"will be parsed as a guarded string in Rust 2024",
@future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::EditionError(Edition::Edition2024),
reference: "issue #123735 <https://github.com/rust-lang/rust/issues/123735>",
};
crate_level_only
}

2
compiler/rustc_lint_defs/src/lib.rs
View File

@ -614,6 +614,8 @@ pub enum BuiltinLintDiag {
ReservedPrefix(Span, String),
/// `'r#` in edition < 2021.
RawPrefix(Span),
/// `##` or `#"` is edition < 2024.
ReservedString(Span),
TrailingMacro(bool, Ident),
BreakWithLabelAndLoop(Span),
UnicodeTextFlow(Span, String),

4
compiler/rustc_parse/messages.ftl
View File

@ -706,6 +706,10 @@ parse_require_colon_after_labeled_expression = labeled expression must be follow
.label = the label
.suggestion = add `:` after the label
parse_reserved_string = invalid string literal
.note = unprefixed guarded string literals are reserved for future use since Rust 2024
.suggestion_whitespace = consider inserting whitespace here
parse_return_types_use_thin_arrow = return types are denoted using `->`
.suggestion = use `->` instead

18
compiler/rustc_parse/src/errors.rs
View File

@ -2110,6 +2110,24 @@ pub(crate) enum UnknownPrefixSugg {
},
}
#[derive(Diagnostic)]
#[diag(parse_reserved_string)]
#[note]
pub(crate) struct ReservedString {
#[primary_span]
pub span: Span,
#[subdiagnostic]
pub sugg: Option<GuardedStringSugg>,
}
#[derive(Subdiagnostic)]
#[suggestion(
parse_suggestion_whitespace,
code = " ",
applicability = "maybe-incorrect",
style = "verbose"
)]
pub(crate) struct GuardedStringSugg(#[primary_span] pub Span);
#[derive(Diagnostic)]
#[diag(parse_too_many_hashes)]
pub(crate) struct TooManyHashes {

84
compiler/rustc_parse/src/lexer/mod.rs
View File

@ -10,7 +10,8 @@ use rustc_lexer::unescape::{self, EscapeError, Mode};
use rustc_lexer::{Base, Cursor, DocStyle, LiteralKind, RawStrError};
use rustc_session::lint::BuiltinLintDiag;
use rustc_session::lint::builtin::{
RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX, TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX, RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
};
use rustc_session::parse::ParseSess;
use rustc_span::symbol::Symbol;
@ -251,6 +252,7 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
let prefix_span = self.mk_sp(start, lit_start);
return (Token::new(self.ident(start), prefix_span), preceded_by_whitespace);
}
rustc_lexer::TokenKind::GuardedStrPrefix => self.maybe_report_guarded_str(start, str_before),
rustc_lexer::TokenKind::Literal { kind, suffix_start } => {
let suffix_start = start + BytePos(suffix_start);
let (kind, symbol) = self.cook_lexer_literal(start, suffix_start, kind);
@ -781,6 +783,86 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
}
}
/// Detect guarded string literal syntax
///
/// RFC 3598 reserved this syntax for future use. As of Rust 2024,
/// using this syntax produces an error. In earlier editions, however, it
/// only results in an (allowed by default) lint, and is treated as
/// separate tokens.
fn maybe_report_guarded_str(&mut self, start: BytePos, str_before: &'src str) -> TokenKind {
let span = self.mk_sp(start, self.pos);
let edition2024 = span.edition().at_least_rust_2024();
let space_pos = start + BytePos(1);
let space_span = self.mk_sp(space_pos, space_pos);
let mut cursor = Cursor::new(str_before);
let (span, unterminated) = match cursor.guarded_double_quoted_string() {
Some(rustc_lexer::GuardedStr { n_hashes, terminated, token_len }) => {
let end = start + BytePos(token_len);
let span = self.mk_sp(start, end);
let str_start = start + BytePos(n_hashes);
if edition2024 {
self.cursor = cursor;
self.pos = end;
}
let unterminated = if terminated { None } else { Some(str_start) };
(span, unterminated)
}
_ => {
// We should only get here in the `##+` case.
debug_assert_eq!(self.str_from_to(start, start + BytePos(2)), "##");
(span, None)
}
};
if edition2024 {
if let Some(str_start) = unterminated {
// Only a fatal error if string is unterminated.
self.dcx()
.struct_span_fatal(
self.mk_sp(str_start, self.pos),
"unterminated double quote string",
)
.with_code(E0765)
.emit()
}
let sugg = if span.from_expansion() {
None
} else {
Some(errors::GuardedStringSugg(space_span))
};
// In Edition 2024 and later, emit a hard error.
let err = self.dcx().emit_err(errors::ReservedString { span, sugg });
token::Literal(token::Lit {
kind: token::Err(err),
symbol: self.symbol_from_to(start, self.pos),
suffix: None,
})
} else {
// Before Rust 2024, only emit a lint for migration.
self.psess.buffer_lint(
RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
span,
ast::CRATE_NODE_ID,
BuiltinLintDiag::ReservedString(space_span),
);
// For backwards compatibility, roll back to after just the first `#`
// and return the `Pound` token.
self.pos = start + BytePos(1);
self.cursor = Cursor::new(&str_before[1..]);
token::Pound
}
}
fn report_too_many_hashes(&self, start: BytePos, num: u32) -> ! {
self.dcx().emit_fatal(errors::TooManyHashes { span: self.mk_sp(start, self.pos), num });
}

6
compiler/rustc_serialize/src/serialize.rs
View File

@ -325,7 +325,7 @@ impl<D: Decoder, const N: usize> Decodable<D> for [u8; N] {
}
}
impl<'a, S: Encoder, T: Encodable<S>> Encodable<S> for Cow<'a, [T]>
impl<S: Encoder, T: Encodable<S>> Encodable<S> for Cow<'_, [T]>
where
[T]: ToOwned<Owned = Vec<T>>,
{
@ -345,14 +345,14 @@ where
}
}
impl<'a, S: Encoder> Encodable<S> for Cow<'a, str> {
impl<S: Encoder> Encodable<S> for Cow<'_, str> {
fn encode(&self, s: &mut S) {
let val: &str = self;
val.encode(s)
}
}
impl<'a, D: Decoder> Decodable<D> for Cow<'a, str> {
impl<D: Decoder> Decodable<D> for Cow<'_, str> {
fn decode(d: &mut D) -> Cow<'static, str> {
let v: String = Decodable::decode(d);
Cow::Owned(v)

6
library/core/src/cell.rs
View File

@ -666,7 +666,7 @@ impl<T: Default> Cell<T> {
impl<T: CoerceUnsized<U>, U> CoerceUnsized<Cell<U>> for Cell<T> {}
// Allow types that wrap `Cell` to also implement `DispatchFromDyn`
// and become object safe method receivers.
// and become dyn-compatible method receivers.
// Note that currently `Cell` itself cannot be a method receiver
// because it does not implement Deref.
// In other words:
@ -2247,7 +2247,7 @@ impl<T> From<T> for UnsafeCell<T> {
impl<T: CoerceUnsized<U>, U> CoerceUnsized<UnsafeCell<U>> for UnsafeCell<T> {}
// Allow types that wrap `UnsafeCell` to also implement `DispatchFromDyn`
// and become object safe method receivers.
// and become dyn-compatible method receivers.
// Note that currently `UnsafeCell` itself cannot be a method receiver
// because it does not implement Deref.
// In other words:
@ -2349,7 +2349,7 @@ impl<T> From<T> for SyncUnsafeCell<T> {
impl<T: CoerceUnsized<U>, U> CoerceUnsized<SyncUnsafeCell<U>> for SyncUnsafeCell<T> {}
// Allow types that wrap `SyncUnsafeCell` to also implement `DispatchFromDyn`
// and become object safe method receivers.
// and become dyn-compatible method receivers.
// Note that currently `SyncUnsafeCell` itself cannot be a method receiver
// because it does not implement Deref.
// In other words:

21
library/core/src/error.rs
View File

@ -335,16 +335,17 @@ impl dyn Error {
#[unstable(feature = "error_iter", issue = "58520")]
#[inline]
pub fn sources(&self) -> Source<'_> {
// You may think this method would be better in the Error trait, and you'd be right.
// Unfortunately that doesn't work, not because of the object safety rules but because we
// save a reference to self in Sources below as a trait object. If this method was
// declared in Error, then self would have the type &T where T is some concrete type which
// implements Error. We would need to coerce self to have type &dyn Error, but that requires
// that Self has a known size (i.e., Self: Sized). We can't put that bound on Error
// since that would forbid Error trait objects, and we can't put that bound on the method
// because that means the method can't be called on trait objects (we'd also need the
// 'static bound, but that isn't allowed because methods with bounds on Self other than
// Sized are not object-safe). Requiring an Unsize bound is not backwards compatible.
// You may think this method would be better in the `Error` trait, and you'd be right.
// Unfortunately that doesn't work, not because of the dyn-incompatibility rules but
// because we save a reference to `self` in `Source`s below as a trait object.
// If this method was declared in `Error`, then `self` would have the type `&T` where
// `T` is some concrete type which implements `Error`. We would need to coerce `self`
// to have type `&dyn Error`, but that requires that `Self` has a known size
// (i.e., `Self: Sized`). We can't put that bound on `Error` since that would forbid
// `Error` trait objects, and we can't put that bound on the method because that means
// the method can't be called on trait objects (we'd also need the `'static` bound,
// but that isn't allowed because methods with bounds on `Self` other than `Sized` are
// dyn-incompatible). Requiring an `Unsize` bound is not backwards compatible.
Source { current: Some(self) }
}

2
library/core/src/iter/traits/iterator.rs
View File

@ -9,7 +9,7 @@ use crate::cmp::{self, Ordering};
use crate::num::NonZero;
use crate::ops::{ChangeOutputType, ControlFlow, FromResidual, Residual, Try};
fn _assert_is_object_safe(_: &dyn Iterator<Item = ()>) {}
fn _assert_is_dyn_compatible(_: &dyn Iterator<Item = ()>) {}
/// A trait for dealing with iterators.
///

3
library/core/src/marker.rs
View File

@ -158,7 +158,7 @@ pub trait Sized {
/// - Arrays `[T; N]` implement `Unsize<[T]>`.
/// - A type implements `Unsize<dyn Trait + 'a>` if all of these conditions are met:
/// - The type implements `Trait`.
/// - `Trait` is object safe.
/// - `Trait` is dyn-compatible[^1].
/// - The type is sized.
/// - The type outlives `'a`.
/// - Structs `Foo<..., T1, ..., Tn, ...>` implement `Unsize<Foo<..., U1, ..., Un, ...>>`
@ -178,6 +178,7 @@ pub trait Sized {
/// [`Rc`]: ../../std/rc/struct.Rc.html
/// [RFC982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
/// [nomicon-coerce]: ../../nomicon/coercions.html
/// [^1]: Formerly known as *object safe*.
#[unstable(feature = "unsize", issue = "18598")]
#[lang = "unsize"]
#[rustc_deny_explicit_impl(implement_via_object = false)]

8
library/core/src/ops/unsize.rs
View File

@ -68,8 +68,8 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *mut T {}
#[unstable(feature = "coerce_unsized", issue = "18598")]
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {}
/// `DispatchFromDyn` is used in the implementation of object safety checks (specifically allowing
/// arbitrary self types), to guarantee that a method's receiver type can be dispatched on.
/// `DispatchFromDyn` is used in the implementation of dyn-compatibility[^1] checks (specifically
/// allowing arbitrary self types), to guarantee that a method's receiver type can be dispatched on.
///
/// Note: `DispatchFromDyn` was briefly named `CoerceSized` (and had a slightly different
/// interpretation).
@ -80,7 +80,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {}
/// type). The compiler must generate an implicit conversion from the trait object/wide pointer to
/// the concrete reference/narrow pointer. Implementing `DispatchFromDyn` indicates that that
/// conversion is allowed and thus that the type implementing `DispatchFromDyn` is safe to use as
/// the self type in an object-safe method. (in the above example, the compiler will require
/// the self type in an dyn-compatible method. (in the above example, the compiler will require
/// `DispatchFromDyn` is implemented for `&'a U`).
///
/// `DispatchFromDyn` does not specify the conversion from wide pointer to narrow pointer; the
@ -112,6 +112,8 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {}
/// T: Unsize<U>,
/// {}
/// ```
///
/// [^1]: Formerly known as *object safety*.
#[unstable(feature = "dispatch_from_dyn", issue = "none")]
#[lang = "dispatch_from_dyn"]
pub trait DispatchFromDyn<T> {

21
library/core/src/primitive_docs.rs
View File

@ -862,6 +862,27 @@ mod prim_array {}
/// assert_eq!(x, &[1, 7, 3]);
/// ```
///
/// It is possible to slice empty subranges of slices by using empty ranges (including `slice.len()..slice.len()`):
/// ```
/// let x = [1, 2, 3];
/// let empty = &x[0..0]; // subslice before the first element
/// assert_eq!(empty, &[]);
/// let empty = &x[..0]; // same as &x[0..0]
/// assert_eq!(empty, &[]);
/// let empty = &x[1..1]; // empty subslice in the middle
/// assert_eq!(empty, &[]);
/// let empty = &x[3..3]; // subslice after the last element
/// assert_eq!(empty, &[]);
/// let empty = &x[3..]; // same as &x[3..3]
/// assert_eq!(empty, &[]);
/// ```
///
/// It is not allowed to use subranges that start with lower bound bigger than `slice.len()`:
/// ```should_panic
/// let x = vec![1, 2, 3];
/// let _ = &x[4..4];
/// ```
///
/// As slices store the length of the sequence they refer to, they have twice
/// the size of pointers to [`Sized`](marker/trait.Sized.html) types.
/// Also see the reference on

2
library/core/tests/hash/mod.rs
View File

@ -164,7 +164,7 @@ fn test_indirect_hasher() {
}
#[test]
fn test_build_hasher_object_safe() {
fn test_build_hasher_dyn_compatible() {
use std::hash::{DefaultHasher, RandomState};
let _: &dyn BuildHasher<Hasher = DefaultHasher> = &RandomState::new();

3
library/std/src/fs.rs
View File

@ -394,7 +394,8 @@ impl File {
///
/// # Errors
///
/// This function will return an error if `path` does not already exist.
/// This function will return an error if `path` does not already exist,
/// or if memory allocation fails for the new buffer.
/// Other errors may also be returned according to [`OpenOptions::open`].
///
/// # Examples

4
library/std/src/keyword_docs.rs
View File

@ -2349,12 +2349,13 @@ mod async_keyword {}
/// [`async`]: ../std/keyword.async.html
mod await_keyword {}
// FIXME(dyn_compat_renaming): Update URL and link text.
#[doc(keyword = "dyn")]
//
/// `dyn` is a prefix of a [trait object]'s type.
///
/// The `dyn` keyword is used to highlight that calls to methods on the associated `Trait`
/// are [dynamically dispatched]. To use the trait this way, it must be 'object safe'.
/// are [dynamically dispatched]. To use the trait this way, it must be 'dyn-compatible'[^1].
///
/// Unlike generic parameters or `impl Trait`, the compiler does not know the concrete type that
/// is being passed. That is, the type has been [erased].
@ -2382,6 +2383,7 @@ mod await_keyword {}
/// [ref-trait-obj]: ../reference/types/trait-object.html
/// [ref-obj-safety]: ../reference/items/traits.html#object-safety
/// [erased]: https://en.wikipedia.org/wiki/Type_erasure
/// [^1]: Formerly known as 'object safe'.
mod dyn_keyword {}
#[doc(keyword = "union")]

2
library/std/src/os/wasi/mod.rs
View File

@ -36,6 +36,8 @@
pub mod ffi;
pub mod fs;
pub mod io;
#[cfg(all(target_os = "wasi", target_env = "p1"))]
pub mod net;
/// A prelude for conveniently writing platform-specific code.

74
library/std/src/sys/pal/wasip2/net.rs
View File

@ -2,13 +2,12 @@
use libc::{c_int, c_void, size_t};
use super::fd::WasiFd;
use crate::ffi::CStr;
use crate::io::{self, BorrowedBuf, BorrowedCursor, IoSlice, IoSliceMut};
use crate::net::{Shutdown, SocketAddr};
use crate::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
use crate::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
use crate::sys::unsupported;
use crate::sys_common::net::{TcpListener, getsockopt, setsockopt, sockaddr_to_addr};
use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
use crate::sys_common::{AsInner, FromInner, IntoInner};
use crate::time::{Duration, Instant};
use crate::{cmp, mem, str};
@ -71,7 +70,9 @@ pub fn cvt_gai(err: c_int) -> io::Result<()> {
pub fn init() {}
pub struct Socket(WasiFd);
pub struct WasiSocket(OwnedFd);
pub struct Socket(WasiSocket);
impl Socket {
pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
@ -327,22 +328,66 @@ impl Socket {
}
}
impl AsInner<WasiFd> for Socket {
impl AsInner<OwnedFd> for WasiSocket {
#[inline]
fn as_inner(&self) -> &WasiFd {
fn as_inner(&self) -> &OwnedFd {
&self.0
}
}
impl IntoInner<WasiFd> for Socket {
fn into_inner(self) -> WasiFd {
impl IntoInner<OwnedFd> for WasiSocket {
fn into_inner(self) -> OwnedFd {
self.0
}
}
impl FromInner<WasiFd> for Socket {
fn from_inner(inner: WasiFd) -> Socket {
Socket(inner)
impl FromInner<OwnedFd> for WasiSocket {
fn from_inner(owned_fd: OwnedFd) -> Self {
Self(owned_fd)
}
}
impl AsFd for WasiSocket {
fn as_fd(&self) -> BorrowedFd<'_> {
self.0.as_fd()
}
}
impl AsRawFd for WasiSocket {
#[inline]
fn as_raw_fd(&self) -> RawFd {
self.0.as_raw_fd()
}
}
impl IntoRawFd for WasiSocket {
fn into_raw_fd(self) -> RawFd {
self.0.into_raw_fd()
}
}
impl FromRawFd for WasiSocket {
unsafe fn from_raw_fd(raw_fd: RawFd) -> Self {
unsafe { Self(FromRawFd::from_raw_fd(raw_fd)) }
}
}
impl AsInner<WasiSocket> for Socket {
#[inline]
fn as_inner(&self) -> &WasiSocket {
&self.0
}
}
impl IntoInner<WasiSocket> for Socket {
fn into_inner(self) -> WasiSocket {
self.0
}
}
impl FromInner<WasiSocket> for Socket {
fn from_inner(sock: WasiSocket) -> Socket {
Socket(sock)
}
}
@ -370,10 +415,3 @@ impl FromRawFd for Socket {
unsafe { Self(FromRawFd::from_raw_fd(raw_fd)) }
}
}
impl AsInner<Socket> for TcpListener {
#[inline]
fn as_inner(&self) -> &Socket {
&self.socket()
}
}

1
src/librustdoc/html/highlight.rs
View File

@ -845,6 +845,7 @@ impl<'src> Classifier<'src> {
// Number literals.
LiteralKind::Float { .. } | LiteralKind::Int { .. } => Class::Number,
},
TokenKind::GuardedStrPrefix => return no_highlight(sink),
TokenKind::Ident | TokenKind::RawIdent if lookahead == Some(TokenKind::Bang) => {
self.in_macro = true;
sink(Highlight::EnterSpan { class: Class::Macro(self.new_span(before, text)) });

2
src/librustdoc/html/static/css/rustdoc.css
View File

@ -2435,7 +2435,7 @@ in src-script.js and main.js
}
/* Position of the "[-]" element. */
details.toggle:not(.top-doc) > summary {
details.toggle:not(.top-doc) > summary, .impl-items > section {
margin-left: 10px;
}
.impl-items > details.toggle > summary:not(.hideme)::before,

6
src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
View File

@ -187,6 +187,12 @@ impl<'a> Converter<'a> {
}
rustc_lexer::TokenKind::RawIdent => IDENT,
rustc_lexer::TokenKind::GuardedStrPrefix => {
err = "Invalid string literal (reserved syntax)";
ERROR
},
rustc_lexer::TokenKind::Literal { kind, .. } => {
self.extend_literal(token_text.len(), kind);
return;

19
tests/rustdoc-gui/methods-left-margin.goml Normal file
View File

@ -0,0 +1,19 @@
// This test is to ensure that methods are correctly aligned on the left side.
go-to: "file://" + |DOC_PATH| + "/test_docs/struct.Foo.html"
// First we ensure that we have methods with and without documentation.
assert: ".impl-items > details.method-toggle > summary > section.method"
assert: ".impl-items > section.method"
// Checking on desktop.
set-window-size: (900, 600)
wait-for-size: ("body", {"width": 900})
store-position: (".impl-items section.method", {"x": x})
assert-position: (".impl-items section.method", {"x": |x|}, ALL)
// Checking on mobile.
set-window-size: (600, 600)
wait-for-size: ("body", {"width": 600})
store-position: (".impl-items section.method", {"x": x})
assert-position: (".impl-items section.method", {"x": |x|}, ALL)

5
tests/rustdoc-gui/notable-trait.goml
View File

@ -84,9 +84,10 @@ call-function: ("check-notable-tooltip-position", {
// Checking on mobile now.
set-window-size: (650, 600)
wait-for-size: ("body", {"width": 650})
call-function: ("check-notable-tooltip-position-complete", {
"x": 15,
"i_x": 293,
"x": 25,
"i_x": 303,
"popover_x": 0,
})

20
tests/ui/rust-2024/auxiliary/reserved-guarded-strings-macro-2021.rs Normal file
View File

@ -0,0 +1,20 @@
//@ force-host
//@ edition:2021
//@ no-prefer-dynamic
#![crate_type = "proc-macro"]
extern crate proc_macro;
use proc_macro::TokenStream;
use std::str::FromStr;
#[proc_macro]
pub fn number_of_tokens_in_a_guarded_string_literal(_: TokenStream) -> TokenStream {
TokenStream::from_str("#\"abc\"#").unwrap().into_iter().count().to_string().parse().unwrap()
}
#[proc_macro]
pub fn number_of_tokens_in_a_guarded_unterminated_string_literal(_: TokenStream) -> TokenStream {
TokenStream::from_str("#\"abc\"").unwrap().into_iter().count().to_string().parse().unwrap()
}

21
tests/ui/rust-2024/auxiliary/reserved-guarded-strings-macro-2024.rs Normal file
View File

@ -0,0 +1,21 @@
//@ force-host
//@ compile-flags: -Zunstable-options
//@ edition:2024
//@ no-prefer-dynamic
#![crate_type = "proc-macro"]
extern crate proc_macro;
use proc_macro::TokenStream;
use std::str::FromStr;
#[proc_macro]
pub fn number_of_tokens_in_a_guarded_string_literal(_: TokenStream) -> TokenStream {
TokenStream::from_str("#\"abc\"#").unwrap().into_iter().count().to_string().parse().unwrap()
}
#[proc_macro]
pub fn number_of_tokens_in_a_guarded_unterminated_string_literal(_: TokenStream) -> TokenStream {
TokenStream::from_str("#\"abc\"").unwrap().into_iter().count().to_string().parse().unwrap()
}

80
tests/ui/rust-2024/reserved-guarded-strings-lexing.rs Normal file
View File

@ -0,0 +1,80 @@
//@ edition:2021
// ignore-tidy-linelength
#![warn(rust_2024_guarded_string_incompatible_syntax)]
macro_rules! demo2 {
( $a:tt $b:tt ) => { println!("two tokens") };
}
macro_rules! demo3 {
( $a:tt $b:tt $c:tt ) => { println!("three tokens") };
}
macro_rules! demo4 {
( $a:tt $b:tt $c:tt $d:tt ) => { println!("four tokens") };
}
macro_rules! demo5 {
( $a:tt $b:tt $c:tt $d:tt $e:tt ) => { println!("five tokens") };
}
macro_rules! demo7 {
( $a:tt $b:tt $c:tt $d:tt $e:tt $f:tt $g:tt ) => { println!("seven tokens") };
}
fn main() {
demo3!(## "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(### "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(## "foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo7!(### "foo"###);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo5!(###"foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo5!(#"foo"###);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!("foo"###);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
// Non-ascii identifiers
demo2!(Ñ"foo");
//~^ ERROR prefix `Ñ` is unknown
demo4!(Ñ#""#);
//~^ ERROR prefix `Ñ` is unknown
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(🙃#"");
//~^ ERROR identifiers cannot contain emoji
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
}

271
tests/ui/rust-2024/reserved-guarded-strings-lexing.stderr Normal file
View File

@ -0,0 +1,271 @@
error: prefix `Ñ` is unknown
--> $DIR/reserved-guarded-strings-lexing.rs:70:12
|
LL | demo2!(Ñ"foo");
| ^ unknown prefix
|
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | demo2!(Ñ "foo");
| +
error: prefix `Ñ` is unknown
--> $DIR/reserved-guarded-strings-lexing.rs:72:12
|
LL | demo4!(Ñ#""#);
| ^ unknown prefix
|
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | demo4!(Ñ #""#);
| +
error: identifiers cannot contain emoji: `🙃`
--> $DIR/reserved-guarded-strings-lexing.rs:76:12
|
LL | demo3!(🙃#"");
| ^^
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:28:12
|
LL | demo3!(## "foo");
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
note: the lint level is defined here
--> $DIR/reserved-guarded-strings-lexing.rs:4:9
|
LL | #![warn(rust_2024_guarded_string_incompatible_syntax)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(# # "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:31:12
|
LL | demo4!(### "foo");
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(# ## "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:31:13
|
LL | demo4!(### "foo");
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(## # "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:36:12
|
LL | demo4!(## "foo"#);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(# # "foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:39:12
|
LL | demo7!(### "foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo7!(# ## "foo"###);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:39:13
|
LL | demo7!(### "foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo7!(## # "foo"###);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:39:21
|
LL | demo7!(### "foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo7!(### "foo"# ##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:39:22
|
LL | demo7!(### "foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo7!(### "foo"## #);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:49:12
|
LL | demo5!(###"foo"#);
| ^^^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(# ##"foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:49:13
|
LL | demo5!(###"foo"#);
| ^^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(## #"foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:49:14
|
LL | demo5!(###"foo"#);
| ^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(### "foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:56:12
|
LL | demo5!(#"foo"###);
| ^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(# "foo"###);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:56:18
|
LL | demo5!(#"foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(#"foo"# ##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:56:19
|
LL | demo5!(#"foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(#"foo"## #);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:63:17
|
LL | demo4!("foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!("foo"# ##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:63:18
|
LL | demo4!("foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!("foo"## #);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:72:13
|
LL | demo4!(Ñ#""#);
| ^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(Ñ# ""#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-lexing.rs:76:13
|
LL | demo3!(🙃#"");
| ^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(🙃# "");
| +
error: aborting due to 3 previous errors; 18 warnings emitted

99
tests/ui/rust-2024/reserved-guarded-strings-migration.fixed Normal file
View File

@ -0,0 +1,99 @@
//@ check-pass
//@ run-rustfix
//@ edition:2021
#![warn(rust_2024_guarded_string_incompatible_syntax)]
macro_rules! demo1 {
( $a:tt ) => { println!("one tokens") };
}
macro_rules! demo2 {
( $a:tt $b:tt ) => { println!("two tokens") };
}
macro_rules! demo3 {
( $a:tt $b:tt $c:tt ) => { println!("three tokens") };
}
macro_rules! demo4 {
( $a:tt $b:tt $c:tt $d:tt ) => { println!("four tokens") };
}
macro_rules! demo5 {
( $a:tt $b:tt $c:tt $d:tt $e:tt ) => { println!("five tokens") };
}
macro_rules! demo6 {
( $a:tt $b:tt $c:tt $d:tt $e:tt $f:tt ) => { println!("six tokens") };
}
fn main() {
demo1!("");
demo2!(# "");
demo3!(# ""#);
demo2!(# "foo");
demo3!(# "foo"#);
demo2!("foo"#);
demo3!(# # "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(# # # "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(# # "foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo6!(# # # "foo"# #);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!("foo"# # #);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo2!(# "");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(# ""#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(# # "");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo2!(# "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(# # "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(# "foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(# # "foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo5!(# # "foo"# #);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
}

99
tests/ui/rust-2024/reserved-guarded-strings-migration.rs Normal file
View File

@ -0,0 +1,99 @@
//@ check-pass
//@ run-rustfix
//@ edition:2021
#![warn(rust_2024_guarded_string_incompatible_syntax)]
macro_rules! demo1 {
( $a:tt ) => { println!("one tokens") };
}
macro_rules! demo2 {
( $a:tt $b:tt ) => { println!("two tokens") };
}
macro_rules! demo3 {
( $a:tt $b:tt $c:tt ) => { println!("three tokens") };
}
macro_rules! demo4 {
( $a:tt $b:tt $c:tt $d:tt ) => { println!("four tokens") };
}
macro_rules! demo5 {
( $a:tt $b:tt $c:tt $d:tt $e:tt ) => { println!("five tokens") };
}
macro_rules! demo6 {
( $a:tt $b:tt $c:tt $d:tt $e:tt $f:tt ) => { println!("six tokens") };
}
fn main() {
demo1!("");
demo2!(# "");
demo3!(# ""#);
demo2!(# "foo");
demo3!(# "foo"#);
demo2!("foo"#);
demo3!(## "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(### "foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(## "foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo6!(### "foo"##);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!("foo"###);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo2!(#"");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(#""#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(##"");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo2!(#"foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(##"foo");
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo3!(#"foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo4!(##"foo"#);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
demo5!(##"foo"##);
//~^ WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
//~| WARNING parsed as a guarded string in Rust 2024 [rust_2024_guarded_string_incompatible_syntax]
//~| WARNING hard error in Rust 2024
}

293
tests/ui/rust-2024/reserved-guarded-strings-migration.stderr Normal file
View File

@ -0,0 +1,293 @@
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:40:12
|
LL | demo3!(## "foo");
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
note: the lint level is defined here
--> $DIR/reserved-guarded-strings-migration.rs:5:9
|
LL | #![warn(rust_2024_guarded_string_incompatible_syntax)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(# # "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:43:12
|
LL | demo4!(### "foo");
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(# ## "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:43:13
|
LL | demo4!(### "foo");
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(## # "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:48:12
|
LL | demo4!(## "foo"#);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(# # "foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:51:12
|
LL | demo6!(### "foo"##);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo6!(# ## "foo"##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:51:13
|
LL | demo6!(### "foo"##);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo6!(## # "foo"##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:51:21
|
LL | demo6!(### "foo"##);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo6!(### "foo"# #);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:59:17
|
LL | demo4!("foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!("foo"# ##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:59:18
|
LL | demo4!("foo"###);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!("foo"## #);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:65:12
|
LL | demo2!(#"");
| ^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo2!(# "");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:68:12
|
LL | demo3!(#""#);
| ^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(# ""#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:71:12
|
LL | demo3!(##"");
| ^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(# #"");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:71:13
|
LL | demo3!(##"");
| ^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(## "");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:76:12
|
LL | demo2!(#"foo");
| ^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo2!(# "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:79:12
|
LL | demo3!(##"foo");
| ^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(# #"foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:79:13
|
LL | demo3!(##"foo");
| ^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(## "foo");
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:84:12
|
LL | demo3!(#"foo"#);
| ^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo3!(# "foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:87:12
|
LL | demo4!(##"foo"#);
| ^^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(# #"foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:87:13
|
LL | demo4!(##"foo"#);
| ^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo4!(## "foo"#);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:92:12
|
LL | demo5!(##"foo"##);
| ^^^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(# #"foo"##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:92:13
|
LL | demo5!(##"foo"##);
| ^^^^^^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(## "foo"##);
| +
warning: will be parsed as a guarded string in Rust 2024
--> $DIR/reserved-guarded-strings-migration.rs:92:19
|
LL | demo5!(##"foo"##);
| ^^
|
= warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
= note: for more information, see issue #123735 <https://github.com/rust-lang/rust/issues/123735>
help: insert whitespace here to avoid this being parsed as a guarded string in Rust 2024
|
LL | demo5!(##"foo"# #);
| +
warning: 22 warnings emitted

18
tests/ui/rust-2024/reserved-guarded-strings-via-macro-2.rs Normal file
View File

@ -0,0 +1,18 @@
//@ edition:2021
//@ aux-build:reserved-guarded-strings-macro-2021.rs
//@ aux-build:reserved-guarded-strings-macro-2024.rs
extern crate reserved_guarded_strings_macro_2021 as m2021;
extern crate reserved_guarded_strings_macro_2024 as m2024;
fn main() {
// Ok:
m2021::number_of_tokens_in_a_guarded_string_literal!();
m2021::number_of_tokens_in_a_guarded_unterminated_string_literal!();
// Error, even though *this* crate is 2021:
m2024::number_of_tokens_in_a_guarded_string_literal!();
//~^ ERROR invalid string literal
m2024::number_of_tokens_in_a_guarded_unterminated_string_literal!();
//~^ ERROR invalid string literal
}

20
tests/ui/rust-2024/reserved-guarded-strings-via-macro-2.stderr Normal file
View File

@ -0,0 +1,20 @@
error: invalid string literal
--> $DIR/reserved-guarded-strings-via-macro-2.rs:14:5
|
LL | m2024::number_of_tokens_in_a_guarded_string_literal!();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
= note: this error originates in the macro `m2024::number_of_tokens_in_a_guarded_string_literal` (in Nightly builds, run with -Z macro-backtrace for more info)
error: invalid string literal
--> $DIR/reserved-guarded-strings-via-macro-2.rs:16:5
|
LL | m2024::number_of_tokens_in_a_guarded_unterminated_string_literal!();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
= note: this error originates in the macro `m2024::number_of_tokens_in_a_guarded_unterminated_string_literal` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors

12
tests/ui/rust-2024/reserved-guarded-strings-via-macro.rs Normal file
View File

@ -0,0 +1,12 @@
//@ run-pass
//@ compile-flags: -Zunstable-options
//@ edition:2024
//@ aux-build:reserved-guarded-strings-macro-2021.rs
extern crate reserved_guarded_strings_macro_2021 as m2021;
fn main() {
// Ok, even though *this* crate is 2024:
assert_eq!(m2021::number_of_tokens_in_a_guarded_string_literal!(), 3);
assert_eq!(m2021::number_of_tokens_in_a_guarded_unterminated_string_literal!(), 2);
}

74
tests/ui/rust-2024/reserved-guarded-strings.rs Normal file
View File

@ -0,0 +1,74 @@
//@ compile-flags: -Zunstable-options
//@ edition:2024
// ignore-tidy-linelength
macro_rules! demo1 {
( $a:tt ) => { println!("one tokens") };
}
macro_rules! demo2 {
( $a:tt $b:tt ) => { println!("two tokens") };
}
macro_rules! demo3 {
( $a:tt $b:tt $c:tt ) => { println!("three tokens") };
}
macro_rules! demo4 {
( $a:tt $b:tt $c:tt $d:tt ) => { println!("four tokens") };
}
macro_rules! demo5 {
( $a:tt $b:tt $c:tt $d:tt $e:tt ) => { println!("five tokens") };
}
macro_rules! demo6 {
( $a:tt $b:tt $c:tt $d:tt $e:tt $f:tt ) => { println!("six tokens") };
}
macro_rules! demo7 {
( $a:tt $b:tt $c:tt $d:tt $e:tt $f:tt $g:tt ) => { println!("seven tokens") };
}
macro_rules! demon {
( $($n:tt)* ) => { println!("unknown number of tokens") };
}
fn main() {
demo1!("");
demo2!(# "");
demo3!(# ""#);
demo2!(# "foo");
demo3!(# "foo"#);
demo2!("foo"#);
demo2!(blah"xx"); //~ ERROR prefix `blah` is unknown
demo2!(blah#"xx"#);
//~^ ERROR prefix `blah` is unknown
//~| ERROR invalid string literal
demo2!(## "foo"); //~ ERROR invalid string literal
demo3!("foo"###); //~ ERROR invalid string literal
demo3!(### "foo"); //~ ERROR invalid string literal
demo3!(## "foo"#); //~ ERROR invalid string literal
demo5!(### "foo"###);
//~^ ERROR invalid string literal
//~| ERROR invalid string literal
demo1!(#""); //~ ERROR invalid string literal
demo1!(#""#); //~ ERROR invalid string literal
demo1!(####""); //~ ERROR invalid string literal
demo1!(#"foo"); //~ ERROR invalid string literal
demo1!(###"foo"); //~ ERROR invalid string literal
demo1!(#"foo"#); //~ ERROR invalid string literal
demo1!(###"foo"#); //~ ERROR invalid string literal
demo1!(###"foo"##); //~ ERROR invalid string literal
demo1!(###"foo"###); //~ ERROR invalid string literal
demo2!(#"foo"###);
//~^ ERROR invalid string literal
//~| ERROR invalid string literal
// More than 255 hashes
demon!(####################################################################################################################################################################################################################################################################"foo");
//~^ ERROR invalid string literal
}

254
tests/ui/rust-2024/reserved-guarded-strings.stderr Normal file
View File

@ -0,0 +1,254 @@
error: prefix `blah` is unknown
--> $DIR/reserved-guarded-strings.rs:45:12
|
LL | demo2!(blah"xx");
| ^^^^ unknown prefix
|
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | demo2!(blah "xx");
| +
error: prefix `blah` is unknown
--> $DIR/reserved-guarded-strings.rs:46:12
|
LL | demo2!(blah#"xx"#);
| ^^^^ unknown prefix
|
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | demo2!(blah #"xx"#);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:46:16
|
LL | demo2!(blah#"xx"#);
| ^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo2!(blah# "xx"#);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:50:12
|
LL | demo2!(## "foo");
| ^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo2!(# # "foo");
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:51:17
|
LL | demo3!("foo"###);
| ^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo3!("foo"# ##);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:52:12
|
LL | demo3!(### "foo");
| ^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo3!(# ## "foo");
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:53:12
|
LL | demo3!(## "foo"#);
| ^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo3!(# # "foo"#);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:54:12
|
LL | demo5!(### "foo"###);
| ^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo5!(# ## "foo"###);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:54:21
|
LL | demo5!(### "foo"###);
| ^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo5!(### "foo"# ##);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:58:12
|
LL | demo1!(#"");
| ^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# "");
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:59:12
|
LL | demo1!(#""#);
| ^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# ""#);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:60:12
|
LL | demo1!(####"");
| ^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# ###"");
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:61:12
|
LL | demo1!(#"foo");
| ^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# "foo");
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:62:12
|
LL | demo1!(###"foo");
| ^^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# ##"foo");
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:63:12
|
LL | demo1!(#"foo"#);
| ^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# "foo"#);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:64:12
|
LL | demo1!(###"foo"#);
| ^^^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# ##"foo"#);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:65:12
|
LL | demo1!(###"foo"##);
| ^^^^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# ##"foo"##);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:66:12
|
LL | demo1!(###"foo"###);
| ^^^^^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo1!(# ##"foo"###);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:67:12
|
LL | demo2!(#"foo"###);
| ^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo2!(# "foo"###);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:67:19
|
LL | demo2!(#"foo"###);
| ^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demo2!(#"foo"## #);
| +
error: invalid string literal
--> $DIR/reserved-guarded-strings.rs:72:12
|
LL | ...n!(####################################################################################################################################################################################################################################################################"foo...
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: unprefixed guarded string literals are reserved for future use since Rust 2024
help: consider inserting whitespace here
|
LL | demon!(# ###################################################################################################################################################################################################################################################################"foo");
| +
error: aborting due to 21 previous errors