Rollup of 7 pull requests

[matthiaskrgr]

Successful merges:

• handle paren in macro expand for let-init-else expr #134034 (handle paren in macro expand for let-init-else expr)
• Refactor diy_float #139186 (Refactor diy_float)
• std: mention remove_dir_all can emit DirectoryNotEmpty when concurrently written into #140062 (std: mention remove_dir_all can emit DirectoryNotEmpty when concurrently written into)
• Improve test coverage of HIR pretty printing. #140430 (Improve test coverage of HIR pretty printing.)
• Optimize the codegen for Span::from_expansion #140485 (Optimize the codegen for Span::from_expansion)
• linker: Quote symbol names in .def files #140505 (linker: Quote symbol names in .def files)
• interpret: better error message for out-of-bounds pointer arithmetic and accesses #140521 (interpret: better error message for out-of-bounds pointer arithmetic and accesses)

r? @ghost
@rustbot modify labels: rollup

Create a similar rollup

[matthiaskrgr]

@bors r+ rollup=never p=5

[bors]

📌 Commit b30d7b6 has been approved by matthiaskrgr

It is now in the queue for this repository.

[bors]

⌛ Testing commit b30d7b6 with merge e55ab24261b17531f417c91517567b29e18264bc...

[rust-log-analyzer]

The job test-various failed! Check out the build log: (web) (plain)

Click to see the possible cause of the failure (guessed by this bot)

test [ui] tests/ui/wrong-hashset-issue-42918.rs ... ok

failures:

---- [ui] tests/ui/unpretty/exhaustive.rs#hir stdout ----
Saved the actual stderr to "/checkout/obj/build/x86_64-unknown-linux-gnu/test/ui/unpretty/exhaustive.hir/exhaustive.hir.stderr"
diff of stderr:

166    = help: add `#![feature(impl_trait_in_bindings)]` to the crate attributes to enable
167    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
168 
- error: aborting due to 20 previous errors
170 
- Some errors have detailed explanations: E0214, E0562, E0697, E0703, E0728.
172 For more information about an error, try `rustc --explain E0214`.
---
To only update this specific test, also pass `--test-args unpretty/exhaustive.rs`

error in revision `hir`: 1 errors occurred comparing output.
status: exit status: 1
command: env -u RUSTC_LOG_COLOR RUSTC_ICE="0" RUST_BACKTRACE="short" "/checkout/obj/build/x86_64-unknown-linux-gnu/stage2/bin/rustc" "/checkout/tests/ui/unpretty/exhaustive.rs" "-Zthreads=1" "-Zsimulate-remapped-rust-src-base=/rustc/FAKE_PREFIX" "-Ztranslate-remapped-path-to-local-path=no" "-Z" "ignore-directory-in-diagnostics-source-blocks=/cargo" "-Z" "ignore-directory-in-diagnostics-source-blocks=/checkout/vendor" "--sysroot" "/checkout/obj/build/x86_64-unknown-linux-gnu/stage2" "--target=wasm32-wasip1" "--cfg" "hir" "--check-cfg" "cfg(test,FALSE,expanded,hir)" "--error-format" "json" "--json" "future-incompat" "-Ccodegen-units=1" "-Zui-testing" "-Zdeduplicate-diagnostics=no" "-Zwrite-long-types-to-disk=no" "-Cstrip=debuginfo" "--emit" "metadata" "-C" "prefer-dynamic" "--out-dir" "/checkout/obj/build/x86_64-unknown-linux-gnu/test/ui/unpretty/exhaustive.hir" "-A" "unused" "-A" "internal_features" "-Crpath" "-Cdebuginfo=0" "-Lnative=/checkout/obj/build/wasm32-wasip1/native/rust-test-helpers" "--edition=2024" "-Zunpretty=hir"
--- stdout -------------------------------
//@ revisions: expanded hir
//@[expanded]compile-flags: -Zunpretty=expanded
//@[expanded]check-pass
//@[hir]compile-flags: -Zunpretty=hir
//@[hir]check-fail
//@ edition:2024

// Note: the HIR revision includes a `.stderr` file because there are some
// errors that only occur once we get past the AST.

