Allow VulkanMemoryModel on Vulkan 1.1 via extension

Match C++ spirv-val behavior: capabilities enabled by declared
extensions should bypass SPIR-V version requirements. Previously,
VulkanMemoryModel had a special-case early return that rejected it
before checking extensions.

Changes:
- Remove VulkanMemoryModel early return in capability validation
- Add extension check to operand version validation (matching C++
  OperandVersionExtensionCheck) so that declared extensions like
  SPV_KHR_vulkan_memory_model can relax SPIR-V version requirements
  for operands like VulkanKHR memory model
- Add test for Vulkan 1.1 + VulkanMemoryModel with extension
- Update test expectations to reflect more precise error types

Author: LegNeato

rust/spirv-tools-core/src/validation/mod.rs

@@ -96,8 +96,8 @@ use rules::capabilities::{
     validate_capabilities,
 };
 use rules::extensions::{
-    extension_operand, extension_satisfied, validate_extension_allowlist, validate_extensions,
-    ExtensionSet,
+    extension_operand, extension_satisfied, has_extension, validate_extension_allowlist,
+    validate_extensions, ExtensionSet,
 };
 use rules::limits::all_limit_rules;
 
@@ -946,12 +946,25 @@ fn validate_instruction_requirements(
             }
             if let Some(required_version) = required_spirv_version_for_operand(operand) {
                 if target_version < required_version {
-                    return Err(ValidationError::OperandRequiresSpirvVersion {
-                        opcode: inst.class.opcode,
-                        operand_index: index,
-                        required_version,
-                        target_version,
-                    });
+                    // Check if an enabling extension is declared that can
+                    // relax the version requirement (matching C++ spirv-val's
+                    // OperandVersionExtensionCheck).
+                    let has_enabling_extension = operand
+                        .required_extensions()
+                        .iter()
+                        .any(|ext| has_extension(extensions, ext))
+                        || grammar_required_extensions_for_operand(operand)
+                            .iter()
+                            .any(|ext| has_extension(extensions, ext));
+
+                    if !has_enabling_extension {
+                        return Err(ValidationError::OperandRequiresSpirvVersion {
+                            opcode: inst.class.opcode,
+                            operand_index: index,
+                            required_version,
+                            target_version,
+                        });
+                    }
                 }
             }
             // Collect ALL capabilities from all sources and check DISJUNCTIVELY

rust/spirv-tools-core/src/validation/rules/capabilities.rs

@@ -81,10 +81,6 @@ pub fn validate_capabilities(
             let grammar_requirements = capability_info_from_grammar(capability);
             let allowed_by_env = env.is_capability_allowed(capability);
 
-            if !allowed_by_env && capability == Capability::VulkanMemoryModel {
-                return Err(ValidationError::DisallowedCapability { capability, env });
-            }
-
             if env.is_opencl()
                 && matches!(
                     capability,
@@ -211,6 +207,11 @@ pub fn validate_capabilities(
             let allowed_by_extension = capability_allowed_by_extension(env, capability, extensions);
             let allowed_by_capability =
                 capability_enabled_by_capability(env, capability, &declared);
+
+            // If the capability is not allowed by any means (env allowlist,
+            // extension, or implied by another capability), reject it
+            // immediately. This matches C++ spirv-val which checks env/ext
+            // allowlists first.
             if !(allowed_by_env || allowed_by_extension || allowed_by_capability) {
                 return Err(ValidationError::DisallowedCapability { capability, env });
             }

rust/spirv-tools-core/src/validation/tests/mod.rs

@@ -6331,16 +6331,40 @@ fn vulkan_1_0_rejects_vulkan_memory_model() {
     let error = text
         .as_str()
         .validate(TargetEnv::Vulkan1_0)
-        .expect_err("Vulkan memory model is 1.2+ optional");
+        .expect_err("Vulkan memory model requires SPIR-V 1.5");
     assert_eq!(
         error,
-        ValidationError::DisallowedCapability {
+        ValidationError::CapabilityRequiresSpirvVersion {
             capability: rspirv::spirv::Capability::VulkanMemoryModel,
-            env: TargetEnv::Vulkan1_0
+            required_version: SpirvVersion::new(1, 5),
+            target_version: TargetEnv::Vulkan1_0.spirv_version(),
         }
     );
 }
 #[test]
+fn vulkan_1_1_allows_vulkan_memory_model_with_extension() {
+    // VulkanMemoryModel is available in Vulkan 1.1 via SPV_KHR_vulkan_memory_model extension.
+    // The capability requires SPIR-V 1.5, but the extension enables it on earlier versions.
+    let text = [
+        "OpCapability Shader",
+        "OpCapability VulkanMemoryModel",
+        "OpExtension \"SPV_KHR_vulkan_memory_model\"",
+        "OpMemoryModel Logical VulkanKHR",
+        "%void = OpTypeVoid",
+        "%fn = OpTypeFunction %void",
+        "%main = OpFunction %void None %fn",
+        "%entry = OpLabel",
+        "OpReturn",
+        "OpFunctionEnd",
+    ]
+    .join("\n");
+    let module = text
+        .as_str()
+        .validate(TargetEnv::Vulkan1_1)
+        .expect("VulkanMemoryModel is optional in Vulkan 1.1 (via SPV_KHR_vulkan_memory_model)");
+    assert_eq!(module.env(), TargetEnv::Vulkan1_1);
+}
+#[test]
 fn vulkan_1_2_allows_physical_storage_buffer_addresses() {
     let text = [
         "OpCapability Shader",
@@ -17525,14 +17549,15 @@ fn memory_model_vulkan_requires_spirv_1_5() {
     let error = words
         .as_slice()
         .validate(TargetEnv::Vulkan1_1Spirv1_4)
-        .expect_err("Vulkan memory model requires SPIR-V 1.5");
+        .expect_err("VulkanKHR memory model operand requires VulkanMemoryModel capability");
+    // The extension satisfies the SPIR-V version requirement, so the real
+    // error surfaces: the VulkanMemoryModel capability is not declared.
     assert_eq!(
         error,
-        ValidationError::OperandRequiresSpirvVersion {
+        ValidationError::MissingOperandCapability {
             opcode: rspirv::spirv::Op::MemoryModel,
             operand_index: 1,
-            required_version: SpirvVersion::new(1, 5),
-            target_version: TargetEnv::Vulkan1_1Spirv1_4.spirv_version(),
+            required_capability: rspirv::spirv::Capability::VulkanMemoryModel,
         }
     );
 }