refactor: Converted user_defined_type_rules to the visitor pattern

Author: ngeor

rusty_linter/src/core/string_length.rs

@@ -3,27 +3,25 @@ use rusty_common::Positioned;
 use rusty_parser::{Expression, TypeQualifier};
 use rusty_variant::{Variant, MAX_INTEGER};
 
-pub trait ValidateStringLength<E> {
-    fn validate_string_length(&self, const_lookup: &impl ConstLookup) -> Result<u16, E>;
+pub trait ValidateStringLength<E, C: ConstLookup + ?Sized> {
+    fn validate_string_length(&self, const_lookup: &C) -> Result<u16, E>;
 }
 
-impl<T, E> ValidateStringLength<Positioned<E>> for Positioned<T>
+impl<T, E, C> ValidateStringLength<Positioned<E>, C> for Positioned<T>
 where
-    T: ValidateStringLength<E>,
+    T: ValidateStringLength<E, C>,
+    C: ConstLookup + ?Sized,
 {
-    fn validate_string_length(
-        &self,
-        const_lookup: &impl ConstLookup,
-    ) -> Result<u16, Positioned<E>> {
+    fn validate_string_length(&self, const_lookup: &C) -> Result<u16, Positioned<E>> {
         let Positioned { element, pos } = self;
         element
             .validate_string_length(const_lookup)
             .map_err(|e| Positioned::new(e, *pos))
     }
 }
 
-impl ValidateStringLength<LintError> for Expression {
-    fn validate_string_length(&self, const_lookup: &impl ConstLookup) -> Result<u16, LintError> {
+impl<C: ConstLookup + ?Sized> ValidateStringLength<LintError, C> for Expression {
+    fn validate_string_length(&self, const_lookup: &C) -> Result<u16, LintError> {
         match self {
             Self::IntegerLiteral(i) => {
                 if (1..=MAX_INTEGER).contains(i) {

rusty_linter/src/core/visitor.rs

@@ -75,3 +75,7 @@ where
         }
     }
 }
+
+pub trait DelegateVisitor<T> {
+    fn delegate(&mut self) -> impl Visitor<T>;
+}

rusty_linter/src/pre_linter/main.rs

@@ -123,11 +123,16 @@ impl Visitor<Statement> for MainContext {
 
 impl Visitor<UserDefinedType> for MainContext {
     fn visit(&mut self, user_defined_type: &UserDefinedType) -> VisitResult {
-        super::user_defined_type_rules::user_defined_type(
+        self.delegate().visit(user_defined_type)
+    }
+}
+
+impl DelegateVisitor<UserDefinedType> for MainContext {
+    fn delegate(&mut self) -> impl Visitor<UserDefinedType> {
+        super::user_defined_type_visitor::UserDefinedTypeVisitor::new(
             &mut self.user_defined_types,
-            &self.global_constants,
-            user_defined_type,
             self.declaration_pos,
+            &self.global_constants,
         )
     }
 }

rusty_linter/src/pre_linter/mod.rs

@@ -2,7 +2,7 @@ mod constant_map;
 mod main;
 mod pre_linter_result;
 mod sub_program_context;
-mod user_defined_type_rules;
+mod user_defined_type_visitor;
 
 pub use self::constant_map::*;
 pub use self::main::*;

rusty_linter/src/pre_linter/user_defined_type_rules.rs

@@ -0,0 +1,92 @@
+use crate::core::LintError;
+use crate::core::{ConstLookup, ValidateStringLength, VisitResult, Visitor};
+use rusty_common::{AtPos, Position, Positioned};
+use rusty_parser::{
+    BareName, Element, ElementPos, ElementType, Expression, UserDefinedType, UserDefinedTypes,
+};
+use std::collections::HashMap;
+
+pub struct UserDefinedTypeVisitor<'a> {
+    user_defined_types: &'a mut UserDefinedTypes,
+    pos: Position,
+    const_lookup: &'a dyn ConstLookup,
+}
+
+impl<'a> UserDefinedTypeVisitor<'a> {
+    pub fn new(
+        user_defined_types: &'a mut UserDefinedTypes,
+        pos: Position,
+        const_lookup: &'a impl ConstLookup,
+    ) -> Self {
+        Self {
+            user_defined_types,
+            pos,
+            const_lookup,
+        }
+    }
+}
+
+impl<'a> Visitor<UserDefinedType> for UserDefinedTypeVisitor<'a> {
+    fn visit(&mut self, user_defined_type: &UserDefinedType) -> VisitResult {
+        let type_name: &BareName = user_defined_type.bare_name();
+        if self.user_defined_types.contains_key(type_name) {
+            // duplicate type definition
+            Err(LintError::DuplicateDefinition.at_pos(self.pos))
+        } else {
+            let mut resolved_elements: HashMap<BareName, ElementType> = HashMap::new();
+            for Positioned {
+                element:
+                    Element {
+                        name: element_name,
+                        element_type,
+                        ..
+                    },
+                pos,
+            } in user_defined_type.elements()
+            {
+                if resolved_elements.contains_key(element_name) {
+                    // duplicate element name within type
+                    return Err(LintError::DuplicateDefinition.at(pos));
+                }
+                let resolved_element_type = match element_type {
+                    ElementType::Integer => ElementType::Integer,
+                    ElementType::Long => ElementType::Long,
+                    ElementType::Single => ElementType::Single,
+                    ElementType::Double => ElementType::Double,
+                    ElementType::FixedLengthString(str_len_expression_pos, _) => {
+                        let l: u16 =
+                            str_len_expression_pos.validate_string_length(self.const_lookup)?;
+                        ElementType::FixedLengthString(
+                            Expression::IntegerLiteral(l as i32).at(str_len_expression_pos),
+                            l,
+                        )
+                    }
+                    ElementType::UserDefined(Positioned {
+                        element: referred_name,
+                        pos,
+                    }) => {
+                        if !self.user_defined_types.contains_key(referred_name) {
+                            return Err(LintError::TypeNotDefined.at(pos));
+                        }
+                        ElementType::UserDefined(referred_name.clone().at(pos))
+                    }
+                };
+                resolved_elements.insert(element_name.clone(), resolved_element_type);
+            }
+            let mut elements: Vec<ElementPos> = vec![];
+            for Positioned {
+                element: Element { name, .. },
+                pos,
+            } in user_defined_type.elements()
+            {
+                let converted_element_type = resolved_elements.remove(name).unwrap();
+                elements.push(Element::new(name.clone(), converted_element_type, vec![]).at(pos));
+            }
+            self.user_defined_types.insert(
+                type_name.clone(),
+                UserDefinedType::new(type_name.clone(), vec![], elements),
+            );
+            Ok(())
+        }
+    }
+}