[v2] Error when contract linearisation is impossible

Add two diagnostics from the linearisation pass:
1) cyclic-inheritance for inheritance cycles.
2) linearisation-impossible for inconsistent C3 orderings.

Add a binder test for the forward-reference case, where solc errors
but slang intentionally accepts it.

Signed-off-by: Vladimir Radosavljevic <vr@matterlabs.dev>

Author: Vladimir Radosavljevic

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

@@ -0,0 +1,23 @@
+use serde::Serialize;
+
+use crate::diagnostics::extensions::DiagnosticExtensions;
+use crate::diagnostics::severity::DiagnosticSeverity;
+
+/// Diagnostic emitted when a contract's or interface's inheritance hierarchy
+/// contains a cycle.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct CyclicInheritance;
+
+impl DiagnosticExtensions for CyclicInheritance {
+    fn severity(&self) -> DiagnosticSeverity {
+        DiagnosticSeverity::Error
+    }
+
+    fn code(&self) -> &'static str {
+        "semantic/cyclic-inheritance"
+    }
+
+    fn message(&self) -> String {
+        "Circular inheritance is not allowed.".to_owned()
+    }
+}

crates/solidity-v2/outputs/cargo/common/src/diagnostics/kinds/semantic/cyclic_inheritance.rs

@@ -0,0 +1,23 @@
+use serde::Serialize;
+
+use crate::diagnostics::extensions::DiagnosticExtensions;
+use crate::diagnostics::severity::DiagnosticSeverity;
+
+/// Diagnostic emitted when the C3 linearisation of a contract's or interface's
+/// inheritance hierarchy cannot be computed.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct LinearisationImpossible;
+
+impl DiagnosticExtensions for LinearisationImpossible {
+    fn severity(&self) -> DiagnosticSeverity {
+        DiagnosticSeverity::Error
+    }
+
+    fn code(&self) -> &'static str {
+        "semantic/linearisation-impossible"
+    }
+
+    fn message(&self) -> String {
+        "Linearization of inheritance graph is impossible.".to_owned()
+    }
+}

crates/solidity-v2/outputs/cargo/common/src/diagnostics/kinds/semantic/linearisation_impossible.rs

@@ -1,10 +1,14 @@
 mod cyclic_constant_definition;
 mod cyclic_constant_dependency;
 mod cyclic_dependency_validator_exhausted;
+mod cyclic_inheritance;
+mod linearisation_impossible;
 
 pub use cyclic_constant_definition::CyclicConstantDefinition;
 pub use cyclic_constant_dependency::CyclicConstantDependency;
 pub use cyclic_dependency_validator_exhausted::CyclicDependencyValidatorExhausted;
+pub use cyclic_inheritance::CyclicInheritance;
+pub use linearisation_impossible::LinearisationImpossible;
 use serde::Serialize;
 
 use crate::diagnostics::kinds::utils::define_diagnostic_kind;
@@ -23,5 +27,10 @@ define_diagnostic_kind! {
         CyclicConstantDependency(CyclicConstantDependency),
         /// Constant dependency graph traversal exceeded the depth limit.
         CyclicDependencyValidatorExhausted(CyclicDependencyValidatorExhausted),
+        /// A contract's or interface's inheritance hierarchy contains a cycle.
+        CyclicInheritance(CyclicInheritance),
+        /// The inheritance hierarchy cannot be linearised into a consistent
+        /// method resolution order.
+        LinearisationImpossible(LinearisationImpossible),
     }
 }

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

@@ -3,6 +3,14 @@ use std::fmt::Debug;
 use std::hash::Hash;
 
 use slang_solidity_v2_common::collections::Map;
+/// The reason why linearisation failed.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum LinearisationFailure {
+    /// The inheritance graph contains a cycle.
+    Cycle,
+    /// The base orderings are inconsistent.
+    Inconsistent,
+}
 
 /// Produces a linearisation of a hierarchy of items using the C3 linearisation
 /// algorithm. Given an item `A` with parents `(B1, B2)` in that order, the
