feat(v2): diagnose duplicate override specifiers

Reject functions, fallback/receive functions, modifiers, and state
variables that carry more than one `override` specifier, matching solc's
ParserError 1827/9125/9102. Closes the SDR[9] and SDR[12] validation
TODOs and the `override` part of SDR[1730] in the IR builder.

Author: teofr

crates/solidity-v2/outputs/cargo/common/generated/public_api.txt

@@ -1,12 +1,14 @@
 mod extra_terminal;
 mod multiple_mutability_specifiers;
+mod multiple_override_specifiers;
 mod multiple_virtual_specifiers;
 mod unexpected_eof;
 mod unexpected_terminal;
 mod unsupported_syntax;
 
 pub use extra_terminal::ExtraTerminal;
 pub use multiple_mutability_specifiers::MultipleMutabilitySpecifiers;
+pub use multiple_override_specifiers::MultipleOverrideSpecifiers;
 pub use multiple_virtual_specifiers::MultipleVirtualSpecifiers;
 use serde::Serialize;
 pub use unexpected_eof::UnexpectedEof;
@@ -37,5 +39,8 @@ define_diagnostic_kind! {
 
         /// More than one `virtual` specifier was provided on a definition.
         MultipleVirtualSpecifiers(MultipleVirtualSpecifiers),
+
+        /// More than one `override` specifier was provided on a definition.
+        MultipleOverrideSpecifiers(MultipleOverrideSpecifiers),
     }
 }

crates/solidity-v2/outputs/cargo/common/src/diagnostics/kinds/syntax/mod.rs

@@ -0,0 +1,23 @@
+use serde::Serialize;
+
+use crate::diagnostics::extensions::DiagnosticExtensions;
+use crate::diagnostics::severity::DiagnosticSeverity;
+
+/// Diagnostic emitted when a definition carries more than one `override`
+/// specifier.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct MultipleOverrideSpecifiers;
+
+impl DiagnosticExtensions for MultipleOverrideSpecifiers {
+    fn severity(&self) -> DiagnosticSeverity {
+        DiagnosticSeverity::Error
+    }
+
+    fn code(&self) -> &'static str {
+        "syntax/multiple-override-specifiers"
+    }
+
+    fn message(&self) -> String {
+        "Only a single override specifier can be provided.".to_string()
+    }
+}

crates/solidity-v2/outputs/cargo/common/src/diagnostics/kinds/syntax/multiple_override_specifiers.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use slang_solidity_v2_common::diagnostics::kinds::syntax::{
-    MultipleMutabilitySpecifiers, MultipleVirtualSpecifiers,
+    MultipleMutabilitySpecifiers, MultipleOverrideSpecifiers, MultipleVirtualSpecifiers,
 };
 use slang_solidity_v2_common::diagnostics::DiagnosticCollection;
 use slang_solidity_v2_cst::structured_cst::nodes as input;
@@ -226,7 +226,6 @@ impl<S: Source> CstToIrBuilder<'_, S> {
                     None
                 }
             }));
-        // TODO(validation) SDR[9]: function definitions can have only a single override specifier
         let override_specifier = self.function_override_specifier(&source.attributes);
         let modifier_invocations = self.function_modifier_invocations(&source.attributes);
         let returns = source
