Add extends and import elements.

Signed-off-by: James Goppert <james.goppert@gmail.com>

Author: jgoppert

src/s1_parser/ast.rs

@@ -1,7 +1,6 @@
 use indexmap::IndexMap;
 use serde::{Deserialize, Serialize};
 use std::fmt;
-use std::hash::{Hash, Hasher};
 
 derive_alias! {
     #[derive(CommonTraits!)] = #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)];
@@ -108,23 +107,19 @@ pub struct ClassDefinition {
     pub node_data: NodeData,
     pub name: String,
     pub class_type: ClassType,
+    pub extends: Vec<TypeSpecifier>,
+    pub imports: Vec<ImportClause>,
     pub flags: ClassFlags,
     pub modification: Vec<Argument>,
     pub description: DescriptionString,
-    //pub composition: Vec<CompositionPart>,
     pub components: IndexMap<String, ComponentDeclaration>,
+    pub classes: IndexMap<String, ClassDefinition>,
     pub equations: Vec<Equation>,
     pub algorithms: Vec<Vec<Statement>>,
     pub initial_equations: Vec<Equation>,
     pub initial_algorithms: Vec<Vec<Statement>>,
 }
 
-impl Hash for ClassDefinition {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.node_data.id.hash(state);
-    }
-}
-
 #[derive(CommonTraits!, Default)]
 pub enum ClassSpecifier {
     #[default]
@@ -189,11 +184,12 @@ pub struct AlgorithmSection {
 }
 
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[allow(clippy::large_enum_variant)]
 pub enum Element {
     #[default]
     Empty,
     ClassDefinition(ClassDefinition),
-    ComponentClause(ComponentClause),
+    ComponentClause(Vec<ComponentDeclaration>),
     ExtendsClause(ExtendsClause),
     ImportClause(ImportClause),
 }
@@ -223,6 +219,12 @@ pub struct ExtendsClause {
 pub struct ComponentDeclaration {
     pub node_data: NodeData,
     pub name: String,
+    pub type_specifier: TypeSpecifier,
+    pub flags: ElementFlags,
+    pub connection: Connection,
+    pub variability: Variability,
+    pub causality: Causality,
+    pub visibility: Visibility,
     pub array_subscripts: Vec<Subscript>,
     pub modification: Option<Modification>,
     pub condition_attribute: Option<Expression>,
@@ -235,18 +237,6 @@ pub struct ClassPrefixes {
     pub class_type: ClassType,
 }
 
-#[derive(CommonTraits!, Default)]
-pub struct ComponentClause {
-    pub node_data: NodeData,
-    pub type_specifier: TypeSpecifier,
-    pub flags: ElementFlags,
-    pub connection: Connection,
-    pub variability: Variability,
-    pub causality: Causality,
-    pub array_subscripts: Vec<Subscript>,
-    pub components: Vec<ComponentDeclaration>,
-}
-
 #[derive(CommonTraits!, Default)]
 pub struct Declaration {
     pub node_data: NodeData,

src/s1_parser/modelica.lalrpop

@@ -204,6 +204,24 @@ pub ClassDefinition: ast::ClassDefinition = {
             match part {
                 ast::CompositionPart::ElementList(list) => {
                     for element in list.elements {
+                        match element {
+                            ast::Element::ImportClause(import) => {
+                                def.imports.push(import);
+                            }
+                            ast::Element::ExtendsClause(extends) => {
+                                def.extends.push(extends.type_specifier);
+                            }
+                            ast::Element::ClassDefinition(class) => {
+                                def.classes.insert(class.name.clone(), class);
+                            }
+                            ast::Element::ComponentClause(components) => {
+                                for mut comp in components {
+                                    comp.visibility = list.visibility.clone();
+                                    def.components.insert(comp.name.clone(), comp);
+                                }
+                            }
+                            ast::Element::Empty => {}
+                        }
                     }
                 },
                 ast::CompositionPart::AlgorithmSection(sec) => {
@@ -423,30 +441,33 @@ pub ElementFlags : ast::ElementFlags = {
 }
 
 pub Element : ast::Element = {
-    <elem: ComponentClause> => ast::Element::ComponentClause(elem),
+    <elem: ElementComponentClause> => ast::Element::ComponentClause(elem),
     <elem: ClassDefinition> => ast::Element::ClassDefinition(elem),
     <elem: ExtendsClause> => ast::Element::ExtendsClause(elem),
 }
 
-pub ElementComponentClause : ast::ComponentClause = {
-    <left: @L> <flags: ElementFlags> <clause: ComponentClause> <right: @R> => {
-        let mut res = clause;
-        res.flags = flags;
-        res.node_data.span = (left, right);
-        res
+pub ElementComponentClause : Vec<ast::ComponentDeclaration> = {
+    <left: @L> <flags: ElementFlags> <mut components: ComponentClause> <right: @R> => {
+        for comp in &mut components {
+            comp.flags.replaceable |= flags.replaceable;
+            comp.flags.redeclare |= flags.redeclare;
+            comp.flags.is_final |= flags.is_final;
+            comp.flags.inner |= flags.inner;
+            comp.flags.outer |= flags.outer;
+        }
+        components
     },
 }
 
 pub ElementClassDefinition : ast::ClassDefinition = {
-    <left: @L> <flags: ElementFlags> <def: ClassDefinition> <right: @R>  => {
-        let mut res = def;
-        res.flags.redeclare = flags.redeclare;
-        res.flags.is_final = flags.is_final;
-        res.flags.inner = flags.inner;
-        res.flags.outer = flags.outer;
-        res.flags.replaceable = flags.replaceable;
-        res.node_data.span = (left, right);
-        res
+    <left: @L> <flags: ElementFlags> <mut def: ClassDefinition> <right: @R>  => {
+        def.flags.redeclare |= flags.redeclare;
+        def.flags.is_final |= flags.is_final;
+        def.flags.inner |= flags.inner;
+        def.flags.outer |= flags.outer;
+        def.flags.replaceable |= flags.replaceable;
+        def.node_data.span = (left, right);
+        def
     },
 }
 
@@ -532,22 +553,21 @@ pub ExtendsClause: ast::ExtendsClause = {
 
 //✅ component-clause :
 //✅    type-prefix type-specifier [ array-subscripts ] component-list
-pub ComponentClause: ast::ComponentClause = {
-    <left: @L> <type_prefix: TypePrefix>
+pub ComponentClause: Vec<ast::ComponentDeclaration> = {
+    <type_prefix: TypePrefix>
     <type_specifier: TypeSpecifier>
     <array_subscripts: ArraySubscripts?>
-    <components: ComponentList> <right: @R> => {
-        let id = context.new_id();
-        ast::ComponentClause {
-            node_data: NodeData::new(id, left, right),
-            type_specifier,
-            flags: ast::ElementFlags::default(),
-            connection: type_prefix.connection,
-            variability: type_prefix.variability,
-            causality: type_prefix.causality, 
-            array_subscripts: array_subscripts.unwrap_or(Vec::new()),
-            components,
+    <mut components: ComponentList> => {
+        for comp in &mut components {
+            comp.type_specifier = type_specifier.clone();
+            comp.causality = type_prefix.causality.clone();
+            comp.variability = type_prefix.variability.clone();
+            comp.connection = type_prefix.connection.clone();
+            if let Some(ref subs) = array_subscripts {
+                comp.array_subscripts = subs.clone();
+            }
         }
+        components
     }
 }
 
@@ -602,6 +622,7 @@ pub ComponentDeclaration: ast::ComponentDeclaration = {
             modification: declaration.modification,
             condition_attribute,
             description,
+            ..Default::default()
         }
     }
 }
@@ -707,21 +728,16 @@ pub Argument: ast::Argument = {
 
 //✅ component-clause1 :
 //✅    type-prefix type-specifier component-declaration1
-pub ComponentClause1: ast::ComponentClause = {
-    <left: @L> <type_prefix: TypePrefix>
+pub ComponentClause1: ast::ComponentDeclaration = {
+    <type_prefix: TypePrefix>
     <type_specifier: TypeSpecifier>
-    <component_declaration1: ComponentDeclaration1> <right: @R> => {
-        let id = context.new_id();
-        ast::ComponentClause {
-            node_data: NodeData::new(id, left, right),
-            type_specifier,
-            flags: ast::ElementFlags::default(),
-            connection: type_prefix.connection,
-            variability: type_prefix.variability,
-            causality: type_prefix.causality, 
-            array_subscripts: Vec::new(),
-            components: vec![component_declaration1],
-        }
+    <component_declaration1: ComponentDeclaration1> => {
+        let mut comp = component_declaration1;
+        comp.type_specifier = type_specifier;
+        comp.causality = type_prefix.causality;
+        comp.variability = type_prefix.variability;
+        comp.connection = type_prefix.connection;
+        comp
     }
 }
 
@@ -738,6 +754,7 @@ pub ComponentDeclaration1: ast::ComponentDeclaration = {
             modification: declaration.modification,
             condition_attribute: None,
             description,
+            ..Default::default()
         }
     }
 }