Add the option allow-empty-functions in no-empty

src/rules/noEmptyRule.ts

@@ -21,9 +21,11 @@ import * as ts from "typescript";
 import * as Lint from "../index";
 
 const ALLOW_EMPTY_CATCH = "allow-empty-catch";
+const ALLOW_EMPTY_FUNCTIONS = "allow-empty-functions";
 
 interface Options {
  allowEmptyCatch: boolean;
+ allowEmptyFunctions: boolean;
 }
 
 export class Rule extends Lint.Rules.AbstractRule {
@@ -34,12 +36,29 @@ export class Rule extends Lint.Rules.AbstractRule {
  descriptionDetails: "Blocks with a comment inside are not considered empty.",
  rationale: "Empty blocks are often indicators of missing code.",
  optionsDescription: Lint.Utils.dedent`
- If \`${ALLOW_EMPTY_CATCH}\` is specified, then catch blocks are allowed to be empty.`,
+ If \`${ALLOW_EMPTY_CATCH}\` is specified, then catch blocks are allowed to be empty.
+ If \`${ALLOW_EMPTY_FUNCTIONS}\` is specified, then function definitions are allowed to be empty.`,
  options: {
- type: "string",
- enum: [ALLOW_EMPTY_CATCH],
+ type: "array",
+ items: {
+ anyOf: [
+ {
+ type: "string",
+ enum: [ALLOW_EMPTY_CATCH],
+ },
+ {
+ type: "string",
+ enum: [ALLOW_EMPTY_FUNCTIONS],
+ },
+ ],
+ },
  },
- optionExamples: [true, [true, ALLOW_EMPTY_CATCH]],
+ optionExamples: [
+ true,
+ [true, ALLOW_EMPTY_CATCH],
+ [true, ALLOW_EMPTY_FUNCTIONS],
+ [true, ALLOW_EMPTY_CATCH, ALLOW_EMPTY_FUNCTIONS],
+ ],
  type: "functionality",
  typescriptOnly: false,
  };
@@ -50,6 +69,7 @@ export class Rule extends Lint.Rules.AbstractRule {
  public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
  return this.applyWithFunction(sourceFile, walk, {
  allowEmptyCatch: this.ruleArguments.indexOf(ALLOW_EMPTY_CATCH) !== -1,
+ allowEmptyFunctions: this.ruleArguments.indexOf(ALLOW_EMPTY_FUNCTIONS) !== -1,
  });
  }
 }
@@ -76,6 +96,13 @@ function isExcluded(node: ts.Node, options: Options): boolean {
  return true;
  }
 
+ if (options.allowEmptyFunctions &&
+ (node.kind === ts.SyntaxKind.FunctionDeclaration ||
+ node.kind === ts.SyntaxKind.FunctionExpression ||
+ node.kind === ts.SyntaxKind.ArrowFunction)) {
+ return true;
+ }
+
  return isConstructorDeclaration(node) &&
  (
  /* If constructor is private or protected, the block is allowed to be empty.

test/rules/no-empty/allow-empty-catch/test.ts.lint

@@ -9,13 +9,19 @@ if (x === 2) {
 }
 ~ [block is empty]
 
-function testFunction() {
- ~
+function testFunction1() {
+  ~
 
 ~nil
 }
 ~ [block is empty]
 
+const testFunction2 = () => { };
+ ~~~ [block is empty]
+
+const testFunction3 = function() {}
+ ~~ [block is empty]
+
 for (var x = 0; x < 1; ++x) { }
  ~~~ [block is empty]
 

test/rules/no-empty/allow-empty-functions/test.ts.lint

@@ -0,0 +1,73 @@
+if (x === 1) {}
+ ~~ [block is empty]
+if (x === 2) {
+ ~
+
+~nil
+
+~nil
+}
+~ [block is empty]
+
+function testFunction1() {
+
+
+
+}
+
+const testFunction2 = () => { };
+
+const testFunction3 = function() {}
+
+for (var x = 0; x < 1; ++x) { }
+ ~~~ [block is empty]
+
+// empty blocks with comments should be legal
+for (var y = 0; y < 1; ++y) {
+ // empty here
+}
+{ // empty block allowed
+}
+{
+ /* this block is also empty, but allowed to be */
+}
+
+class testClass {
+ constructor(private allowed: any, private alsoAllowed: any) {
+ }
+}
+
+class testClass2 {
+ constructor(protected allowed: any) {
+ }
+}
+
+class testClass3 {
+ constructor(notAllowed: any) {
+ ~
+ }
+~~~~~ [block is empty]
+}
+
+class testClass4 {
+ constructor(readonly allowed: any) {
+ }
+}
+
+class PrivateClassConstructor {
+ private constructor() {}
+}
+
+class ProtectedClassConstructor {
+ protected constructor() {}
+}
+
+class PublicClassConstructor {
+ public constructor() {}
+ ~~ [block is empty]
+}
+
+try {
+ throw new Error();
+} catch (error) {}
+ ~~ [block is empty]

test/rules/no-empty/allow-empty-functions/tslint.json

@@ -0,0 +1,5 @@
+{
+ "rules": {
+ "no-empty": [true, "allow-empty-functions"]
+ }
+}

test/rules/no-empty/default/test.ts.lint

@@ -9,13 +9,19 @@ if (x === 2) {
 }
 ~ [block is empty]
 
-function testFunction() {
- ~
+function testFunction1() {
+  ~
 
 ~nil
 }
 ~ [block is empty]
 
+const testFunction2 = () => { };
+ ~~~ [block is empty]
+
+const testFunction3 = function() {}
+ ~~ [block is empty]
+
 for (var x = 0; x < 1; ++x) { }
  ~~~ [block is empty]