refactor: Remove complex nested context objects in linter converter

Removed the complex nested context objects in linter converter
(`pos_context`, `dim_list_state`, `expr_state`, etc)
that required explicit lifelines and were implementing Deref trait.

Introduced instead a `ConvertibleIn` trait which accepts the extra
information as a second parameter.

Author: ngeor

rusty_linter/src/converter/common/mod.rs

@@ -1,10 +1,8 @@
 mod context;
-mod pos_context;
 mod program_rules;
 mod traits;
 mod types;
 
 pub use self::context::*;
-pub use self::pos_context::*;
 pub use self::traits::*;
 pub use self::types::*;

rusty_linter/src/converter/common/pos_context.rs

@@ -1,11 +1,12 @@
 use crate::converter::common::Context;
 use crate::converter::common::Convertible;
-use crate::converter::common::PosContext;
+use crate::converter::common::ConvertibleIn;
 use crate::core::IntoQualified;
 use crate::core::LintErrorPos;
 use crate::core::SubprogramName;
 use crate::names::ImplicitVars;
-use rusty_common::{AtPos, HasPos, Positioned};
+use rusty_common::Position;
+use rusty_common::{AtPos, Positioned};
 use rusty_parser::{
     DimVar, FunctionImplementation, GlobalStatement, GlobalStatementPos, Program, Statement,
     Statements, SubImplementation,
@@ -37,8 +38,12 @@ impl Convertible for Program {
     }
 }
 