#![feature(auto_traits)]#![feature(box_patterns)]#![feature(builtin_syntax)]#![feature(concat_idents)]#![feature(const_trait_impl)]#![feature(decl_macro)]#![feature(deref_patterns)]#![feature(dyn_star)]#![feature(explicit_tail_calls)]#![feature(gen_blocks)]#![feature(more_qualified_paths)]#![feature(never_patterns)]#![feature(never_type)]#![feature(pattern_types)]#![feature(pattern_type_macro)]#![feature(prelude_import)]#![feature(specialization)]#![feature(trace_macros)]#![feature(trait_alias)]#![feature(try_blocks)]#![feature(yeet_expr)]#![allow(incomplete_features)]
#[prelude_import]
use std::prelude::rust_2024::*;
#[macro_use]
extern crate std;

#[prelude_import]
---
}

//! inner single-line doc comment
/*!
     * inner multi-line doc comment
     */
#[doc = "inner doc attribute"]#[allow(dead_code, unused_variables)]#[no_std]
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()]#[attr = Repr([ReprC])]
    struct Struct;
}

mod expressions {
    /// ExprKind::Array
    fn expr_array() {
        [];
        [true];
        [true];
        [true, true];
        ["long........................................................................"];
        ["long............................................................",
                true];
    }

    /// ExprKind::ConstBlock
    fn expr_const_block() {
---
                };
    }

    /// 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'; 1000i8; 1.00000000000000000000001; }

    /// ExprKind::Cast
    fn expr_cast() { let expr; expr as T; expr as T<u8>; }

    /// ExprKind::Type
    fn expr_type() { let expr; 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() {
        loop { if false { } else { break; } }
        'a: loop { if false { } else { break; } }
        loop { if let true = true { } else { break; } }
    }

    /// ExprKind::ForLoop
    fn expr_for_loop() {
        let x;
        {
                let _t =
                    match #[lang = "into_iter"](x) {
                            mut iter =>
                                loop {
                                        match #[lang = "next"](&mut iter) {
                                                #[lang = "None"] {} => break,
                                                #[lang = "Some"] {  0: _ } => { }
                                            }
                                    },
                        };
                _t
            };
        {
                let _t =
                    match #[lang = "into_iter"](x) {
                            mut iter =>
                                'a:
                                    loop {
                                        match #[lang = "next"](&mut iter) {
                                                #[lang = "None"] {} => break,
                                                #[lang = "Some"] {  0: _ } => { }
                                            }
                                    },
                        };
                _t
            }
    }

    /// 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;
        || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        move || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        || value; //[hir]~ ERROR closures cannot be static
        move || value; //[hir]~ ERROR closures cannot be static
        || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        move || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        || -> u8 { value };
        1 + (|| { });
    }

    /// ExprKind::Block
    fn expr_block() {
        { }
        unsafe { }
        'a: { }
        #[allow()]
        { }
        #[allow()]
        { }
    }

    /// ExprKind::Gen
    fn expr_gen() {
        |mut _task_context: ResumeTy| { };
        move |mut _task_context: ResumeTy| { };
        || { };
        move || { };
        |mut _task_context: ResumeTy| { };
        move |mut _task_context: ResumeTy| { };
    }

    /// ExprKind::Await
    fn expr_await() {
        let fut;
        {
            fut; //[hir]~ ERROR `await` is only allowed
            (/*ERROR*/)
        };
    }

    /// ExprKind::TryBlock
    fn expr_try_block() {
        { #[lang = "from_output"](()) }
        { return; #[lang = "from_output"](()) }
    }

    /// 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);
        #[lang = "RangeFull"] {  };
        #[lang = "RangeTo"] { end: hi };
        #[lang = "RangeFrom"] { start: lo };
        #[lang = "Range"] { start: lo, end: hi };
        #[lang = "Range"] { start: lo, end: hi };
        #[lang = "RangeToInclusive"] { end: hi };
        #[lang = "range_inclusive_new"](lo, hi);
        #[lang = "range_inclusive_new"](-2, -1);
    }

    /// ExprKind::Underscore
    fn expr_underscore() {
        (/*ERROR*/); //[hir]~ ERROR in expressions, `_` can only
    }

    /// 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; //[hir]~ ERROR parenthesized type parameters
        x::<T, T>; //[hir]~ ERROR parenthesized type parameters
        crate::expressions::expr_path;
        //[hir]~^ ERROR parenthesized type parameters
        //[hir]~| ERROR parenthesized type parameters
        core::marker::PhantomData;
        //[hir]~^ ERROR parenthesized type parameters
        //[hir]~| ERROR parenthesized type parameters
    }

    /// 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)
            _);
    }

