refactor: Introducing new Visitor pattern in linter

Author: ngeor

rusty_linter/src/core/mod.rs

@@ -8,6 +8,7 @@ mod traits;
 mod type_resolver;
 mod type_resolver_impl;
 mod types;
+mod visitor;
 
 pub use self::casting::*;
 pub use self::const_value_resolver::*;
@@ -19,3 +20,4 @@ pub use self::traits::*;
 pub use self::type_resolver::*;
 pub use self::type_resolver_impl::*;
 pub use self::types::*;
+pub use self::visitor::*;

rusty_linter/src/core/visitor.rs

@@ -0,0 +1,60 @@
+use rusty_common::{Position, Positioned};
+use rusty_parser::*;
+
+use crate::LintErrorPos;
+
+pub type VisitResult = Result<(), LintErrorPos>;
+
+pub trait Visitor<T> {
+    fn visit(&mut self, element: &T) -> VisitResult;
+}
+
+pub trait PosVisitor {
+    fn set_pos(&mut self, pos: Position);
+}
+
+impl<P, T> Visitor<Vec<T>> for P
+where
+    P: Visitor<T>,
+{
+    fn visit(&mut self, elements: &Vec<T>) -> VisitResult {
+        for element in elements {
+            self.visit(element)?;
+        }
+        Ok(())
+    }
+}
+
+impl<P, T> Visitor<Positioned<T>> for P
+where
+    P: Visitor<T> + PosVisitor,
+{
+    fn visit(&mut self, element: &Positioned<T>) -> VisitResult {
+        let Positioned { element, pos } = element;
+        self.set_pos(*pos);
+        self.visit(element)
+    }
+}
+
+impl<P> Visitor<GlobalStatement> for P
+where
+    P: Visitor<DefType>
+        + Visitor<FunctionDeclaration>
+        + Visitor<FunctionImplementation>
+        + Visitor<Statement>
+        + Visitor<SubDeclaration>
+        + Visitor<SubImplementation>
+        + Visitor<UserDefinedType>,
+{
+    fn visit(&mut self, element: &GlobalStatement) -> VisitResult {
+        match element {
+            GlobalStatement::DefType(def_type) => self.visit(def_type),
+            GlobalStatement::FunctionDeclaration(f) => self.visit(f),
+            GlobalStatement::FunctionImplementation(f) => self.visit(f),
+            GlobalStatement::Statement(statement) => self.visit(statement),
+            GlobalStatement::SubDeclaration(s) => self.visit(s),
+            GlobalStatement::SubImplementation(s) => self.visit(s),
+            GlobalStatement::UserDefinedType(user_defined_type) => self.visit(user_defined_type),
+        }
+    }
+}

rusty_linter/src/pre_linter/main.rs

@@ -1,5 +1,8 @@
 use crate::core::IntoTypeQualifier;
+use crate::core::PosVisitor;
 use crate::core::TypeResolverImpl;
+use crate::core::VisitResult;
+use crate::core::Visitor;
 use crate::core::{LintError, LintErrorPos};
 use crate::core::{LintResult, ResolvedParamType};
 use crate::pre_linter::const_rules::global_const;
@@ -26,7 +29,7 @@ pub fn pre_lint_program(program: &Program) -> Result<PreLinterResult, LintErrorP
         global_constants: Default::default(),
         declaration_pos: Position::start(),
     };