-impl<'a> Convertible<PosContext<'a>, Vec<GlobalStatementPos>> for GlobalStatement {
-    fn convert(self, ctx: &mut PosContext<'a>) -> Result<Vec<GlobalStatementPos>, LintErrorPos> {
+impl ConvertibleIn<Position, Vec<GlobalStatementPos>> for GlobalStatement {
+    fn convert_in(
+        self,
+        ctx: &mut Context,
+        pos: Position,
+    ) -> Result<Vec<GlobalStatementPos>, LintErrorPos> {
         match self {
             Self::DefType(def_type) => {
                 ctx.resolver.set(&def_type);
@@ -48,17 +53,17 @@ impl<'a> Convertible<PosContext<'a>, Vec<GlobalStatementPos>> for GlobalStatemen
             | Self::SubDeclaration(_, _)
             | Self::UserDefinedType(_) => Ok(vec![]),
             Self::FunctionImplementation(f) => on_function_implementation(f, ctx)
-                .map(|f| vec![Self::FunctionImplementation(f).at_pos(ctx.pos())]),
+                .map(|f| vec![Self::FunctionImplementation(f).at_pos(pos.clone())]),
             Self::SubImplementation(s) => on_sub_implementation(s, ctx)
-                .map(|s| vec![Self::SubImplementation(s).at_pos(ctx.pos())]),
-            Self::Statement(s) => on_statement(s, ctx),
+                .map(|s| vec![Self::SubImplementation(s).at_pos(pos.clone())]),
+            Self::Statement(s) => on_statement(s, ctx, pos.clone()),
         }
     }
 }
 
 fn on_function_implementation(
     function_implementation: FunctionImplementation,
-    ctx: &mut PosContext,
+    ctx: &mut Context,
 ) -> Result<FunctionImplementation, LintErrorPos> {
     let FunctionImplementation {
         name: Positioned {
@@ -92,7 +97,7 @@ fn on_function_implementation(
 
 fn on_sub_implementation(
     sub_implementation: SubImplementation,
-    ctx: &mut PosContext,
+    ctx: &mut Context,
 ) -> Result<SubImplementation, LintErrorPos> {
     let SubImplementation {
         name,
@@ -146,11 +151,12 @@ fn convert_block_hoisting_implicit_vars_and_pop_name_scope(
 
 fn on_statement(
     statement: Statement,
-    ctx: &mut PosContext,
+    ctx: &mut Context,
+    pos: Position,
 ) -> Result<Vec<GlobalStatementPos>, LintErrorPos> {
     // a statement might be converted into multiple statements due to implicit vars
-    let statements = vec![statement.at_pos(ctx.pos())];
-    let statements = statements.convert(ctx)?;
+    let statements = vec![statement.at_pos(pos)];
+    let statements: Statements = statements.convert(ctx)?;
     Ok(statements
         .into_iter()
         .map(|statement_pos| statement_pos.map(GlobalStatement::Statement))

rusty_linter/src/converter/common/program_rules.rs

@@ -1,54 +1,75 @@
 use crate::converter::common::Context;
 use crate::core::LintErrorPos;
 
-pub trait Convertible<C = Context, O = Self>: Sized {
-    fn convert(self, ctx: &mut C) -> Result<O, LintErrorPos>;
-
-    fn convert_in<'a, ParentContext, U>(
-        self,
-        parent_ctx: &'a mut ParentContext,
-        value: U,
-    ) -> Result<O, LintErrorPos>
-    where
-        C: FromParentContext<'a, ParentContext, U>,
-    {
-        let mut child_state = C::create_from_parent_context(parent_ctx, value);
-        self.convert(&mut child_state)
+/// Convert from the current type into the target type O.
+/// By default, O is the same as the current type.
+pub trait Convertible<O = Self>: Sized {
+    fn convert(self, ctx: &mut Context) -> Result<O, LintErrorPos>;
+}
+
+// Blanket implementation for Option
+
+impl<T, O> Convertible<Option<O>> for Option<T>
+where
+    T: Convertible<O>,
+{
+    fn convert(self, ctx: &mut Context) -> Result<Option<O>, LintErrorPos> {
+        match self {
+            Some(t) => t.convert(ctx).map(Some),
+            None => Ok(None),
+        }
+    }
+}
+
+// Blanket implementation for Vec
+
+impl<T, O> Convertible<Vec<O>> for Vec<T>
+where
+    T: Convertible<O>,
+{
+    fn convert(self, ctx: &mut Context) -> Result<Vec<O>, LintErrorPos> {
+        self.into_iter().map(|t| t.convert(ctx)).collect()
     }
+}
+
+/// Convert from the current type into the target type O,
+/// using additional information in the value U.
+/// By default, O is the same as the current type.
+pub trait ConvertibleIn<U, O = Self>: Sized {
+    fn convert_in(self, ctx: &mut Context, value: U) -> Result<O, LintErrorPos>;
 
-    fn convert_in_default<'a, ParentContext, U>(
-        self,
-        parent_ctx: &'a mut ParentContext,
-    ) -> Result<O, LintErrorPos>
+    fn convert_in_default(self, ctx: &mut Context) -> Result<O, LintErrorPos>
     where
-        C: FromParentContext<'a, ParentContext, U>,
         U: Default,
     {
-        self.convert_in(parent_ctx, U::default())
+        self.convert_in(ctx, U::default())
     }
 }
 
-impl<C, T> Convertible<C> for Option<T>
+// Blanket implementation for Option
+
+impl<U, T, O> ConvertibleIn<U, Option<O>> for Option<T>
 where
-    T: Convertible<C, T>,
+    T: ConvertibleIn<U, O>,
 {
-    fn convert(self, ctx: &mut C) -> Result<Self, LintErrorPos> {
+    fn convert_in(self, ctx: &mut Context, extra: U) -> Result<Option<O>, LintErrorPos> {
         match self {
-            Some(t) => t.convert(ctx).map(Some),
+            Some(t) => t.convert_in(ctx, extra).map(Some),
             None => Ok(None),
         }
     }
 }
 
-impl<C, T> Convertible<C> for Vec<T>
+// Blanket implementation for Vec
+
+impl<U, T, O> ConvertibleIn<U, Vec<O>> for Vec<T>
 where
-    T: Convertible<C, T>,
+    T: ConvertibleIn<U, O>,
+    U: Clone,
 {
-    fn convert(self, ctx: &mut C) -> Result<Self, LintErrorPos> {
-        self.into_iter().map(|t| t.convert(ctx)).collect()
+    fn convert_in(self, ctx: &mut Context, extra: U) -> Result<Vec<O>, LintErrorPos> {
+        self.into_iter()
+            .map(|t| t.convert_in(ctx, extra.clone()))
+            .collect()
     }
 }
-
-pub trait FromParentContext<'a, T, U> {
-    fn create_from_parent_context(parent: &'a mut T, value: U) -> Self;
-}

rusty_linter/src/converter/common/traits.rs

@@ -1,4 +1,5 @@
 //! Contains simple types and type aliases.
+use rusty_common::{Position, Positioned};
 
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub enum DimContext {
@@ -10,6 +11,12 @@ pub enum DimContext {
     Redim,
 }
 
+pub struct DimNameState {
+    pub dim_context: DimContext,
+    pub shared: bool,
+    pub pos: Position,
+}
+
 /// Indicates the context in which an expression is being resolved.
 #[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
 pub enum ExprContext {
@@ -26,3 +33,5 @@ pub enum ExprContext {
     /// Used in resolving left-side of property expressions
     ResolvingPropertyOwner,
 }
+
+pub type ExprContextPos = Positioned<ExprContext>;

rusty_linter/src/converter/common/types.rs

@@ -1,5 +1,6 @@
 use crate::converter::common::Context;
 use crate::converter::common::Convertible;
+use crate::converter::common::ConvertibleIn;
 use crate::core::LintErrorPos;
 use rusty_parser::ArrayDimension;