Do not use anonymous fields in names module

ngeor · ngeor · commit f664c82badd1 · 2026-02-26T20:55:43.000+01:00
diff --git a/rusty_linter/src/names/compacts.rs b/rusty_linter/src/names/compacts.rs
@@ -10,11 +10,13 @@ use crate::names::traits::SingleNameTrait;
 /// With compact variables, it's possible to have the same name
 /// but with different types e.g. `A$` and `A%`.
 #[derive(Default)]
-pub struct Compacts(HashMap<TypeQualifier, VariableInfo>);
+pub struct Compacts {
+    map: HashMap<TypeQualifier, VariableInfo>,
+}
 
 impl SingleNameTrait for Compacts {
     fn get_compact(&self, qualifier: TypeQualifier) -> Option<&VariableInfo> {
-        self.0.get(&qualifier)
+        self.map.get(&qualifier)
     }
 
     fn get_extended(&self) -> Option<&VariableInfo> {
@@ -26,7 +28,7 @@ impl SingleNameTrait for Compacts {
     }
 
     fn collect_var_info(&self, only_shared: bool) -> Vec<(BuiltInStyle, &VariableInfo)> {
-        self.0
+        self.map
             .values()
             .filter(|v| v.shared || !only_shared)
             .map(|v| (BuiltInStyle::Compact, v))
@@ -40,7 +42,7 @@ impl SingleNameTrait for Compacts {
             .expect("Should be resolved");
 
         // if it already exists, it should be a REDIM
-        debug_assert!(match self.0.get(&q) {
+        debug_assert!(match self.map.get(&q) {
             Some(existing_v) => {
                 existing_v.redim_info.is_some()
             }
@@ -49,6 +51,6 @@ impl SingleNameTrait for Compacts {
             }
         });
 
-        self.0.insert(q, variable_info);
+        self.map.insert(q, variable_info);
     }
 }
diff --git a/rusty_linter/src/names/main.rs b/rusty_linter/src/names/main.rs
@@ -41,7 +41,10 @@ pub struct Names {
 /// TODO merge [ImplicitVars] into [NamesInner]
 /// TODO use bi_tuple macro
 #[derive(Default)]
-struct NamesOneLevel(NamesInner, ImplicitVars);
+struct NamesOneLevel {
+    names: NamesInner,
+    implicit_vars: ImplicitVars,
+}
 
 impl Names {
     pub fn new() -> Self {
@@ -63,22 +66,22 @@ impl Names {
     }
 
     pub fn get_implicit_vars_mut(&mut self) -> &mut ImplicitVars {
-        &mut self.current_data_mut().1
+        &mut self.current_data_mut().implicit_vars
     }
 
     pub fn names(&self) -> &NamesInner {
-        &self.current_data().0
+        &self.current_data().names
     }
 
     pub fn names_mut(&mut self) -> &mut NamesInner {
-        &mut self.current_data_mut().0
+        &mut self.current_data_mut().names
     }
 
     /// Returns the global names, but only if we are currently within a sub program.
     fn global_names(&self) -> Option<&NamesInner> {
         match &self.current_scope_name {
             ScopeName::Global => None,
-            _ => self.data.get(&ScopeName::Global).map(|x| &x.0),
+            _ => self.data.get(&ScopeName::Global).map(|x| &x.names),
         }
     }
 
@@ -210,7 +213,7 @@ impl Names {
             .data
             .get(scope_name)
             .unwrap_or_else(|| panic!("Subprogram {:?} should be resolved", scope_name));
-        match one_level.0.get_variable_info_by_name(name) {
+        match one_level.names.get_variable_info_by_name(name) {
             Some(i) => i,
             None => {
                 if scope_name != &ScopeName::Global {
@@ -219,7 +222,7 @@ impl Names {
                         .data
                         .get(&ScopeName::Global)
                         .expect("Global name scope missing!")
-                        .0
+                        .names
                         .get_variable_info_by_name(name)
                         .unwrap_or_else(|| {
                             panic!("Could not resolve {} even in global namespace", name)
diff --git a/rusty_linter/src/names/name_info.rs b/rusty_linter/src/names/name_info.rs
@@ -6,92 +6,102 @@ use crate::names::traits::SingleNameTrait;
 
 /// Stores information about a constant or variable name.
 /// The name itself isn't stored here.
-pub struct NameInfo(NameInfoInner);
+pub struct NameInfo {
+    inner: NameInfoInner,
+}
 
 impl NameInfo {
     pub fn constant(v: Variant) -> Self {
-        Self(NameInfoInner::Constant(v))
+        Self {
+            inner: NameInfoInner::Constant { value: v },
+        }
     }
 
     pub fn compacts() -> Self {
-        Self(NameInfoInner::Compacts(Compacts::default()))
+        Self {
+            inner: NameInfoInner::Compacts {
+                compacts: Compacts::default(),
+            },
+        }
     }
 
     pub fn extended(variable_info: VariableInfo) -> Self {
-        Self(NameInfoInner::Extended(variable_info))
+        Self {
+            inner: NameInfoInner::Extended { variable_info },
+        }
     }
 }
 
 impl SingleNameTrait for NameInfo {
     fn get_compact(&self, qualifier: TypeQualifier) -> Option<&VariableInfo> {
-        self.0.get_compact(qualifier)
+        self.inner.get_compact(qualifier)
     }
 
     fn get_extended(&self) -> Option<&VariableInfo> {
-        self.0.get_extended()
+        self.inner.get_extended()
     }
 
     fn get_const_value(&self) -> Option<&Variant> {
-        self.0.get_const_value()
+        self.inner.get_const_value()
     }
 
     fn collect_var_info(&self, only_shared: bool) -> Vec<(BuiltInStyle, &VariableInfo)> {
-        self.0.collect_var_info(only_shared)
+        self.inner.collect_var_info(only_shared)
     }
 
     fn insert_compact(&mut self, variable_info: VariableInfo) {
-        self.0.insert_compact(variable_info);
+        self.inner.insert_compact(variable_info);
     }
 }
 
 /// Nested enum for [NameInfo].
 /// The external struct is preventing direct access to the enum members
 /// outside of the module.
 enum NameInfoInner {
-    Constant(Variant),
-    Compacts(Compacts),
-    Extended(VariableInfo),
+    Constant { value: Variant },
+    Compacts { compacts: Compacts },
+    Extended { variable_info: VariableInfo },
 }
 
 impl SingleNameTrait for NameInfoInner {
     fn get_compact(&self, qualifier: TypeQualifier) -> Option<&VariableInfo> {
         match self {
-            Self::Compacts(compacts) => compacts.get_compact(qualifier),
+            Self::Compacts { compacts } => compacts.get_compact(qualifier),
             _ => None,
         }
     }
 
     fn get_extended(&self) -> Option<&VariableInfo> {
         match self {
-            Self::Extended(v) => Some(v),
+            Self::Extended { variable_info } => Some(variable_info),
             _ => None,
         }
     }
 
     fn get_const_value(&self) -> Option<&Variant> {
         match self {
-            Self::Constant(v) => Some(v),
+            Self::Constant { value } => Some(value),
             _ => None,
         }
     }
 
     fn collect_var_info(&self, only_shared: bool) -> Vec<(BuiltInStyle, &VariableInfo)> {
         match self {
-            Self::Compacts(compacts) => compacts.collect_var_info(only_shared),
-            Self::Extended(v) => {
-                if v.shared || !only_shared {
-                    vec![(BuiltInStyle::Extended, v)]
+            Self::Compacts { compacts } => compacts.collect_var_info(only_shared),
+            Self::Extended { variable_info } => {
+                if variable_info.shared || !only_shared {
+                    vec![(BuiltInStyle::Extended, variable_info)]
                 } else {
                     vec![]
                 }
             }
-            Self::Constant(_) => vec![],
+            Self::Constant { .. } => vec![],
         }
     }
 
     fn insert_compact(&mut self, variable_info: VariableInfo) {
         match self {
-            Self::Compacts(compacts) => compacts.insert_compact(variable_info),
+            Self::Compacts { compacts } => compacts.insert_compact(variable_info),
             _ => panic!("Cannot insert compact because it already exists as CONST or extended"),
         }
     }
diff --git a/rusty_linter/src/names/names_inner.rs b/rusty_linter/src/names/names_inner.rs
@@ -10,25 +10,27 @@ use crate::names::traits::{ManyNamesTrait, SingleNameTrait};
 /// Stores information about multiple constants or variable names.
 /// This struct does not support multiple levels (e.g. `FUNCTION` or `SUB`).
 #[derive(Default)]
-pub struct NamesInner(HashMap<BareName, NameInfo>);
+pub struct NamesInner {
+    map: HashMap<BareName, NameInfo>,
+}
 
 impl NamesInner {
     /// Returns true if this name is a constant, or an extended variable,
     /// or a compact variable. In the case of compact variables, multiple may
     /// exist with the same bare name, e.g. `A$` and `A%`.
     pub fn contains_key(&self, bare_name: &BareName) -> bool {
-        self.0.contains_key(bare_name)
+        self.map.contains_key(bare_name)
     }
 
     pub fn insert_const(&mut self, bare_name: BareName, v: Variant) {
-        debug_assert!(!self.0.contains_key(&bare_name));
-        self.0.insert(bare_name, NameInfo::constant(v));
+        debug_assert!(!self.map.contains_key(&bare_name));
+        self.map.insert(bare_name, NameInfo::constant(v));
     }
 
     pub fn insert_extended(&mut self, bare_name: BareName, variable_context: VariableInfo) {
         // if it exists as REDIM extended, it's okay
         // all other cases where it already exists are not okay
-        debug_assert!(match self.0.get(&bare_name) {
+        debug_assert!(match self.map.get(&bare_name) {
             Some(name_info) => {
                 match name_info.get_extended() {
                     Some(e) => e.redim_info.is_some(),
@@ -39,7 +41,7 @@ impl NamesInner {
                 true
             }
         });
-        self.0
+        self.map
             .insert(bare_name, NameInfo::extended(variable_context));
     }
 
@@ -58,21 +60,21 @@ impl NamesInner {
 
 impl ConstLookup for NamesInner {
     fn get_const_value(&self, bare_name: &BareName) -> Option<&rusty_variant::Variant> {
-        self.0
+        self.map
             .get(bare_name)
             .and_then(|name_info| name_info.get_const_value())
     }
 }
 
 impl ManyNamesTrait for NamesInner {
     fn get_compact(&self, bare_name: &BareName, qualifier: TypeQualifier) -> Option<&VariableInfo> {
-        self.0
+        self.map
             .get(bare_name)
             .and_then(|name_info| name_info.get_compact(qualifier))
     }
 
     fn get_extended(&self, bare_name: &BareName) -> Option<&VariableInfo> {
-        self.0
+        self.map
             .get(bare_name)
             .and_then(|name_info| name_info.get_extended())
     }
@@ -82,21 +84,21 @@ impl ManyNamesTrait for NamesInner {
         bare_name: &BareName,
         only_shared: bool,
     ) -> Vec<(rusty_parser::BuiltInStyle, &VariableInfo)> {
-        self.0
+        self.map
             .get(bare_name)
             .map(|name_info| name_info.collect_var_info(only_shared))
             .unwrap_or_default()
     }
 
     fn insert_compact(&mut self, bare_name: BareName, variable_info: VariableInfo) {
-        match self.0.get_mut(&bare_name) {
+        match self.map.get_mut(&bare_name) {
             Some(name_info) => {
                 name_info.insert_compact(variable_info);
             }
             None => {
                 let mut name_info = NameInfo::compacts();
                 name_info.insert_compact(variable_info);
-                self.0.insert(bare_name, name_info);
+                self.map.insert(bare_name, name_info);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,13 @@ use crate::names::traits::SingleNameTrait;`
`10`	`10`	`/// With compact variables, it's possible to have the same name`
`11`	`11`	/// but with different types e.g. `A$` and `A%`.
`12`	`12`	`#[derive(Default)]`
`13`		`-pub struct Compacts(HashMap<TypeQualifier, VariableInfo>);`
	`13`	`+pub struct Compacts {`
	`14`	`+ map: HashMap<TypeQualifier, VariableInfo>,`
	`15`	`+}`
`14`	`16`
`15`	`17`	`impl SingleNameTrait for Compacts {`
`16`	`18`	`fn get_compact(&self, qualifier: TypeQualifier) -> Option<&VariableInfo> {`
`17`		`- self.0.get(&qualifier)`
	`19`	`+ self.map.get(&qualifier)`
`18`	`20`	`}`
`19`	`21`
`20`	`22`	`fn get_extended(&self) -> Option<&VariableInfo> {`
`@@ -26,7 +28,7 @@ impl SingleNameTrait for Compacts {`
`26`	`28`	`}`
`27`	`29`
`28`	`30`	`fn collect_var_info(&self, only_shared: bool) -> Vec<(BuiltInStyle, &VariableInfo)> {`
`29`		`- self.0`
	`31`	`+ self.map`
`30`	`32`	`.values()`
`31`	`33`	`.filter(\|v\| v.shared \|\| !only_shared)`
`32`	`34`	`.map(\|v\| (BuiltInStyle::Compact, v))`
`@@ -40,7 +42,7 @@ impl SingleNameTrait for Compacts {`
`40`	`42`	`.expect("Should be resolved");`
`41`	`43`
`42`	`44`	`// if it already exists, it should be a REDIM`
`43`		`- debug_assert!(match self.0.get(&q) {`
	`45`	`+ debug_assert!(match self.map.get(&q) {`
`44`	`46`	`Some(existing_v) => {`
`45`	`47`	`existing_v.redim_info.is_some()`
`46`	`48`	`}`
`@@ -49,6 +51,6 @@ impl SingleNameTrait for Compacts {`
`49`	`51`	`}`
`50`	`52`	`});`
`51`	`53`
`52`		`- self.0.insert(q, variable_info);`
	`54`	`+ self.map.insert(q, variable_info);`
`53`	`55`	`}`
`54`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,92 +6,102 @@ use crate::names::traits::SingleNameTrait;`
`6`	`6`
`7`	`7`	`/// Stores information about a constant or variable name.`
`8`	`8`	`/// The name itself isn't stored here.`
`9`		`-pub struct NameInfo(NameInfoInner);`
	`9`	`+pub struct NameInfo {`
	`10`	`+ inner: NameInfoInner,`
	`11`	`+}`
`10`	`12`
`11`	`13`	`impl NameInfo {`
`12`	`14`	`pub fn constant(v: Variant) -> Self {`
`13`		`- Self(NameInfoInner::Constant(v))`
	`15`	`+ Self {`
	`16`	`+ inner: NameInfoInner::Constant { value: v },`
	`17`	`+ }`
`14`	`18`	`}`
`15`	`19`
`16`	`20`	`pub fn compacts() -> Self {`
`17`		`- Self(NameInfoInner::Compacts(Compacts::default()))`
	`21`	`+ Self {`
	`22`	`+ inner: NameInfoInner::Compacts {`
	`23`	`+ compacts: Compacts::default(),`
	`24`	`+ },`
	`25`	`+ }`
`18`	`26`	`}`
`19`	`27`
`20`	`28`	`pub fn extended(variable_info: VariableInfo) -> Self {`
`21`		`- Self(NameInfoInner::Extended(variable_info))`
	`29`	`+ Self {`
	`30`	`+ inner: NameInfoInner::Extended { variable_info },`
	`31`	`+ }`
`22`	`32`	`}`
`23`	`33`	`}`
`24`	`34`
`25`	`35`	`impl SingleNameTrait for NameInfo {`
`26`	`36`	`fn get_compact(&self, qualifier: TypeQualifier) -> Option<&VariableInfo> {`
`27`		`- self.0.get_compact(qualifier)`
	`37`	`+ self.inner.get_compact(qualifier)`
`28`	`38`	`}`
`29`	`39`
`30`	`40`	`fn get_extended(&self) -> Option<&VariableInfo> {`
`31`		`- self.0.get_extended()`
	`41`	`+ self.inner.get_extended()`
`32`	`42`	`}`
`33`	`43`
`34`	`44`	`fn get_const_value(&self) -> Option<&Variant> {`
`35`		`- self.0.get_const_value()`
	`45`	`+ self.inner.get_const_value()`
`36`	`46`	`}`
`37`	`47`
`38`	`48`	`fn collect_var_info(&self, only_shared: bool) -> Vec<(BuiltInStyle, &VariableInfo)> {`
`39`		`- self.0.collect_var_info(only_shared)`
	`49`	`+ self.inner.collect_var_info(only_shared)`
`40`	`50`	`}`
`41`	`51`
`42`	`52`	`fn insert_compact(&mut self, variable_info: VariableInfo) {`
`43`		`- self.0.insert_compact(variable_info);`
	`53`	`+ self.inner.insert_compact(variable_info);`
`44`	`54`	`}`
`45`	`55`	`}`
`46`	`56`
`47`	`57`	`/// Nested enum for [NameInfo].`
`48`	`58`	`/// The external struct is preventing direct access to the enum members`
`49`	`59`	`/// outside of the module.`
`50`	`60`	`enum NameInfoInner {`
`51`		`- Constant(Variant),`
`52`		`- Compacts(Compacts),`
`53`		`- Extended(VariableInfo),`
	`61`	`+ Constant { value: Variant },`
	`62`	`+ Compacts { compacts: Compacts },`
	`63`	`+ Extended { variable_info: VariableInfo },`
`54`	`64`	`}`
`55`	`65`
`56`	`66`	`impl SingleNameTrait for NameInfoInner {`
`57`	`67`	`fn get_compact(&self, qualifier: TypeQualifier) -> Option<&VariableInfo> {`
`58`	`68`	`match self {`
`59`		`- Self::Compacts(compacts) => compacts.get_compact(qualifier),`
	`69`	`+ Self::Compacts { compacts } => compacts.get_compact(qualifier),`
`60`	`70`	`_ => None,`
`61`	`71`	`}`
`62`	`72`	`}`
`63`	`73`
`64`	`74`	`fn get_extended(&self) -> Option<&VariableInfo> {`
`65`	`75`	`match self {`
`66`		`- Self::Extended(v) => Some(v),`
	`76`	`+ Self::Extended { variable_info } => Some(variable_info),`
`67`	`77`	`_ => None,`
`68`	`78`	`}`
`69`	`79`	`}`
`70`	`80`
`71`	`81`	`fn get_const_value(&self) -> Option<&Variant> {`
`72`	`82`	`match self {`
`73`		`- Self::Constant(v) => Some(v),`
	`83`	`+ Self::Constant { value } => Some(value),`
`74`	`84`	`_ => None,`
`75`	`85`	`}`
`76`	`86`	`}`
`77`	`87`
`78`	`88`	`fn collect_var_info(&self, only_shared: bool) -> Vec<(BuiltInStyle, &VariableInfo)> {`
`79`	`89`	`match self {`
`80`		`- Self::Compacts(compacts) => compacts.collect_var_info(only_shared),`
`81`		`- Self::Extended(v) => {`
`82`		`- if v.shared \|\| !only_shared {`
`83`		`- vec![(BuiltInStyle::Extended, v)]`
	`90`	`+ Self::Compacts { compacts } => compacts.collect_var_info(only_shared),`
	`91`	`+ Self::Extended { variable_info } => {`
	`92`	`+ if variable_info.shared \|\| !only_shared {`
	`93`	`+ vec![(BuiltInStyle::Extended, variable_info)]`
`84`	`94`	`} else {`
`85`	`95`	`vec![]`
`86`	`96`	`}`
`87`	`97`	`}`
`88`		`- Self::Constant(_) => vec![],`
	`98`	`+ Self::Constant { .. } => vec![],`
`89`	`99`	`}`
`90`	`100`	`}`
`91`	`101`
`92`	`102`	`fn insert_compact(&mut self, variable_info: VariableInfo) {`
`93`	`103`	`match self {`
`94`		`- Self::Compacts(compacts) => compacts.insert_compact(variable_info),`
	`104`	`+ Self::Compacts { compacts } => compacts.insert_compact(variable_info),`
`95`	`105`	`_ => panic!("Cannot insert compact because it already exists as CONST or extended"),`
`96`	`106`	`}`
`97`	`107`	`}`