refactor: Converted function validate_string_length into a trait

Author: ngeor

rusty_linter/src/converter/dim_rules/dim_type_rules.rs

@@ -1,7 +1,7 @@
 use crate::converter::common::DimNameState;
 use crate::converter::common::*;
-use crate::core::validate_string_length;
 use crate::core::IntoTypeQualifier;
+use crate::core::ValidateStringLength;
 use crate::core::{LintError, LintErrorPos};
 use rusty_common::*;
 use rusty_parser::*;
@@ -97,7 +97,7 @@ fn fixed_length_string_to_dim_type(
     length_expression: &ExpressionPos,
 ) -> Result<DimType, LintErrorPos> {
     require_extended_can_be_defined(ctx, bare_name, length_expression.pos)?;
-    let string_length: u16 = validate_string_length(length_expression, &ctx.names)?;
+    let string_length: u16 = length_expression.validate_string_length(&ctx.names)?;
     Ok(DimType::fixed_length_string(
         string_length,
         length_expression.pos(),

rusty_linter/src/converter/dim_rules/redim.rs

@@ -1,8 +1,8 @@
 use crate::converter::common::Context;
 use crate::converter::common::Convertible;
 use crate::converter::common::DimNameState;
-use crate::core::validate_string_length;
 use crate::core::IntoTypeQualifier;
+use crate::core::ValidateStringLength;
 use crate::core::{LintError, LintErrorPos};
 use rusty_common::*;
 use rusty_parser::*;
@@ -188,7 +188,7 @@ fn fixed_length_string_to_dim_type(
     array_dimensions: &ArrayDimensions,
     length_expression: &ExpressionPos,
 ) -> Result<DimType, LintErrorPos> {
-    let string_length: u16 = validate_string_length(length_expression, &ctx.names)?;
+    let string_length: u16 = length_expression.validate_string_length(&ctx.names)?;
     ctx.names
         .find_name_or_shared_in_parent(bare_name)
         .into_iter()

rusty_linter/src/core/string_length.rs

@@ -1,44 +1,55 @@
-use crate::core::{ConstLookup, LintResult};
-use crate::core::{LintError, LintErrorPos};
+use crate::core::{ConstLookup, LintError};
 use rusty_common::Positioned;
-use rusty_parser::{Expression, ExpressionPos, TypeQualifier};
+use rusty_parser::{Expression, TypeQualifier};
 use rusty_variant::{Variant, MAX_INTEGER};
 
-pub fn validate_string_length(
-    expr_pos: &ExpressionPos,
-    lookup: &impl ConstLookup,
-) -> Result<u16, LintErrorPos> {
-    let Positioned { element: expr, pos } = expr_pos;
-    do_validate_string_length(expr, lookup).with_err_at(pos)
+pub trait ValidateStringLength<E> {
+    fn validate_string_length(&self, const_lookup: &impl ConstLookup) -> Result<u16, E>;
 }
 
-fn do_validate_string_length(
-    expr: &Expression,
-    lookup: &impl ConstLookup,
-) -> Result<u16, LintError> {
-    match expr {
-        Expression::IntegerLiteral(i) => {
-            if (1..=MAX_INTEGER).contains(i) {
-                Ok(*i as u16)
-            } else {
-                Err(LintError::InvalidConstant)
-            }
-        }
-        Expression::Variable(name, _) => {
-            if let Some(qualifier) = name.qualifier() {
-                if qualifier != TypeQualifier::PercentInteger {
-                    return Err(LintError::InvalidConstant);
-                }
-            }
+impl<T, E> ValidateStringLength<Positioned<E>> for Positioned<T>
+where
+    T: ValidateStringLength<E>,
+{
+    fn validate_string_length(
+        &self,
+        const_lookup: &impl ConstLookup,
+    ) -> Result<u16, Positioned<E>> {
+        let Positioned { element, pos } = self;
+        element
+            .validate_string_length(const_lookup)
+            .map_err(|e| Positioned::new(e, *pos))
+    }
+}
 
-            if let Some(Variant::VInteger(i)) = lookup.get_resolved_constant(name.bare_name()) {
+impl ValidateStringLength<LintError> for Expression {
+    fn validate_string_length(&self, const_lookup: &impl ConstLookup) -> Result<u16, LintError> {
+        match self {
+            Self::IntegerLiteral(i) => {
                 if (1..=MAX_INTEGER).contains(i) {
-                    return Ok(*i as u16);
+                    Ok(*i as u16)
+                } else {
+                    Err(LintError::InvalidConstant)
                 }
             }
+            Self::Variable(name, _) => {
+                if let Some(qualifier) = name.qualifier() {
+                    if qualifier != TypeQualifier::PercentInteger {
+                        return Err(LintError::InvalidConstant);
+                    }
+                }
+
+                if let Some(Variant::VInteger(i)) =
+                    const_lookup.get_resolved_constant(name.bare_name())
+                {
+                    if (1..=MAX_INTEGER).contains(i) {
+                        return Ok(*i as u16);
+                    }
+                }
 
-            Err(LintError::InvalidConstant)
+                Err(LintError::InvalidConstant)
+            }
+            _ => Err(LintError::InvalidConstant),
         }
-        _ => Err(LintError::InvalidConstant),
     }
 }

rusty_linter/src/pre_linter/user_defined_type_rules.rs

@@ -1,4 +1,4 @@
-use crate::core::validate_string_length;
+use crate::core::ValidateStringLength;
 use crate::core::{LintError, LintErrorPos};
 use crate::pre_linter::ConstantMap;
 use rusty_common::{AtPos, Position, Positioned};
@@ -39,7 +39,7 @@ pub fn user_defined_type(
                 ElementType::Single => ElementType::Single,
                 ElementType::Double => ElementType::Double,
                 ElementType::FixedLengthString(str_len_expression_pos, _) => {
-                    let l: u16 = validate_string_length(str_len_expression_pos, global_constants)?;
+                    let l: u16 = str_len_expression_pos.validate_string_length(global_constants)?;
                     ElementType::FixedLengthString(
                         Expression::IntegerLiteral(l as i32).at(str_len_expression_pos),
                         l,