refactor: Combined all VarType* traits into one VarType trait

Author: ngeor

rusty_linter/src/converter/dim_rules/dim_type_rules.rs

@@ -28,7 +28,7 @@ pub fn on_dim_type(
     }
 }
 
-pub fn bare_to_dim_type<T: VarTypeNewBuiltInCompact>(
+pub fn bare_to_dim_type<T: VarType>(
     ctx: &mut Context,
     bare_name: &BareName,
     pos: Position,
@@ -61,7 +61,7 @@ fn require_compact_can_be_defined(
         })
 }
 
-pub fn built_in_to_dim_type<T: VarTypeNewBuiltInCompact + VarTypeNewBuiltInExtended>(
+pub fn built_in_to_dim_type<T: VarType>(
     ctx: &mut Context,
     bare_name: &BareName,
     q: TypeQualifier,
@@ -104,7 +104,7 @@ fn fixed_length_string_to_dim_type(
     ))
 }
 
-pub fn user_defined_to_dim_type<T: VarTypeNewUserDefined>(
+pub fn user_defined_to_dim_type<T: VarType>(
     ctx: &mut Context,
     bare_name: &BareName,
     user_defined_type: BareNamePos,

rusty_linter/src/converter/dim_rules/validation.rs

@@ -4,18 +4,15 @@ use crate::core::{HasSubprograms, HasUserDefinedTypes};
 use crate::core::{LintError, LintErrorPos};
 use crate::names::ManyNamesTrait;
 use rusty_common::{AtPos, Position, Positioned};
-use rusty_parser::{
-    DimVar, Parameter, TypedName, VarTypeIsExtended, VarTypeQualifier,
-    VarTypeToUserDefinedRecursively,
-};
+use rusty_parser::{DimVar, Parameter, TypedName, VarType};
 
 pub fn validate<T>(
     var_name: &TypedName<T>,
     ctx: &Context,
     pos: Position,
 ) -> Result<(), LintErrorPos>
 where
-    T: VarTypeIsExtended + VarTypeQualifier + VarTypeToUserDefinedRecursively,
+    T: VarType,
     TypedName<T>: CannotClashWithFunctions,
 {
     cannot_clash_with_subs(var_name, ctx, pos)?;
@@ -24,7 +21,7 @@ where
     cannot_clash_with_local_constants(var_name, ctx, pos)
 }
 
-fn cannot_clash_with_subs<T, C: HasSubprograms>(
+fn cannot_clash_with_subs<T: VarType, C: HasSubprograms>(
     var_name: &TypedName<T>,
     ctx: &C,
     pos: Position,
@@ -36,7 +33,7 @@ fn cannot_clash_with_subs<T, C: HasSubprograms>(
     }
 }
 
-fn cannot_clash_with_local_constants<T>(
+fn cannot_clash_with_local_constants<T: VarType>(
     var_name: &TypedName<T>,
     ctx: &Context,
     pos: Position,
@@ -98,7 +95,7 @@ fn user_defined_type_must_exist<T>(
     ctx: &Context,
 ) -> Result<(), LintErrorPos>
 where
-    T: VarTypeToUserDefinedRecursively,
+    T: VarType,
 {
     match var_name.var_type.as_user_defined_recursively() {
         Some(Positioned {

rusty_linter/src/names/names.rs

@@ -6,8 +6,7 @@ use crate::names::traits::ManyNamesTrait;
 use crate::{core::ConstLookup, names::ImplicitVars};
 use rusty_common::CaseInsensitiveString;
 use rusty_parser::{
-    BareName, BuiltInStyle, HasExpressionType, Name, QualifiedName, RedimInfo, TypeQualifier,
-    VarTypeIsExtended, VariableInfo,
+    BareName, BuiltInStyle, Name, QualifiedName, RedimInfo, TypeQualifier, VarType, VariableInfo,
 };
 use rusty_variant::Variant;
 
@@ -134,7 +133,7 @@ impl Names {
         self.get_const_value_recursively(bare_name).is_some()
     }
 
-    pub fn insert<T: HasExpressionType + VarTypeIsExtended>(
+    pub fn insert<T: VarType>(
         &mut self,
         bare_name: BareName,
         dim_type: &T,

rusty_linter/src/post_linter/dots_linter.rs

@@ -221,7 +221,7 @@ impl Visitor<Statement> for UserDefinedNamesCollector {
 
 impl<T> Visitor<TypedName<T>> for UserDefinedNamesCollector
 where
-    T: VarTypeToUserDefinedRecursively,
+    T: VarType,
 {
     fn visit(&mut self, element: &TypedName<T>) -> VisitResult {
         if element.var_type.as_user_defined_recursively().is_some() {

rusty_parser/src/specific/core/dim_name.rs

@@ -1,3 +1,4 @@
+use crate::specific::core::var_name;
 use crate::specific::*;
 use rusty_common::*;
 

rusty_parser/src/specific/core/dim_type.rs

@@ -1,8 +1,6 @@
 use crate::specific::{
     ArrayDimensions, BareNamePos, BuiltInStyle, Expression, ExpressionPos, ExpressionType,
-    HasExpressionType, TypeQualifier, VarTypeIsExtended, VarTypeNewBuiltInCompact,
-    VarTypeNewBuiltInExtended, VarTypeNewUserDefined, VarTypeQualifier, VarTypeToArray,
-    VarTypeToUserDefinedRecursively,
+    HasExpressionType, TypeQualifier, VarType,
 };
 use rusty_common::{AtPos, Position};
 
@@ -16,53 +14,36 @@ pub enum DimType {
     Array(ArrayDimensions, Box<Self>),
 }
 
-impl VarTypeNewBuiltInCompact for DimType {
+impl VarType for DimType {
     fn new_built_in_compact(q: TypeQualifier) -> Self {
         Self::BuiltIn(q, BuiltInStyle::Compact)
     }
-}
 
-impl VarTypeNewBuiltInExtended for DimType {
     fn new_built_in_extended(q: TypeQualifier) -> Self {
         Self::BuiltIn(q, BuiltInStyle::Extended)
     }
-}
-
-impl VarTypeToArray for DimType {
-    type ArrayType = ArrayDimensions;
 
-    fn to_array(self, array_type: Self::ArrayType) -> Self {
-        if array_type.is_empty() {
-            self
-        } else {
-            Self::Array(array_type, Box::new(self))
-        }
-    }
-}
-
-impl VarTypeNewUserDefined for DimType {
     fn new_user_defined(bare_name_pos: BareNamePos) -> Self {
         Self::UserDefined(bare_name_pos)
     }
-}
 
-impl VarTypeToUserDefinedRecursively for DimType {
     fn as_user_defined_recursively(&self) -> Option<&BareNamePos> {
         match self {
             Self::UserDefined(n) => Some(n),
             Self::Array(_, e) => e.as_user_defined_recursively(),
             _ => None,
         }
     }
-}
 
-impl DimType {
-    pub fn fixed_length_string(len: u16, pos: Position) -> Self {
-        Self::FixedLengthString(Expression::IntegerLiteral(len as i32).at_pos(pos), len)
+    fn to_qualifier_recursively(&self) -> Option<TypeQualifier> {
+        match self {
+            Self::BuiltIn(q, _) => Some(*q),
+            Self::FixedLengthString(_, _) => Some(TypeQualifier::DollarString),
+            Self::Array(_, e) => e.to_qualifier_recursively(),
+            _ => None,
+        }
     }
-}
 
-impl VarTypeIsExtended for DimType {
     fn is_extended(&self) -> bool {
         match self {
             Self::BuiltIn(_, BuiltInStyle::Extended)
@@ -74,6 +55,12 @@ impl VarTypeIsExtended for DimType {
     }
 }
 
+impl DimType {
+    pub fn fixed_length_string(len: u16, pos: Position) -> Self {
+        Self::FixedLengthString(Expression::IntegerLiteral(len as i32).at_pos(pos), len)
+    }
+}
+
 impl HasExpressionType for DimType {
     fn expression_type(&self) -> ExpressionType {
         match self {
@@ -87,14 +74,3 @@ impl HasExpressionType for DimType {
         }
     }
 }
-
-impl VarTypeQualifier for DimType {
-    fn to_qualifier_recursively(&self) -> Option<TypeQualifier> {
-        match self {
-            Self::BuiltIn(q, _) => Some(*q),
-            Self::FixedLengthString(_, _) => Some(TypeQualifier::DollarString),
-            Self::Array(_, e) => e.to_qualifier_recursively(),
-            _ => None,
-        }
-    }
-}

rusty_parser/src/specific/core/param_name.rs

@@ -1,4 +1,5 @@
 use crate::pc::*;
+use crate::specific::core::var_name;
 use crate::specific::pc_specific::*;
 use crate::specific::Keyword;
 use crate::specific::*;
@@ -19,72 +20,34 @@ pub enum ParamType {
     Array(Box<Self>),
 }
 
-impl VarTypeNewBuiltInCompact for ParamType {
+impl VarType for ParamType {
     fn new_built_in_compact(q: TypeQualifier) -> Self {
         Self::BuiltIn(q, BuiltInStyle::Compact)
     }
-}
-
-impl VarTypeNewBuiltInExtended for ParamType {
     fn new_built_in_extended(q: TypeQualifier) -> Self {
         Self::BuiltIn(q, BuiltInStyle::Extended)
     }
-}
 
-impl VarTypeToArray for ParamType {
-    type ArrayType = Option<(Token, Token)>;
-
-    fn to_array(self, array_type: Self::ArrayType) -> Self {
-        if array_type.is_none() {
-            self
-        } else {
-            Self::Array(Box::new(self))
-        }
-    }
-}
-
-impl VarTypeNewUserDefined for ParamType {
     fn new_user_defined(bare_name_pos: BareNamePos) -> Self {
         Self::UserDefined(bare_name_pos)
     }
-}
 
-impl VarTypeToUserDefinedRecursively for ParamType {
     fn as_user_defined_recursively(&self) -> Option<&BareNamePos> {
         match self {
             Self::UserDefined(n) => Some(n),
             Self::Array(e) => e.as_user_defined_recursively(),
             _ => None,
         }
     }
-}
 
-impl HasExpressionType for ParamType {
-    fn expression_type(&self) -> ExpressionType {
-        match self {
-            Self::BuiltIn(qualifier, _) => ExpressionType::BuiltIn(*qualifier),
-            Self::UserDefined(Positioned { element, .. }) => {
-                ExpressionType::UserDefined(element.clone())
-            }
-            Self::Array(boxed_element_type) => {
-                ExpressionType::Array(Box::new(boxed_element_type.expression_type()))
-            }
-            _ => ExpressionType::Unresolved,
-        }
-    }
-}
-
-impl VarTypeQualifier for ParamType {
     fn to_qualifier_recursively(&self) -> Option<TypeQualifier> {
         match self {
             Self::BuiltIn(q, _) => Some(*q),
             Self::Array(e) => e.to_qualifier_recursively(),
             _ => None,
         }
     }
-}
 
-impl VarTypeIsExtended for ParamType {
     fn is_extended(&self) -> bool {
         match self {
             Self::BuiltIn(_, BuiltInStyle::Extended) | Self::UserDefined(_) => true,
@@ -94,6 +57,21 @@ impl VarTypeIsExtended for ParamType {
     }
 }
 
+impl HasExpressionType for ParamType {
+    fn expression_type(&self) -> ExpressionType {
+        match self {
+            Self::BuiltIn(qualifier, _) => ExpressionType::BuiltIn(*qualifier),
+            Self::UserDefined(Positioned { element, .. }) => {
+                ExpressionType::UserDefined(element.clone())
+            }
+            Self::Array(boxed_element_type) => {
+                ExpressionType::Array(Box::new(boxed_element_type.expression_type()))
+            }
+            _ => ExpressionType::Unresolved,
+        }
+    }
+}
+
 /// Parses a Param name. Possible options:
 /// A
 /// A%