Add rule to remove function call parentheses

Author: jeparlefrancais

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "darklua"
-version = "0.3.3"
+version = "0.3.4"
 authors = ["jeparlefrancais <jeparlefrancais21@gmail.com>"]
 edition = "2018"
 readme = "README.md"

Cargo.toml

@@ -5,6 +5,7 @@ You can find the available rules and their properties here. The default rule sta
   - [Convert local functions to assignments](#convert-local-functions-to-assignments)
   - [Group local assignments](#group-local-assignments)
   - [Remove empty do statements](#remove-empty-do-statements)
+  - [Remove function call parens](#remove-function-call-parens)
   - [Remove method definitions](#remove-method-definitions)
   - [Remove unused if branch](#remove-unused-if-branch)
   - [Remove unused while](#remove-unused-while)
@@ -93,6 +94,20 @@ This rule does not have any properties.
 
 ---
 
+## Remove function call parens
+```remove_function_call_parens```
+
+This rule will remove parens in a function call when there is only one string or one table as arguments. It does not have any properties.
+
+### Examples
+```json5
+{
+    rule: 'remove_function_call_parens',
+}
+```
+
+---
+
 ## Remove method definitions
 ```remove_method_definition```
 

RULES.md

@@ -24,6 +24,10 @@ impl StringExpression {
         value.map(|value| Self { value })
     }
 
+    pub fn empty() -> Self {
+        Self { value: "".to_owned() }
+    }
+
     pub fn from_value<T: Into<String>>(value: T) -> Self {
         Self { value: value.into() }
     }

src/nodes/expressions/string.rs

@@ -0,0 +1,84 @@
+use crate::nodes::{Arguments, Block, Expression, FunctionCall, StringExpression, TableExpression};
+use crate::process::{DefaultVisitor, NodeProcessor, NodeVisitor};
+use crate::rules::{Rule, RuleConfigurationError, RuleProperties};
+
+use std::mem;
+
+#[derive(Debug, Clone, Default)]
+struct Processor {}
+
+impl NodeProcessor for Processor {
+    fn process_function_call(&mut self, call: &mut FunctionCall) {
+        let new_arguments = match call.mutate_arguments() {
+            Arguments::Tuple(expressions) if expressions.len() == 1 => {
+                let expression = expressions.iter_mut().next().unwrap();
+
+                match expression {
+                    Expression::String(string) => {
+                        let mut steal_string = StringExpression::empty();
+                        mem::swap(string, &mut steal_string);
+                        Some(Arguments::String(steal_string))
+                    }
+                    Expression::Table(table) => {
+                        let mut steal_table = TableExpression::default();
+                        mem::swap(table, &mut steal_table);
+                        Some(Arguments::Table(steal_table))
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        };
+
+        if let Some(new_arguments) = new_arguments {
+            mem::replace(call.mutate_arguments(), new_arguments);
+        }
+    }
+}
+
+pub const REMOVE_FUNCTION_CALL_PARENS: &'static str = "remove_function_call_parens";
+
+/// A rule that removes parentheses when calling functions with a string or a table.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct RemoveFunctionCallParens {}
+
+impl Rule for RemoveFunctionCallParens {
+    fn process(&self, block: &mut Block) {
+        let mut processor = Processor::default();
+        DefaultVisitor::visit_block(block, &mut processor);
+    }
+
+    fn configure(&mut self, properties: RuleProperties) -> Result<(), RuleConfigurationError> {
+        for (key, _value) in properties {
+            return Err(RuleConfigurationError::UnexpectedProperty(key))
+        }
+
+        Ok(())
+    }
+
+    fn get_name(&self) -> &'static str {
+        REMOVE_FUNCTION_CALL_PARENS
+    }
+
+    fn serialize_to_properties(&self) -> RuleProperties {
+        RuleProperties::new()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use insta::assert_json_snapshot;
+
+    fn new_rule() -> RemoveFunctionCallParens {
+        RemoveFunctionCallParens::default()
+    }
+
+    #[test]
+    fn serialize_default_rule() {
+        let rule: Box<dyn Rule> = Box::new(new_rule());
+
+        assert_json_snapshot!("default_remove_function_call_parens", rule);
+    }
+}

src/rules/call_parens.rs

@@ -1,6 +1,7 @@
 //! A module that contains the different rules that mutates a Lua block.
 
 mod empty_do;
+mod call_parens;
 mod group_local;
 mod method_def;
 mod no_local_function;
@@ -9,6 +10,7 @@ mod unused_if_branch;
 mod unused_while;
 
 pub use empty_do::*;
+pub use call_parens::*;
 pub use group_local::*;
 pub use method_def::*;
 pub use no_local_function::*;
@@ -91,6 +93,7 @@ pub fn get_default_rules() -> Vec<Box<dyn Rule>> {
         Box::new(ConvertLocalFunctionToAssign::default()),
         Box::new(GroupLocalAssignment::default()),
         Box::new(RenameVariables::default()),
+        Box::new(RemoveFunctionCallParens::default()),
     ]
 }
 
@@ -102,6 +105,7 @@ impl FromStr for Box<dyn Rule> {
             CONVERT_LOCAL_FUNCTION_TO_ASSIGN_RULE_NAME => Box::new(ConvertLocalFunctionToAssign::default()),
             GROUP_LOCAL_ASSIGNMENT => Box::new(GroupLocalAssignment::default()),
             REMOVE_EMPTY_DO_RULE_NAME => Box::new(RemoveEmptyDo::default()),
+            REMOVE_FUNCTION_CALL_PARENS => Box::new(RemoveFunctionCallParens::default()),
             REMOVE_METHOD_DEFINITION_RULE_NAME => Box::new(RemoveMethodDefinition::default()),
             REMOVE_UNUSED_IF_BRANCH_RULE_NAME => Box::new(RemoveUnusedIfBranch::default()),
             REMOVE_UNUSED_WHILE_RULE_NAME => Box::new(RemoveUnusedWhile::default()),

src/rules/mod.rs

@@ -0,0 +1,5 @@
+---
+source: src/rules/call_parens.rs
+expression: rule
+---
+"remove_function_call_parens"

src/rules/snapshots/test__default_remove_function_call_parens.snap

@@ -9,5 +9,6 @@ expression: rules
   "remove_method_definition",
   "convert_local_function_to_assign",
   "group_local_assignment",
-  "rename_variables"
+  "rename_variables",
+  "remove_function_call_parens"
 ]

src/rules/snapshots/test__default_rules.snap

@@ -42,6 +42,7 @@ macro_rules! test_rule_wihout_effects {
 
 mod group_local_assignment;
 mod no_local_function;
+mod remove_call_parens;
 mod remove_empty_do;
 mod remove_method_definition;
 mod remove_unused_if_branch;

tests/rule_tests/mod.rs

@@ -0,0 +1,28 @@
+use darklua_core::rules::{RemoveFunctionCallParens, Rule};
+
+test_rule!(
+    RemoveFunctionCallParens::default(),
+    call_statement_with_empty_string("foo('')") => "foo''",
+    call_statement_with_empty_table("foo({})") => "foo{}",
+    call_expression_with_empty_string("return foo('')") => "return foo''",
+    call_expression_with_empty_table("return foo({})") => "return foo{}"
+);
+
+test_rule_wihout_effects!(
+    RemoveFunctionCallParens::default(),
+    two_strings("foo('bar', 'baz')"),
+    two_tables("foo({}, {})"),
+    variable_parameter("foo(bar)")
+);
+
+#[test]
+fn deserialize_from_object_notation() {
+    json5::from_str::<Box<dyn Rule>>(r#"{
+        rule: 'remove_function_call_parens',
+    }"#).unwrap();
+}
+
+#[test]
+fn deserialize_from_string() {
+    json5::from_str::<Box<dyn Rule>>("'remove_function_call_parens'").unwrap();
+}