chore: Improve naming of ConstValueResolver for clarity

* Renamed `ConstValueResolver` to `ConstEvaluator`
* Renamed `resolve_const` to `eval_const`
* Renamed `get_resolved_constant` to `get_const_value`

Author: ngeor

rusty_linter/src/converter/statement/const_rules.rs

@@ -1,5 +1,5 @@
 use crate::converter::common::Context;
-use crate::core::ConstValueResolver;
+use crate::core::ConstEvaluator;
 use crate::core::{qualifier_of_const_variant, CastVariant, HasSubprograms, LintResult};
 use crate::core::{LintError, LintErrorPos};
 use rusty_common::*;
@@ -40,7 +40,7 @@ fn new_const(
         element: const_name,
         pos,
     } = left_side;
-    let value_before_casting = ctx.names.resolve_const(&right_side)?;
+    let value_before_casting = ctx.names.eval_const(&right_side)?;
     let value_qualifier = qualifier_of_const_variant(&value_before_casting);
     let final_value = if const_name.is_bare_or_of_type(value_qualifier) {
         value_before_casting

rusty_linter/src/core/const_value_resolver.rs

@@ -4,35 +4,37 @@ use rusty_parser::{AsBareName, Expression, ExpressionPos, Operator, TypeQualifie
 use rusty_variant::Variant;
 use std::cmp::Ordering;
 
+/// A lookup map of resolved constant values.
 pub trait ConstLookup {
-    fn get_resolved_constant(&self, name: &CaseInsensitiveString) -> Option<&Variant>;
+    /// Gets the value ([Variant]) of a constant.
+    fn get_const_value(&self, name: &CaseInsensitiveString) -> Option<&Variant>;
 }
 
-/// Resolves the value ([Variant]) of a `CONST` expression.
-pub trait ConstValueResolver<T> {
-    /// Resolves the value ([Variant]) of a `CONST` expression.
-    fn resolve_const(&self, item: &T) -> Result<Variant, LintErrorPos>;
+/// Evaluates the value ([Variant]) of a `CONST` expression.
+pub trait ConstEvaluator<T> {
+    /// Evaluates the value ([Variant]) of a `CONST` expression.
+    fn eval_const(&self, item: &T) -> Result<Variant, LintErrorPos>;
 }
 
-impl<S> ConstValueResolver<Positioned<&CaseInsensitiveString>> for S
+impl<S> ConstEvaluator<Positioned<&CaseInsensitiveString>> for S
 where
     S: ConstLookup,
 {
-    fn resolve_const(
+    fn eval_const(
         &self,
         item: &Positioned<&CaseInsensitiveString>,
     ) -> Result<Variant, LintErrorPos> {
-        self.get_resolved_constant(&item.element)
+        self.get_const_value(&item.element)
             .cloned()
             .ok_or(LintError::InvalidConstant.at_pos(item.pos))
     }
 }
 
-impl<S> ConstValueResolver<ExpressionPos> for S
+impl<S> ConstEvaluator<ExpressionPos> for S
 where
     S: ConstLookup,
 {
-    fn resolve_const(&self, item: &ExpressionPos) -> Result<Variant, LintErrorPos> {
+    fn eval_const(&self, item: &ExpressionPos) -> Result<Variant, LintErrorPos> {
         let Positioned {
             element: expression,
             pos,
@@ -46,7 +48,7 @@ where
             Expression::Variable(name_expr, _) => {
                 let bare_name = name_expr.as_bare_name();
                 let bare_name_pos = Positioned::new(bare_name, *pos);
-                let v = self.resolve_const(&bare_name_pos)?;
+                let v = self.eval_const(&bare_name_pos)?;
                 if let Some(qualifier) = name_expr.qualifier() {
                     let v_q = match v {
                         Variant::VDouble(_) => TypeQualifier::HashDouble,
@@ -68,8 +70,8 @@ where
                 }
             }
             Expression::BinaryExpression(op, left, right, _) => {
-                let v_left = self.resolve_const(left)?;
-                let v_right = self.resolve_const(right)?;
+                let v_left = self.eval_const(left)?;
+                let v_right = self.eval_const(right)?;
                 (match *op {
                     Operator::Less => v_left
                         .try_cmp(&v_right)
@@ -109,15 +111,15 @@ where
                 .map_err(|e| e.at(right))
             }
             Expression::UnaryExpression(op, child) => {
-                let v = self.resolve_const(child)?;
+                let v = self.eval_const(child)?;
                 (match *op {
                     UnaryOperator::Minus => v.negate(),
                     UnaryOperator::Not => v.unary_not(),
                 })
                 .map_err(LintError::from)
                 .map_err(|e| e.at(child))
             }
-            Expression::Parenthesis(child) => self.resolve_const(child),
+            Expression::Parenthesis(child) => self.eval_const(child),
             Expression::Property(_, _, _)
             | Expression::FunctionCall(_, _)
             | Expression::ArrayElement(_, _, _)
@@ -126,11 +128,11 @@ where
     }
 }
 
-impl<S> ConstValueResolver<Box<ExpressionPos>> for S
+impl<S> ConstEvaluator<Box<ExpressionPos>> for S
 where
     S: ConstLookup,
 {
-    fn resolve_const(&self, item: &Box<ExpressionPos>) -> Result<Variant, LintErrorPos> {
-        self.resolve_const(item.as_ref())
+    fn eval_const(&self, item: &Box<ExpressionPos>) -> Result<Variant, LintErrorPos> {
+        self.eval_const(item.as_ref())
     }
 }

rusty_linter/src/core/string_length.rs

@@ -38,7 +38,7 @@ impl<C: ConstLookup + ?Sized> ValidateStringLength<LintError, C> for Expression
                 }
 
                 if let Some(Variant::VInteger(i)) =
-                    const_lookup.get_resolved_constant(name.as_bare_name())
+                    const_lookup.get_const_value(name.as_bare_name())
                 {
                     if (1..=MAX_INTEGER).contains(i) {
                         return Ok(*i as u16);

rusty_linter/src/names/names.rs

@@ -243,7 +243,7 @@ impl Names {
 }
 
 impl ConstLookup for Names {
-    fn get_resolved_constant(&self, name: &CaseInsensitiveString) -> Option<&Variant> {
+    fn get_const_value(&self, name: &CaseInsensitiveString) -> Option<&Variant> {
         self.names().get_const_value(name).or_else(|| {
             self.global_names()
                 .and_then(|global_names| global_names.get_const_value(name))

rusty_linter/src/pre_linter/constant_map.rs

@@ -10,7 +10,7 @@ use crate::core::*;
 pub struct ConstantMap(HashMap<BareName, Variant>);
 
 impl ConstLookup for ConstantMap {
-    fn get_resolved_constant(&self, name: &CaseInsensitiveString) -> Option<&Variant> {
+    fn get_const_value(&self, name: &CaseInsensitiveString) -> Option<&Variant> {
         self.0.get(name)
     }
 }
@@ -20,7 +20,7 @@ impl Visitor<Constant> for ConstantMap {
     fn visit(&mut self, element: &Constant) -> VisitResult {
         let (name_pos, expression_pos) = element.into();
         self.ensure_is_not_already_defined(name_pos)
-            .and_then(|_| self.resolve_const(expression_pos))
+            .and_then(|_| self.eval_const(expression_pos))
             .and_then(|v| {
                 Self::cast_resolved_value_to_declared_type(v, &name_pos.element, expression_pos)
             })