feat: extensions of interfaces (#1425)

Interfaces can now be extended by other interfaces. 
This involves changes in the parsing, indexing, resolving and most importantly the validation stage.
Extends the already existing validations for extended `FUNCTION_BLOCKS` to also take interfaces into account, wherever applicable.

Author: mhasel

compiler/plc_ast/src/ast.rs

@@ -50,13 +50,14 @@ pub struct Pou {
 
 #[derive(Debug, PartialEq)]
 pub struct Interface {
-    pub name: String,
+    pub id: AstId,
+    pub identifier: Identifier,
     pub methods: Vec<Pou>,
     pub location: SourceLocation,
-    pub location_name: SourceLocation,
+    pub extensions: Vec<Identifier>,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub struct Identifier {
     pub name: String,
     pub location: SourceLocation,
@@ -310,6 +311,22 @@ pub enum AccessModifier {
     Internal,
 }
 
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
+pub enum DeclarationKind {
+    Abstract,
+    Concrete,
+}
+
+impl DeclarationKind {
+    pub fn is_abstract(&self) -> bool {
+        matches!(self, DeclarationKind::Abstract)
+    }
+
+    pub fn is_concrete(&self) -> bool {
+        matches!(self, DeclarationKind::Concrete)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum PouType {
     Program,
@@ -323,6 +340,8 @@ pub enum PouType {
 
         /// The fully qualified name of the property this GET or SET method represents
         property: Option<String>,
+
+        declaration_kind: DeclarationKind,
     },
     Init,
     ProjectInit,
@@ -1350,7 +1369,7 @@ impl Operator {
 
 #[cfg(test)]
 mod tests {
-    use crate::ast::{ArgumentProperty, PouType, VariableBlockType};
+    use crate::ast::{ArgumentProperty, DeclarationKind, PouType, VariableBlockType};
 
     #[test]
     fn display_pou() {
@@ -1359,7 +1378,15 @@ mod tests {
         assert_eq!(PouType::FunctionBlock.to_string(), "FunctionBlock");
         assert_eq!(PouType::Action.to_string(), "Action");
         assert_eq!(PouType::Class.to_string(), "Class");
-        assert_eq!(PouType::Method { parent: String::new(), property: None }.to_string(), "Method");
+        assert_eq!(
+            PouType::Method {
+                parent: String::new(),
+                property: None,
+                declaration_kind: DeclarationKind::Concrete
+            }
+            .to_string(),
+            "Method"
+        );
     }
 
     #[test]

compiler/plc_lowering/src/inheritance.rs

@@ -1967,7 +1967,7 @@ mod units_tests {
 
         let (_, project) = parse_and_annotate("test", vec![src]).unwrap();
         let unit = &project.units[0].get_unit().units[3];
-        assert_debug_snapshot!(unit, @r###"
+        assert_debug_snapshot!(unit, @r#"
         POU {
             name: "child.foo",
             variable_blocks: [
@@ -2014,11 +2014,12 @@ mod units_tests {
             pou_type: Method {
                 parent: "child",
                 property: None,
+                declaration_kind: Concrete,
             },
             return_type: None,
             interfaces: [],
         }
-        "###);
+        "#);
     }
 
     #[test]
@@ -2040,14 +2041,15 @@ mod units_tests {
 
         let (_, project) = parse_and_annotate("test", vec![src]).unwrap();
         let unit = &project.units[0].get_unit().implementations[1];
-        assert_debug_snapshot!(unit, @r###"
+        assert_debug_snapshot!(unit, @r#"
         Implementation {
             name: "bar.set0",
             type_name: "bar.set0",
             linkage: Internal,
             pou_type: Method {
                 parent: "bar",
                 property: None,
+                declaration_kind: Concrete,
             },
             statements: [
                 Assignment {
@@ -2111,7 +2113,7 @@ mod units_tests {
                 Protected,
             ),
         }
-        "###);
+        "#);
     }
 }
 

src/index.rs

@@ -6,8 +6,8 @@ use itertools::Itertools;
 use rustc_hash::{FxHashSet, FxHasher};
 
 use plc_ast::ast::{
-    AstId, AstNode, AstStatement, ConfigVariable, DirectAccessType, GenericBinding, HardwareAccessType,
-    Identifier, Interface, LinkageType, PouType, TypeNature,
+    AstId, AstNode, AstStatement, ConfigVariable, DeclarationKind, DirectAccessType, GenericBinding,
+    HardwareAccessType, Identifier, Interface, LinkageType, PouType, TypeNature,
 };
 use plc_diagnostics::diagnostics::Diagnostic;
 use plc_source::source_location::SourceLocation;
@@ -491,48 +491,117 @@ impl ImplementationType {
     }
 }
 
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Hash)]
 pub struct InterfaceIndexEntry {
-    /// The interface name
-    pub name: String,
+    /// The interface identifier, consisting of its name and name-location
+    pub identifier: Identifier,
 
     /// The location of the interface as a whole
     pub location: SourceLocation,
 
-    /// The location of the interface name
-    pub location_name: SourceLocation,
-
     /// A list of qualified names of the methods in this interface; the actual methods are located in
     /// [`Index::pous`]
     pub methods: Vec<String>,
+
+    /// A list of other interfaces this interface extends
+    pub extensions: Vec<Identifier>,
 }
 
 impl InterfaceIndexEntry {
-    /// Returns a list of methods defined in this interface
-    pub fn get_methods<'idx>(&self, index: &'idx Index) -> Vec<&'idx PouIndexEntry> {
+    pub fn get_name(&self) -> &str {
+        self.identifier.name.as_str()
+    }
+
+    pub fn get_name_location(&self) -> &SourceLocation {
+        &self.identifier.location
+    }
+
+    pub fn get_location(&self) -> &SourceLocation {
+        &self.location
+    }
+
+    /// Returns a list of methods this interface declared
+    pub fn get_declared_methods<'idx>(&self, index: &'idx Index) -> Vec<&'idx PouIndexEntry> {
         self.methods
             .iter()
             .map(|name| index.find_pou(name).expect("must exist because of present InterfaceIndexEntry"))
             .collect()
     }
+
+    /// Returns a list of methods this interface inherited
+    pub fn get_derived_methods<'idx>(&'idx self, index: &'idx Index) -> Vec<&'idx PouIndexEntry> {
+        self.get_derived_methods_recursive(index, &mut FxHashSet::default())
+    }
+
+    /// Returns a list of methods defined in this interface, including inherited methods from derived interfaces
+    pub fn get_methods<'idx>(&'idx self, index: &'idx Index) -> Vec<&'idx PouIndexEntry> {
+        self.get_methods_recursive(index, &mut FxHashSet::default())
+    }
+
+    /// Returns a list of interfaces this interface implements
+    pub fn get_extensions(&self) -> Vec<&Identifier> {
+        self.extensions.iter().collect()
+    }
+
+    /// Returns a list of interfaces this interface inherited
+    pub fn get_derived_interfaces<'idx>(
+        &self,
+        index: &'idx Index,
+    ) -> Vec<Result<&'idx InterfaceIndexEntry, Identifier>> {
+        self.extensions
+            .iter()
+            .flat_map(|id| index.find_interface(&id.name).map(Result::Ok).or(Some(Err(id.to_owned()))))
+            .collect()
+    }
+
+    fn get_methods_recursive<'idx>(
+        &'idx self,
+        index: &'idx Index,
+        seen: &mut FxHashSet<&'idx str>,
+    ) -> Vec<&'idx PouIndexEntry> {
+        seen.insert(self.get_name());
+        self.get_declared_methods(index)
+            .into_iter()
+            .chain(self.get_derived_methods_recursive(index, seen))
+            .collect_vec()
+    }
+
+    fn get_derived_methods_recursive<'idx>(
+        &'idx self,
+        index: &'idx Index,
+        seen: &mut FxHashSet<&'idx str>,
+    ) -> Vec<&'idx PouIndexEntry> {
+        self.get_derived_interfaces(index)
+            .iter()
+            .filter_map(|it| it.as_ref().ok())
+            .flat_map(|it| {
+                if !seen.contains(it.get_name()) {
+                    it.get_methods_recursive(index, seen)
+                } else {
+                    vec![]
+                }
+            })
+            .collect()
+    }
 }
 
 impl std::fmt::Debug for InterfaceIndexEntry {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("InterfaceIndexEntry")
-            .field("name", &self.name)
+            .field("name", &self.get_name())
             .field("methods", &self.methods)
+            .field("extensions", &self.extensions)
             .finish()
     }
 }
 
 impl From<&Interface> for InterfaceIndexEntry {
     fn from(interface: &Interface) -> Self {
         InterfaceIndexEntry {
-            name: interface.name.clone(),
+            identifier: interface.identifier.clone(),
             location: interface.location.clone(),
-            location_name: interface.location_name.clone(),
             methods: interface.methods.iter().map(|method| method.name.clone()).collect(),
+            extensions: interface.extensions.clone(),
         }
     }
 }
@@ -574,15 +643,16 @@ pub enum PouIndexEntry {
     },
     Method {
         name: String,
-        parent_pou_name: String,
+        parent_name: String,
+        declaration_kind: DeclarationKind,
         return_type: String,
         instance_struct_name: String,
         linkage: LinkageType,
         location: SourceLocation,
     },
     Action {
         name: String,
-        parent_pou_name: String,
+        parent_name: String,
         instance_struct_name: String,
         linkage: LinkageType,
         location: SourceLocation,
@@ -693,7 +763,7 @@ impl PouIndexEntry {
     ) -> PouIndexEntry {
         PouIndexEntry::Action {
             name: qualified_name.into(),
-            parent_pou_name: pou_name.into(),
+            parent_name: pou_name.into(),
             instance_struct_name: pou_name.into(),
             linkage,
             location,
@@ -729,12 +799,14 @@ impl PouIndexEntry {
         name: &str,
         return_type: &str,
         owner_class: &str,
+        declaration_kind: DeclarationKind,
         linkage: LinkageType,
         location: SourceLocation,
     ) -> PouIndexEntry {
         PouIndexEntry::Method {
             name: name.into(),
-            parent_pou_name: owner_class.into(),
+            parent_name: owner_class.into(),
+            declaration_kind,
             instance_struct_name: name.into(),
             return_type: return_type.into(),
             linkage,
@@ -775,14 +847,21 @@ impl PouIndexEntry {
 
     pub fn get_parent_pou_name(&self) -> Option<&str> {
         match self {
-            PouIndexEntry::Method { parent_pou_name, .. } | PouIndexEntry::Action { parent_pou_name, .. } => {
-                Some(parent_pou_name.as_str())
+            PouIndexEntry::Method { parent_name, .. } | PouIndexEntry::Action { parent_name, .. } => {
+                Some(parent_name.as_str())
             }
 
             _ => None,
         }
     }
 
+    pub fn get_declaration_kind(&self) -> Option<DeclarationKind> {
+        match self {
+            PouIndexEntry::Method { declaration_kind, .. } => Some(*declaration_kind),
+            _ => None,
+        }
+    }
+
     /// returns the name of the struct-type used to store the POUs state
     /// (interface-variables)
     pub fn get_instance_struct_type_name(&self) -> Option<&str> {
@@ -819,8 +898,8 @@ impl PouIndexEntry {
             | PouIndexEntry::FunctionBlock { .. }
             | PouIndexEntry::Class { .. }
             | PouIndexEntry::Function { .. } => self.get_name(),
-            PouIndexEntry::Action { parent_pou_name, .. } | PouIndexEntry::Method { parent_pou_name, .. } => {
-                parent_pou_name.as_str()
+            PouIndexEntry::Action { parent_name, .. } | PouIndexEntry::Method { parent_name, .. } => {
+                parent_name.as_str()
             }
         }
     }
@@ -1925,11 +2004,11 @@ impl Index {
 
     /// Returns all methods declared on container, or its parents.
     /// If a method is declared in the container the parent method is not included
-    pub fn find_methods(&self, container: &str) -> Vec<&PouIndexEntry> {
-        self.find_method_recursive(container, vec![], &mut FxHashSet::default())
+    pub fn get_methods(&self, container: &str) -> Vec<&PouIndexEntry> {
+        self.get_methods_recursive(container, vec![], &mut FxHashSet::default())
     }
 
-    fn find_method_recursive<'b>(
+    fn get_methods_recursive<'b>(
         &'b self,
         container: &str,
         current_methods: Vec<&'b PouIndexEntry>,
@@ -1952,7 +2031,7 @@ impl Index {
                 if !seen.insert(super_class) {
                     return res;
                 };
-                self.find_method_recursive(super_class, res, seen)
+                self.get_methods_recursive(super_class, res, seen)
             } else {
                 res
             }

src/index/indexer.rs

@@ -67,6 +67,8 @@ impl AstVisitor for SymbolIndexer {
             self.visit_pou(method);
         }
 
-        self.index.interfaces.insert(interface.name.clone(), InterfaceIndexEntry::from(interface));
+        self.index
+            .interfaces
+            .insert(interface.identifier.name.to_owned(), InterfaceIndexEntry::from(interface));
     }
 }