refactor: Made fields of TypedName private

ngeor · ngeor · commit 7bd3ce05d2c4 · 2025-12-27T14:08:01.000+01:00
diff --git a/rusty_basic/src/instruction_generator/dim.rs b/rusty_basic/src/instruction_generator/dim.rs
@@ -55,10 +55,7 @@ impl InstructionGenerator {
     }
 
     fn generate_dim_name(&mut self, dim_name: DimVar, shared: bool, pos: Position) {
-        let DimVar {
-            bare_name,
-            var_type: dim_type,
-        } = dim_name;
+        let (bare_name, dim_type) = dim_name.into();
         match dim_type {
             DimType::Array(array_dimensions, box_element_type) => {
                 self.push(Instruction::BeginCollectArguments, pos);
diff --git a/rusty_basic/src/interpreter/variables.rs b/rusty_basic/src/interpreter/variables.rs
@@ -59,10 +59,7 @@ impl Variables {
     }
 
     fn param_to_name(param_name: Parameter) -> Name {
-        let Parameter {
-            bare_name,
-            var_type: param_type,
-        } = param_name;
+        let (bare_name, param_type) = param_name.into();
         match param_type {
             ParamType::Bare => panic!("Unresolved param {:?}", bare_name),
             ParamType::BuiltIn(q, _) => Name::Qualified(bare_name, q),
@@ -79,10 +76,7 @@ impl Variables {
     }
 
     pub fn insert_dim(&mut self, dim_name: DimVar, value: Variant) {
-        let DimVar {
-            bare_name,
-            var_type: dim_type,
-        } = dim_name;
+        let (bare_name, dim_type) = dim_name.into();
         self.insert_dim_internal(bare_name, dim_type, value);
     }
 
@@ -177,7 +171,7 @@ impl Variables {
     }
 
     pub fn get_by_dim_name(&self, dim_name: &DimVar) -> Option<&Variant> {
-        self.get_by_dim_name_internal(&dim_name.bare_name, &dim_name.var_type)
+        self.get_by_dim_name_internal(dim_name.bare_name(), dim_name.var_type())
     }
 
     fn get_by_dim_name_internal(
diff --git a/rusty_common/src/positioned.rs b/rusty_common/src/positioned.rs
@@ -28,6 +28,14 @@ impl<T> Positioned<T> {
             pos,
         }
     }
+
+    pub fn try_map<F, U, E>(self, op: F) -> Result<Positioned<U>, E>
+    where
+        F: FnOnce(T) -> Result<U, E>,
+    {
+        let Self { element, pos } = self;
+        op(element).map(|new_element| Positioned::new(new_element, pos))
+    }
 }
 
 // AtPos
diff --git a/rusty_linter/src/converter/dim_rules/dim_rules.rs b/rusty_linter/src/converter/dim_rules/dim_rules.rs
@@ -35,10 +35,7 @@ impl ConvertibleIn<DimNameState> for DimVar {
         validation::validate(&self, ctx, extra.pos)?;
         let shared = extra.shared;
         shared_illegal_in_sub_function(ctx, shared, extra.pos)?;
-        let Self {
-            bare_name,
-            var_type,
-        } = self;
+        let (bare_name, var_type) = self.into();
         let (var_type, redim_info) = if extra.dim_context == DimContext::Redim {
             on_redim_type(var_type, &bare_name, ctx, extra)?
         } else {
diff --git a/rusty_linter/src/converter/dim_rules/param_rules.rs b/rusty_linter/src/converter/dim_rules/param_rules.rs
@@ -9,10 +9,7 @@ use rusty_parser::Parameter;
 impl ConvertibleIn<Position> for Parameter {
     fn convert_in(self, ctx: &mut Context, pos: Position) -> Result<Self, LintErrorPos> {
         validation::validate(&self, ctx, pos)?;
-        let Self {
-            bare_name,
-            var_type,
-        } = self;
+        let (bare_name, var_type) = self.into();
         let var_type = on_param_type(var_type, &bare_name, ctx, pos)?;
         ctx.names.insert(bare_name.clone(), &var_type, false, None);
         Ok(Self::new(bare_name, var_type))
diff --git a/rusty_linter/src/converter/dim_rules/validation.rs b/rusty_linter/src/converter/dim_rules/validation.rs
@@ -26,7 +26,7 @@ fn cannot_clash_with_subs<T: VarType, C: HasSubprograms>(
     ctx: &C,
     pos: Position,
 ) -> Result<(), LintErrorPos> {
-    if ctx.subs().contains_key(&var_name.bare_name) {
+    if ctx.subs().contains_key(var_name.bare_name()) {
         Err(LintError::DuplicateDefinition.at_pos(pos))
     } else {
         Ok(())
@@ -38,7 +38,7 @@ fn cannot_clash_with_local_constants<T: VarType>(
     ctx: &Context,
     pos: Position,
 ) -> Result<(), LintErrorPos> {
-    match ctx.names.names().get_const_value(&var_name.bare_name) {
+    match ctx.names.names().get_const_value(var_name.bare_name()) {
         Some(_) => Err(LintError::DuplicateDefinition.at_pos(pos)),
         _ => Ok(()),
     }
@@ -55,7 +55,7 @@ impl CannotClashWithFunctions for DimVar {
         ctx: &Context,
         pos: Position,
     ) -> Result<(), LintErrorPos> {
-        if ctx.functions().contains_key(&self.bare_name) {
+        if ctx.functions().contains_key(self.bare_name()) {
             Err(LintError::DuplicateDefinition.at_pos(pos))
         } else {
             Ok(())
@@ -69,15 +69,15 @@ impl CannotClashWithFunctions for Parameter {
         ctx: &Context,
         pos: Position,
     ) -> Result<(), LintErrorPos> {
-        if let Some(func_qualifier) = ctx.function_qualifier(&self.bare_name) {
-            if self.var_type.is_extended() {
+        if let Some(func_qualifier) = ctx.function_qualifier(self.bare_name()) {
+            if self.var_type().is_extended() {
                 Err(LintError::DuplicateDefinition.at_pos(pos))
             } else {
                 // for some reason you can have a FUNCTION Add(Add)
                 let q = self
-                    .var_type
+                    .var_type()
                     .to_qualifier_recursively()
-                    .unwrap_or_else(|| self.bare_name.qualify(ctx));
+                    .unwrap_or_else(|| self.bare_name().qualify(ctx));
                 if q == func_qualifier {
                     Ok(())
                 } else {
@@ -97,7 +97,7 @@ fn user_defined_type_must_exist<T>(
 where
     T: VarType,
 {
-    match var_name.var_type.as_user_defined_recursively() {
+    match var_name.var_type().as_user_defined_recursively() {
         Some(Positioned {
             element: type_name,
             pos,
diff --git a/rusty_linter/src/post_linter/dots_linter.rs b/rusty_linter/src/post_linter/dots_linter.rs
@@ -65,13 +65,13 @@ where
 
 impl NoDotNamesCheck<Parameter, LintError> for DotsLinter {
     fn ensure_no_dots(&self, x: &Parameter) -> Result<(), LintError> {
-        self.ensure_no_dots(&x.bare_name)
+        self.ensure_no_dots(x.bare_name())
     }
 }
 
 impl NoDotNamesCheck<DimVar, LintError> for DotsLinter {
     fn ensure_no_dots(&self, x: &DimVar) -> Result<(), LintError> {
-        self.ensure_no_dots(&x.bare_name)
+        self.ensure_no_dots(x.bare_name())
     }
 }
 
@@ -224,8 +224,8 @@ where
     T: VarType,
 {
     fn visit(&mut self, element: &TypedName<T>) -> VisitResult {
-        if element.var_type.as_user_defined_recursively().is_some() {
-            self.user_defined_names.insert(element.bare_name.clone());
+        if element.var_type().as_user_defined_recursively().is_some() {
+            self.user_defined_names.insert(element.bare_name().clone());
         }
         Ok(())
     }
diff --git a/rusty_linter/src/post_linter/expression_reducer.rs b/rusty_linter/src/post_linter/expression_reducer.rs
@@ -310,22 +310,8 @@ pub trait ExpressionReducer {
     }
 
     fn visit_dim_var_pos(&mut self, dim_var_pos: DimVarPos) -> Result<DimVarPos, LintErrorPos> {
-        let DimVarPos {
-            element:
-                DimVar {
-                    bare_name,
-                    var_type: dim_type,
-                },
-            pos,
-        } = dim_var_pos;
-        let converted_dim_type = self.visit_dim_type(dim_type)?;
-        Ok(DimVarPos {
-            element: DimVar {
-                bare_name,
-                var_type: converted_dim_type,
-            },
-            pos,
-        })
+        dim_var_pos
+            .try_map(|dim_var| dim_var.try_map_type(|dim_type| self.visit_dim_type(dim_type)))
     }
 
     fn visit_dim_type(&mut self, dim_type: DimType) -> Result<DimType, LintErrorPos> {
diff --git a/rusty_linter/src/pre_linter/main.rs b/rusty_linter/src/pre_linter/main.rs
@@ -150,7 +150,7 @@ impl MainContext {
     }
 
     fn on_parameter(&self, parameter: &Parameter) -> Result<ResolvedParamType, LintError> {
-        self.resolve_param_type(&parameter.bare_name, &parameter.var_type)
+        self.resolve_param_type(parameter.bare_name(), parameter.var_type())
     }
 
     fn resolve_param_type(
diff --git a/rusty_parser/src/specific/core/dim.rs b/rusty_parser/src/specific/core/dim.rs
@@ -80,10 +80,10 @@ mod tests {
                             pos,
                         } = dim_list.variables.pop().unwrap();
                         assert_eq!(pos, Position::new(1, 5));
-                        assert_eq!(dim_name.bare_name, var_name_bare);
-                        match dim_name.var_type {
+                        assert_eq!(*dim_name.bare_name(), var_name_bare);
+                        match dim_name.var_type() {
                             DimType::UserDefined(Positioned { element, .. }) => {
-                                assert_eq!(element, var_type_bare);
+                                assert_eq!(*element, var_type_bare);
                             }
                             _ => panic!("Expected user defined type"),
                         }
diff --git a/rusty_parser/src/specific/core/var_name.rs b/rusty_parser/src/specific/core/var_name.rs
@@ -12,9 +12,8 @@ use crate::specific::*;
 /// and [Parameter].
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct TypedName<T: VarType> {
-    // TODO make fields private
-    pub bare_name: BareName,
-    pub var_type: T,
+    bare_name: BareName,
+    var_type: T,
 }
 
 impl<T: VarType> TypedName<T> {
@@ -24,6 +23,25 @@ impl<T: VarType> TypedName<T> {
             var_type,
         }
     }
+
+    pub fn bare_name(&self) -> &BareName {
+        self.as_ref()
+    }
+
+    pub fn var_type(&self) -> &T {
+        self.as_ref()
+    }
+
+    pub fn try_map_type<F, E>(self, f: F) -> Result<Self, E>
+    where
+        F: FnOnce(T) -> Result<T, E>,
+    {
+        let Self {
+            bare_name,
+            var_type,
+        } = self;
+        f(var_type).map(|new_var_type| Self::new(bare_name, new_var_type))
+    }
 }
 
 impl<T: VarType> AsRef<BareName> for TypedName<T> {
@@ -38,6 +56,12 @@ impl<T: VarType> AsRef<T> for TypedName<T> {
     }
 }
 
+impl<T: VarType> From<TypedName<T>> for (BareName, T) {
+    fn from(value: TypedName<T>) -> Self {
+        (value.bare_name, value.var_type)
+    }
+}
+
 pub trait VarType: HasExpressionType {
     fn new_built_in_compact(q: TypeQualifier) -> Self;
 

Original file line number	Diff line number	Diff line change
`@@ -59,10 +59,7 @@ impl Variables {`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`fn param_to_name(param_name: Parameter) -> Name {`
`62`		`- let Parameter {`
`63`		`- bare_name,`
`64`		`- var_type: param_type,`
`65`		`- } = param_name;`
	`62`	`+ let (bare_name, param_type) = param_name.into();`
`66`	`63`	`match param_type {`
`67`	`64`	`ParamType::Bare => panic!("Unresolved param {:?}", bare_name),`
`68`	`65`	`ParamType::BuiltIn(q, _) => Name::Qualified(bare_name, q),`
`@@ -79,10 +76,7 @@ impl Variables {`
`79`	`76`	`}`
`80`	`77`
`81`	`78`	`pub fn insert_dim(&mut self, dim_name: DimVar, value: Variant) {`
`82`		`- let DimVar {`
`83`		`- bare_name,`
`84`		`- var_type: dim_type,`
`85`		`- } = dim_name;`
	`79`	`+ let (bare_name, dim_type) = dim_name.into();`
`86`	`80`	`self.insert_dim_internal(bare_name, dim_type, value);`
`87`	`81`	`}`
`88`	`82`
`@@ -177,7 +171,7 @@ impl Variables {`
`177`	`171`	`}`
`178`	`172`
`179`	`173`	`pub fn get_by_dim_name(&self, dim_name: &DimVar) -> Option<&Variant> {`
`180`		`- self.get_by_dim_name_internal(&dim_name.bare_name, &dim_name.var_type)`
	`174`	`+ self.get_by_dim_name_internal(dim_name.bare_name(), dim_name.var_type())`
`181`	`175`	`}`
`182`	`176`
`183`	`177`	`fn get_by_dim_name_internal(`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,14 @@ impl<T> Positioned<T> {`
`28`	`28`	`pos,`
`29`	`29`	`}`
`30`	`30`	`}`
	`31`	`+`
	`32`	`+ pub fn try_map<F, U, E>(self, op: F) -> Result<Positioned<U>, E>`
	`33`	`+ where`
	`34`	`+ F: FnOnce(T) -> Result<U, E>,`
	`35`	`+ {`
	`36`	`+ let Self { element, pos } = self;`
	`37`	`+ op(element).map(\|new_element\| Positioned::new(new_element, pos))`
	`38`	`+ }`
`31`	`39`	`}`
`32`	`40`
`33`	`41`	`// AtPos`
Original file line number	Diff line number	Diff line change
`@@ -65,13 +65,13 @@ where`
`65`	`65`
`66`	`66`	`impl NoDotNamesCheck<Parameter, LintError> for DotsLinter {`
`67`	`67`	`fn ensure_no_dots(&self, x: &Parameter) -> Result<(), LintError> {`
`68`		`- self.ensure_no_dots(&x.bare_name)`
	`68`	`+ self.ensure_no_dots(x.bare_name())`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`impl NoDotNamesCheck<DimVar, LintError> for DotsLinter {`
`73`	`73`	`fn ensure_no_dots(&self, x: &DimVar) -> Result<(), LintError> {`
`74`		`- self.ensure_no_dots(&x.bare_name)`
	`74`	`+ self.ensure_no_dots(x.bare_name())`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`@@ -224,8 +224,8 @@ where`
`224`	`224`	`T: VarType,`
`225`	`225`	`{`
`226`	`226`	`fn visit(&mut self, element: &TypedName<T>) -> VisitResult {`
`227`		`- if element.var_type.as_user_defined_recursively().is_some() {`
`228`		`- self.user_defined_names.insert(element.bare_name.clone());`
	`227`	`+ if element.var_type().as_user_defined_recursively().is_some() {`
	`228`	`+ self.user_defined_names.insert(element.bare_name().clone());`
`229`	`229`	`}`
`230`	`230`	`Ok(())`
`231`	`231`	`}`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ impl MainContext {`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`fn on_parameter(&self, parameter: &Parameter) -> Result<ResolvedParamType, LintError> {`
`153`		`- self.resolve_param_type(&parameter.bare_name, &parameter.var_type)`
	`153`	`+ self.resolve_param_type(parameter.bare_name(), parameter.var_type())`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`fn resolve_param_type(`
Original file line number	Diff line number	Diff line change
`@@ -80,10 +80,10 @@ mod tests {`
`80`	`80`	`pos,`
`81`	`81`	`} = dim_list.variables.pop().unwrap();`
`82`	`82`	`assert_eq!(pos, Position::new(1, 5));`
`83`		`- assert_eq!(dim_name.bare_name, var_name_bare);`
`84`		`- match dim_name.var_type {`
	`83`	`+ assert_eq!(*dim_name.bare_name(), var_name_bare);`
	`84`	`+ match dim_name.var_type() {`
`85`	`85`	`DimType::UserDefined(Positioned { element, .. }) => {`
`86`		`- assert_eq!(element, var_type_bare);`
	`86`	`+ assert_eq!(*element, var_type_bare);`
`87`	`87`	`}`
`88`	`88`	`_ => panic!("Expected user defined type"),`
`89`	`89`	`}`