Rollup of 14 pull requests

Cargo.lock

@@ -5177,7 +5177,7 @@ dependencies = [
 
 [[package]]
 name = "rustfmt-nightly"
-version = "1.11.0"
+version = "1.12.0"
 dependencies = [
  "annotate-snippets 0.12.16",
  "anyhow",

compiler/rustc_ast/src/ast.rs

@@ -1779,7 +1779,7 @@ pub enum ExprKind {
     Lit(token::Lit),
     /// A cast (e.g., `foo as f64`).
     Cast(Box<Expr>, Box<Ty>),
-    /// A type ascription (e.g., `builtin # type_ascribe(42, usize)`).
+    /// A type ascription (e.g., `k#type_ascribe(42, usize)`).
     ///
     /// Usually not written directly in user code but
     /// indirectly via the macro `type_ascribe!(...)`.
@@ -1871,7 +1871,7 @@ pub enum ExprKind {
     /// Output of the `asm!()` macro.
     InlineAsm(Box<InlineAsm>),
 
-    /// An `offset_of` expression (e.g., `builtin # offset_of(Struct, field)`).
+    /// An `offset_of` expression (e.g., `k#offset_of(Struct, field)`).
     ///
     /// Usually not written directly in user code but
     /// indirectly via the macro `core::mem::offset_of!(...)`.
@@ -2570,7 +2570,7 @@ pub enum TyKind {
     /// Pattern types like `pattern_type!(u32 is 1..=)`, which is the same as `NonZero<u32>`,
     /// just as part of the type system.
     Pat(Box<Ty>, Box<TyPat>),
-    /// A `field_of` expression (e.g., `builtin # field_of(Struct, field)`).
+    /// A `field_of` expression (e.g., `k#field_of(Struct, field)`).
     ///
     /// Usually not written directly in user code but indirectly via the macro
     /// `core::field::field_of!(...)`.

compiler/rustc_ast/src/token.rs

@@ -313,6 +313,8 @@ pub fn ident_can_begin_expr(name: Symbol, span: Span, kind: IdentKind) -> bool {
     // WARNING: Take care when modifying this function! It will change the stable(!) set of
     //          tokens that are allowed to match an `expr` nonterminal which is user observable.
 
+    // NOTE: We don't care about forced keywords that are gated behind `internal_syntax`.
+
     let ident_token = Token::new(Ident(name, kind), span);
 
     // FIXME: Remove `box` from this list given we officially no longer support box expressions
@@ -350,6 +352,8 @@ fn ident_can_begin_type(name: Symbol, span: Span, kind: IdentKind) -> bool {
     // WARNING: Take care when modifying this function! It will change the stable(!) set of
     //          tokens that are allowed to match an `ty` nonterminal which is user observable.
 
+    // NOTE: We don't care about forced keywords that are gated behind `internal_syntax`.
+
     let ident_token = Token::new(Ident(name, kind), span);
 
     !ident_token.is_reserved_ident()
@@ -936,6 +940,10 @@ impl Token {
         self.non_raw_ident().is_some_and(|id| id.name == kw)
     }
 
+    pub fn is_forced_keyword(&self, kw: Symbol) -> bool {
+        self.ident().is_some_and(|(id, kind)| kind == IdentKind::ForcedKeyword && id.name == kw)
+    }
+
     /// Returns `true` if the token is a given keyword, `kw` or if `case` is `Insensitive` and this
     /// token is an identifier equal to `kw` ignoring the case.
     pub fn is_keyword_case(&self, kw: Symbol, case: Case) -> bool {

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -431,7 +431,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
 
     // tidy-alphabetical-start
     gate_all!(async_for_loop, "`for await` loops are experimental");
-    gate_all!(builtin_syntax, "`builtin #` syntax is unstable");
     gate_all!(const_block_items, "const block items are experimental");
     gate_all!(const_closures, "const closures are experimental");
     gate_all!(const_trait_impl, "const trait impls are experimental");
@@ -452,6 +451,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(global_registration, "global registration is experimental");
     gate_all!(guard_patterns, "guard patterns are experimental", "consider using match arm guards");
     gate_all!(impl_restriction, "`impl` restrictions are experimental");
+    gate_all!(internal_syntax, "this syntax is internal");
     gate_all!(more_qualified_paths, "usage of qualified paths in this context is experimental");
     gate_all!(move_expr, "`move(expr)` syntax is experimental");
     gate_all!(mut_ref, "mutable by-reference bindings are experimental");

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1442,7 +1442,7 @@ impl<'a> State<'a> {
                 self.print_ty_pat(pat);
             }
             ast::TyKind::FieldOf(ty, variant, field) => {
-                self.word("builtin # field_of");
+                self.word("k#field_of");
                 self.popen();
                 let ib = self.ibox(0);
                 self.print_type(ty);
@@ -2012,6 +2012,11 @@ impl<'a> State<'a> {
                 self.pclose();
             }
             PatKind::Deref(inner) => {
+                // FIXME(deref_patterns, internal_syntax, forced_keywords, clippy):
+                // This should render `k#deref(...)` but unfortunately Clippy uses `pat_to_string`
+                // for the suggestions of its lint `unnested_or_patterns`. Smh fix Clippy to not
+                // rely on AST pretty printing `deref!(…)` for `Deref` patterns and please don't
+                // think about adding a flag to AST pretty to control the output.
                 self.word("deref!");
                 self.popen();
                 self.print_pat(inner);

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -497,7 +497,7 @@ impl<'a> State<'a> {
                 self.print_type(ty);
             }
             ast::ExprKind::Type(expr, ty) => {
-                self.word("builtin # type_ascribe");
+                self.word("k#type_ascribe");
                 self.popen();
                 let ib = self.ibox(0);
                 self.print_expr(expr, FixupContext::default());
@@ -777,12 +777,12 @@ impl<'a> State<'a> {
                 self.print_expr(result, fixup.rightmost_subexpression());
             }
             ast::ExprKind::InlineAsm(a) => {
-                // FIXME: Print `builtin # asm` once macro `asm` uses `builtin_syntax`.
+                // FIXME: Print `k#asm` once macro `asm` uses `internal_syntax`.
                 self.word(format!("{}!", a.asm_macro.macro_name()));
                 self.print_inline_asm(a);
             }
             ast::ExprKind::FormatArgs(fmt) => {
-                // FIXME: Print `builtin # format_args` once macro `format_args` uses `builtin_syntax`.
+                // FIXME: Print `k#format_args` once macro `format_args` uses `internal_syntax`.
                 self.word("format_args!");
                 self.popen();
                 let ib = self.ibox(0);
@@ -795,7 +795,7 @@ impl<'a> State<'a> {
                 self.pclose();
             }
             ast::ExprKind::OffsetOf(container, fields) => {
-                self.word("builtin # offset_of");
+                self.word("k#offset_of");
                 self.popen();
                 let ib = self.ibox(0);
                 self.print_type(container);
@@ -855,10 +855,9 @@ impl<'a> State<'a> {
                 self.print_block_with_attrs(blk, attrs, cb, ib)
             }
             ast::ExprKind::UnsafeBinderCast(kind, expr, ty) => {
-                self.word("builtin # ");
                 match kind {
-                    ast::UnsafeBinderCastKind::Wrap => self.word("wrap_binder"),
-                    ast::UnsafeBinderCastKind::Unwrap => self.word("unwrap_binder"),
+                    ast::UnsafeBinderCastKind::Wrap => self.word("k#wrap_binder"),
+                    ast::UnsafeBinderCastKind::Unwrap => self.word("k#unwrap_binder"),
                 }
                 self.popen();
                 let ib = self.ibox(0);

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -288,7 +288,7 @@ impl<'a> State<'a> {
                 self.bclose(item.span, empty, cb);
             }
             ast::ItemKind::GlobalAsm(asm) => {
-                // FIXME: Print `builtin # global_asm` once macro `global_asm` uses `builtin_syntax`.
+                // FIXME: Print `k#global_asm` once macro `global_asm` uses `internal_syntax`.
                 let (cb, ib) = self.head(visibility_qualified(&item.vis, "global_asm!"));
                 self.print_inline_asm(asm);
                 self.word(";");

compiler/rustc_attr_ir/src/lang_items.rs

@@ -163,7 +163,7 @@ language_item_table! {
     Unsize,                  sym::unsize,              unsize_trait,               Target::Trait,          GenericRequirement::Minimum(1);
     AlignOf,                 sym::mem_align_const,     align_const,                Target::AssocConst(AssocCtxt::Trait),     GenericRequirement::Exact(0);
     SizeOf,                  sym::mem_size_const,      size_const,                 Target::AssocConst(AssocCtxt::Trait),     GenericRequirement::Exact(0);
-    OffsetOf,                sym::offset_of,           offset_of,                  Target::Fn,             GenericRequirement::Exact(1);
+    OffsetOf,                kw::OffsetOf,             offset_of,                  Target::Fn,             GenericRequirement::Exact(1);
     /// Trait injected by `#[derive(PartialEq)]`, (i.e. "Partial EQ").
     StructuralPeq,           sym::structural_peq,      structural_peq_trait,       Target::Trait,          GenericRequirement::None;
     Copy,                    sym::copy,                copy_trait,                 Target::Trait,          GenericRequirement::Exact(0);
@@ -239,7 +239,7 @@ language_item_table! {
     Complex,                 sym::complex,             complex,                    Target::Struct,         GenericRequirement::Exact(1);
     PpcF128,                 sym::ppcf128,             ppcf128,                    Target::Struct,         GenericRequirement::None;
 
-    Deref,                   sym::deref,               deref_trait,                Target::Trait,          GenericRequirement::Exact(0);
+    Deref,                   kw::Deref,                deref_trait,                Target::Trait,          GenericRequirement::Exact(0);
     DerefMut,                sym::deref_mut,           deref_mut_trait,            Target::Trait,          GenericRequirement::Exact(0);
     DerefPure,               sym::deref_pure,          deref_pure_trait,           Target::Trait,          GenericRequirement::Exact(0);
     DerefTarget,             sym::deref_target,        deref_target,               Target::AssocTy(AssocCtxt::Trait),        GenericRequirement::None;

compiler/rustc_attr_parsing/src/attributes/lint.rs

@@ -8,6 +8,7 @@ use thin_vec::ThinVec;
 
 use crate::attributes::{AcceptMapping, AttributeParser, AttributeStability};
 use crate::context::{AcceptContext, ExpectStringLiteral, FinalizeContext};
+use crate::diagnostics::{MalformedLintAttributeInput, MalformedLintAttributeInputHelp};
 use crate::parser::{ArgParser, MetaItemOrLitParser};
 use crate::target_checking::AllowedTargets;
 use crate::target_checking::Policy::{Allow, Warn};
@@ -36,9 +37,11 @@ impl LintParser {
                 let p = parsers.last()?.meta_item()?;
                 let nv = p.args().as_name_value()?;
                 if !p.path().word_is(sym::reason) {
-                    cx.emit_err(diagnostics::MalformedAttribute {
+                    // FIXME: We should recommend `reason` here
+                    cx.emit_err(MalformedLintAttributeInput {
                         span: p.span(),
-                        kind: diagnostics::MalformedAttributeKind::BadAttributeArgument(p.span()),
+                        help: MalformedLintAttributeInputHelp::Other { kind: kind.sym() },
+                        kind: kind.sym(),
                     });
                 } else {
                     parsers = &parsers[..(parsers.len() - 1)];
@@ -78,26 +81,28 @@ impl LintParser {
                                 nv.expect_string_literal(cx);
                             }
                             ArgParser::NameValue(_) | ArgParser::List(_) => {
-                                cx.emit_err(diagnostics::MalformedAttribute {
+                                cx.emit_err(MalformedLintAttributeInput {
                                     span: p.span(),
-                                    kind: diagnostics::MalformedAttributeKind::BadAttributeArgument(
-                                        item.span(),
-                                    ),
+                                    help: MalformedLintAttributeInputHelp::Other {
+                                        kind: kind.sym(),
+                                    },
+                                    kind: kind.sym(),
                                 });
                             }
                         }
                     }
                     MetaItemOrLitParser::Lit(lit) => {
-                        cx.emit_err(diagnostics::BadAttributeLit {
+                        cx.emit_err(MalformedLintAttributeInput {
                             span: item.span(),
                             help: if lit.kind.is_str() {
-                                diagnostics::BadAttributeLitHelp::StrLit {
+                                MalformedLintAttributeInputHelp::StrLit {
                                     sym: lit.symbol,
                                     kind: kind.sym(),
                                 }
                             } else {
-                                diagnostics::BadAttributeLitHelp::Other { kind: kind.sym() }
+                                MalformedLintAttributeInputHelp::Other { kind: kind.sym() }
                             },
+                            kind: kind.sym(),
                         });
                     }
                 }

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -2196,24 +2196,23 @@ pub(crate) struct MalformedAttribute {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum MalformedAttributeKind {
-    #[label("bad attribute argument")]
-    BadAttributeArgument(#[primary_span] Span),
     #[label("reason in lint attribute must come last")]
     ReasonMustComeLast(#[primary_span] Span),
 }
 
 #[derive(Diagnostic)]
-#[diag("expected a lint, found literal")]
-pub(crate) struct BadAttributeLit {
+#[diag("malformed `{$kind}` attribute input")]
+pub(crate) struct MalformedLintAttributeInput {
     #[primary_span]
     #[label("not the name of a lint")]
     pub span: Span,
+    pub kind: Symbol,
     #[subdiagnostic]
-    pub help: BadAttributeLitHelp,
+    pub help: MalformedLintAttributeInputHelp,
 }
 
 #[derive(Subdiagnostic)]
-pub(crate) enum BadAttributeLitHelp {
+pub(crate) enum MalformedLintAttributeInputHelp {
     #[help("try using `#[{$kind}({$sym})]`")]
     StrLit { sym: Symbol, kind: Symbol },
     #[help("for example, write `#[{$kind}(dead_code)]` for `dead_code`")]

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -657,22 +657,17 @@ pub(crate) unsafe fn llvm_optimize<'ll>(
         None
     };
 
-    fn handle_offload<'ll>(cx: &SimpleCx<'ll>, old_fn: &'ll llvm::Value) {
+    // Wraps `old_fn` into a new kernel that takes the implicit `dyn_ptr` as its first argument.
+    // Returns the new function, or `None` if nothing was wrapped
+    fn handle_offload<'ll>(
+        cx: &SimpleCx<'ll>,
+        old_fn: &'ll llvm::Value,
+    ) -> Option<&'ll llvm::Value> {
         let old_fn_ty = cx.get_type_of_global(old_fn);
         let old_param_types = cx.func_params_types(old_fn_ty);
         let old_param_count = old_param_types.len();
         if old_param_count == 0 {
-            return;
-        }
-
-        let first_param = llvm::get_param(old_fn, 0);
-        let c_name = llvm::get_value_name(first_param);
-        let first_arg_name = str::from_utf8(&c_name).unwrap();
-        // We might call llvm_optimize (and thus this code) multiple times on the same IR,
-        // but we shouldn't add this helper ptr multiple times.
-        // FIXME(offload): This could break if the user calls his first argument `dyn_ptr`.
-        if first_arg_name == "dyn_ptr" {
-            return;
+            return None;
         }
 
         // Create the new parameter list, with ptr as the first argument
@@ -747,6 +742,7 @@ pub(crate) unsafe fn llvm_optimize<'ll>(
         }
         // Now we can re-use the old name, without name collision.
         llvm::set_value_name(new_fn, &name);
+        Some(new_fn)
     }
 
     if cgcx.target_is_like_gpu
@@ -755,10 +751,13 @@ pub(crate) unsafe fn llvm_optimize<'ll>(
         let cx = SimpleCx::new(llmod, llcx, cgcx.pointer_size);
         for func in cx.get_functions() {
             let offload_kernel = "offload-kernel";
-            if attributes::has_string_attr(func, offload_kernel) {
-                handle_offload(&cx, func);
+            if !attributes::has_string_attr(func, offload_kernel) {
+                continue;
+            }
+            match handle_offload(&cx, func) {
+                Some(new_fn) => attributes::remove_string_attr_from_llfn(new_fn, offload_kernel),
+                None => attributes::remove_string_attr_from_llfn(func, offload_kernel),
             }
-            attributes::remove_string_attr_from_llfn(func, offload_kernel);
         }
     }
 
@@ -822,8 +821,9 @@ pub(crate) unsafe fn llvm_optimize<'ll>(
     };
 
     // This assumes that we previously compiled our kernels for a gpu target, which created a
-    // `<crate>.bc` artifact. The user is supposed to provide us with a path to this artifact, we
-    // don't need any other artifacts from the previous run.
+    // `<crate>.ptx` (NVPTX) or `<crate>.elf` (AMDGPU) artifact.
+    // The user is supposed to provide us with a path to this artifact,
+    // we don't need any other artifacts from the previous run.
     if !cgcx.target_is_like_gpu && is_final_stage {
         if let Some(device_path) = config
             .offload
@@ -833,15 +833,18 @@ pub(crate) unsafe fn llvm_optimize<'ll>(
             let device_pathbuf = PathBuf::from(device_path);
             if device_pathbuf.is_relative() {
                 dcx.emit_err(crate::diagnostics::OffloadWithoutAbsPath);
-            } else if device_pathbuf.extension().and_then(|e| e.to_str()) != Some("bc") {
+            } else if !matches!(
+                device_pathbuf.extension().and_then(|e| e.to_str()),
+                Some("ptx" | "elf")
+            ) {
                 dcx.emit_err(crate::diagnostics::OffloadWrongFileName);
             } else if !device_pathbuf.exists() {
                 dcx.emit_err(crate::diagnostics::OffloadNonexistingPath);
             }
-            let device_bitcode_c = path_to_c_string(device_pathbuf.as_path());
+            let device_image_c = path_to_c_string(device_pathbuf.as_path());
             let ok = unsafe {
                 llvm::RustOffloadWrapper::get_instance()
-                    .llvm_rust_offload_wrap_images(llmod, device_bitcode_c.as_c_str())
+                    .llvm_rust_offload_wrap_images(llmod, device_image_c.as_c_str())
             };
             if !ok {
                 dcx.emit_err(crate::diagnostics::OffloadWrapImagesFailed);