feat: new enforceSuppressionCode rule

.README/README.md

@@ -165,6 +165,7 @@ When `true`, only checks files with a [`@flow` annotation](http://flowtype.org/d
 {"gitdown": "include", "file": "./rules/define-flow-type.md"}
 {"gitdown": "include", "file": "./rules/delimiter-dangle.md"}
 {"gitdown": "include", "file": "./rules/enforce-line-break.md"}
+{"gitdown": "include", "file": "./rules/enforce-suppression-code.md"}
 {"gitdown": "include", "file": "./rules/generic-spacing.md"}
 {"gitdown": "include", "file": "./rules/interface-id-match.md"}
 {"gitdown": "include", "file": "./rules/newline-after-flow-annotation.md"}

.README/rules/enforce-suppression-code.md

@@ -0,0 +1,5 @@
+### `enforce-suppression-code`
+
+This rule enforces a suppression code on flow suppression comments such as `$FlowFixMe` and `$FlowExpectedError`.
+
+<!-- assertions enforceSuppressionCode -->

src/index.js

@@ -7,6 +7,7 @@ import booleanStyle from './rules/booleanStyle';
 import defineFlowType from './rules/defineFlowType';
 import delimiterDangle from './rules/delimiterDangle';
 import enforceLineBreak from './rules/enforceLineBreak';
+import enforceSuppressionCode from './rules/enforceSuppressionCode';
 import genericSpacing from './rules/genericSpacing';
 import interfaceIdMatch from './rules/interfaceIdMatch';
 import newlineAfterFlowAnnotation from './rules/newlineAfterFlowAnnotation';
@@ -56,6 +57,7 @@ const rules = {
   'define-flow-type': defineFlowType,
   'delimiter-dangle': delimiterDangle,
   'enforce-line-break': enforceLineBreak,
+  'enforce-suppression-code': enforceSuppressionCode,
   'generic-spacing': genericSpacing,
   'interface-id-match': interfaceIdMatch,
   'newline-after-flow-annotation': newlineAfterFlowAnnotation,

src/rules/enforceSuppressionCode.js

@@ -0,0 +1,57 @@
+const schema = [
+  {
+    type: 'string',
+  },
+];
+
+const message = (suppression = '') => {
+  return `${suppression} is missing a suppression code`;
+};
+
+const create = (context) => {
+  const isMissingSuppressionCode = function (value) {
+    const suppressionTypes = ['$FlowFixMe', '$FlowExpectedError', '$FlowIssue', '$FlowIgnore'];
+
+    let failedType;
+    suppressionTypes.forEach((cur) => {
+      if (value.startsWith(cur) &&
+          !value.startsWith(`${cur}[`) &&
+          !value.endsWith(']')) {
+        failedType = cur;
+      }
+    });
+
+    return failedType;
+  };
+
+  const handleComment = function (comment) {
+    const value = comment.type === 'Block' ?
+      comment.value.replace(/\*/g, '') :
+      comment.value;
+    const suppression = value.trim().split(' ').filter((arg) => {
+      return arg.length > 0;
+    })[0];
+    const failedType = isMissingSuppressionCode(suppression);
+
+    if (failedType) {
+      context.report(comment, message(failedType));
+    }
+  };
+
+  return {
+    Program () {
+      context
+        .getSourceCode()
+        .getAllComments()
+        .filter((comment) => {
+          return comment.type === 'Block' || comment.type === 'Line';
+        })
+        .forEach(handleComment);
+    },
+  };
+};
+
+export default {
+  create,
+  schema,
+};

tests/rules/assertions/enforceSuppressionCode.js

@@ -0,0 +1,90 @@
+export default {
+  invalid: [
+    {
+      code: '// $FlowFixMe I am doing something evil here\nconst text = \'HELLO\';',
+      errors: [
+        {
+          message: '$FlowFixMe is missing a suppression code',
+        },
+      ],
+    },
+    {
+      code: '// $FlowExpectedError I am doing something evil here\nconst text = \'HELLO\';',
+      errors: [
+        {
+          message: '$FlowExpectedError is missing a suppression code',
+        },
+      ],
+    },
+    {
+      code: '// $FlowIssue I am doing something evil here\nconst text = \'HELLO\';',
+      errors: [
+        {
+          message: '$FlowIssue is missing a suppression code',
+        },
+      ],
+    },
+    {
+      code: '// $FlowIgnore I am doing something evil here\nconst text = \'HELLO\';',
+      errors: [
+        {
+          message: '$FlowIgnore is missing a suppression code',
+        },
+      ],
+    },
+    {
+      code: '/* $FlowIgnore I am doing something evil here */',
+      errors: [
+        {
+          message: '$FlowIgnore is missing a suppression code',
+        },
+      ],
+    },
+    {
+      code: '{ /* $FlowIgnore I am doing something evil here */ }',
+      errors: [
+        {
+          message: '$FlowIgnore is missing a suppression code',
+        },
+      ],
+    },
+    {
+      code: `/**
+  * $FlowIgnore I am doing something evil here
+  */`,
+      errors: [
+        {
+          message: '$FlowIgnore is missing a suppression code',
+        },
+      ],
+    },
+  ],
+  valid: [
+    {
+      code: 'const text = \'HELLO\';',
+    },
+    {
+      code: '// $FlowFixMe[incompatible-call] TODO 48\nconst text = \'HELLO\';',
+    },
+    {
+      code: '// $FlowExpectedError[incompatible-call] TODO 48\nconst text = \'HELLO\';',
+    },
+    {
+      code: '// $FlowIssue[incompatible-call] TODO 48\nconst text = \'HELLO\';',
+    },
+    {
+      code: '// $FlowIgnore[incompatible-call] TODO 48\nconst text = \'HELLO\';',
+    },
+    {
+      code: '/* $FlowIgnore[incompatible-call] TODO 48 */',
+    },
+    {
+      code: `/**
+ * $FlowIgnore[incompatible-call] TODO 48
+ */`,
+    },
+    {
+      code: '/* $FlowIgnore[incompatible-call] TODO 48 */',
+    },
+  ],
+};

tests/rules/index.js

@@ -18,6 +18,7 @@ const reportingRules = [
   'define-flow-type',
   'delimiter-dangle',
   'enforce-line-break',
+  'enforce-suppression-code',
   'generic-spacing',
   'interface-id-match',
   'newline-after-flow-annotation',