refactor: Changed Statement::SubCall to use a struct instead of two fields

Author: ngeor

rusty_basic/src/instruction_generator/calls.rs

@@ -66,8 +66,8 @@ impl InstructionGenerator {
         self.generate_un_stash_function_return_value(pos);
     }
 
-    pub fn generate_sub_call_instructions(&mut self, name_pos: BareNamePos, args: Expressions) {
-        let Positioned { element: name, pos } = name_pos;
+    pub fn generate_sub_call_instructions(&mut self, sub_call: SubCall, pos: Position) {
+        let (name, args) = sub_call.into();
         let subprogram_name = SubprogramName::Sub(name);
         // cloning to fight the borrow checker
         let sub_impl_parameters: Vec<Parameter> = self

rusty_basic/src/instruction_generator/statement.rs

@@ -29,7 +29,7 @@ impl Visitor<StatementPos> for InstructionGenerator {
                 // because the linter has replaced expressions that reference constants
                 // with their actual value.
             }
-            Statement::SubCall(n, args) => self.generate_sub_call_instructions(n.at_pos(pos), args),
+            Statement::SubCall(sub_call) => self.generate_sub_call_instructions(sub_call, pos),
             Statement::BuiltInSubCall(n, args) => {
                 self.generate_built_in_sub_call_instructions(n, args, pos)
             }

rusty_linter/src/converter/statement/main.rs

@@ -14,7 +14,7 @@ impl ConvertibleIn<Position> for Statement {
             Self::Assignment(a) => assignment::on_assignment(a, ctx, pos),
             // CONST is mapped to None and is filtered out
             Self::Const(c) => const_rules::on_const(ctx, c),
-            Self::SubCall(n, args) => ctx.sub_call(n, args),
+            Self::SubCall(sub_call) => ctx.sub_call(sub_call),
             Self::BuiltInSubCall(built_in_sub, args) => {
                 let converted_args = args.convert_in(ctx, ExprContext::Argument)?;
                 Ok(Self::BuiltInSubCall(built_in_sub, converted_args))

rusty_linter/src/converter/statement/sub_call.rs

@@ -2,21 +2,16 @@ use crate::converter::common::Context;
 use crate::converter::common::ConvertibleIn;
 use crate::converter::common::ExprContext;
 use crate::core::LintErrorPos;
-use rusty_parser::{
-    BuiltInSub, {BareName, Expressions, Statement},
-};
+use rusty_parser::{BuiltInSub, Statement, SubCall};
 
 impl Context {
-    pub fn sub_call(
-        &mut self,
-        sub_name: BareName,
-        args: Expressions,
-    ) -> Result<Statement, LintErrorPos> {
+    pub fn sub_call(&mut self, sub_call: SubCall) -> Result<Statement, LintErrorPos> {
+        let (sub_name, args) = sub_call.into();
         let converted_args = args.convert_in(self, ExprContext::Argument)?;
         let opt_built_in: Option<BuiltInSub> = BuiltInSub::parse_non_keyword_sub(sub_name.as_ref());
         match opt_built_in {
             Some(b) => Ok(Statement::BuiltInSubCall(b, converted_args)),
-            None => Ok(Statement::SubCall(sub_name, converted_args)),
+            None => Ok(Statement::sub_call(sub_name, converted_args)),
         }
     }
 }

rusty_linter/src/post_linter/expression_reducer.rs

@@ -108,9 +108,9 @@ pub trait ExpressionReducer {
                 // any further.
                 Ok(Statement::Const(c))
             }
-            Statement::SubCall(b, e) => self
-                .visit_sub_call(b, e)
-                .map(|(reduced_name, reduced_expr)| Statement::SubCall(reduced_name, reduced_expr)),
+            Statement::SubCall(s) => self.visit_sub_call(s).map(|(reduced_name, reduced_expr)| {
+                Statement::sub_call(reduced_name, reduced_expr)
+            }),
             Statement::BuiltInSubCall(b, e) => {
                 self.visit_built_in_sub_call(b, e)
                     .map(|(reduced_name, reduced_expr)| {
@@ -140,9 +140,9 @@ pub trait ExpressionReducer {
 
     fn visit_sub_call(
         &mut self,
-        name: CaseInsensitiveString,
-        args: Expressions,
+        sub_call: SubCall,
     ) -> Result<(CaseInsensitiveString, Expressions), LintErrorPos> {
+        let (name, args) = sub_call.into();
         Ok((name, self.visit_expressions(args)?))
     }
 

rusty_linter/src/post_linter/post_conversion_linter.rs

@@ -57,7 +57,7 @@ pub trait PostConversionLinter {
     fn visit_statement_pos(&mut self, s: &Statement, pos: Position) -> Result<(), LintErrorPos> {
         match s {
             Statement::Assignment(a) => self.visit_assignment(a, pos),
-            Statement::SubCall(b, e) => self.visit_sub_call(b, pos, e),
+            Statement::SubCall(sub_call) => self.visit_sub_call(sub_call, pos),
             Statement::BuiltInSubCall(b, e) => self.visit_built_in_sub_call(b, pos, e),
             Statement::IfBlock(i) => self.visit_if_block(i),
             Statement::SelectCase(s) => self.visit_select_case(s),
@@ -138,12 +138,8 @@ pub trait PostConversionLinter {
         Ok(())
     }
 
-    fn visit_sub_call(
-        &mut self,
-        _name: &CaseInsensitiveString,
-        _pos: Position,
-        args: &Expressions,
-    ) -> Result<(), LintErrorPos> {
+    fn visit_sub_call(&mut self, sub_call: &SubCall, _pos: Position) -> Result<(), LintErrorPos> {
+        let (_, args) = sub_call.into();
         self.visit_expressions(args)
     }
 

rusty_linter/src/post_linter/user_defined_sub_linter.rs

@@ -3,7 +3,7 @@ use super::user_defined_function_linter::lint_call_args;
 use crate::core::HasSubprograms;
 use crate::core::{LintError, LintErrorPos};
 use rusty_common::*;
-use rusty_parser::Expressions;
+use rusty_parser::SubCall;
 
 pub struct UserDefinedSubLinter<'a, R> {
     pub linter_context: &'a R,
@@ -13,12 +13,8 @@ impl<'a, R> PostConversionLinter for UserDefinedSubLinter<'a, R>
 where
     R: HasSubprograms,
 {
-    fn visit_sub_call(
-        &mut self,
-        name: &CaseInsensitiveString,
-        pos: Position,
-        args: &Expressions,
-    ) -> Result<(), LintErrorPos> {
+    fn visit_sub_call(&mut self, sub_call: &SubCall, pos: Position) -> Result<(), LintErrorPos> {
+        let (name, args) = sub_call.into();
         match self.linter_context.subs().get(name) {
             Some(sub_signature_pos) => {
                 lint_call_args(args, sub_signature_pos.element.param_types(), pos)

rusty_linter/src/tests/array.rs

@@ -104,7 +104,7 @@ fn test_passing_array_parameter_with_parenthesis() {
                     .build_list_rc(2, 9)
             ))
             .at_rc(2, 5),
-            GlobalStatement::Statement(Statement::SubCall(
+            GlobalStatement::Statement(Statement::sub_call(
                 "Menu".into(),
                 vec![Expression::ArrayElement(
                     "choice$".into(),

rusty_linter/src/tests/constant.rs

@@ -133,7 +133,7 @@ fn test_constant_definition_and_usage_in_sub_call_arg() {
                 Expression::StringLiteral("hello".to_owned()).at_rc(2, 15)
             ),)
             .at_rc(2, 5),
-            GlobalStatement::Statement(Statement::SubCall(
+            GlobalStatement::Statement(Statement::sub_call(
                 "MySub".into(),
                 vec![Expression::StringLiteral("hello".to_owned()).at_rc(3, 11)]
             ))

rusty_parser/src/specific/built_ins/close.rs

@@ -67,7 +67,7 @@ mod tests {
     fn test_one_file_number_no_hash_no_leading_space() {
         let input = "CLOSE1";
         let statement = parse(input).demand_single_statement();
-        assert_eq!(statement, Statement::SubCall("CLOSE1".into(), vec![]));
+        assert_eq!(statement, Statement::sub_call("CLOSE1".into(), vec![]));
     }
 
     #[test]