Refactor LL6 rule: handle function calls broken after opening parenthesis

me-cr · me-cr · commit b934564aae55 · 2025-07-01T10:01:32.000-06:00
diff --git a/example_files/example_lint_cfg.json b/example_files/example_lint_cfg.json
@@ -13,5 +13,6 @@
     "indent_paren_expr": {},
     "indent_switch_case": {},
     "indent_empty_loop": {},
-    "indent_continuation_line": {}
+    "indent_continuation_line": {},
+    "func_call_break_on_open_paren": {}
 }
diff --git a/src/analysis/parsing/expression.rs b/src/analysis/parsing/expression.rs
@@ -25,7 +25,7 @@ use crate::lint::{DMLStyleError,
                                     CurrentRules},
                                     AuxParams};
 use crate::lint::rules::indentation::IndentParenExprArgs;
-use crate::lint::rules::linebreaking::FuncCallBreakOnOpeningParenArgs;
+use crate::lint::rules::linebreaking::FuncCallBreakOnOpenParenArgs;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct UnaryExpressionContent {
@@ -170,6 +170,8 @@ impl TreeElement for ParenExpressionContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
         rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_paren_expression(self));
+        rules.func_call_break_on_open_paren.check(acc,
+            FuncCallBreakOnOpenParenArgs::from_paren_expression(self, _aux.depth));
     }
 }
 
@@ -220,8 +222,8 @@ impl TreeElement for FunctionCallContent {
         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));
+        rules.func_call_break_on_open_paren
+            .check(acc, FuncCallBreakOnOpenParenArgs::from_function_call(self, aux.depth));
     }
 }
 
@@ -337,6 +339,8 @@ impl TreeElement for CastContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
         rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_cast(self));
+        rules.func_call_break_on_open_paren
+            .check(acc, FuncCallBreakOnOpenParenArgs::from_cast(self, _aux.depth));
     }
 }
 
diff --git a/src/analysis/parsing/structure.rs b/src/analysis/parsing/structure.rs
@@ -16,6 +16,7 @@ use crate::analysis::parsing::parser::{doesnt_understand_tokens,
                                        FileParser, Parse, ParseContext,
                                        FileInfo};
 use crate::analysis::LocalDMLError;
+use crate::lint::rules::linebreaking::FuncCallBreakOnOpenParenArgs;
 use crate::lint::rules::spacing::{SpBracesArgs,
                                   NspInparenArgs,
                                   NspFunparArgs,
@@ -240,6 +241,7 @@ impl TreeElement for MethodContent {
         rules.nsp_inparen.check(acc, NspInparenArgs::from_method(self));
         rules.sp_punct.check(acc, SpPunctArgs::from_method(self));
         rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_method(self));
+        rules.func_call_break_on_open_paren.check(acc, FuncCallBreakOnOpenParenArgs::from_method(self, _aux.depth));
     }
 }
 
diff --git a/src/lint/mod.rs b/src/lint/mod.rs
@@ -2,7 +2,7 @@ use std::fmt;
 use std::fs;
 use std::path::{Path, PathBuf};
 use log::{debug, error, trace};
-use rules::linebreaking::FuncCallBreakOnOpeningParenOptions;
+use rules::linebreaking::FuncCallBreakOnOpenParenOptions;
 use serde::{Deserialize, Serialize};
 use rules::{instantiate_rules, CurrentRules, RuleType};
 use rules::{spacing::{SpBraceOptions, SpPunctOptions, NspFunparOptions,
@@ -77,7 +77,7 @@ pub struct LintCfg {
     #[serde(default)]
     pub indent_continuation_line: Option<IndentContinuationLineOptions>,
     #[serde(default)]
-    pub func_call_break_on_opening_paren: Option<FuncCallBreakOnOpeningParenOptions>,
+    pub func_call_break_on_open_paren: Option<FuncCallBreakOnOpenParenOptions>,
 }
 
 impl Default for LintCfg {
@@ -98,7 +98,7 @@ 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{}),
+            func_call_break_on_open_paren: Some(FuncCallBreakOnOpenParenOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
         }
     }
 }
