fix: Use a struct ShallowVisitor instead of a trait to avoid

conflicting implementations

Author: ngeor

rusty_linter/src/core/visitor.rs

@@ -46,36 +46,59 @@ where
     }
 }
 
-/// Indicates a visitor that can visit global statements
+/// Creates a delegate visitor for the given type T.
+pub trait DelegateVisitor<T> {
+    fn delegate(&mut self) -> impl Visitor<T>;
+}
+
+/// A visitor that can visit global statements
 /// but does not enter the implementations of functions or subs.
-pub trait ShallowGlobalStatementVisitor:
-    Visitor<DefType>
-    + Visitor<FunctionDeclaration>
-    + Visitor<FunctionImplementation>
-    + Visitor<Statement>
-    + Visitor<SubDeclaration>
-    + Visitor<SubImplementation>
-    + Visitor<UserDefinedType>
+/// Actual visiting logic is handled by the delegate.
+pub struct ShallowVisitor<P> {
+    delegate: P,
+}
+
+impl<P> ShallowVisitor<P> {
+    pub fn new(delegate: P) -> Self {
+        Self { delegate }
+    }
+
+    /// Returns the delegate back.
+    pub fn delegate(self) -> P {
+        self.delegate
+    }
+}
+
+impl<P> SetPosition for ShallowVisitor<P>
+where
+    P: SetPosition,
 {
+    fn set_position(&mut self, pos: Position) {
+        self.delegate.set_position(pos);
+    }
 }
 
-impl<P> Visitor<GlobalStatement> for P
+impl<P> Visitor<GlobalStatement> for ShallowVisitor<P>
 where
-    P: ShallowGlobalStatementVisitor,
+    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),
+            GlobalStatement::DefType(def_type) => self.delegate.visit(def_type),
+            GlobalStatement::FunctionDeclaration(f) => self.delegate.visit(f),
+            GlobalStatement::FunctionImplementation(f) => self.delegate.visit(f),
+            GlobalStatement::Statement(statement) => self.delegate.visit(statement),
+            GlobalStatement::SubDeclaration(s) => self.delegate.visit(s),
+            GlobalStatement::SubImplementation(s) => self.delegate.visit(s),
+            GlobalStatement::UserDefinedType(user_defined_type) => {
+                self.delegate.visit(user_defined_type)
+            }
         }
     }
 }
-
-pub trait DelegateVisitor<T> {
-    fn delegate(&mut self) -> impl Visitor<T>;
-}

rusty_linter/src/pre_linter/main.rs

@@ -20,8 +20,9 @@ struct MainContext {
 }
 
 pub fn pre_lint_program(program: &Program) -> Result<PreLinterResult, LintErrorPos> {
-    let mut ctx = MainContext::default();
-    <MainContext as Visitor<Program>>::visit(&mut ctx, program)?;
+    let mut visitor = ShallowVisitor::new(MainContext::default());
+    visitor.visit(program)?;
+    let ctx = visitor.delegate();
     ctx.post_visit_functions()?;
     ctx.post_visit_subs()?;
     Ok(PreLinterResult::new(
@@ -131,8 +132,6 @@ impl DelegateVisitor<UserDefinedType> for MainContext {
     }
 }
 
-impl ShallowGlobalStatementVisitor for MainContext {}
-
 impl MainContext {
     fn on_parameters(&self, parameters: &Parameters) -> Result<ResolvedParamTypes, LintErrorPos> {
         parameters