Added fixer for newline-before-return rule

src/rules/curlyRule.ts

@@ -19,6 +19,7 @@ import { isBlock, isIfStatement, isIterationStatement, isSameLine } from "tsutil
 import * as ts from "typescript";
 
 import * as Lint from "../index";
+import { newLineWithIndentation } from "../utils";
 
 import { codeExamples } from "./code-examples/curly.examples";
 
@@ -172,29 +173,10 @@ class CurlyWalker extends Lint.AbstractWalker<Options> {
  Lint.Replacement.appendText(statement.end, " }"),
  ];
  } else {
- const match = /\n([\t ])/.exec(node.getFullText(this.sourceFile)); // determine which character to use (tab or space)
- const indentation =
- match === null
- ? ""
- : // indentation should match start of statement
- match[1].repeat(
- ts.getLineAndCharacterOfPosition(
- this.sourceFile,
- node.getStart(this.sourceFile),
- ).character,
- );
-
- const maybeCarriageReturn =
- this.sourceFile.text[this.sourceFile.getLineEndOfPosition(node.pos) - 1] === "\r"
- ? "\r"
- : "";
-
+ const newLine = newLineWithIndentation(node, this.sourceFile);
  return [
  Lint.Replacement.appendText(statement.pos, " {"),
- Lint.Replacement.appendText(
- statement.end,
- `${maybeCarriageReturn}\n${indentation}}`,
- ),
+ Lint.Replacement.appendText(statement.end, `${newLine}}`),
  ];
  }
  }

src/rules/newlineBeforeReturnRule.ts

@@ -19,13 +19,15 @@ import { getPreviousStatement } from "tsutils";
 import * as ts from "typescript";
 
 import * as Lint from "../index";
+import { newLineWithIndentation } from "../utils";
 
 export class Rule extends Lint.Rules.AbstractRule {
  /* tslint:disable:object-literal-sort-keys */
  public static metadata: Lint.IRuleMetadata = {
  ruleName: "newline-before-return",
  description: "Enforces blank line before return when not the only line in the block.",
  rationale: "Helps maintain a readable style in your codebase.",
+ hasFix: true,
  optionsDescription: "Not configurable.",
  options: {},
  optionExamples: [true],
@@ -78,10 +80,17 @@ class NewlineBeforeReturnWalker extends Lint.AbstractWalker<void> {
  }
  }
  const prevLine = ts.getLineAndCharacterOfPosition(this.sourceFile, prev.end).line;
-
  if (prevLine >= line - 1) {
+ const fixer = Lint.Replacement.replaceFromTo(
+ line === prevLine ? node.pos : node.pos + 1,
+ start,
+ line === prevLine
+ ? newLineWithIndentation(prev, this.sourceFile, 2)
+ : newLineWithIndentation(prev, this.sourceFile),
+ );
+
  // Previous statement is on the same or previous line
- this.addFailure(start, start, Rule.FAILURE_STRING);
+ this.addFailure(start, start, Rule.FAILURE_STRING, fixer);
  }
  }
 }

src/utils.ts

@@ -294,6 +294,31 @@ function tryResolveSync(packageName: string, relativeTo?: string): string | unde
  }
 }
 
+/**
+ * Gets the full indentation of the provided node
+ */
+export function getIndentation(node: ts.Node, sourceFile: ts.SourceFile): string {
+ const text = sourceFile.text.substr(node.pos, node.getStart() - node.pos);
+ const matches = text.match(/([ \t]*)$/);
+ return matches !== null ? matches[1] : "";
+}
+
+/**
+ * Creates x new lines with a proper indentation at the last one based on the provided node
+ */
+export function newLineWithIndentation(
+ node: ts.Node,
+ sourceFile: ts.SourceFile,
+ linesCount: number = 1,
+) {
+ const maybeCarriageReturn =
+ sourceFile.text[sourceFile.getLineEndOfPosition(node.pos) - 1] === "\r" ? "\r" : "";
+
+ const indentation = getIndentation(node, sourceFile);
+
+ return `${`${maybeCarriageReturn}\n`.repeat(linesCount)}${indentation}`;
+}
+
 /**
  * @deprecated Copied from tsutils 2.27.2. This will be removed once TSLint requires tsutils > 3.0.
  */

test/rules/newline-before-return/default/test.ts.fix

@@ -0,0 +1,126 @@
+function foo(bar) {
+ if (!bar) {
+ return;
+ }
+
+ return bar;
+}
+
+function foo(bar) {
+ if (!bar) {
+ var statement = '';
+
+ return statement;
+ }
+
+ return bar;
+}
+
+function foo(bar) {
+ if (!bar) {
+ return;
+ }
+
+ /* multi-line
+ comment */
+ return bar;
+}
+
+var fn = () => null;
+function foo() {
+ fn();
+
+ return;
+}
+
+function foo(fn) {
+ fn();
+
+ return;
+}
+
+function foo(fn) {
+ fn();
+
+ return;
+}
+
+function foo(fn) {
+ fn();
+
+ return;
+}
+
+function foo() {
+ return;
+}
+
+function foo() {
+
+ return;
+}
+
+function foo(bar) {
+ if (!bar) return;
+}
+
+function foo(bar) {
+ let someCall;
+ if (!bar) return;
+}
+
+function foo(bar) {
+ if (!bar) { return };
+}
+
+function foo(bar) {
+ if (!bar) {
+ return;
+ }
+}
+
+function foo(bar) {
+ if (!bar) {
+ return;
+ }
+
+ return bar;
+}
+
+function foo(bar) {
+ if (!bar) {
+
+ return;
+ }
+}
+
+function foo() {
+
+ // comment
+ return;
+}
+
+function test() {
+ console.log("Any statement");
+ // Any comment
+
+ return;
+}
+
+function foo() {
+ fn();
+ // comment
+
+ // comment
+ return;
+}
+
+function bar() {
+ "some statement";
+
+ //comment
+ //comment
+ //comment
+ return;
+}
+

test/rules/newline-before-return/default/test.ts.lint

@@ -38,6 +38,16 @@ function foo(fn) {
  ~nil [0]
 }
 
+function foo(fn) {
+ fn(); return;
+ ~nil [0]
+}
+
+function foo(fn) {
+ fn(); return;
+ ~nil [0]
+}
+
 function foo() {
  return;
 }

test/rules/newline-before-return/default/test.tsx.fix

@@ -0,0 +1,17 @@
+import * as React from 'react';
+
+<div>{ [].map((child: any) => {
+ let i = 0;
+
+ return <span />;
+}) }</div>
+
+<div>{ [].map((child: any) => {
+ return <span />;
+}) }</div>
+
+<div>{ [].map((child: any) =>
+ <span />;
+) }</div>
+
+