tool: versionize rust_gpu::spirv to rust_gpu::spirv_v0_9

Author: Firestar99

crates/rustc_codegen_spirv/src/attr.rs

@@ -518,6 +518,7 @@ pub(crate) fn provide(providers: &mut Providers) {
 // FIXME(eddyb) find something nicer for the error type.
 type ParseAttrError = (Span, String);
 
+#[allow(clippy::get_first)]
 fn parse_attrs_for_checking<'a>(
     sym: &'a Symbols,
     attrs: &'a [Attribute],
@@ -530,12 +531,10 @@ fn parse_attrs_for_checking<'a>(
                 Attribute::Unparsed(item) => {
                     // #[...]
                     let s = &item.path.segments;
-                    if let Some(rust_gpu) = s.get(0)
-                        && rust_gpu.name == sym.rust_gpu
-                    {
+                    if let Some(rust_gpu) = s.get(0) && rust_gpu.name == sym.rust_gpu {
                         // #[rust_gpu ...]
                         match s.get(1) {
-                            Some(command) if command.name == sym.spirv => {
+                            Some(command) if command.name == sym.spirv_attr_with_version => {
                                 // #[rust_gpu::spirv ...]
                                 if let Some(args) = attr.meta_item_list() {
                                     // #[rust_gpu::spirv(...)]
@@ -551,10 +550,11 @@ fn parse_attrs_for_checking<'a>(
                             }
                             _ => {
                                 // #[rust_gpu::...] but not a know version
+                                let spirv = sym.spirv_attr_with_version.as_str();
                                 Err((
                                     attr.span(),
-                                    "unknown `rust_gpu` attribute, expected `rust_gpu::spirv`"
-                                        .to_string(),
+                                    format!("unknown `rust_gpu` attribute, expected `rust_gpu::{spirv}`. \
+                                Do the versions of `spirv-std` and `rustc_codegen_spirv` match?"),
                                 ))
                             }
                         }

crates/rustc_codegen_spirv/src/lib.rs

@@ -133,6 +133,8 @@ mod custom_decorations;
 mod custom_insts;
 mod link;
 mod linker;
+#[path = "../../spirv_attr_version.rs"]
+mod spirv_attr_version;
 mod spirv_type;
 mod spirv_type_constraints;
 mod symbols;

crates/rustc_codegen_spirv/src/symbols.rs

@@ -1,5 +1,6 @@
 use crate::attr::{IntrinsicType, SpirvAttribute};
 use crate::builder::libm_intrinsics;
+use crate::spirv_attr_version::spirv_attr_with_version;
 use rspirv::spirv::{BuiltIn, ExecutionMode, ExecutionModel, StorageClass};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_span::symbol::Symbol;
@@ -13,7 +14,7 @@ use std::rc::Rc;
 pub struct Symbols {
     pub discriminant: Symbol,
     pub rust_gpu: Symbol,
-    pub spirv: Symbol,
+    pub spirv_attr_with_version: Symbol,
     pub libm: Symbol,
     pub entry_point_name: Symbol,
     pub spv_khr_vulkan_memory_model: Symbol,
@@ -404,7 +405,7 @@ impl Symbols {
         Self {
             discriminant: Symbol::intern("discriminant"),
             rust_gpu: Symbol::intern("rust_gpu"),
-            spirv: Symbol::intern("spirv"),
+            spirv_attr_with_version: Symbol::intern(&spirv_attr_with_version()),
             libm: Symbol::intern("libm"),
             entry_point_name: Symbol::intern("entry_point_name"),
             spv_khr_vulkan_memory_model: Symbol::intern("SPV_KHR_vulkan_memory_model"),

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

@@ -72,13 +72,16 @@
 #![doc = include_str!("../README.md")]
 
 mod image;
+#[path = "../../../spirv_attr_version.rs"]
+mod spirv_attr_version;
 
 use proc_macro::TokenStream;
 use proc_macro2::{Delimiter, Group, Span, TokenTree};
 
 use syn::{ImplItemFn, visit_mut::VisitMut};
 
-use quote::{ToTokens, TokenStreamExt, quote};
+use crate::spirv_attr_version::spirv_attr_with_version;
+use quote::{ToTokens, TokenStreamExt, format_ident, quote};
 use std::fmt::Write;
 
 /// A macro for creating SPIR-V `OpTypeImage` types. Always produces a
@@ -143,11 +146,12 @@ pub fn Image(item: TokenStream) -> TokenStream {
 /// `#[cfg_attr(target_arch="spirv", rust_gpu::spirv(..))]`.
 #[proc_macro_attribute]
 pub fn spirv(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let spirv = format_ident!("{}", &spirv_attr_with_version());
     let mut tokens: Vec<TokenTree> = Vec::new();
 
     // prepend with #[rust_gpu::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", rust_gpu::#spirv(#attr))] });
 
     let item: proc_macro2::TokenStream = item.into();
     for tt in item {
@@ -166,9 +170,13 @@ pub fn spirv(attr: TokenStream, item: TokenStream) -> TokenStream {
                         {
                             // group matches [spirv ...]
                             // group stream doesn't include the brackets
-                            let inner = group.stream();
+                            let inner = group
+                                .stream()
+                                .into_iter()
+                                .skip(1)
+                                .collect::<proc_macro2::TokenStream>();
                             group_tokens.extend(
-                                quote! { [cfg_attr(target_arch="spirv", rust_gpu::#inner)] },
+                                quote! { [cfg_attr(target_arch="spirv", rust_gpu::#spirv #inner)] },
                             );
                         }
                         _ => group_tokens.append(tt),

crates/spirv_attr_version.rs

@@ -0,0 +1,21 @@
+//! This is placed outside any crate, and included by both `spirv_std` and `rustc_codegen_spirv`.
+//! I could have made a new crate, shared between the two, but decided against having even more small crates for sharing
+//! types. Instead, you get this single small file to specify the versioned spirv attribute.
+//!
+//! This also ensures that the macros below take the *exact* version of the two crates above, and not some dependency
+//! that both of them depend on.
+
+/// The spirv attribute with version tag
+///
+/// ```ignore
+/// # we don't know the namespace of our function
+/// let spirv = spirv_attr_with_version();
+/// let attr = format!("#[rust_gpu::{spirv}(vertex)]");
+/// // version here may be out-of-date
+/// assert_eq!("#[rust_gpu::spirv_v0_9(vertex)]", attr);
+/// ```
+pub fn spirv_attr_with_version() -> String {
+    let major: u32 = env!("CARGO_PKG_VERSION_MAJOR").parse().unwrap();
+    let minor: u32 = env!("CARGO_PKG_VERSION_MINOR").parse().unwrap();
+    format!("spirv_v{major}_{minor}")
+}