---




        //[hir]~ ERROR `yield` can only be used





---


        // ...

        //[hir]~ ERROR invalid ABI





---




        //[hir]~ ERROR `..` patterns are not allowed here





---




        //[hir]~ ERROR parenthesized type parameters


        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed





        // concat_idents is deprecated




        { 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;
        match #[lang = "branch"](expr) {
                #[lang = "Break"] {  0: residual } =>
                    #[allow(unreachable_code)]
                    return #[lang = "from_residual"](residual),
                #[lang = "Continue"] {  0: val } => #[allow(unreachable_code)]
                    val,
            };
    }
    /// ExprKind::Yield
    fn expr_yield() { yield (); yield true; }
    /// ExprKind::Yeet
    fn expr_yeet() {
        return #[lang = "from_yeet"](());
        return #[lang = "from_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_arguments::new_const(&[]);
        format_arguments::new_v1(&[""],
            &[format_argument::new_display(&expr)]);
    }
}
mod items {
    /// ItemKind::ExternCrate
    mod item_extern_crate {/// ItemKind::ExternCrate
        extern crate core;
        extern crate self as unpretty;
        extern crate core as _;
    }
    /// ItemKind::Use
    mod item_use {/// ItemKind::Use
        use ::{};
        use crate::expressions;
        use crate::items::item_use;
        use core::*;
    }
    /// ItemKind::Static
    mod item_static {/// ItemKind::Static
        static A: () = { };
        static mut B: () = { };
    }
    /// ItemKind::Const
    mod item_const {/// ItemKind::Const
        const A: () = { };
        trait TraitItems {
            const
            B:
            ();
            const
            C:
            ()
            =
            { };
        }
    }
    /// ItemKind::Fn
    mod item_fn {/// ItemKind::Fn
        const unsafe extern "C" fn f() { }
        async unsafe extern "C" fn g()
            ->
                /*impl Trait*/ |mut _task_context: ResumeTy|
            { { let _t = { }; _t } }
        fn h<'a, T>() where T: 'a { }
        trait TraitItems {
            unsafe extern "C" fn f();
        }
        impl TraitItems for _ {
            unsafe extern "C" fn f() { }
        }
    }
    /// ItemKind::Mod
    mod item_mod {/// ItemKind::Mod
    }
    /// ItemKind::ForeignMod
    mod item_foreign_mod {/// ItemKind::ForeignMod
        extern "Rust" { }
        extern "C" { }
    }
    /// ItemKind::GlobalAsm
    mod item_global_asm {/// ItemKind::GlobalAsm
        global_asm! (".globl my_asm_func") }
        /// ItemKind::TyAlias
        mod item_ty_alias {/// ItemKind::TyAlias
            type Type<'a> where T: 'a = T;
        }
        /// ItemKind::Enum
        mod item_enum {/// ItemKind::Enum
            enum Void { }
            enum Empty {
                Unit,
                Tuple(),
                Struct {
                    },
            }
            enum Generic<'a, T> where T: 'a {
                Tuple(T),
                Struct {
                        t: T,
                    },
            }
        }
        /// ItemKind::Struct
        mod item_struct {/// ItemKind::Struct
            struct Unit;
            struct Tuple();
            struct Newtype(Unit);
            struct Struct {
            }
            struct Generic<'a, T> where T: 'a {
                t: T,
            }
        }
        /// ItemKind::Union
        mod item_union {/// ItemKind::Union
            union Generic<'a, T> where T: 'a {
                t: T,
            }
        }
        /// ItemKind::Trait
        mod item_trait {/// ItemKind::Trait
            auto unsafe trait Send { }
            trait Trait<'a>: Sized where Self: 'a { }
        }
        /// ItemKind::TraitAlias
        mod item_trait_alias {/// ItemKind::TraitAlias
            trait Trait<T> = Sized where for<'a> T: 'a;
        }
        /// ItemKind::Impl
        mod item_impl {/// ItemKind::Impl
            impl () { }
            impl <T> () { }
            impl Default for () { }
            impl const <T> Default for () { }
        }
        /// ItemKind::MacCall
        mod item_mac_call {/// ItemKind::MacCall
        }
        /// ItemKind::MacroDef
        mod item_macro_def {/// ItemKind::MacroDef
            macro_rules! mac { () => {...}; }
            macro stringify { () => {} }
        }
        /// ItemKind::Delegation
        /*! FIXME: todo */
        mod item_delegation {/// ItemKind::Delegation
            /*! FIXME: todo */
        }
        /// ItemKind::DelegationMac
        /*! FIXME: todo */
        mod item_delegation_mac {/// ItemKind::DelegationMac
            /*! FIXME: todo */
        }
    }
    mod patterns {
        /// PatKind::Missing
        fn pat_missing() { let _: for fn(u32, T, &'_ str); }
        /// 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::Expr
        fn pat_expr() { let 1000i8; 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::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 Send + 'static;
            let _: dyn for<'a> Send;
            let _: dyn* Send;
        }
        /// TyKind::ImplTrait
        const fn ty_impl_trait() {
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
        }
        /// TyKind::Paren
        fn ty_paren() { let _: T; }
        /// TyKind::Typeof
        /*! unused for now */
        fn ty_typeof() { }
        /// TyKind::Infer
        fn ty_infer() { let _: _; }
        /// TyKind::ImplicitSelf
        /*! there is no syntax for this */
        fn ty_implicit_self() { }
        /// TyKind::MacCall
        #[expect(deprecated)]
        fn ty_mac_call() { let _: T; let _: T; let _: T; }
        /// TyKind::CVarArgs
        /*! FIXME: todo */
        fn ty_c_var_args() { }
        /// TyKind::Pat
        fn ty_pat() { let _: u32 is 1..=RangeMax; }
    }
    mod visibilities {
        /// VisibilityKind::Public
        mod visibility_public {/// VisibilityKind::Public
            struct Pub;
        }
        /// VisibilityKind::Restricted
        mod visibility_restricted {/// VisibilityKind::Restricted
            struct PubCrate;
            struct PubSelf;
            struct PubSuper;
            struct PubInCrate;
            struct PubInSelf;
            struct PubInSuper;
            struct PubInCrateVisibilities;
            struct PubInSelfSuper;
            struct PubInSuperMod;
        }
    }
------------------------------------------
--- stderr -------------------------------
error[E0697]: closures cannot be static
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:211:9
   |
LL |         static || value;            //[hir]~ ERROR closures cannot be static
   |         ^^^^^^^^^

error[E0697]: closures cannot be static
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:212:9
   |
LL |         static move || value;       //[hir]~ ERROR closures cannot be static
   |         ^^^^^^^^^^^^^^

error[E0728]: `await` is only allowed inside `async` functions and blocks
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:241:13
   |
LL |     fn expr_await() {
   |     --------------- this is not `async`
LL |         let fut;
LL |         fut.await;  //[hir]~ ERROR `await` is only allowed
   |             ^^^^^ only allowed inside `async` functions and blocks

error: in expressions, `_` can only be used on the left-hand side of an assignment
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:290:9
   |
LL |         _;      //[hir]~ ERROR in expressions, `_` can only
   |         ^ `_` not allowed here

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:300:9
   |
LL |         x::();            //[hir]~ ERROR parenthesized type parameters
   |         ^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:301:9
   |
LL |         x::(T, T) -> T;   //[hir]~ ERROR parenthesized type parameters
   |         ^^^^^^^^^^^^^^ only `Fn` traits may use parentheses
   |
help: use angle brackets instead
   |
LL -         x::(T, T) -> T;   //[hir]~ ERROR parenthesized type parameters
LL +         x::<T, T> -> T;   //[hir]~ ERROR parenthesized type parameters
   |

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:302:9
   |
LL |         crate::() -> ()::expressions::() -> ()::expr_path;
   |         ^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:302:26
   |
LL |         crate::() -> ()::expressions::() -> ()::expr_path;
   |                          ^^^^^^^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:305:9
   |
LL |         core::()::marker::()::PhantomData;
   |         ^^^^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:305:19
   |
LL |         core::()::marker::()::PhantomData;
   |                   ^^^^^^^^^^ only `Fn` traits may use parentheses

error[E0658]: inline assembly is not stable yet on this architecture
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:346:9
   |
LL | /         core::arch::asm!(
LL | |             "mov {tmp}, {x}",
LL | |             "shl {tmp}, 1",
LL | |             "shl {x}, 2",
...  |
LL | |             tmp = out(reg) _,
LL | |         );
   | |_________^
   |
   = note: see issue #93335 <https://github.com/rust-lang/rust/issues/93335> for more information
   = help: add `#![feature(asm_experimental_arch)]` to the crate attributes to enable
   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

error: invalid register class `reg`: unknown register class
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:351:13
   |
LL |             x = inout(reg) x,
   |             ^^^^^^^^^^^^^^^^
   |
   = note: the following register classes are supported on this target: `local`

error: invalid register class `reg`: unknown register class
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:352:13
   |
LL |             tmp = out(reg) _,
   |             ^^^^^^^^^^^^^^^^
   |

[rust-log-analyzer]

The job test-various failed! Check out the build log: (web) (plain)

Click to see the possible cause of the failure (guessed by this bot)

test [ui] tests/ui/wrong-hashset-issue-42918.rs ... ok

failures:

---- [ui] tests/ui/unpretty/exhaustive.rs#hir stdout ----
Saved the actual stderr to "/checkout/obj/build/x86_64-unknown-linux-gnu/test/ui/unpretty/exhaustive.hir/exhaustive.hir.stderr"
diff of stderr:

166    = help: add `#![feature(impl_trait_in_bindings)]` to the crate attributes to enable
167    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
168 
- error: aborting due to 20 previous errors
170 
- Some errors have detailed explanations: E0214, E0562, E0697, E0703, E0728.
172 For more information about an error, try `rustc --explain E0214`.
---
To only update this specific test, also pass `--test-args unpretty/exhaustive.rs`

error in revision `hir`: 1 errors occurred comparing output.
status: exit status: 1
command: env -u RUSTC_LOG_COLOR RUSTC_ICE="0" RUST_BACKTRACE="short" "/checkout/obj/build/x86_64-unknown-linux-gnu/stage2/bin/rustc" "/checkout/tests/ui/unpretty/exhaustive.rs" "-Zthreads=1" "-Zsimulate-remapped-rust-src-base=/rustc/FAKE_PREFIX" "-Ztranslate-remapped-path-to-local-path=no" "-Z" "ignore-directory-in-diagnostics-source-blocks=/cargo" "-Z" "ignore-directory-in-diagnostics-source-blocks=/checkout/vendor" "--sysroot" "/checkout/obj/build/x86_64-unknown-linux-gnu/stage2" "--target=wasm32-wasip1" "--cfg" "hir" "--check-cfg" "cfg(test,FALSE,expanded,hir)" "--error-format" "json" "--json" "future-incompat" "-Ccodegen-units=1" "-Zui-testing" "-Zdeduplicate-diagnostics=no" "-Zwrite-long-types-to-disk=no" "-Cstrip=debuginfo" "--emit" "metadata" "-C" "prefer-dynamic" "--out-dir" "/checkout/obj/build/x86_64-unknown-linux-gnu/test/ui/unpretty/exhaustive.hir" "-A" "unused" "-A" "internal_features" "-Crpath" "-Cdebuginfo=0" "-Lnative=/checkout/obj/build/wasm32-wasip1/native/rust-test-helpers" "--edition=2024" "-Zunpretty=hir"
--- stdout -------------------------------
//@ revisions: expanded hir
//@[expanded]compile-flags: -Zunpretty=expanded
//@[expanded]check-pass
//@[hir]compile-flags: -Zunpretty=hir
//@[hir]check-fail
//@ edition:2024

// Note: the HIR revision includes a `.stderr` file because there are some
// errors that only occur once we get past the AST.

#![feature(auto_traits)]#![feature(box_patterns)]#![feature(builtin_syntax)]#![feature(concat_idents)]#![feature(const_trait_impl)]#![feature(decl_macro)]#![feature(deref_patterns)]#![feature(dyn_star)]#![feature(explicit_tail_calls)]#![feature(gen_blocks)]#![feature(more_qualified_paths)]#![feature(never_patterns)]#![feature(never_type)]#![feature(pattern_types)]#![feature(pattern_type_macro)]#![feature(prelude_import)]#![feature(specialization)]#![feature(trace_macros)]#![feature(trait_alias)]#![feature(try_blocks)]#![feature(yeet_expr)]#![allow(incomplete_features)]
#[prelude_import]
use std::prelude::rust_2024::*;
#[macro_use]
extern crate std;

#[prelude_import]
---
}

//! inner single-line doc comment
/*!
     * inner multi-line doc comment
     */
#[doc = "inner doc attribute"]#[allow(dead_code, unused_variables)]#[no_std]
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()]#[attr = Repr([ReprC])]
    struct Struct;
}

