[v2] Error on unresolvable or invalid inheritance bases

Add a diagnostic when encountering unresolvable or invalid inheritance
bases.
Adds two diagnostic groups: Resolution (IdentifierNotFound) for bases
that don't resolve, and Type System (InvalidBase) for bases that resolve
to a non-contract/interface (e.g. a library, struct, or free function).

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

Author: Vladimir Radosavljevic

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

@@ -1,13 +1,17 @@
 mod utils;
 
 pub mod compilation;
+pub mod resolution;
 pub mod structure;
 pub mod syntax;
+pub mod type_system;
 
 use compilation::CompilationDiagnosticKind;
+use resolution::ResolutionDiagnosticKind;
 use serde::Serialize;
 use structure::StructureDiagnosticKind;
 use syntax::SyntaxDiagnosticKind;
+use type_system::TypeSystemDiagnosticKind;
 
 use crate::diagnostics::kinds::utils::define_diagnostic_kind;
 
@@ -23,5 +27,11 @@ define_diagnostic_kind! {
         Syntax(SyntaxDiagnosticKind),
         /// A diagnostic about structural shape.
         Structure(StructureDiagnosticKind),
+        /// A diagnostic produced for undeclared identifiers, duplicate
+        /// definitions, import failures, shadowing, ambiguous references
+        /// and scope errors.
+        Resolution(ResolutionDiagnosticKind),
+        /// A diagnostic about the type system.
+        TypeSystem(TypeSystemDiagnosticKind),
     }
 }

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

@@ -0,0 +1,23 @@
+use serde::Serialize;
+
+use crate::diagnostics::extensions::DiagnosticExtensions;
+use crate::diagnostics::severity::DiagnosticSeverity;
+
+/// Diagnostic emitted when an identifier could not be resolved — it was not
+/// found, or was not unique.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct IdentifierNotFound;
+
+impl DiagnosticExtensions for IdentifierNotFound {
+    fn severity(&self) -> DiagnosticSeverity {
+        DiagnosticSeverity::Error
+    }
+
+    fn code(&self) -> &'static str {
+        "resolution/identifier-not-found"
+    }
+
+    fn message(&self) -> String {
+        "Identifier not found or not unique.".to_owned()
+    }
+}

crates/solidity-v2/outputs/cargo/common/src/diagnostics/kinds/resolution/identifier_not_found.rs

@@ -0,0 +1,20 @@
+mod identifier_not_found;
+
+pub use identifier_not_found::IdentifierNotFound;
+use serde::Serialize;
+
+use crate::diagnostics::kinds::utils::define_diagnostic_kind;
+use crate::diagnostics::kinds::DiagnosticKind;
+
+define_diagnostic_kind! {
+    parent_kind = DiagnosticKind::Resolution;
+
+    /// Group of diagnostics for undeclared identifiers, duplicate
+    /// definitions, import failures, shadowing, ambiguous references
+    /// and scope errors.
+    #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+    pub enum ResolutionDiagnosticKind {
+        /// An identifier could not be resolved.
+        IdentifierNotFound(IdentifierNotFound),
+    }
+}

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

@@ -0,0 +1,24 @@
+use serde::Serialize;
+
+use crate::diagnostics::extensions::DiagnosticExtensions;
+use crate::diagnostics::severity::DiagnosticSeverity;
+
+/// Diagnostic emitted when a base in an inheritance list resolves to something
+/// that is not a contract or interface (for example a library, struct, or free
+/// function), and therefore cannot be used as a base.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct InvalidBase;
+
+impl DiagnosticExtensions for InvalidBase {
+    fn severity(&self) -> DiagnosticSeverity {
+        DiagnosticSeverity::Error
+    }
+
+    fn code(&self) -> &'static str {
+        "type-system/invalid-base"
+    }
+
+    fn message(&self) -> String {
+        "Only a contract or interface can be used as a base.".to_owned()
+    }
+}

crates/solidity-v2/outputs/cargo/common/src/diagnostics/kinds/type_system/invalid_base.rs

@@ -0,0 +1,20 @@
+mod invalid_base;
+
+pub use invalid_base::InvalidBase;
+use serde::Serialize;
+
+use crate::diagnostics::kinds::utils::define_diagnostic_kind;
+use crate::diagnostics::kinds::DiagnosticKind;
+
+define_diagnostic_kind! {
+    parent_kind = DiagnosticKind::TypeSystem;
+
+    /// Group of diagnostics about the type system — type mismatches, invalid
+    /// conversions, operator type errors, function-call type mismatches, and ABI
+    /// encoding constraints that are properties of a type.
+    #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+    pub enum TypeSystemDiagnosticKind {
+        /// A base in an inheritance list is not a contract or interface.
+        InvalidBase(InvalidBase),
+    }
+}

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

