Add rule LL6 for funcall broken after left paren

Author: jvsqzj

src/analysis/parsing/expression.rs

@@ -25,6 +25,7 @@ use crate::lint::{DMLStyleError,
                                     CurrentRules},
                                     AuxParams};
 use crate::lint::rules::indentation::IndentParenExprArgs;
+use crate::lint::rules::linebreaking::FuncCallBreakOnOpeningParenArgs;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct UnaryExpressionContent {
@@ -214,11 +215,13 @@ impl TreeElement for FunctionCallContent {
                 noderef, ReferenceKind::Callable));
         }
     }
-    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
         rules.nsp_funpar.check(acc, NspFunparArgs::from_function_call(self));
         rules.nsp_inparen.check(acc, NspInparenArgs::from_function_call(self));
         rules.sp_punct.check(acc, SpPunctArgs::from_function_call(self));
         rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_function_call(self));
+        rules.func_call_break_on_opening_paren
+            .check(acc, FuncCallBreakOnOpeningParenArgs::from_function_call(self, aux.depth));
     }
 }
 

src/lint/mod.rs

@@ -2,6 +2,7 @@ use std::fmt;
 use std::fs;
 use std::path::{Path, PathBuf};
 use log::{debug, error, trace};
+use rules::linebreaking::FuncCallBreakOnOpeningParenOptions;
 use serde::{Deserialize, Serialize};
 use rules::{instantiate_rules, CurrentRules, RuleType};
 use rules::{spacing::{SpBraceOptions, SpPunctOptions, NspFunparOptions,
@@ -75,6 +76,8 @@ pub struct LintCfg {
     pub indent_empty_loop: Option<IndentEmptyLoopOptions>,
     #[serde(default)]
     pub indent_continuation_line: Option<IndentContinuationLineOptions>,
+    #[serde(default)]
+    pub func_call_break_on_opening_paren: Option<FuncCallBreakOnOpeningParenOptions>,
 }
 
 impl Default for LintCfg {
@@ -95,10 +98,12 @@ impl Default for LintCfg {
             indent_switch_case: Some(IndentSwitchCaseOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
             indent_empty_loop: Some(IndentEmptyLoopOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
             indent_continuation_line: Some(IndentContinuationLineOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
+            func_call_break_on_opening_paren: Some(FuncCallBreakOnOpeningParenOptions{}),
         }
     }
 }
 
+
 #[derive(Debug, Clone)]
 pub struct DMLStyleError {
     pub error: LocalDMLError,

src/lint/rules/linebreaking.rs

@@ -0,0 +1,83 @@
+use serde::{Deserialize, Serialize};
+use crate::analysis::parsing::lexer::TokenKind;
+use crate::analysis::parsing::tree::{ZeroRange, TreeElement};
+use crate::analysis::parsing::{expression::{CastContent, FunctionCallContent}};
+use crate::lint::{DMLStyleError, LintCfg, RuleType};
+use crate::lint::rules::indentation::IndentParenExprArgs;
+use super::Rule;
+
+pub struct FuncCallBreakOnOpeningParen {
+    pub enabled: bool,
+}
+
+pub struct FuncCallBreakOnOpeningParenArgs {
+    pub member_ranges: Vec<ZeroRange>,
+    pub expected_depth: u32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct FuncCallBreakOnOpeningParenOptions{}
+
+// pub struct FunctionCallContent {
+//     pub fun: Expression,
+//     pub lparen: LeafToken,
+//     pub arguments: Vec<(SingleInitializer, Option<LeafToken>)>,
+//     pub rparen: LeafToken,
+// }
+
+impl FuncCallBreakOnOpeningParenArgs {
+    pub fn from_function_call(node: &FunctionCallContent, depth: u32) -> Option<FuncCallBreakOnOpeningParenArgs> {
+        let mut filtered_member_ranges: Vec<ZeroRange> = vec![];
+        for (arg, _comma) in node.arguments.iter() {
+            filtered_member_ranges.extend(
+                IndentParenExprArgs::filter_out_parenthesized_tokens(arg.tokens())
+                    .iter().filter(|t| t.kind != TokenKind::RParen).map(|t| t.range)
+            );
+        }
+        if filtered_member_ranges.is_empty()
+            || ! IndentParenExprArgs::is_broken_after_lparen(
+                node.lparen.range(),
+                filtered_member_ranges.first()?.to_owned()) {
+            return None
+        }
+        Some(FuncCallBreakOnOpeningParenArgs {
+            member_ranges: filtered_member_ranges,
+            expected_depth: depth,
+        })
+    }
+}
+
+impl FuncCallBreakOnOpeningParen {
+    pub fn check(&self, acc: &mut Vec<DMLStyleError>, args: Option<FuncCallBreakOnOpeningParenArgs>) {
+        if !self.enabled {
+            return;
+        } 
+        let Some(args) = args else { return; };
+        // TODO : enable shared access to indentation_spaces param for all related rules
+        let expected_line_start = args.expected_depth * 4; // Assuming 4 spaces per indent level
+        let mut last_row = args.member_ranges.first().unwrap().row_start.0;
+
+        for member_range in args.member_ranges {
+            if member_range.row_start.0 != last_row {
+                last_row = member_range.row_start.0;
+                if member_range.col_start.0 != expected_line_start {
+                    acc.push(self.create_err(member_range));
+                }
+            }
+        }
+    }
+}
+
+impl Rule for FuncCallBreakOnOpeningParen {
+    fn name() -> &'static str {
+        "FUNC_CALL_BREAK_ON_OPENING_PAREN"
+    }
+    fn description() -> &'static str {
+        "Function or method calls broken right after opening parenthesis should
+        indent continuation lines one more level."
+    }
+    fn get_rule_type() -> RuleType {
+        RuleType::LL6
+    }
+}
+

src/lint/rules/mod.rs

@@ -1,5 +1,6 @@
 pub mod spacing;
 pub mod indentation;
+pub mod linebreaking;
 
 #[cfg(test)]
 pub mod tests;
@@ -8,6 +9,7 @@ use spacing::{SpBracesRule,
     SpPunctRule, NspFunparRule, NspInparenRule,
     NspUnaryRule, NspTrailingRule};
 use indentation::{LongLinesRule, IndentNoTabRule, IndentCodeBlockRule, IndentClosingBraceRule, IndentParenExprRule, IndentSwitchCaseRule, IndentEmptyLoopRule, IndentContinuationLineRule};
+use linebreaking::FuncCallBreakOnOpeningParen;
 use crate::lint::{LintCfg, DMLStyleError};
 use crate::analysis::{LocalDMLError, parsing::tree::ZeroRange};
 
@@ -26,6 +28,7 @@ pub struct CurrentRules {
     pub indent_switch_case: IndentSwitchCaseRule,
     pub indent_empty_loop: IndentEmptyLoopRule,
     pub indent_continuation_line: IndentContinuationLineRule,
+    pub func_call_break_on_opening_paren: FuncCallBreakOnOpeningParen,
 }
 
 pub fn  instantiate_rules(cfg: &LintCfg) -> CurrentRules {
@@ -44,6 +47,7 @@ pub fn  instantiate_rules(cfg: &LintCfg) -> CurrentRules {
         indent_switch_case: IndentSwitchCaseRule::from_options(&cfg.indent_switch_case),
         indent_empty_loop: IndentEmptyLoopRule::from_options(&cfg.indent_empty_loop),
         indent_continuation_line: IndentContinuationLineRule::from_options(&cfg.indent_continuation_line),
+        func_call_break_on_opening_paren: FuncCallBreakOnOpeningParen { enabled: cfg.func_call_break_on_opening_paren.is_some() },
     }
 }
 
@@ -72,6 +76,7 @@ pub enum RuleType {
     NspUnary,
     NspTrailing,
     LL1,
+    LL6,
     IN2,
     IN3,
     IN4,