Apply consistent naming convention for linelength rules

Author: jvsqzj

example_files/example_lint_cfg.json

@@ -19,9 +19,9 @@
     "indent_switch_case": {},
     "indent_empty_loop": {},
     "indent_continuation_line": {},
-    "func_call_break_on_open_paren": {},
-    "method_output_break": {},
-    "conditional_expression_break_before_op": {},
+    "break_conditional_expression": {},
+    "break_method_output": {},
+    "break_conditional_expression_before_op": {},
     "break_before_binary_op": {},
     "annotate_lints": true
 }

src/analysis/parsing/expression.rs

@@ -162,7 +162,7 @@ impl TreeElement for TertiaryExpressionContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
         rules.sp_ternary.check(SpTernaryArgs::from_tertiary_expression_content(self), acc);
-        rules.conditional_expression_break_before_op
+        rules.break_conditional_expression_before_op
             .check(ConditionalExpressionBreakBeforeOperatorArgs::from_tertiary_expression(self), acc);
     }
 }
@@ -183,7 +183,7 @@ impl TreeElement for ParenExpressionContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
         rules.indent_paren_expr.check(IndentParenExprArgs::from_paren_expression(self), acc);
-        rules.func_call_break_on_open_paren.check(
+        rules.break_conditional_expression.check(
             FuncCallBreakOnOpenParenArgs::from_paren_expression(self, aux.depth), acc);
     }
 }
@@ -235,7 +235,7 @@ impl TreeElement for FunctionCallContent {
         rules.nsp_inparen.check(NspInparenArgs::from_function_call(self), acc);
         rules.sp_punct.check(SpPunctArgs::from_function_call(self), acc);
         rules.indent_paren_expr.check(IndentParenExprArgs::from_function_call(self), acc);
-        rules.func_call_break_on_open_paren
+        rules.break_conditional_expression
             .check(FuncCallBreakOnOpenParenArgs::from_function_call(self, aux.depth), acc);
     }
 }
@@ -352,7 +352,7 @@ impl TreeElement for CastContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
         rules.indent_paren_expr.check(IndentParenExprArgs::from_cast(self), acc);
-        rules.func_call_break_on_open_paren
+        rules.break_conditional_expression
             .check(FuncCallBreakOnOpenParenArgs::from_cast(self, aux.depth), acc);
     }
 }

src/analysis/parsing/structure.rs

@@ -244,8 +244,8 @@ impl TreeElement for MethodContent {
         rules.nsp_inparen.check(NspInparenArgs::from_method(self), acc);
         rules.sp_punct.check(SpPunctArgs::from_method(self), acc);
         rules.indent_paren_expr.check(IndentParenExprArgs::from_method(self), acc);
-        rules.func_call_break_on_open_paren.check(FuncCallBreakOnOpenParenArgs::from_method(self, aux.depth), acc);
-        rules.method_output_break.check(MethodOutputBreakArgs::from_method(self), acc);
+        rules.break_conditional_expression.check(FuncCallBreakOnOpenParenArgs::from_method(self, aux.depth), acc);
+        rules.break_method_output.check(MethodOutputBreakArgs::from_method(self), acc);
     }
 }
 

src/lint/features.md

