Fix capability extension validation to use ANY-of semantics

Grammar extension lists for capabilities are alternatives: at least one
of the listed extensions must be present, not all of them. For example,
ShaderViewportIndexLayerEXT can be enabled by either
SPV_EXT_shader_viewport_index_layer OR SPV_NV_viewport_array2.

The previous code iterated all grammar extensions and failed on the
first one not found, effectively requiring ALL extensions. This matches
the C++ behavior which uses HasAnyOfExtensions() to check if any single
extension from the grammar list is present.

Add regression tests for capabilities with alternative extensions.

Author: LegNeato

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

@@ -120,10 +120,16 @@ pub fn validate_capabilities(
                 && (always_require_extension || !version_allows_core);
 
             if grammar_requires_extension {
-                for &required_ext in grammar_requirements.required_extensions {
-                    if !extension_allowed_in_env(required_ext, env) {
+                // Grammar extension lists are alternatives (ANY suffices).
+                // Only error if NONE of the alternative extensions is allowed.
+                let any_ext_allowed = grammar_requirements
+                    .required_extensions
+                    .iter()
+                    .any(|&ext| extension_allowed_in_env(ext, env));
+                if !any_ext_allowed {
+                    if let Some(&ext) = grammar_requirements.required_extensions.first() {
                         return Err(ValidationError::DisallowedExtension {
-                            extension: ExtensionName::from(required_ext),
+                            extension: ExtensionName::from(ext),
                             env,
                         });
                     }
@@ -171,19 +177,36 @@ pub fn validate_capabilities(
             }
 
             if !grammar_requirements.required_extensions.is_empty() && grammar_requires_extension {
-                for &required_ext in grammar_requirements.required_extensions {
-                    if !extension_allowed_in_env(required_ext, env) {
+                // Grammar extension lists are alternatives (ANY suffices).
+                // The capability is valid if at least one listed extension is
+                // both allowed in the environment and declared in the module.
+                let any_ext_satisfied = grammar_requirements
+                    .required_extensions
+                    .iter()
+                    .any(|&ext| extension_allowed_in_env(ext, env) && has_extension(extensions, ext));
+                if !any_ext_satisfied {
+                    let any_allowed = grammar_requirements
+                        .required_extensions
+                        .iter()
+                        .any(|&ext| extension_allowed_in_env(ext, env));
+                    if !any_allowed {
                         return Err(ValidationError::DisallowedExtension {
-                            extension: ExtensionName::from(required_ext),
+                            extension: ExtensionName::from(
+                                grammar_requirements.required_extensions[0],
+                            ),
                             env,
                         });
                     }
-                    if !has_extension(extensions, required_ext) {
-                        return Err(ValidationError::DisallowedCapabilityMissingExtension {
-                            capability,
-                            required_extension: required_ext.to_string(),
-                        });
-                    }
+                    // At least one is allowed but none is declared
+                    let first_allowed = grammar_requirements
+                        .required_extensions
+                        .iter()
+                        .find(|&&ext| extension_allowed_in_env(ext, env))
+                        .unwrap();
+                    return Err(ValidationError::DisallowedCapabilityMissingExtension {
+                        capability,
+                        required_extension: first_allowed.to_string(),
+                    });
                 }
             }
 

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

@@ -30277,3 +30277,84 @@ fn udot_signed_result_rejected() {
         "Expected DotProductResultNotUnsignedIntScalar, got: {error:?}"
     );
 }
+
+// Grammar extension lists are alternatives: ANY listed extension suffices.
+// ShaderViewportIndexLayerEXT lists two alternative extensions:
+//   SPV_EXT_shader_viewport_index_layer OR SPV_NV_viewport_array2
+#[test]
+fn capability_with_alternative_extensions_accepts_any_single_extension() {
+    // Should succeed with only SPV_NV_viewport_array2 (not both extensions)
+    let text_nv = [
+        "OpCapability Shader",
+        "OpCapability Geometry",
+        "OpCapability MultiViewport",
+        "OpCapability ShaderViewportIndexLayerEXT",
+        "OpExtension \"SPV_NV_viewport_array2\"",
+        "OpMemoryModel Logical GLSL450",
+        "OpEntryPoint Vertex %main \"main\"",
+        "%void = OpTypeVoid",
+        "%fn = OpTypeFunction %void",
+        "%main = OpFunction %void None %fn",
+        "%entry = OpLabel",
+        "OpReturn",
+        "OpFunctionEnd",
+    ]
+    .join("\n");
+    text_nv
+        .as_str()
+        .validate(TargetEnv::Vulkan1_1)
+        .expect("Capability with one of its alternative extensions should be accepted");
+
+    // Should succeed with only SPV_EXT_shader_viewport_index_layer
+    let text_ext = [
+        "OpCapability Shader",
+        "OpCapability Geometry",
+        "OpCapability MultiViewport",
+        "OpCapability ShaderViewportIndexLayerEXT",
+        "OpExtension \"SPV_EXT_shader_viewport_index_layer\"",
+        "OpMemoryModel Logical GLSL450",
+        "OpEntryPoint Vertex %main \"main\"",
+        "%void = OpTypeVoid",
+        "%fn = OpTypeFunction %void",
+        "%main = OpFunction %void None %fn",
+        "%entry = OpLabel",
+        "OpReturn",
+        "OpFunctionEnd",
+    ]
+    .join("\n");
+    text_ext
+        .as_str()
+        .validate(TargetEnv::Vulkan1_1)
+        .expect("Capability with the other alternative extension should be accepted");
+}
+
+#[test]
+fn capability_with_alternative_extensions_rejects_when_none_declared() {
+    // Should fail when neither alternative extension is declared
+    let text = [
+        "OpCapability Shader",
+        "OpCapability Geometry",
+        "OpCapability MultiViewport",
+        "OpCapability ShaderViewportIndexLayerEXT",
+        "OpMemoryModel Logical GLSL450",
+        "OpEntryPoint Vertex %main \"main\"",
+        "%void = OpTypeVoid",
+        "%fn = OpTypeFunction %void",
+        "%main = OpFunction %void None %fn",
+        "%entry = OpLabel",
+        "OpReturn",
+        "OpFunctionEnd",
+    ]
+    .join("\n");
+    let error = text
+        .as_str()
+        .validate(TargetEnv::Vulkan1_1)
+        .expect_err("Capability without any required extension should be rejected");
+    assert!(
+        matches!(
+            error,
+            ValidationError::DisallowedCapabilityMissingExtension { .. }
+        ),
+        "Expected DisallowedCapabilityMissingExtension, got: {error:?}"
+    );
+}