mod expressions {
    /// ExprKind::Array
    fn expr_array() {
        [];
        [true];
        [true];
        [true, true];
        ["long........................................................................"];
        ["long............................................................",
                true];
    }

    /// ExprKind::ConstBlock
    fn expr_const_block() {
---
                };
    }

    /// 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'; 1000i8; 1.00000000000000000000001; }

    /// ExprKind::Cast
    fn expr_cast() { let expr; expr as T; expr as T<u8>; }

    /// ExprKind::Type
    fn expr_type() { let expr; 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() {
        loop { if false { } else { break; } }
        'a: loop { if false { } else { break; } }
        loop { if let true = true { } else { break; } }
    }

    /// ExprKind::ForLoop
    fn expr_for_loop() {
        let x;
        {
                let _t =
                    match #[lang = "into_iter"](x) {
                            mut iter =>
                                loop {
                                        match #[lang = "next"](&mut iter) {
                                                #[lang = "None"] {} => break,
                                                #[lang = "Some"] {  0: _ } => { }
                                            }
                                    },
                        };
                _t
            };
        {
                let _t =
                    match #[lang = "into_iter"](x) {
                            mut iter =>
                                'a:
                                    loop {
                                        match #[lang = "next"](&mut iter) {
                                                #[lang = "None"] {} => break,
                                                #[lang = "Some"] {  0: _ } => { }
                                            }
                                    },
                        };
                _t
            }
    }

    /// 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;
        || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        move || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        || value; //[hir]~ ERROR closures cannot be static
        move || value; //[hir]~ ERROR closures cannot be static
        || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        move || |mut _task_context: ResumeTy| { { let _t = value; _t } };
        || -> u8 { value };
        1 + (|| { });
    }

    /// ExprKind::Block
    fn expr_block() {
        { }
        unsafe { }
        'a: { }
        #[allow()]
        { }
        #[allow()]
        { }
    }

    /// ExprKind::Gen
    fn expr_gen() {
        |mut _task_context: ResumeTy| { };
        move |mut _task_context: ResumeTy| { };
        || { };
        move || { };
        |mut _task_context: ResumeTy| { };
        move |mut _task_context: ResumeTy| { };
    }

    /// ExprKind::Await
    fn expr_await() {
        let fut;
        {
            fut; //[hir]~ ERROR `await` is only allowed
            (/*ERROR*/)
        };
    }

    /// ExprKind::TryBlock
    fn expr_try_block() {
        { #[lang = "from_output"](()) }
        { return; #[lang = "from_output"](()) }
    }

    /// 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);
        #[lang = "RangeFull"] {  };
        #[lang = "RangeTo"] { end: hi };
        #[lang = "RangeFrom"] { start: lo };
        #[lang = "Range"] { start: lo, end: hi };
        #[lang = "Range"] { start: lo, end: hi };
        #[lang = "RangeToInclusive"] { end: hi };
        #[lang = "range_inclusive_new"](lo, hi);
        #[lang = "range_inclusive_new"](-2, -1);
    }

    /// ExprKind::Underscore
    fn expr_underscore() {
        (/*ERROR*/); //[hir]~ ERROR in expressions, `_` can only
    }

    /// 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; //[hir]~ ERROR parenthesized type parameters
        x::<T, T>; //[hir]~ ERROR parenthesized type parameters
        crate::expressions::expr_path;
        //[hir]~^ ERROR parenthesized type parameters
        //[hir]~| ERROR parenthesized type parameters
        core::marker::PhantomData;
        //[hir]~^ ERROR parenthesized type parameters
        //[hir]~| ERROR parenthesized type parameters
    }

    /// 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)
            _);
    }