@@ -470,13 +469,13 @@ impl<S: Source> CstToIrBuilder<'_, S> {
         &mut self,
         attributes: &input::FunctionAttributes,
     ) -> Option<output::OverridePaths> {
-        attributes.elements.iter().find_map(|attribute| {
+        self.extract_single_override(attributes.elements.iter().filter_map(|attribute| {
             if let input::FunctionAttribute::OverrideSpecifier(specifier) = attribute {
-                Some(self.build_override_specifier_as_paths(specifier))
+                Some(specifier)
             } else {
                 None
             }
-        })
+        }))
     }
 
     fn function_modifier_invocations(
@@ -646,13 +645,13 @@ impl<S: Source> CstToIrBuilder<'_, S> {
         &mut self,
         attributes: &input::FallbackFunctionAttributes,
     ) -> Option<output::OverridePaths> {
-        attributes.elements.iter().find_map(|attribute| {
+        self.extract_single_override(attributes.elements.iter().filter_map(|attribute| {
             if let input::FallbackFunctionAttribute::OverrideSpecifier(specifier) = attribute {
-                Some(self.build_override_specifier_as_paths(specifier))
+                Some(specifier)
             } else {
                 None
             }
-        })
+        }))
     }
 
     fn fallback_function_modifier_invocations(
@@ -721,13 +720,13 @@ impl<S: Source> CstToIrBuilder<'_, S> {
         &mut self,
         attributes: &input::ReceiveFunctionAttributes,
     ) -> Option<output::OverridePaths> {
-        attributes.elements.iter().find_map(|attribute| {
+        self.extract_single_override(attributes.elements.iter().filter_map(|attribute| {
             if let input::ReceiveFunctionAttribute::OverrideSpecifier(specifier) = attribute {
-                Some(self.build_override_specifier_as_paths(specifier))
+                Some(specifier)
             } else {
                 None
             }
-        })
+        }))
     }
 
     fn receive_function_modifier_invocations(
@@ -761,7 +760,6 @@ impl<S: Source> CstToIrBuilder<'_, S> {
         let visibility = output::FunctionVisibility::Internal;
         // mutability is irrelevant for modifiers
         let mutability = output::FunctionMutability::NonPayable;
-        // TODO(validation) SDR[1730]: modifiers can have only a single override specifier
         let virtual_keyword =
             self.extract_first_virtual(source.attributes.elements.iter().filter_map(|attribute| {
                 if let input::ModifierAttribute::VirtualKeyword(virtual_keyword) = attribute {
@@ -795,13 +793,13 @@ impl<S: Source> CstToIrBuilder<'_, S> {
         &mut self,
         attributes: &input::ModifierAttributes,
     ) -> Option<output::OverridePaths> {
-        attributes.elements.iter().find_map(|attribute| {
+        self.extract_single_override(attributes.elements.iter().filter_map(|attribute| {
             if let input::ModifierAttribute::OverrideSpecifier(specifier) = attribute {
-                Some(self.build_override_specifier_as_paths(specifier))
+                Some(specifier)
             } else {
                 None
             }
-        })
+        }))
     }
 
     //
@@ -833,14 +831,13 @@ impl<S: Source> CstToIrBuilder<'_, S> {
         &mut self,
         attributes: &input::StateVariableAttributes,
     ) -> Option<output::OverridePaths> {
-        // TODO(validation) SDR[12]: only one override specifier is allowed
-        attributes.elements.iter().find_map(|attribute| {
+        self.extract_single_override(attributes.elements.iter().filter_map(|attribute| {
             if let input::StateVariableAttribute::OverrideSpecifier(specifier) = attribute {
-                Some(self.build_override_specifier_as_paths(specifier))
+                Some(specifier)
             } else {
                 None
             }
-        })
+        }))
     }
 
     fn state_variable_as_constant_definition(
@@ -1029,4 +1026,24 @@ impl<S: Source> CstToIrBuilder<'_, S> {
 
         Some(first)
     }
+
+    /// Extracts and transforms the first `override` specifier, emitting an
+    /// error for any subsequent ones.
+    fn extract_single_override<'a>(
+        &mut self,
+        specifiers: impl IntoIterator<Item = &'a input::OverrideSpecifier>,
+    ) -> Option<output::OverridePaths> {
+        let mut specifiers = specifiers.into_iter();
+        let first = self.build_override_specifier_as_paths(specifiers.next()?);
+
+        for specifier in specifiers {
+            self.diagnostics.push(
+                self.file_id.to_owned(),
+                specifier.calculate_text_range().unwrap(),
+                MultipleOverrideSpecifiers,
+            );
+        }
+
+        Some(first)
+    }
 }

crates/solidity-v2/outputs/cargo/ir/src/ir/builder/mod.rs

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity *;
+
+contract C {
+    fallback() external override override {}
+}