rename tool from rust_gpu to rustc_codegen_spirv

Author: Firestar99

crates/rustc_codegen_spirv/src/symbols.rs

@@ -15,7 +15,7 @@ use std::rc::Rc;
 /// is to allocate all our keywords up front and intern them all, so we can do comparisons really easily and fast.
 pub struct Symbols {
     pub discriminant: Symbol,
-    pub rust_gpu: Symbol,
+    pub rustc_codegen_spirv: Symbol,
     pub spirv: Symbol,
     pub libm: Symbol,
     pub entry_point_name: Symbol,
@@ -406,7 +406,7 @@ impl Symbols {
         }
         Self {
             discriminant: Symbol::intern("discriminant"),
-            rust_gpu: Symbol::intern("rust_gpu"),
+            rustc_codegen_spirv: Symbol::intern("rustc_codegen_spirv"),
             spirv: Symbol::intern("spirv"),
             libm: Symbol::intern("libm"),
             entry_point_name: Symbol::intern("entry_point_name"),
@@ -450,34 +450,34 @@ pub(crate) fn parse_attrs_for_checking<'a>(
             Attribute::Unparsed(item) => {
                 // #[...]
                 let s = &item.path.segments;
-                if s.len() > 1 && s[0].name == sym.rust_gpu {
-                    // #[rust_gpu ...]
+                if s.len() > 1 && s[0].name == sym.rustc_codegen_spirv {
+                    // #[rustc_codegen_spirv ...]
                     if s.len() != 2 || s[1].name != sym.spirv {
-                        // #[rust_gpu::...] but not #[rust_gpu::spirv]
+                        // #[rustc_codegen_spirv::...] but not #[rustc_codegen_spirv::spirv]
                         (
                             Some(Err((
                                 attr.span(),
-                                "unknown `rust_gpu` attribute, expected `rust_gpu::spirv`"
+                                "unknown `rustc_codegen_spirv` attribute, expected `rustc_codegen_spirv::spirv`"
                                     .to_string(),
                             ))),
                             Default::default(),
                         )
                     } else if let Some(args) = attr.meta_item_list() {
-                        // #[rust_gpu::spirv(...)]
+                        // #[rustc_codegen_spirv::spirv(...)]
                         (None, args)
                     } else {
-                        // #[rust_gpu::spirv]
+                        // #[rustc_codegen_spirv::spirv]
                         (
                             Some(Err((
                                 attr.span(),
-                                "#[rust_gpu::spirv(..)] attribute must have at least one argument"
+                                "#[rustc_codegen_spirv::spirv(..)] attribute must have at least one argument"
                                     .to_string(),
                             ))),
                             Default::default(),
                         )
                     }
                 } else {
-                    // #[...] but not #[rust_gpu ...]
+                    // #[...] but not #[rustc_codegen_spirv ...]
                     (None, Default::default())
                 }
             }

crates/spirv-builder/src/lib.rs

@@ -862,7 +862,7 @@ fn invoke_rustc(builder: &SpirvBuilder) -> Result<PathBuf, SpirvBuilderError> {
         "-Zbinary-dep-depinfo".to_string(),
         "-Csymbol-mangling-version=v0".to_string(),
         "-Zcrate-attr=feature(register_tool)".to_string(),
-        "-Zcrate-attr=register_tool(rust_gpu)".to_string(),
+        "-Zcrate-attr=register_tool(rustc_codegen_spirv)".to_string(),
         // HACK(eddyb) this is the same configuration that we test with, and
         // ensures no unwanted surprises from e.g. `core` debug assertions.
         "-Coverflow-checks=off".to_string(),

crates/spirv-std/macros/src/lib.rs

@@ -140,14 +140,14 @@ pub fn Image(item: TokenStream) -> TokenStream {
 }
 
 /// Replaces all (nested) occurrences of the `#[spirv(..)]` attribute with
-/// `#[cfg_attr(target_arch="spirv", rust_gpu::spirv(..))]`.
+/// `#[cfg_attr(target_arch="spirv", rustc_codegen_spirv::spirv(..))]`.
 #[proc_macro_attribute]
 pub fn spirv(attr: TokenStream, item: TokenStream) -> TokenStream {
     let mut tokens: Vec<TokenTree> = Vec::new();
 
-    // prepend with #[rust_gpu::spirv(..)]
+    // prepend with #[rustc_codegen_spirv::spirv(..)]
     let attr: proc_macro2::TokenStream = attr.into();
-    tokens.extend(quote! { #[cfg_attr(target_arch="spirv", rust_gpu::spirv(#attr))] });
+    tokens.extend(quote! { #[cfg_attr(target_arch="spirv", rustc_codegen_spirv::spirv(#attr))] });
 
     let item: proc_macro2::TokenStream = item.into();
     for tt in item {
@@ -164,7 +164,7 @@ pub fn spirv(attr: TokenStream, item: TokenStream) -> TokenStream {
                             // group matches [spirv ...]
                             let inner = group.stream(); // group stream doesn't include the brackets
                             sub_tokens.extend(
-                                quote! { [cfg_attr(target_arch="spirv", rust_gpu::#inner)] },
+                                quote! { [cfg_attr(target_arch="spirv", rustc_codegen_spirv::#inner)] },
                             );
                         }
                         _ => sub_tokens.push(tt),

docs/src/migration-to-register-tool.md

@@ -29,17 +29,17 @@ You'll also need to remove the `feature(register_attr)` and `register_attr(spirv
 
 ```rust
 #![feature(register_tool)]
-#![register_tool(rust_gpu)]
+#![register_tool(rustc_codegen_spirv)]
 ```
 
 That's it. Your shaders should now compile like before.
 
 ## Technical Background
 
-Unfortunately, since the new Rust nightly toolchain in September 2022, `register_attr(spirv)` can no longer be used to register a global `spirv` attribute. Without this registration, the compiler would simply complain about `spirv` being an unknown attribute. However, the alternative, `register_tool`, requires us to scope the attribute in a namespace. For instance, as we've chosen the `rust_gpu` namespace, this would mean that you'd need to start writing `#[rust_gpu::spirv(..)]` instead, which would be quite tedious and would break a lot of code. And it's not possible to `use` a name from a tool namespace to bring it into scope.
+Unfortunately, since the new Rust nightly toolchain in September 2022, `register_attr(spirv)` can no longer be used to register a global `spirv` attribute. Without this registration, the compiler would simply complain about `spirv` being an unknown attribute. However, the alternative, `register_tool`, requires us to scope the attribute in a namespace. For instance, as we've chosen the `rustc_codegen_spirv` namespace, this would mean that you'd need to start writing `#[rustc_codegen_spirv::spirv(..)]` instead, which would be quite tedious and would break a lot of code. And it's not possible to `use` a name from a tool namespace to bring it into scope.
 
-Instead, we opted to implement a proc macro attribute called `spirv` instead[^1]. This macro attribute scans the item it is applied to, and translates any `#[spirv(..)]` it finds into `#[rust_gpu::spirv(..)]` which will be subsequently handled by the codegen backend. Because it is now a proc macro attribute exported from `spirv_std`, you need to do `use spirv_std::spirv` to make it globally visible in your crate. ***Note that we recommend using the `spirv` proc macro attribute itself rather than the `rust_gpu::spirv` attribute it translates to, as the latter is subject to change.***
+Instead, we opted to implement a proc macro attribute called `spirv` instead[^1]. This macro attribute scans the item it is applied to, and translates any `#[spirv(..)]` it finds into `#[rustc_codegen_spirv::spirv(..)]` which will be subsequently handled by the codegen backend. Because it is now a proc macro attribute exported from `spirv_std`, you need to do `use spirv_std::spirv` to make it globally visible in your crate. ***Note that we recommend using the `spirv` proc macro attribute itself rather than the `rustc_codegen_spirv::spirv` attribute it translates to, as the latter is subject to change.***
 
-We've also added the `feature(register_tool)` and `register_tool(rust_gpu)` crate attributes by default when compiling through `SpirvBuilder`. This will silence any error that you would otherwise get for applying a `rust_gpu` scoped attribute.
+We've also added the `feature(register_tool)` and `register_tool(rustc_codegen_spirv)` crate attributes by default when compiling through `SpirvBuilder`. This will silence any error that you would otherwise get for applying a `rustc_codegen_spirv` scoped attribute.
 
-[^1]: This is not entirely true. In reality, the `spirv` proc macro attribute already existed, but only for non-spirv builds. It was used to turn the `#[spirv(..)]` attribute into a no-op. The proc macro is now used on all platforms, and it emits `#[cfg_attr(target_arch="spirv", rust_gpu::spirv(..))]` for each usage of `#[spirv(..)]`.
+[^1]: This is not entirely true. In reality, the `spirv` proc macro attribute already existed, but only for non-spirv builds. It was used to turn the `#[spirv(..)]` attribute into a no-op. The proc macro is now used on all platforms, and it emits `#[cfg_attr(target_arch="spirv", rustc_codegen_spirv::spirv(..))]` for each usage of `#[spirv(..)]`.

docs/src/writing-shader-crates.md

@@ -132,7 +132,7 @@ rustflags = [
     "-Zbinary-dep-depinfo",
     "-Csymbol-mangling-version=v0",
     "-Zcrate-attr=feature(register_tool)",
-    "-Zcrate-attr=register_tool(rust_gpu)"
+    "-Zcrate-attr=register_tool(rustc_codegen_spirv)"
 ]
 
 [unstable]

tests/compiletests/src/main.rs

@@ -363,7 +363,7 @@ fn rust_flags(codegen_backend_path: &Path) -> String {
         "-Zbinary-dep-depinfo",
         "-Csymbol-mangling-version=v0",
         "-Zcrate-attr=feature(register_tool)",
-        "-Zcrate-attr=register_tool(rust_gpu)",
+        "-Zcrate-attr=register_tool(rustc_codegen_spirv)",
         // HACK(eddyb) this is the same configuration that we test with, and
         // ensures no unwanted surprises from e.g. `core` debug assertions.
         "-Coverflow-checks=off",