diff --git a/src/lint/rules/indentation.rs b/src/lint/rules/indentation.rs
@@ -505,9 +505,14 @@ impl IndentParenExprRule {
         args: Option<IndentParenExprArgs>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
+        if args.members_ranges.is_empty() { return; }
         let expected_line_start = args.lparen.col_start.0 + 1;
         let mut last_row = args.lparen.row_start.0;
-
+        if last_row != args.members_ranges.first().unwrap().row_start.0 {
+            // If the first member is not on the same line as the lparen,
+            // then it is not a continuation line, so we do not check it.
+            return;
+        }
         for member_range in args.members_ranges {
             if member_range.row_start.0 != last_row {
                 last_row = member_range.row_start.0;
diff --git a/src/lint/rules/linebreaking.rs b/src/lint/rules/linebreaking.rs
@@ -1,32 +1,86 @@
 use serde::{Deserialize, Serialize};
 use crate::analysis::parsing::lexer::TokenKind;
+use crate::analysis::parsing::structure::MethodContent;
 use crate::analysis::parsing::tree::{ZeroRange, TreeElement};
-use crate::analysis::parsing::{expression::{CastContent, FunctionCallContent}};
-use crate::lint::{DMLStyleError, LintCfg, RuleType};
+use crate::analysis::parsing::expression::{CastContent, FunctionCallContent, ParenExpressionContent};
+use crate::lint::{DMLStyleError, RuleType};
 use crate::lint::rules::indentation::IndentParenExprArgs;
 use super::Rule;
 
-pub struct FuncCallBreakOnOpeningParen {
+pub const INDENTATION_LEVEL_DEFAULT: u32 = 4;
+
+fn default_indentation_spaces() -> u32 {
+    INDENTATION_LEVEL_DEFAULT
+}
+
+pub struct FuncCallBreakOnOpenParenRule {
     pub enabled: bool,
+    indentation_spaces: u32
 }
 
-pub struct FuncCallBreakOnOpeningParenArgs {
-    pub member_ranges: Vec<ZeroRange>,
+pub struct FuncCallBreakOnOpenParenArgs {
+    pub members_ranges: Vec<ZeroRange>,
     pub expected_depth: u32,
+    pub lparen: ZeroRange,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct FuncCallBreakOnOpeningParenOptions{}
+pub struct FuncCallBreakOnOpenParenOptions{
+    #[serde(default = "default_indentation_spaces")]
+    pub indentation_spaces: u32,
+}
+
+impl Rule for FuncCallBreakOnOpenParenRule {
+    fn name() -> &'static str {
+        "FUNC_CALL_BREAK_ON_OPEN_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
+    }
+}
 
-// pub struct FunctionCallContent {
-//     pub fun: Expression,
-//     pub lparen: LeafToken,
-//     pub arguments: Vec<(SingleInitializer, Option<LeafToken>)>,
-//     pub rparen: LeafToken,
-// }
+impl FuncCallBreakOnOpenParenRule {
+    pub fn from_options(options: &Option<FuncCallBreakOnOpenParenOptions>) -> FuncCallBreakOnOpenParenRule {
+        match options {
+            Some(options) => FuncCallBreakOnOpenParenRule {
+                enabled: true,
+                indentation_spaces: options.indentation_spaces
+            },
+            None => FuncCallBreakOnOpenParenRule {
+                enabled: false,
+                indentation_spaces: 0
+            }
+        }
+    }
+
+    pub fn check(&self, acc: &mut Vec<DMLStyleError>, args: Option<FuncCallBreakOnOpenParenArgs>) {
+        if !self.enabled { return; }
+        let Some(args) = args else { return; };
+        if args.members_ranges.is_empty() { return; }
+        let expected_line_start = self.indentation_spaces * (args.expected_depth + 1);
+        let mut last_row = args.lparen.row_start.0;
+        if last_row == args.members_ranges.first().unwrap().row_start.0 {
+            // If the first member is on the same line as the lparen, we don't
+            // need to check it.
+            return;
+        }
+        for member_range in args.members_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 FuncCallBreakOnOpeningParenArgs {
-    pub fn from_function_call(node: &FunctionCallContent, depth: u32) -> Option<FuncCallBreakOnOpeningParenArgs> {
+impl FuncCallBreakOnOpenParenArgs {
+    pub fn from_function_call(node: &FunctionCallContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
         let mut filtered_member_ranges: Vec<ZeroRange> = vec![];
         for (arg, _comma) in node.arguments.iter() {
             filtered_member_ranges.extend(
@@ -40,44 +94,44 @@ impl FuncCallBreakOnOpeningParenArgs {
                 filtered_member_ranges.first()?.to_owned()) {
             return None
         }
-        Some(FuncCallBreakOnOpeningParenArgs {
-            member_ranges: filtered_member_ranges,
+        Some(FuncCallBreakOnOpenParenArgs {
+            members_ranges: filtered_member_ranges,
             expected_depth: depth,
+            lparen: node.lparen.range(),
         })
     }
-}
 
-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;
+    pub fn from_paren_expression(node: &ParenExpressionContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
+        Some(FuncCallBreakOnOpenParenArgs {
+            members_ranges: IndentParenExprArgs::filter_out_parenthesized_tokens(node.expr.tokens())
+                .iter().filter(|t| t.kind != TokenKind::RParen).map(|t| t.range).collect(),
+            expected_depth: depth,
+            lparen: node.lparen.range(),
+        })
+    }
 
-        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));
-                }
-            }
+    pub fn from_method(node: &MethodContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
+        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));
         }
+        Some(FuncCallBreakOnOpenParenArgs {
+            members_ranges: filtered_member_ranges,
+            expected_depth: depth,
+            lparen: node.lparen.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
+    pub fn from_cast(node: &CastContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
+        let mut cast_member_tokens = node.from.tokens();
+        cast_member_tokens.append(&mut node.to.tokens());
+        Some(FuncCallBreakOnOpenParenArgs {
+            members_ranges: IndentParenExprArgs::filter_out_parenthesized_tokens(cast_member_tokens)
+                .iter().filter(|t| t.kind != TokenKind::RParen).map(|t| t.range).collect(),
+            expected_depth: depth,
+            lparen: node.lparen.range(),
+        })
     }
 }
-
diff --git a/src/lint/rules/mod.rs b/src/lint/rules/mod.rs
@@ -9,7 +9,7 @@ use spacing::{SpBracesRule,
     SpPunctRule, NspFunparRule, NspInparenRule,
     NspUnaryRule, NspTrailingRule};
 use indentation::{LongLinesRule, IndentNoTabRule, IndentCodeBlockRule, IndentClosingBraceRule, IndentParenExprRule, IndentSwitchCaseRule, IndentEmptyLoopRule, IndentContinuationLineRule};
-use linebreaking::FuncCallBreakOnOpeningParen;
+use linebreaking::FuncCallBreakOnOpenParenRule;
 use crate::lint::{LintCfg, DMLStyleError};
 use crate::analysis::{LocalDMLError, parsing::tree::ZeroRange};
 
@@ -28,7 +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 func_call_break_on_open_paren: FuncCallBreakOnOpenParenRule,
 }
 
 pub fn  instantiate_rules(cfg: &LintCfg) -> CurrentRules {
@@ -47,7 +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() },
+        func_call_break_on_open_paren: FuncCallBreakOnOpenParenRule::from_options(&cfg.func_call_break_on_open_paren),
     }
 }
 
diff --git a/src/lint/rules/tests/indentation/paren_expr.rs b/src/lint/rules/tests/indentation/paren_expr.rs
@@ -90,20 +90,6 @@ fn funcall_paren_incorrect() {
     assert_snippet(FUNCALL_PAREN_INCORRECT, expected_errors, &rules);
 }
 
-static FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_CORRECT: &str = "
-method effect() {
-    callback(
-        0xABC,
-        identifier,
-        false);
-}
-";
-#[test]
-fn funcall_broken_after_paren_exception_correct() {
-    let rules = set_up();
-    assert_snippet(FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_CORRECT, vec![], &rules);
-}
-
 static FUNCALL_NESTED_PAREN_CORRECT: &str = "
 method effect() {
     callback(another_cb(varname,
@@ -361,8 +347,7 @@ fn switch_paren_incorrect() {
 }
 
 static NESTED_PAREN_EXPR_CORRECT: &str = "
-param result = (
-                (reg0.val
+param result = ((reg0.val
                  * reg1.enable.val)
                 &
                 mask_reg
@@ -377,8 +362,7 @@ fn nested_paren_expr_correct(){
 }
 
 static NESTED_PAREN_EXPR_INCORRECT: &str = "
-param result = (
-    (reg0.val
+param result = ((reg0.val
      * reg1.enable.val)
                 &
                  mask_reg
@@ -391,8 +375,8 @@ fn nested_paren_expr_incorrect(){
     let rules = set_up();
     let expected_errors = define_expected_errors!(
         RuleType::IN5,
-        (2, 2, 4, 5),
-        (5, 5, 17, 25),
+        (2, 2, 5, 6),
+        (4, 4, 17, 25),
     );
     assert_snippet(NESTED_PAREN_EXPR_INCORRECT, expected_errors, &rules);
 }
diff --git a/src/lint/rules/tests/line_length_breaking/func_call_break_open_paren.rs b/src/lint/rules/tests/line_length_breaking/func_call_break_open_paren.rs
diff --git a/src/lint/rules/tests/line_length_breaking/mod.rs b/src/lint/rules/tests/line_length_breaking/mod.rs
diff --git a/src/lint/rules/tests/mod.rs b/src/lint/rules/tests/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,6 @@`
`13`	`13`	`"indent_paren_expr": {},`
`14`	`14`	`"indent_switch_case": {},`
`15`	`15`	`"indent_empty_loop": {},`
`16`		`- "indent_continuation_line": {}`
	`16`	`+ "indent_continuation_line": {},`
	`17`	`+ "func_call_break_on_open_paren": {}`
`17`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ use crate::lint::{DMLStyleError,`
`25`	`25`	`CurrentRules},`
`26`	`26`	`AuxParams};`
`27`	`27`	`use crate::lint::rules::indentation::IndentParenExprArgs;`
`28`		`-use crate::lint::rules::linebreaking::FuncCallBreakOnOpeningParenArgs;`
	`28`	`+use crate::lint::rules::linebreaking::FuncCallBreakOnOpenParenArgs;`
`29`	`29`
`30`	`30`	`#[derive(Debug, Clone, PartialEq)]`
`31`	`31`	`pub struct UnaryExpressionContent {`
`@@ -170,6 +170,8 @@ impl TreeElement for ParenExpressionContent {`
`170`	`170`	`}`
`171`	`171`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`172`	`172`	`rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_paren_expression(self));`
	`173`	`+ rules.func_call_break_on_open_paren.check(acc,`
	`174`	`+ FuncCallBreakOnOpenParenArgs::from_paren_expression(self, _aux.depth));`
`173`	`175`	`}`
`174`	`176`	`}`
`175`	`177`
`@@ -220,8 +222,8 @@ impl TreeElement for FunctionCallContent {`
`220`	`222`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_function_call(self));`
`221`	`223`	`rules.sp_punct.check(acc, SpPunctArgs::from_function_call(self));`
`222`	`224`	`rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_function_call(self));`
`223`		`- rules.func_call_break_on_opening_paren`
`224`		`- .check(acc, FuncCallBreakOnOpeningParenArgs::from_function_call(self, aux.depth));`
	`225`	`+ rules.func_call_break_on_open_paren`
	`226`	`+ .check(acc, FuncCallBreakOnOpenParenArgs::from_function_call(self, aux.depth));`
`225`	`227`	`}`
`226`	`228`	`}`
`227`	`229`
`@@ -337,6 +339,8 @@ impl TreeElement for CastContent {`
`337`	`339`	`}`
`338`	`340`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`339`	`341`	`rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_cast(self));`
	`342`	`+ rules.func_call_break_on_open_paren`
	`343`	`+ .check(acc, FuncCallBreakOnOpenParenArgs::from_cast(self, _aux.depth));`
`340`	`344`	`}`
`341`	`345`	`}`
`342`	`346`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ use crate::analysis::parsing::parser::{doesnt_understand_tokens,`
`16`	`16`	`FileParser, Parse, ParseContext,`
`17`	`17`	`FileInfo};`
`18`	`18`	`use crate::analysis::LocalDMLError;`
	`19`	`+use crate::lint::rules::linebreaking::FuncCallBreakOnOpenParenArgs;`
`19`	`20`	`use crate::lint::rules::spacing::{SpBracesArgs,`
`20`	`21`	`NspInparenArgs,`
`21`	`22`	`NspFunparArgs,`
`@@ -240,6 +241,7 @@ impl TreeElement for MethodContent {`
`240`	`241`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_method(self));`
`241`	`242`	`rules.sp_punct.check(acc, SpPunctArgs::from_method(self));`
`242`	`243`	`rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_method(self));`
	`244`	`+ rules.func_call_break_on_open_paren.check(acc, FuncCallBreakOnOpenParenArgs::from_method(self, _aux.depth));`
`243`	`245`	`}`
`244`	`246`	`}`
`245`	`247`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ use std::fmt;`
`2`	`2`	`use std::fs;`
`3`	`3`	`use std::path::{Path, PathBuf};`
`4`	`4`	`use log::{debug, error, trace};`
`5`		`-use rules::linebreaking::FuncCallBreakOnOpeningParenOptions;`
	`5`	`+use rules::linebreaking::FuncCallBreakOnOpenParenOptions;`
`6`	`6`	`use serde::{Deserialize, Serialize};`
`7`	`7`	`use rules::{instantiate_rules, CurrentRules, RuleType};`
`8`	`8`	`use rules::{spacing::{SpBraceOptions, SpPunctOptions, NspFunparOptions,`
`@@ -77,7 +77,7 @@ pub struct LintCfg {`
`77`	`77`	`#[serde(default)]`
`78`	`78`	`pub indent_continuation_line: Option<IndentContinuationLineOptions>,`
`79`	`79`	`#[serde(default)]`
`80`		`- pub func_call_break_on_opening_paren: Option<FuncCallBreakOnOpeningParenOptions>,`
	`80`	`+ pub func_call_break_on_open_paren: Option<FuncCallBreakOnOpenParenOptions>,`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`impl Default for LintCfg {`
`@@ -98,7 +98,7 @@ impl Default for LintCfg {`
`98`	`98`	`indent_switch_case: Some(IndentSwitchCaseOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),`
`99`	`99`	`indent_empty_loop: Some(IndentEmptyLoopOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),`
`100`	`100`	`indent_continuation_line: Some(IndentContinuationLineOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),`
`101`		`- func_call_break_on_opening_paren: Some(FuncCallBreakOnOpeningParenOptions{}),`
	`101`	`+ func_call_break_on_open_paren: Some(FuncCallBreakOnOpenParenOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`	`}`