Add MethodOutputBreak (LL5) Rule (#24)

* Add MethodOutputBreak (LL5) Rule

Author: alecalvop

example_files/example_lint_cfg.json

@@ -20,5 +20,6 @@
     "indent_empty_loop": {},
     "indent_continuation_line": {},
     "func_call_break_on_open_paren": {},
+    "method_output_break": {},
     "annotate_lints": true
 }

src/analysis/parsing/structure.rs

@@ -16,7 +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::linebreaking::{FuncCallBreakOnOpenParenArgs, MethodOutputBreakArgs};
 use crate::lint::rules::spacing::{SpBracesArgs,
                                   NspInparenArgs,
                                   NspFunparArgs,
@@ -245,6 +245,7 @@ impl TreeElement for MethodContent {
         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);
     }
 }
 

src/lint/features.md

@@ -47,5 +47,12 @@ Below are listed the currently supported rules for linting:
 
 ## Line Length
 - **LL1**, `long_lines`: Lines should be kept shorter than 80 characters. This limit can be set to a custom value
+- **LL5**, `method_output_break`: Break long method declarations with output parameters before the arrow.
+```
+    method inquiry_status(uint64 physical_address)
+        -> (uint16 status) {
+        ...
+    }
+```
 
 ##### Check [Issue #76 For remaining and planned checks](https://github.com/intel/dml-language-server/issues/76)

src/lint/mod.rs

@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use lazy_static::lazy_static;
 use log::{debug, error, trace};
-use rules::linebreaking::FuncCallBreakOnOpenParenOptions;
+use rules::linebreaking::{FuncCallBreakOnOpenParenOptions, MethodOutputBreakOptions};
 use serde::{Deserialize, Serialize};
 use regex::Regex;
 use rules::{instantiate_rules, CurrentRules, RuleType};
@@ -116,6 +116,8 @@ pub struct LintCfg {
     pub indent_continuation_line: Option<IndentContinuationLineOptions>,
     #[serde(default)]
     pub func_call_break_on_open_paren: Option<FuncCallBreakOnOpenParenOptions>,
+    #[serde(default)]
+    pub method_output_break: Option<MethodOutputBreakOptions>,
     #[serde(default = "get_true")]
     pub annotate_lints: bool,
 }
@@ -163,6 +165,7 @@ impl Default for LintCfg {
             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{}),
             annotate_lints: true,
         }
     }

src/lint/rules/linebreaking.rs

@@ -14,6 +14,58 @@ fn default_indentation_spaces() -> u32 {
     INDENTATION_LEVEL_DEFAULT
 }
 
+pub struct MethodOutputBreakRule {
+    pub enabled: bool
+}
+
+pub struct MethodOutputBreakArgs {
+    pub before_arrow_range: ZeroRange,
+    pub arrow_range: ZeroRange,
+    pub after_arrow_range: ZeroRange,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct MethodOutputBreakOptions{
+}
+
+impl Rule for MethodOutputBreakRule {
+    fn name() -> &'static str {
+        "method_output_break"
+    }
+    fn description() -> &'static str {
+        "Break long method declarations with output parameters before the arrow."
+    }
+    fn get_rule_type() -> RuleType {
+        RuleType::LL5
+    }
+}
+
+impl MethodOutputBreakArgs {
+    pub fn from_method(node: &MethodContent) -> Option<MethodOutputBreakArgs> {
+        let Some(returns) = &node.returns else { return None; };
+        Some(MethodOutputBreakArgs {
+            before_arrow_range: node.rparen.range(),
+            arrow_range: returns.0.range(),
+            after_arrow_range: returns.1.range(),
+        })
+    }
+}
+
+impl MethodOutputBreakRule {
+    pub fn check(&self, args: Option<MethodOutputBreakArgs>, acc: &mut Vec<DMLStyleError>) {
+        if !self.enabled { return; }
+        let Some(args) = args else { return; };
+        if args.before_arrow_range.row_end.0 == args.after_arrow_range.row_start.0 {
+            // If all parts are on the same line, we don't need to check it.
+            return;
+        }
+        // If the arrow and the return type are not on the same line, report an error.
+        if args.arrow_range.row_start.0 != args.after_arrow_range.row_start.0 {
+            acc.push(self.create_err(args.arrow_range));
+        }
+    }
+}
+
 pub struct FuncCallBreakOnOpenParenRule {
     pub enabled: bool,
     indentation_spaces: u32

src/lint/rules/mod.rs

@@ -24,7 +24,8 @@ use indentation::{LongLinesRule,
     IndentSwitchCaseRule,
     IndentEmptyLoopRule,
     IndentContinuationLineRule};
-use linebreaking::FuncCallBreakOnOpenParenRule;
+use linebreaking::{FuncCallBreakOnOpenParenRule,
+    MethodOutputBreakRule};
 use crate::lint::{LintCfg, DMLStyleError};
 use crate::analysis::{LocalDMLError, parsing::tree::ZeroRange};
 
@@ -49,6 +50,7 @@ pub struct CurrentRules {
     pub indent_empty_loop: IndentEmptyLoopRule,
     pub indent_continuation_line: IndentContinuationLineRule,
     pub func_call_break_on_open_paren: FuncCallBreakOnOpenParenRule,
+    pub method_output_break: MethodOutputBreakRule,
 }
 
 pub fn  instantiate_rules(cfg: &LintCfg) -> CurrentRules {
@@ -73,6 +75,7 @@ pub fn  instantiate_rules(cfg: &LintCfg) -> CurrentRules {
         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() },
     }
 }
 
@@ -107,6 +110,7 @@ pub enum RuleType {
     NspUnary,
     NspTrailing,
     LL1,
+    LL5,
     LL6,
     IN2,
     IN3,

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

@@ -0,0 +1,60 @@
+use crate::lint::rules::tests::common::{set_up, assert_snippet};
+use crate::lint::rules::RuleType;
+
+// LL5: Break long method declarations with output parameters before the arrow.
+
+static METHOD_OUTPUT_BREAK_CORRECT: &str = "
+method inquiry_status(uint64 physical_address)
+        -> (uint16 status) {
+    return 0;
+}
+
+method inquiry_status(uint64 physical_address)
+    -> (uint16 status) {
+    return 0;
+}
+
+method inquiry_status(uint64 physical_address) -> (uint16 status) {
+    return 0;
+}
+
+method other_method(uint64 arg1,
+                    uint64 arg2)
+        -> (uint16 status) {
+    return 0;
+}
+";
+#[test]
+fn method_output_break_correct() {
+    let rules = set_up();
+    assert_snippet(METHOD_OUTPUT_BREAK_CORRECT, vec![], &rules);
+}
+
+static METHOD_OUTPUT_BREAK_INCORRECT: &str = "
+method inquiry_status(uint64 physical_address) ->
+    (uint16 status) {
+    return 0;
+}
+
+method inquiry_status(uint64 physical_address) ->
+        (uint16 status) {
+    return 0;
+}
+
+method other_method(uint64 arg1,
+                    uint64 arg2) ->
+        (uint16 status) {
+    return 0;
+}
+";
+#[test]
+fn method_output_break_incorrect() {
+    let rules = set_up();
+    let expected_errors = define_expected_errors!(
+        RuleType::LL5,
+        (1, 1, 47, 49),
+        (6, 6, 47, 49),
+        (12, 12, 33, 35),
+    );
+    assert_snippet(METHOD_OUTPUT_BREAK_INCORRECT, expected_errors, &rules);
+}

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

@@ -1 +1,2 @@
-mod func_call_break_open_paren;
+mod func_call_break_open_paren;
+mod method_output_break;