-    ctx.on_program(program)?;
+    <MainContext as Visitor<Program>>::visit(&mut ctx, program)?;
     ctx.functions.post_visit()?;
     ctx.subs.post_visit()?;
     Ok(PreLinterResult::new(
@@ -42,41 +45,70 @@ pub fn pre_lint_program(program: &Program) -> Result<PreLinterResult, LintErrorP
 // FUNCTION/SUB -> depends on resolver for resolving bare names and on user_defined_types to ensure types exist
 
 impl MainContext {
-    fn on_program(&mut self, program: &Program) -> Result<(), LintErrorPos> {
-        for Positioned { element, pos } in program {
-            self.declaration_pos = *pos;
-            match element {
-                GlobalStatement::DefType(def_type) => {
-                    self.on_def_type(def_type);
-                }
-                GlobalStatement::FunctionDeclaration(f) => {
-                    self.on_function_declaration(f)?;
-                }
-                GlobalStatement::FunctionImplementation(f) => {
-                    self.on_function_implementation(f)?;
-                }
-                GlobalStatement::Statement(s) => {
-                    self.on_statement(s)?;
-                }
-                GlobalStatement::SubDeclaration(s) => {
-                    self.on_sub_declaration(s)?;
-                }
-                GlobalStatement::SubImplementation(s) => {
-                    self.on_sub_implementation(s)?;
-                }
-                GlobalStatement::UserDefinedType(user_defined_type) => {
-                    self.on_user_defined_type(user_defined_type, *pos)?;
+    fn on_parameters(&self, parameters: &Parameters) -> Result<ResolvedParamTypes, LintErrorPos> {
+        parameters
+            .iter()
+            .map(|p| self.on_parameter_pos(p))
+            .collect()
+    }
+
+    fn on_parameter_pos(
+        &self,
+        parameter_pos: &ParameterPos,
+    ) -> Result<ResolvedParamType, LintErrorPos> {
+        self.on_parameter(&parameter_pos.element)
+            .with_err_at(parameter_pos)
+    }
+
+    fn on_parameter(&self, parameter: &Parameter) -> Result<ResolvedParamType, LintError> {
+        self.resolve_param_type(&parameter.bare_name, &parameter.var_type)
+    }
+
+    fn resolve_param_type(
+        &self,
+        bare_name: &BareName,
+        param_type: &ParamType,
+    ) -> Result<ResolvedParamType, LintError> {
+        match param_type {
+            ParamType::Bare => {
+                let q = bare_name.qualify(&self.resolver);
+                Ok(ResolvedParamType::BuiltIn(q, BuiltInStyle::Compact))
+            }
+            ParamType::BuiltIn(q, built_in_style) => {
+                Ok(ResolvedParamType::BuiltIn(*q, *built_in_style))
+            }
+            ParamType::UserDefined(u) => {
+                let type_name: &BareName = &u.element;
+                if self.user_defined_types.contains_key(type_name) {
+                    Ok(ResolvedParamType::UserDefined(type_name.clone()))
+                } else {
+                    Err(LintError::TypeNotDefined)
                 }
             }
+            ParamType::Array(element_type) => {
+                let element_param_type =
+                    self.resolve_param_type(bare_name, element_type.as_ref())?;
+                Ok(ResolvedParamType::Array(Box::new(element_param_type)))
+            }
         }
-        Ok(())
     }
+}
+
+impl PosVisitor for MainContext {
+    fn set_pos(&mut self, pos: Position) {
+        self.declaration_pos = pos;
+    }
+}
 
-    fn on_def_type(&mut self, def_type: &DefType) {
+impl Visitor<DefType> for MainContext {
+    fn visit(&mut self, def_type: &DefType) -> VisitResult {
         self.resolver.set(def_type);
+        Ok(())
     }
+}
 
-    fn on_function_declaration(&mut self, f: &FunctionDeclaration) -> Result<(), LintErrorPos> {
+impl Visitor<FunctionDeclaration> for MainContext {
+    fn visit(&mut self, f: &FunctionDeclaration) -> VisitResult {
         let FunctionDeclaration {
             name,
             parameters: params,
@@ -88,11 +120,10 @@ impl MainContext {
             .add_declaration(bare_name, signature, self.declaration_pos)
             .with_err_at(name)
     }
+}
 
-    fn on_function_implementation(
-        &mut self,
-        f: &FunctionImplementation,
-    ) -> Result<(), LintErrorPos> {
+impl Visitor<FunctionImplementation> for MainContext {
+    fn visit(&mut self, f: &FunctionImplementation) -> VisitResult {
         let FunctionImplementation { name, params, .. } = f;
         let param_types: ResolvedParamTypes = self.on_parameters(params)?;
         let bare_name = name.element.bare_name();
@@ -101,15 +132,10 @@ impl MainContext {
             .add_implementation(bare_name, signature, self.declaration_pos)
             .with_err_at(name)
     }
+}
 
-    fn on_statement(&mut self, s: &Statement) -> Result<(), LintErrorPos> {
-        match s {
-            Statement::Const(name, expr) => self.on_const(name, expr),
-            _ => Ok(()),
-        }
-    }
-
-    fn on_sub_declaration(&mut self, s: &SubDeclaration) -> Result<(), LintErrorPos> {
+impl Visitor<SubDeclaration> for MainContext {
+    fn visit(&mut self, s: &SubDeclaration) -> VisitResult {
         let SubDeclaration {
             name,
             parameters: params,
@@ -121,8 +147,10 @@ impl MainContext {
             .add_declaration(bare_name, signature, self.declaration_pos)
             .with_err_at(name)
     }
+}
 
-    fn on_sub_implementation(&mut self, s: &SubImplementation) -> Result<(), LintErrorPos> {
+impl Visitor<SubImplementation> for MainContext {
+    fn visit(&mut self, s: &SubImplementation) -> VisitResult {
         let SubImplementation { name, params, .. } = s;
         let param_types: ResolvedParamTypes = self.on_parameters(params)?;
         let bare_name = &name.element;
@@ -131,69 +159,24 @@ impl MainContext {
             .add_implementation(bare_name, signature, self.declaration_pos)
             .with_err_at(name)
     }
+}
 
-    fn on_user_defined_type(
-        &mut self,
-        user_defined_type: &UserDefinedType,
-        pos: Position,
-    ) -> Result<(), LintErrorPos> {
+impl Visitor<Statement> for MainContext {
+    fn visit(&mut self, s: &Statement) -> VisitResult {
+        match s {
+            Statement::Const(name, expr) => global_const(&mut self.global_constants, name, expr),
+            _ => Ok(()),
+        }
+    }
+}
+
+impl Visitor<UserDefinedType> for MainContext {
+    fn visit(&mut self, user_defined_type: &UserDefinedType) -> VisitResult {
         super::user_defined_type_rules::user_defined_type(
             &mut self.user_defined_types,
             &self.global_constants,
             user_defined_type,
-            pos,
+            self.declaration_pos,
         )
     }
-
-    fn on_const(&mut self, name: &NamePos, expr: &ExpressionPos) -> Result<(), LintErrorPos> {
-        global_const(&mut self.global_constants, name, expr)
-    }
-
-    fn on_parameters(&self, parameters: &Parameters) -> Result<ResolvedParamTypes, LintErrorPos> {
-        parameters
-            .iter()
-            .map(|p| self.on_parameter_pos(p))
-            .collect()
-    }
-
-    fn on_parameter_pos(
-        &self,
-        parameter_pos: &ParameterPos,
-    ) -> Result<ResolvedParamType, LintErrorPos> {
-        self.on_parameter(&parameter_pos.element)
-            .with_err_at(parameter_pos)
-    }
-
-    fn on_parameter(&self, parameter: &Parameter) -> Result<ResolvedParamType, LintError> {
-        self.resolve_param_type(&parameter.bare_name, &parameter.var_type)
-    }
-
-    fn resolve_param_type(
-        &self,
-        bare_name: &BareName,
-        param_type: &ParamType,
-    ) -> Result<ResolvedParamType, LintError> {
-        match param_type {
-            ParamType::Bare => {
-                let q = bare_name.qualify(&self.resolver);
-                Ok(ResolvedParamType::BuiltIn(q, BuiltInStyle::Compact))
-            }
-            ParamType::BuiltIn(q, built_in_style) => {
-                Ok(ResolvedParamType::BuiltIn(*q, *built_in_style))
-            }
-            ParamType::UserDefined(u) => {
-                let type_name: &BareName = &u.element;
-                if self.user_defined_types.contains_key(type_name) {
-                    Ok(ResolvedParamType::UserDefined(type_name.clone()))
-                } else {
-                    Err(LintError::TypeNotDefined)
-                }
-            }
-            ParamType::Array(element_type) => {
-                let element_param_type =
-                    self.resolve_param_type(bare_name, element_type.as_ref())?;
-                Ok(ResolvedParamType::Array(Box::new(element_param_type)))
-            }
-        }
-    }
 }