---




        //[hir]~ ERROR `yield` can only be used





---


        // ...

        //[hir]~ ERROR invalid ABI





---




        //[hir]~ ERROR `..` patterns are not allowed here





---




        //[hir]~ ERROR parenthesized type parameters


        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed
        //[hir]~ ERROR `impl Trait` is not allowed





        // concat_idents is deprecated




        { 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;
        match #[lang = "branch"](expr) {
                #[lang = "Break"] {  0: residual } =>
                    #[allow(unreachable_code)]
                    return #[lang = "from_residual"](residual),
                #[lang = "Continue"] {  0: val } => #[allow(unreachable_code)]
                    val,
            };
    }
    /// ExprKind::Yield
    fn expr_yield() { yield (); yield true; }
    /// ExprKind::Yeet
    fn expr_yeet() {
        return #[lang = "from_yeet"](());
        return #[lang = "from_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_arguments::new_const(&[]);
        format_arguments::new_v1(&[""],
            &[format_argument::new_display(&expr)]);
    }
}
mod items {
    /// ItemKind::ExternCrate
    mod item_extern_crate {/// ItemKind::ExternCrate
        extern crate core;
        extern crate self as unpretty;
        extern crate core as _;
    }
    /// ItemKind::Use
    mod item_use {/// ItemKind::Use
        use ::{};
        use crate::expressions;
        use crate::items::item_use;
        use core::*;
    }
    /// ItemKind::Static
    mod item_static {/// ItemKind::Static
        static A: () = { };
        static mut B: () = { };
    }
    /// ItemKind::Const
    mod item_const {/// ItemKind::Const
        const A: () = { };
        trait TraitItems {
            const
            B:
            ();
            const
            C:
            ()
            =
            { };
        }
    }
    /// ItemKind::Fn
    mod item_fn {/// ItemKind::Fn
        const unsafe extern "C" fn f() { }
        async unsafe extern "C" fn g()
            ->
                /*impl Trait*/ |mut _task_context: ResumeTy|
            { { let _t = { }; _t } }
        fn h<'a, T>() where T: 'a { }
        trait TraitItems {
            unsafe extern "C" fn f();
        }
        impl TraitItems for _ {
            unsafe extern "C" fn f() { }
        }
    }
    /// ItemKind::Mod
    mod item_mod {/// ItemKind::Mod
    }
    /// ItemKind::ForeignMod
    mod item_foreign_mod {/// ItemKind::ForeignMod
        extern "Rust" { }
        extern "C" { }
    }
    /// ItemKind::GlobalAsm
    mod item_global_asm {/// ItemKind::GlobalAsm
        global_asm! (".globl my_asm_func") }
        /// ItemKind::TyAlias
        mod item_ty_alias {/// ItemKind::TyAlias
            type Type<'a> where T: 'a = T;
        }
        /// ItemKind::Enum
        mod item_enum {/// ItemKind::Enum
            enum Void { }
            enum Empty {
                Unit,
                Tuple(),
                Struct {
                    },
            }
            enum Generic<'a, T> where T: 'a {
                Tuple(T),
                Struct {
                        t: T,
                    },
            }
        }
        /// ItemKind::Struct
        mod item_struct {/// ItemKind::Struct
            struct Unit;
            struct Tuple();
            struct Newtype(Unit);
            struct Struct {
            }
            struct Generic<'a, T> where T: 'a {
                t: T,
            }
        }
        /// ItemKind::Union
        mod item_union {/// ItemKind::Union
            union Generic<'a, T> where T: 'a {
                t: T,
            }
        }
        /// ItemKind::Trait
        mod item_trait {/// ItemKind::Trait
            auto unsafe trait Send { }
            trait Trait<'a>: Sized where Self: 'a { }
        }
        /// ItemKind::TraitAlias
        mod item_trait_alias {/// ItemKind::TraitAlias
            trait Trait<T> = Sized where for<'a> T: 'a;
        }
        /// ItemKind::Impl
        mod item_impl {/// ItemKind::Impl
            impl () { }
            impl <T> () { }
            impl Default for () { }
            impl const <T> Default for () { }
        }
        /// ItemKind::MacCall
        mod item_mac_call {/// ItemKind::MacCall
        }
        /// ItemKind::MacroDef
        mod item_macro_def {/// ItemKind::MacroDef
            macro_rules! mac { () => {...}; }
            macro stringify { () => {} }
        }
        /// ItemKind::Delegation
        /*! FIXME: todo */
        mod item_delegation {/// ItemKind::Delegation
            /*! FIXME: todo */
        }
        /// ItemKind::DelegationMac
        /*! FIXME: todo */
        mod item_delegation_mac {/// ItemKind::DelegationMac
            /*! FIXME: todo */
        }
    }
    mod patterns {
        /// PatKind::Missing
        fn pat_missing() { let _: for fn(u32, T, &'_ str); }
        /// 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::Expr
        fn pat_expr() { let 1000i8; 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::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 Send + 'static;
            let _: dyn for<'a> Send;
            let _: dyn* Send;
        }
        /// TyKind::ImplTrait
        const fn ty_impl_trait() {
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
            let _: (/*ERROR*/);
        }
        /// TyKind::Paren
        fn ty_paren() { let _: T; }
        /// TyKind::Typeof
        /*! unused for now */
        fn ty_typeof() { }
        /// TyKind::Infer
        fn ty_infer() { let _: _; }
        /// TyKind::ImplicitSelf
        /*! there is no syntax for this */
        fn ty_implicit_self() { }
        /// TyKind::MacCall
        #[expect(deprecated)]
        fn ty_mac_call() { let _: T; let _: T; let _: T; }
        /// TyKind::CVarArgs
        /*! FIXME: todo */
        fn ty_c_var_args() { }
        /// TyKind::Pat
        fn ty_pat() { let _: u32 is 1..=RangeMax; }
    }
    mod visibilities {
        /// VisibilityKind::Public
        mod visibility_public {/// VisibilityKind::Public
            struct Pub;
        }
        /// VisibilityKind::Restricted
        mod visibility_restricted {/// VisibilityKind::Restricted
            struct PubCrate;
            struct PubSelf;
            struct PubSuper;
            struct PubInCrate;
            struct PubInSelf;
            struct PubInSuper;
            struct PubInCrateVisibilities;
            struct PubInSelfSuper;
            struct PubInSuperMod;
        }
    }
------------------------------------------
--- stderr -------------------------------
error[E0697]: closures cannot be static
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:211:9
   |
LL |         static || value;            //[hir]~ ERROR closures cannot be static
   |         ^^^^^^^^^

error[E0697]: closures cannot be static
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:212:9
   |
LL |         static move || value;       //[hir]~ ERROR closures cannot be static
   |         ^^^^^^^^^^^^^^

error[E0728]: `await` is only allowed inside `async` functions and blocks
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:241:13
   |
LL |     fn expr_await() {
   |     --------------- this is not `async`
LL |         let fut;
LL |         fut.await;  //[hir]~ ERROR `await` is only allowed
   |             ^^^^^ only allowed inside `async` functions and blocks

error: in expressions, `_` can only be used on the left-hand side of an assignment
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:290:9
   |
LL |         _;      //[hir]~ ERROR in expressions, `_` can only
   |         ^ `_` not allowed here

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:300:9
   |
LL |         x::();            //[hir]~ ERROR parenthesized type parameters
   |         ^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:301:9
   |
LL |         x::(T, T) -> T;   //[hir]~ ERROR parenthesized type parameters
   |         ^^^^^^^^^^^^^^ only `Fn` traits may use parentheses
   |
help: use angle brackets instead
   |
LL -         x::(T, T) -> T;   //[hir]~ ERROR parenthesized type parameters
LL +         x::<T, T> -> T;   //[hir]~ ERROR parenthesized type parameters
   |

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:302:9
   |
LL |         crate::() -> ()::expressions::() -> ()::expr_path;
   |         ^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:302:26
   |
LL |         crate::() -> ()::expressions::() -> ()::expr_path;
   |                          ^^^^^^^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:305:9
   |
LL |         core::()::marker::()::PhantomData;
   |         ^^^^^^^^ only `Fn` traits may use parentheses

error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:305:19
   |
LL |         core::()::marker::()::PhantomData;
   |                   ^^^^^^^^^^ only `Fn` traits may use parentheses

error[E0658]: inline assembly is not stable yet on this architecture
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:346:9
   |
LL | /         core::arch::asm!(
LL | |             "mov {tmp}, {x}",
LL | |             "shl {tmp}, 1",
LL | |             "shl {x}, 2",
...  |
LL | |             tmp = out(reg) _,
LL | |         );
   | |_________^
   |
   = note: see issue #93335 <https://github.com/rust-lang/rust/issues/93335> for more information
   = help: add `#![feature(asm_experimental_arch)]` to the crate attributes to enable
   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

error: invalid register class `reg`: unknown register class
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:351:13
   |
LL |             x = inout(reg) x,
   |             ^^^^^^^^^^^^^^^^
   |
   = note: the following register classes are supported on this target: `local`

error: invalid register class `reg`: unknown register class
##[error]  --> /checkout/tests/ui/unpretty/exhaustive.rs:352:13
   |
LL |             tmp = out(reg) _,
   |             ^^^^^^^^^^^^^^^^
   |

[bors]

💔 Test failed - checks-actions