@@ -72,7 +72,7 @@ impl SemanticContext {
         let mut types = TypeRegistry::default();
 
         p1_collect_definitions::run(files, &mut binder, diagnostics);
-        p2_linearise_contracts::run(files, &mut binder);
+        p2_linearise_contracts::run(files, &mut binder, diagnostics);
         p3_type_definitions::run(files, &mut binder, &mut types, language_version);
         p4_resolve_references::run(files, &mut binder, &mut types, language_version);
 

crates/solidity-v2/outputs/cargo/semantic/src/context/mod.rs

@@ -1,5 +1,8 @@
 use std::collections::HashMap;
 
+use slang_solidity_v2_common::diagnostics::kinds::resolution::IdentifierNotFound;
+use slang_solidity_v2_common::diagnostics::kinds::type_system::InvalidBase;
+use slang_solidity_v2_common::diagnostics::DiagnosticCollection;
 use slang_solidity_v2_common::nodes::NodeId;
 use slang_solidity_v2_ir::ir;
 
@@ -11,27 +14,49 @@ mod c3;
 
 /// In this pass we collect all bases of contracts and interfaces and then
 /// compute the linearisation for each of them.
-pub fn run(files: &[impl SemanticFile], binder: &mut Binder) {
+pub fn run(
+    files: &[impl SemanticFile],
+    binder: &mut Binder,
+    diagnostics: &mut DiagnosticCollection,
+) {
     for file in files {
-        Pass::visit_file_collect_bases(file, binder);
+        Pass::visit_file_collect_bases(file, binder, diagnostics);
     }
     for file in files {
-        Pass::visit_file_linearise_contracts(file, binder);
+        Pass::visit_file_linearise_contracts(file, binder, diagnostics);
     }
 }
 
 struct Pass<'a> {
     binder: &'a mut Binder,
+    diagnostics: &'a mut DiagnosticCollection,
+    file_id: String,
 }
 
 impl<'a> Pass<'a> {
-    fn visit_file_collect_bases(file: &impl SemanticFile, binder: &'a mut Binder) {
-        let mut pass = Self { binder };
+    fn visit_file_collect_bases(
+        file: &impl SemanticFile,
+        binder: &'a mut Binder,
+        diagnostics: &'a mut DiagnosticCollection,
+    ) {
+        let mut pass = Self {
+            binder,
+            diagnostics,
+            file_id: file.id().to_owned(),
+        };
         pass.collect_bases_from(file.ir_root());
     }
 
-    fn visit_file_linearise_contracts(file: &impl SemanticFile, binder: &'a mut Binder) {
-        let mut pass = Self { binder };
+    fn visit_file_linearise_contracts(
+        file: &impl SemanticFile,
+        binder: &'a mut Binder,
+        diagnostics: &'a mut DiagnosticCollection,
+    ) {
+        let mut pass = Self {
+            binder,
+            diagnostics,
+            file_id: file.id().to_owned(),
+        };
         pass.linearise_contracts_from(file.ir_root());
     }
 
@@ -80,22 +105,38 @@ impl<'a> Pass<'a> {
         types: &ir::InheritanceTypes,
         scope_id: ScopeId,
     ) -> Vec<NodeId> {
-        // TODO(validation) SDR[23]: check that we are able to resolve all bases as
-        // otherwise we end up with a short list saved in the definition
-        types
-            .iter()
-            .filter_map(|inheritance_type| {
-                resolve_identifier_path_in_scope(self.binder, &inheritance_type.type_name, scope_id)
-                    .as_definition_id()
-                    .filter(|definition_id| {
-                        // bases are either contracts or interfaces, discard anything else
-                        matches!(
-                            self.binder.find_definition_by_id(*definition_id).unwrap(),
-                            Definition::Contract(_) | Definition::Interface(_)
-                        )
-                    })
-            })
-            .collect()
+        let mut resolved_bases = Vec::new();
+        for inheritance_type in types {
+            let resolution = resolve_identifier_path_in_scope(
+                self.binder,
+                &inheritance_type.type_name,
+                scope_id,
+            );
+            match resolution.as_definition_id() {
+                None => {
+                    self.diagnostics.push(
+                        self.file_id.clone(),
+                        inheritance_type.range.clone(),
+                        IdentifierNotFound,
+                    );
+                }
+                Some(definition_id) => {
+                    match self.binder.find_definition_by_id(definition_id).unwrap() {
+                        Definition::Contract(_) | Definition::Interface(_) => {
+                            resolved_bases.push(definition_id);
+                        }
+                        _ => {
+                            self.diagnostics.push(
+                                self.file_id.clone(),
+                                inheritance_type.range.clone(),
+                                InvalidBase,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+        resolved_bases
     }
 
     fn linearise_contracts_from(&mut self, source_unit: &ir::SourceUnit) {

crates/solidity-v2/outputs/cargo/semantic/src/passes/p2_linearise_contracts/mod.rs

@@ -30,11 +30,11 @@ contract Test is Base layout at 0 {}
     let mut binder = Binder::default();
     let mut diagnostics = DiagnosticCollection::default();
     p1_collect_definitions::run(&files, &mut binder, &mut diagnostics);
+    p2_linearise_contracts::run(&files, &mut binder, &mut diagnostics);
     assert!(
         diagnostics.is_empty(),
         "Semantic diagnostics: {diagnostics:?}"
     );
-    p2_linearise_contracts::run(&files, &mut binder);
 
     // Verify definitions were collected
     assert_eq!(2, binder.definitions().len());
@@ -93,11 +93,11 @@ interface A is C {}
     let mut binder = Binder::default();
     let mut diagnostics = DiagnosticCollection::default();
     p1_collect_definitions::run(&files, &mut binder, &mut diagnostics);
+    p2_linearise_contracts::run(&files, &mut binder, &mut diagnostics);
     assert!(
         diagnostics.is_empty(),
         "Semantic diagnostics: {diagnostics:?}"
     );
-    p2_linearise_contracts::run(&files, &mut binder);
 
     let contract_to_bases = get_contract_to_bases_map(&binder);
 
@@ -147,7 +147,11 @@ contract Test is Base, Foo { // Base should resolve to the contract, not the var
         diagnostics.is_empty(),
         "Semantic diagnostics: {diagnostics:?}"
     );
-    p2_linearise_contracts::run(&files, &mut binder);
+    p2_linearise_contracts::run(&files, &mut binder, &mut diagnostics);
+    assert!(
+        !diagnostics.is_empty(),
+        "Expected diagnostics for invalid input"
+    );
 
     let contract_to_bases = get_contract_to_bases_map(&binder);
 
@@ -198,11 +202,11 @@ contract Test is Base {
 
     let mut diagnostics = DiagnosticCollection::default();
     p1_collect_definitions::run(&files, &mut binder, &mut diagnostics);
+    p2_linearise_contracts::run(&files, &mut binder, &mut diagnostics);
     assert!(
         diagnostics.is_empty(),
         "Semantic diagnostics: {diagnostics:?}"
     );
-    p2_linearise_contracts::run(&files, &mut binder);
 
     let types_before = types.iter_types().count();
     p3_type_definitions::run(&files, &mut binder, &mut types, language_version);
@@ -257,11 +261,11 @@ contract Test is Base {
 
     let mut diagnostics = DiagnosticCollection::default();
     p1_collect_definitions::run(&files, &mut binder, &mut diagnostics);
+    p2_linearise_contracts::run(&files, &mut binder, &mut diagnostics);
     assert!(
         diagnostics.is_empty(),
         "Semantic diagnostics: {diagnostics:?}"
     );
-    p2_linearise_contracts::run(&files, &mut binder);
     p3_type_definitions::run(&files, &mut binder, &mut types, language_version);
     p4_resolve_references::run(&files, &mut binder, &mut types, language_version);
 

crates/solidity-v2/outputs/cargo/semantic/src/passes/tests/binder.rs

@@ -32,11 +32,11 @@ fn analyze(language_version: LanguageVersion, source: &str) -> TypeAnalysis {
     let mut types = TypeRegistry::default();
     let mut diagnostics = DiagnosticCollection::default();
     p1_collect_definitions::run(&files, &mut binder, &mut diagnostics);
+    p2_linearise_contracts::run(&files, &mut binder, &mut diagnostics);
     assert!(
         diagnostics.is_empty(),
         "Semantic diagnostics: {diagnostics:?}"
     );
-    p2_linearise_contracts::run(&files, &mut binder);
     p3_type_definitions::run(&files, &mut binder, &mut types, language_version);
     p4_resolve_references::run(&files, &mut binder, &mut types, language_version);