@@ -18,7 +26,7 @@ use slang_solidity_v2_common::collections::Map;
 pub(crate) fn linearise<Item: Clone + Debug + Eq + Hash + PartialEq>(
     target: &Item,
     parents: &Map<Item, Vec<Item>>,
-) -> Option<Vec<Item>> {
+) -> Result<Vec<Item>, LinearisationFailure> {
     let mut linearisations: Map<Item, Vec<Item>> = Map::default();
 
     // Keeps a running queue of pending linearisations.
@@ -52,7 +60,7 @@ pub(crate) fn linearise<Item: Clone + Debug + Eq + Hash + PartialEq>(
         }
         if merge_set.len() == item_parents.len() {
             merge_set.push(item_parents.clone());
-            let merge_result = merge(merge_set)?;
+            let merge_result = merge(merge_set).ok_or(LinearisationFailure::Inconsistent)?;
 
             let mut result = Vec::new();
             result.push(item.clone());
@@ -73,7 +81,7 @@ pub(crate) fn linearise<Item: Clone + Debug + Eq + Hash + PartialEq>(
                     if *check_item == item {
                         if items_linearised == linearisations.len() {
                             // no progress since last checkpoint; this indicates a cycle
-                            return None;
+                            return Err(LinearisationFailure::Cycle);
                         }
                         // Update progress and re-try
                         checkpoint = Some((item.clone(), linearisations.len()));
@@ -88,7 +96,9 @@ pub(crate) fn linearise<Item: Clone + Debug + Eq + Hash + PartialEq>(
         }
     }
 
-    linearisations.remove(target)
+    linearisations
+        .remove(target)
+        .ok_or(LinearisationFailure::Inconsistent)
 }
 
 /// Merges the items in the set in C3 linearisation order. Returns None if
@@ -203,8 +213,8 @@ mod tests {
         parents.insert('D', vec!['B', 'C']);
         parents.insert('E', vec!['C', 'B']);
 
-        assert_eq!(Some(vec!['D', 'B', 'C', 'A']), linearise(&'D', &parents));
-        assert_eq!(Some(vec!['E', 'C', 'B', 'A']), linearise(&'E', &parents));
+        assert_eq!(Ok(vec!['D', 'B', 'C', 'A']), linearise(&'D', &parents));
+        assert_eq!(Ok(vec!['E', 'C', 'B', 'A']), linearise(&'E', &parents));
     }
 
     #[test]
@@ -214,7 +224,10 @@ mod tests {
         parents.insert('A', vec!['X']);
         parents.insert('C', vec!['X', 'A']);
 
-        assert_eq!(None, linearise(&'C', &parents));
+        assert_eq!(
+            Err(LinearisationFailure::Inconsistent),
+            linearise(&'C', &parents)
+        );
     }
 
     #[test]
@@ -223,8 +236,8 @@ mod tests {
         parents.insert('B', vec!['A']);
         parents.insert('A', vec!['B']);
 
-        assert_eq!(None, linearise(&'A', &parents));
-        assert_eq!(None, linearise(&'B', &parents));
+        assert_eq!(Err(LinearisationFailure::Cycle), linearise(&'A', &parents));
+        assert_eq!(Err(LinearisationFailure::Cycle), linearise(&'B', &parents));
     }
 
     #[test]
@@ -234,8 +247,8 @@ mod tests {
         parents.insert('Y', vec!['Z']);
         parents.insert('Z', vec!['X']);
 
-        assert_eq!(None, linearise(&'X', &parents));
-        assert_eq!(None, linearise(&'Y', &parents));
-        assert_eq!(None, linearise(&'Z', &parents));
+        assert_eq!(Err(LinearisationFailure::Cycle), linearise(&'X', &parents));
+        assert_eq!(Err(LinearisationFailure::Cycle), linearise(&'Y', &parents));
+        assert_eq!(Err(LinearisationFailure::Cycle), linearise(&'Z', &parents));
     }
 }