@@ -53,8 +53,8 @@ Below are listed the currently supported rules for linting:
          + another_very_long_expression)
         * a_third_long_expression;
 ```
-- **LL3**, `conditional_expression_break`: Break conditional expressions before the ?, or both before the ? and before the :.
-- **LL5**, `method_output_break`: Break long method declarations with output parameters before the arrow.
+- **LL3**, `break_conditional_expression`: Break conditional expressions before the ?, or both before the ? and before the :.
+- **LL5**, `break_method_output`: Break long method declarations with output parameters before the arrow.
 ```
     method inquiry_status(uint64 physical_address)
         -> (uint16 status) {

src/lint/mod.rs

@@ -118,11 +118,11 @@ pub struct LintCfg {
     #[serde(default)]
     pub indent_continuation_line: Option<IndentContinuationLineOptions>,
     #[serde(default)]
-    pub func_call_break_on_open_paren: Option<FuncCallBreakOnOpenParenOptions>,
+    pub break_conditional_expression: Option<FuncCallBreakOnOpenParenOptions>,
     #[serde(default)]
-    pub conditional_expression_break_before_op: Option<ConditionalExpressionBreakBeforeOperatorOptions>,
+    pub break_conditional_expression_before_op: Option<ConditionalExpressionBreakBeforeOperatorOptions>,
     #[serde(default)]
-    pub method_output_break: Option<MethodOutputBreakOptions>,
+    pub break_method_output: Option<MethodOutputBreakOptions>,
     #[serde(default)]
     pub break_before_binary_op: Option<BreakBeforeBinaryOpOptions>,
     #[serde(default = "get_true")]
@@ -171,9 +171,9 @@ 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_open_paren: Some(FuncCallBreakOnOpenParenOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
-            method_output_break: Some(MethodOutputBreakOptions{}),
-            conditional_expression_break_before_op: Some(ConditionalExpressionBreakBeforeOperatorOptions{}),
+            break_conditional_expression: Some(FuncCallBreakOnOpenParenOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
+            break_method_output: Some(MethodOutputBreakOptions{}),
+            break_conditional_expression_before_op: Some(ConditionalExpressionBreakBeforeOperatorOptions{}),
             break_before_binary_op: Some(BreakBeforeBinaryOpOptions{}),
             annotate_lints: true,
         }

src/lint/rules/linebreaking.rs

@@ -32,7 +32,7 @@ pub struct MethodOutputBreakOptions{
 
 impl Rule for MethodOutputBreakRule {
     fn name() -> &'static str {
-        "method_output_break"
+        "break_method_output"
     }
     fn description() -> &'static str {
         "Break long method declarations with output parameters before the arrow."
@@ -87,7 +87,7 @@ pub struct FuncCallBreakOnOpenParenOptions{
 
 impl Rule for FuncCallBreakOnOpenParenRule {
     fn name() -> &'static str {
-        "FUNC_CALL_BREAK_ON_OPEN_PAREN"
+        "break_func_call_open_paren"
     }
     fn description() -> &'static str {
         "Function or method calls broken right after opening parenthesis should
@@ -332,7 +332,7 @@ pub struct ConditionalExpressionBreakBeforeOperatorOptions{
 
 impl Rule for ConditionalExpressionBreakBeforeOperatorRule {
     fn name() -> &'static str {
-        "COND_EXPRESSION_BREAK_BEFORE_OPERATOR"
+        "break_conditional_expression"
     }
     fn description() -> &'static str {
         "Break conditional expressions before the ?, or both before the ? and before the :."

src/lint/rules/mod.rs

@@ -51,9 +51,9 @@ pub struct CurrentRules {
     pub indent_switch_case: IndentSwitchCaseRule,
     pub indent_empty_loop: IndentEmptyLoopRule,
     pub indent_continuation_line: IndentContinuationLineRule,
-    pub func_call_break_on_open_paren: FuncCallBreakOnOpenParenRule,
-    pub method_output_break: MethodOutputBreakRule,
-    pub conditional_expression_break_before_op: ConditionalExpressionBreakBeforeOperatorRule,
+    pub break_conditional_expression: FuncCallBreakOnOpenParenRule,
+    pub break_method_output: MethodOutputBreakRule,
+    pub break_conditional_expression_before_op: ConditionalExpressionBreakBeforeOperatorRule,
     pub break_before_binary_op: BreakBeforeBinaryOpRule, // Placeholder for future rule
 }
 
@@ -78,9 +78,9 @@ 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_open_paren: FuncCallBreakOnOpenParenRule::from_options(&cfg.func_call_break_on_open_paren),
-        method_output_break: MethodOutputBreakRule { enabled: cfg.method_output_break.is_some() },
-        conditional_expression_break_before_op: ConditionalExpressionBreakBeforeOperatorRule::from_options(&cfg.conditional_expression_break_before_op),
+        break_conditional_expression: FuncCallBreakOnOpenParenRule::from_options(&cfg.break_conditional_expression),
+        break_method_output: MethodOutputBreakRule { enabled: cfg.break_method_output.is_some() },
+        break_conditional_expression_before_op: ConditionalExpressionBreakBeforeOperatorRule::from_options(&cfg.break_conditional_expression_before_op),
         break_before_binary_op: BreakBeforeBinaryOpRule { enabled: cfg.break_before_binary_op.is_some() },
     }
 }

src/lint/rules/tests/line_length_breaking/mod.rs

@@ -2,50 +2,50 @@ use crate::lint::rules::tests::common::{set_up, assert_snippet};
 use crate::lint::rules::RuleType;
 
 
-static CORRECT_BREAK_BEFORE_QUESTION_MARK: &str = "
+static BEFORE_QUESTION_MARK_CORRECT: &str = "
 method bootprep_type_to_string(uint8 prep_type) -> (const char*) {
     return
         prep_type == PREP_GENERAL
         ? \"PrepGeneral\" : \"PrepEarly\";
 }";
 #[test]
-fn condexpr_correct_break_before_question_mark() {
+fn before_question_mark_correct() {
     let rules = set_up();
     let expected_errors = vec![];
-    assert_snippet(CORRECT_BREAK_BEFORE_QUESTION_MARK, expected_errors, &rules);
+    assert_snippet(BEFORE_QUESTION_MARK_CORRECT, expected_errors, &rules);
 }
 
-static CORRECT_BREAK_BEFORE_COLON_AND_QUESTION_MARK: &str = "
+static BEFORE_COLON_AND_QUESTION_MARK_CORRECT: &str = "
 method bootprep_type_to_string(uint8 prep_type) -> (const char*) {
     return
         prep_type == PREP_GENERAL
         ? \"PrepGeneral\"
         : \"PrepEarly\";
 }";
 #[test]
-fn condexpr_correct_break_after_colon_and_question_mark() {
+fn after_colon_and_question_mark_correct() {
     let rules = set_up();
     let expected_errors = vec![];
-    assert_snippet(CORRECT_BREAK_BEFORE_COLON_AND_QUESTION_MARK, expected_errors, &rules);
+    assert_snippet(BEFORE_COLON_AND_QUESTION_MARK_CORRECT, expected_errors, &rules);
 }
 
-static BREAK_ONLY_BEFORE_COLON: &str = "
+static ONLY_BEFORE_COLON: &str = "
 method harvest_resource() {
     harvest_resource(my->gas < GAS_THRESHOLD ? Rsrc_Gas
                      : (my->minerals < MINERAL_THRESHOLD
                         ? Rsrc_Minerals : nearest_resource()));
 }";
 #[test]
-fn condexpr_only_before_colon() {
+fn only_before_colon() {
     let rules = set_up();
     let expected_errors = define_expected_errors!(
         RuleType::LL3,
         (3, 3, 21, 22),
     );
-    assert_snippet(BREAK_ONLY_BEFORE_COLON, expected_errors, &rules);
+    assert_snippet(ONLY_BEFORE_COLON, expected_errors, &rules);
 }
 
-static CORRECT_NESTED: &str = "
+static NESTED_CORRECT: &str = "
 method bootprep_type_to_string(uint8 prep_type) -> (const char*) {
     return
         prep_type == PREP_GENERAL
@@ -54,13 +54,13 @@ method bootprep_type_to_string(uint8 prep_type) -> (const char*) {
         ? \"PrepEarly\" : \"UnknownBootPrepType\";
 }";
 #[test]
-fn condexpr_correct_nested() {
+fn nested_correct() {
     let rules = set_up();
     let expected_errors = vec![];
-    assert_snippet(CORRECT_NESTED, expected_errors, &rules);
+    assert_snippet(NESTED_CORRECT, expected_errors, &rules);
 }
 
-static BREAK_AFTER_OPERATORS_NESTED: &str = "
+static AFTER_OPERATORS_NESTED: &str = "
 method bootprep_type_to_string(uint8 prep_type) -> (const char*) {
     return
         prep_type == PREP_GENERAL ?
@@ -69,14 +69,14 @@ method bootprep_type_to_string(uint8 prep_type) -> (const char*) {
         \"UnknownBootPrepType\";
 }";
 #[test]
-fn condexpr_broken_after_operators_nested() {
+fn after_operators_nested() {
     let rules = set_up();
     let expected_errors = define_expected_errors!(
         RuleType::LL3,
         (3, 3, 34, 35),
         (4, 4, 22, 23),
         (5, 5, 46, 47),
     );
-    assert_snippet(BREAK_AFTER_OPERATORS_NESTED, expected_errors, &rules);
+    assert_snippet(AFTER_OPERATORS_NESTED, expected_errors, &rules);
 }
 

src/lint/rules/tests/line_length_breaking/conditional_expression_break.rs renamed to src/lint/rules/tests/linelength/break_conditional_expression.rs

@@ -4,7 +4,7 @@ use crate::lint::rules::RuleType;
 // LL6: Function and method invocations can be broken after the opening parenthesis,
 //  with the continuation lines indented one level.
 
-static FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_CORRECT: &str = "
+static AFTER_PAREN_EXCEPTION_CORRECT: &str = "
 method effect() {
     callback(
         0xABC,
@@ -13,12 +13,12 @@ method effect() {
 }
 ";
 #[test]
-fn funcall_broken_after_paren_exception_correct() {
+fn after_paren_exception_correct() {
     let rules = set_up();
-    assert_snippet(FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_CORRECT, vec![], &rules);
+    assert_snippet(AFTER_PAREN_EXCEPTION_CORRECT, vec![], &rules);
 }
 
-static FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_INCORRECT: &str = "
+static AFTER_PAREN_EXCEPTION_INCORRECT: &str = "
 method effect() {
     callback(
         0xABC,
@@ -27,14 +27,14 @@ method effect() {
 }
 ";
 #[test]
-fn funcall_broken_after_paren_exception_incorrect() {
+fn after_paren_exception_incorrect() {
     let rules = set_up();
     let expected_errors = define_expected_errors!(
         RuleType::LL6,
         (4, 4, 12, 22),
         (5, 5, 4, 9),
     );
-    assert_snippet(FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_INCORRECT, expected_errors, &rules);
+    assert_snippet(AFTER_PAREN_EXCEPTION_INCORRECT, expected_errors, &rules);
 }
 
 static FIRST_LINE_INCORRECT: &str = "
@@ -55,7 +55,7 @@ fn first_line_incorrect() {
     assert_snippet(FIRST_LINE_INCORRECT, expected_errors, &rules);
 }
 
-static PAREN_NESTED_CORRECT: &str = "
+static NESTED_PAREN_CORRECT: &str = "
 param result = (
     (reg0.val
      * reg1.enable.val)
@@ -64,12 +64,12 @@ param result = (
 ";
 
 #[test]
-fn paren_nested_correct(){
+fn nested_paren_correct(){
     let rules = set_up();
-    assert_snippet(PAREN_NESTED_CORRECT, vec![], &rules);
+    assert_snippet(NESTED_PAREN_CORRECT, vec![], &rules);
 }
 
-static PAREN_NESTED_INCORRECT: &str = "
+static NESTED_PAREN_INCORRECT: &str = "
 param result = (
     (reg0.val
      * reg1.enable.val)
@@ -78,14 +78,14 @@ param result = (
 ";
 
 #[test]
-fn paren_nested_incorrect(){
+fn nested_paren_incorrect(){
     let rules = set_up();
     let expected_errors = define_expected_errors!(
         RuleType::LL6,
         (4, 4, 16, 17),
         (5, 5, 16, 17),
     );
-    assert_snippet(PAREN_NESTED_INCORRECT, expected_errors, &rules);
+    assert_snippet(NESTED_PAREN_INCORRECT, expected_errors, &rules);
 }
 
 static METHOD_CORRECT: &str = "