mirror of
https://github.com/rust-lang/rust
synced 2024-09-06 01:11:17 +00:00
721 lines
15 KiB
Plaintext
721 lines
15 KiB
Plaintext
#![feature(prelude_import)]
|
|
//@ compile-flags: -Zunpretty=expanded -Zunstable-options
|
|
//@ edition:2024
|
|
//@ check-pass
|
|
|
|
#![feature(async_closure)]
|
|
#![feature(auto_traits)]
|
|
#![feature(box_patterns)]
|
|
#![feature(builtin_syntax)]
|
|
#![feature(concat_idents)]
|
|
#![feature(const_trait_impl)]
|
|
#![feature(core_pattern_type)]
|
|
#![feature(decl_macro)]
|
|
#![feature(deref_patterns)]
|
|
#![feature(explicit_tail_calls)]
|
|
#![feature(gen_blocks)]
|
|
#![feature(let_chains)]
|
|
#![feature(more_qualified_paths)]
|
|
#![feature(never_patterns)]
|
|
#![feature(never_type)]
|
|
#![feature(pattern_types)]
|
|
#![feature(prelude_import)]
|
|
#![feature(raw_ref_op)]
|
|
#![feature(specialization)]
|
|
#![feature(trace_macros)]
|
|
#![feature(trait_alias)]
|
|
#![feature(try_blocks)]
|
|
#![feature(unnamed_fields)]
|
|
#![feature(unsafe_extern_blocks)]
|
|
#![feature(yeet_expr)]
|
|
#![allow(incomplete_features)]
|
|
#[prelude_import]
|
|
use std::prelude::rust_2024::*;
|
|
#[macro_use]
|
|
extern crate std;
|
|
|
|
#[prelude_import]
|
|
use self::prelude::*;
|
|
|
|
mod prelude {
|
|
pub use std::prelude::rust_2024::*;
|
|
|
|
pub type T = _;
|
|
|
|
pub trait Trait {
|
|
const CONST: ();
|
|
}
|
|
}
|
|
|
|
mod attributes {
|
|
//! inner single-line doc comment
|
|
/*!
|
|
* inner multi-line doc comment
|
|
*/
|
|
#![doc = "inner doc attribute"]
|
|
#![allow(dead_code, unused_variables)]
|
|
#![no_std]
|
|
|
|
/// outer single-line doc comment
|
|
/**
|
|
* outer multi-line doc comment
|
|
*/
|
|
#[doc = "outer doc attribute"]
|
|
#[doc = "macro"]
|
|
#[allow()]
|
|
#[repr(C)]
|
|
struct Struct;
|
|
}
|
|
|
|
mod expressions {
|
|
/// ExprKind::Array
|
|
fn expr_array() {
|
|
[];
|
|
[true];
|
|
[true];
|
|
[true, true];
|
|
["long........................................................................"];
|
|
["long............................................................",
|
|
true];
|
|
}
|
|
|
|
/// ExprKind::ConstBlock
|
|
fn expr_const_block() {
|
|
const {};
|
|
const { 1 };
|
|
const {
|
|
struct S;
|
|
};
|
|
}
|
|
|
|
/// ExprKind::Call
|
|
fn expr_call() {
|
|
let f;
|
|
f();
|
|
f::<u8>();
|
|
f::<1>();
|
|
f::<'static, u8, 1>();
|
|
f(true);
|
|
f(true);
|
|
()();
|
|
}
|
|
|
|
/// ExprKind::MethodCall
|
|
fn expr_method_call() {
|
|
let x;
|
|
x.f();
|
|
x.f::<u8>();
|
|
x.collect::<Vec<_>>();
|
|
}
|
|
|
|
/// ExprKind::Tup
|
|
fn expr_tup() { (); (true,); (true, false); (true, false); }
|
|
|
|
/// ExprKind::Binary
|
|
fn expr_binary() {
|
|
let (a, b, c, d, x, y);
|
|
true || false;
|
|
true || false && false;
|
|
a < 1 && 2 < b && c > 3 && 4 > d;
|
|
a & b & !c;
|
|
a + b * c - d + -1 * -2 - -3;
|
|
x = !y;
|
|
}
|
|
|
|
/// ExprKind::Unary
|
|
fn expr_unary() { let expr; *expr; !expr; -expr; }
|
|
|
|
/// ExprKind::Lit
|
|
fn expr_lit() { 'x'; 1_000_i8; 1.00000000000000000000001; }
|
|
|
|
/// ExprKind::Cast
|
|
fn expr_cast() { let expr; expr as T; expr as T<u8>; }
|
|
|
|
/// ExprKind::Type
|
|
fn expr_type() { let expr; builtin # type_ascribe(expr, T); }
|
|
|
|
/// ExprKind::Let
|
|
fn expr_let() {
|
|
let b;
|
|
if let Some(a) = b {}
|
|
if let _ = true && false {}
|
|
if let _ = (true && false) {}
|
|
}
|
|
|
|
/// ExprKind::If
|
|
fn expr_if() {
|
|
if true {}
|
|
if !true {}
|
|
if let true = true {} else {}
|
|
if true {} else if false {}
|
|
if true {} else if false {} else {}
|
|
if true { return; } else if false { 0 } else { 0 }
|
|
}
|
|
|
|
/// ExprKind::While
|
|
fn expr_while() {
|
|
while false {}
|
|
'a: while false {}
|
|
while let true = true {}
|
|
}
|
|
|
|
/// ExprKind::ForLoop
|
|
fn expr_for_loop() { let x; for _ in x {} 'a: for _ in x {} }
|
|
|
|
/// ExprKind::Loop
|
|
fn expr_loop() { loop {} 'a: loop {} }
|
|
|
|
/// ExprKind::Match
|
|
fn expr_match() {
|
|
let value;
|
|
match value {}
|
|
match value { ok => 1, }
|
|
match value { ok => 1, err => 0, }
|
|
}
|
|
|
|
/// ExprKind::Closure
|
|
fn expr_closure() {
|
|
let value;
|
|
|| {};
|
|
|x| {};
|
|
|x: u8| {};
|
|
|| ();
|
|
move || value;
|
|
async || value;
|
|
async move || value;
|
|
static || value;
|
|
static move || value;
|
|
(static async || value);
|
|
(static async move || value);
|
|
|| -> u8 { value };
|
|
1 + (|| {});
|
|
}
|
|
|
|
/// ExprKind::Block
|
|
fn expr_block() {
|
|
{}
|
|
unsafe {}
|
|
'a: {}
|
|
|
|
#[allow()]
|
|
{}
|
|
{
|
|
#![allow()]
|
|
}
|
|
}
|
|
|
|
/// ExprKind::Gen
|
|
fn expr_gen() {
|
|
async {};
|
|
async move {};
|
|
gen {};
|
|
gen move {};
|
|
async gen {};
|
|
async gen move {};
|
|
}
|
|
|
|
/// ExprKind::Await
|
|
fn expr_await() { let fut; fut.await; }
|
|
|
|
/// ExprKind::TryBlock
|
|
fn expr_try_block() { try {} try { return; } }
|
|
|
|
/// ExprKind::Assign
|
|
fn expr_assign() { let expr; expr = true; }
|
|
|
|
/// ExprKind::AssignOp
|
|
fn expr_assign_op() { let expr; expr += true; }
|
|
|
|
/// ExprKind::Field
|
|
fn expr_field() { let expr; expr.field; expr.0; }
|
|
|
|
/// ExprKind::Index
|
|
fn expr_index() { let expr; expr[true]; }
|
|
|
|
/// ExprKind::Range
|
|
fn expr_range() {
|
|
let (lo, hi);
|
|
..;
|
|
..hi;
|
|
lo..;
|
|
lo..hi;
|
|
lo..hi;
|
|
..=hi;
|
|
lo..=hi;
|
|
-2..=-1;
|
|
}
|
|
|
|
/// ExprKind::Underscore
|
|
fn expr_underscore() { _; }
|
|
|
|
/// ExprKind::Path
|
|
fn expr_path() {
|
|
let x;
|
|
crate::expressions::expr_path;
|
|
crate::expressions::expr_path::<'static>;
|
|
<T as Default>::default;
|
|
<T as ::core::default::Default>::default::<>;
|
|
x::();
|
|
x::(T, T) -> T;
|
|
crate::() -> ()::expressions::() -> ()::expr_path;
|
|
core::()::marker::()::PhantomData;
|
|
}
|
|
|
|
/// ExprKind::AddrOf
|
|
fn expr_addr_of() {
|
|
let expr;
|
|
&expr;
|
|
&mut expr;
|
|
&raw const expr;
|
|
&raw mut expr;
|
|
}
|
|
|
|
/// ExprKind::Break
|
|
fn expr_break() { 'a: { break; break 'a; break true; break 'a true; } }
|
|
|
|
/// ExprKind::Continue
|
|
fn expr_continue() { 'a: { continue; continue 'a; } }
|
|
|
|
/// ExprKind::Ret
|
|
fn expr_ret() { return; return true; }
|
|
|
|
/// ExprKind::InlineAsm
|
|
fn expr_inline_asm() {
|
|
let x;
|
|
asm!("mov {1}, {0}\nshl {1}, 1\nshl {0}, 2\nadd {0}, {1}",
|
|
inout(reg)
|
|
x,
|
|
out(reg)
|
|
_);
|
|
}
|
|
|
|
/// ExprKind::OffsetOf
|
|
fn expr_offset_of() {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ...
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ builtin # offset_of(T, field) };
|
|
}
|
|
/// ExprKind::MacCall
|
|
fn expr_mac_call() { "..."; "..."; "..."; }
|
|
/// ExprKind::Struct
|
|
fn expr_struct() {
|
|
struct Struct {}
|
|
let (x, base);
|
|
Struct {};
|
|
<Struct as ToOwned>::Owned {};
|
|
Struct { .. };
|
|
Struct { ..base };
|
|
Struct { x };
|
|
Struct { x, ..base };
|
|
Struct { x: true };
|
|
Struct { x: true, .. };
|
|
Struct { x: true, ..base };
|
|
Struct { 0: true, ..base };
|
|
}
|
|
/// ExprKind::Repeat
|
|
fn expr_repeat() { [(); 0]; }
|
|
/// ExprKind::Paren
|
|
fn expr_paren() { let expr; (expr); }
|
|
/// ExprKind::Try
|
|
fn expr_try() { let expr; expr?; }
|
|
/// ExprKind::Yield
|
|
fn expr_yield() { yield; yield true; }
|
|
/// ExprKind::Yeet
|
|
fn expr_yeet() { do yeet; do yeet 0; }
|
|
/// ExprKind::Become
|
|
fn expr_become() { become true; }
|
|
/// ExprKind::IncludedBytes
|
|
fn expr_include_bytes() {
|
|
b"data for include_bytes in ../expanded-exhaustive.rs\n";
|
|
}
|
|
/// ExprKind::FormatArgs
|
|
fn expr_format_args() {
|
|
let expr;
|
|
format_args!("");
|
|
format_args!("{0}", expr);
|
|
}
|
|
}
|
|
mod items {
|
|
/// ItemKind::ExternCrate
|
|
mod item_extern_crate {
|
|
extern crate core;
|
|
extern crate self as unpretty;
|
|
pub extern crate core as _;
|
|
}
|
|
/// ItemKind::Use
|
|
mod item_use {
|
|
use crate::{expressions, items::item_use};
|
|
pub use core::*;
|
|
}
|
|
/// ItemKind::Static
|
|
mod item_static {
|
|
pub static A: () = {};
|
|
static mut B: () = {};
|
|
}
|
|
/// ItemKind::Const
|
|
mod item_const {
|
|
pub const A: () = {};
|
|
trait TraitItems {
|
|
const B: ();
|
|
const C: () = {};
|
|
}
|
|
}
|
|
/// ItemKind::Fn
|
|
mod item_fn {
|
|
pub const unsafe extern "C" fn f() {}
|
|
pub async unsafe extern fn g() {}
|
|
fn h<'a, T>() where T: 'a {}
|
|
trait TraitItems {
|
|
unsafe extern fn f();
|
|
}
|
|
impl TraitItems for _ {
|
|
default unsafe extern fn f() {}
|
|
}
|
|
}
|
|
/// ItemKind::Mod
|
|
mod item_mod { }
|
|
/// ItemKind::ForeignMod
|
|
mod item_foreign_mod {
|
|
unsafe extern "C++" {}
|
|
unsafe extern {}
|
|
}
|
|
/// ItemKind::GlobalAsm
|
|
mod item_global_asm {
|
|
global_asm! (".globl my_asm_func");
|
|
}
|
|
/// ItemKind::TyAlias
|
|
mod item_ty_alias {
|
|
pub type Type<'a> where T: 'a = T;
|
|
}
|
|
/// ItemKind::Enum
|
|
mod item_enum {
|
|
pub enum Void {}
|
|
enum Empty { Unit, Tuple(), Struct {}, }
|
|
enum Generic<'a, T> where T: 'a {
|
|
Tuple(T),
|
|
Struct {
|
|
t: T,
|
|
},
|
|
}
|
|
}
|
|
/// ItemKind::Struct
|
|
mod item_struct {
|
|
pub struct Unit;
|
|
struct Tuple();
|
|
struct Newtype(Unit);
|
|
struct Struct {}
|
|
struct Generic<'a, T> where T: 'a {
|
|
t: T,
|
|
}
|
|
}
|
|
/// ItemKind::Union
|
|
mod item_union {
|
|
union Generic<'a, T> where T: 'a {
|
|
t: T,
|
|
}
|
|
}
|
|
/// ItemKind::Trait
|
|
mod item_trait {
|
|
pub unsafe auto trait Send {}
|
|
trait Trait<'a>: Sized where Self: 'a {}
|
|
}
|
|
/// ItemKind::TraitAlias
|
|
mod item_trait_alias {
|
|
pub trait Trait<T> = Sized where for<'a> T: 'a;
|
|
}
|
|
/// ItemKind::Impl
|
|
mod item_impl {
|
|
impl () {}
|
|
impl<T> () {}
|
|
impl Default for () {}
|
|
impl<T> const Default for () {}
|
|
}
|
|
/// ItemKind::MacCall
|
|
mod item_mac_call { }
|
|
/// ItemKind::MacroDef
|
|
mod item_macro_def {
|
|
macro_rules! mac { () => { ... }; }
|
|
pub macro stringify { () => {} }
|
|
}
|
|
/// ItemKind::Delegation
|
|
mod item_delegation {
|
|
/*! FIXME: todo */
|
|
}
|
|
/// ItemKind::DelegationMac
|
|
mod item_delegation_mac {
|
|
/*! FIXME: todo */
|
|
}
|
|
}
|
|
mod patterns {
|
|
/// PatKind::Wild
|
|
fn pat_wild() { let _; }
|
|
/// PatKind::Ident
|
|
fn pat_ident() {
|
|
let x;
|
|
let ref x;
|
|
let mut x;
|
|
let ref mut x;
|
|
let ref mut x @ _;
|
|
}
|
|
/// PatKind::Struct
|
|
fn pat_struct() {
|
|
let T {};
|
|
let T::<T> {};
|
|
let T::<'static> {};
|
|
let T { x };
|
|
let T { x: _x };
|
|
let T { .. };
|
|
let T { x, .. };
|
|
let T { x: _x, .. };
|
|
let T { 0: _x, .. };
|
|
let <T as ToOwned>::Owned {};
|
|
}
|
|
/// PatKind::TupleStruct
|
|
fn pat_tuple_struct() {
|
|
struct Tuple();
|
|
let Tuple();
|
|
let Tuple::<T>();
|
|
let Tuple::<'static>();
|
|
let Tuple(x);
|
|
let Tuple(..);
|
|
let Tuple(x, ..);
|
|
}
|
|
/// PatKind::Or
|
|
fn pat_or() { let (true | false); let (true); let (true | false); }
|
|
/// PatKind::Path
|
|
fn pat_path() {
|
|
let core::marker::PhantomData;
|
|
let core::marker::PhantomData::<T>;
|
|
let core::marker::PhantomData::<'static>;
|
|
let <T as Trait>::CONST;
|
|
}
|
|
/// PatKind::Tuple
|
|
fn pat_tuple() { let (); let (true,); let (true, false); }
|
|
/// PatKind::Box
|
|
fn pat_box() { let box pat; }
|
|
/// PatKind::Deref
|
|
fn pat_deref() { let deref!(pat); }
|
|
/// PatKind::Ref
|
|
fn pat_ref() { let &pat; let &mut pat; }
|
|
/// PatKind::Lit
|
|
fn pat_lit() { let 1_000_i8; let -""; }
|
|
/// PatKind::Range
|
|
fn pat_range() { let ..1; let 0..; let 0..1; let 0..=1; let -2..=-1; }
|
|
/// PatKind::Slice
|
|
fn pat_slice() { let []; let [true]; let [true]; let [true, false]; }
|
|
/// PatKind::Rest
|
|
fn pat_rest() { let ..; }
|
|
/// PatKind::Never
|
|
fn pat_never() { let !; let Some(!); }
|
|
/// PatKind::Paren
|
|
fn pat_paren() { let (pat); }
|
|
/// PatKind::MacCall
|
|
fn pat_mac_call() { let ""; let ""; let ""; }
|
|
}
|
|
mod statements {
|
|
/// StmtKind::Let
|
|
fn stmt_let() {
|
|
let _;
|
|
let _ = true;
|
|
let _: T = true;
|
|
let _ = true else { return; };
|
|
}
|
|
/// StmtKind::Item
|
|
fn stmt_item() {
|
|
struct Struct {}
|
|
struct Unit;
|
|
}
|
|
/// StmtKind::Expr
|
|
fn stmt_expr() { () }
|
|
/// StmtKind::Semi
|
|
fn stmt_semi() { 1 + 1; }
|
|
/// StmtKind::Empty
|
|
fn stmt_empty() { ; }
|
|
/// StmtKind::MacCall
|
|
fn stmt_mac_call() { "..."; "..."; "..."; }
|
|
}
|
|
mod types {
|
|
/// TyKind::Slice
|
|
fn ty_slice() { let _: [T]; }
|
|
/// TyKind::Array
|
|
fn ty_array() { let _: [T; 0]; }
|
|
/// TyKind::Ptr
|
|
fn ty_ptr() { let _: *const T; let _: *mut T; }
|
|
/// TyKind::Ref
|
|
fn ty_ref() {
|
|
let _: &T;
|
|
let _: &mut T;
|
|
let _: &'static T;
|
|
let _: &'static mut [T];
|
|
let _: &T<T<T<T<T>>>>;
|
|
let _: &T<T<T<T<T>>>>;
|
|
}
|
|
/// TyKind::BareFn
|
|
fn ty_bare_fn() {
|
|
let _: fn();
|
|
let _: fn() -> ();
|
|
let _: fn(T);
|
|
let _: fn(t: T);
|
|
let _: fn();
|
|
let _: for<'a> fn();
|
|
}
|
|
/// TyKind::Never
|
|
fn ty_never() { let _: !; }
|
|
/// TyKind::Tup
|
|
fn ty_tup() { let _: (); let _: (T,); let _: (T, T); }
|
|
/// TyKind::AnonStruct
|
|
fn ty_anon_struct() {
|
|
struct Struct {
|
|
_: struct {
|
|
t: T,
|
|
},
|
|
}
|
|
}
|
|
/// TyKind::AnonUnion
|
|
fn ty_anon_union() {
|
|
struct Struct {
|
|
_: union {
|
|
t: T,
|
|
},
|
|
}
|
|
}
|
|
/// TyKind::Path
|
|
fn ty_path() {
|
|
let _: T;
|
|
let _: T<'static>;
|
|
let _: T<T>;
|
|
let _: T<T>;
|
|
let _: T() -> !;
|
|
let _: <T as ToOwned>::Owned;
|
|
}
|
|
/// TyKind::TraitObject
|
|
fn ty_trait_object() {
|
|
let _: dyn Send;
|
|
let _: dyn Send + 'static;
|
|
let _: dyn 'static + Send;
|
|
let _: dyn for<'a> Send;
|
|
}
|
|
/// TyKind::ImplTrait
|
|
const fn ty_impl_trait() {
|
|
let _: impl Send;
|
|
let _: impl Send + 'static;
|
|
let _: impl 'static + Send;
|
|
let _: impl ?Sized;
|
|
let _: impl ~const Clone;
|
|
let _: impl for<'a> Send;
|
|
}
|
|
/// TyKind::Paren
|
|
fn ty_paren() { let _: (T); }
|
|
/// TyKind::Typeof
|
|
fn ty_typeof() {
|
|
/*! unused for now */
|
|
}
|
|
/// TyKind::Infer
|
|
fn ty_infer() { let _: _; }
|
|
/// TyKind::ImplicitSelf
|
|
fn ty_implicit_self() {
|
|
/*! there is no syntax for this */
|
|
}
|
|
/// TyKind::MacCall
|
|
fn ty_mac_call() { let _: T; let _: T; let _: T; }
|
|
/// TyKind::CVarArgs
|
|
fn ty_c_var_args() {
|
|
/*! FIXME: todo */
|
|
}
|
|
/// TyKind::Pat
|
|
fn ty_pat() { let _: u32 is 1..; }
|
|
}
|
|
mod visibilities {
|
|
/// VisibilityKind::Public
|
|
mod visibility_public {
|
|
pub struct Pub;
|
|
}
|
|
/// VisibilityKind::Restricted
|
|
mod visibility_restricted {
|
|
pub(crate) struct PubCrate;
|
|
pub(self) struct PubSelf;
|
|
pub(super) struct PubSuper;
|
|
pub(in crate) struct PubInCrate;
|
|
pub(in self) struct PubInSelf;
|
|
pub(in super) struct PubInSuper;
|
|
pub(in crate::visibilities) struct PubInCrateVisibilities;
|
|
pub(in self::super) struct PubInSelfSuper;
|
|
pub(in super::visibility_restricted) struct PubInSuperMod;
|
|
}
|
|
}
|