feat: add mixed to no-weak-types (#362)

BREAKING CHANGE:

`mixed` is now treated as a weak type by default.

README.md

@@ -1131,7 +1131,7 @@ import Foo from './foo';
 // Message: Expected newline after flow annotation
 
 // Options: ["always-windows"]
-// @flow
+// @flow
 import Foo from './foo';
 // Message: Expected newline after flow annotation
 
@@ -1151,8 +1151,8 @@ The following patterns are not considered problems:
 import Foo from './foo';
 
 // Options: ["always-windows"]
-// @flow
-
+// @flow
+
 import Foo from './foo';
 
 // Options: ["never"]
@@ -1568,19 +1568,20 @@ The following patterns are not considered problems:
 <a name="eslint-plugin-flowtype-rules-no-weak-types"></a>
 ### <code>no-weak-types</code>
 
-Warns against weak type annotations *any*, *Object* and *Function*.
+Warns against weak type annotations *any*, *mixed*, *Object* and *Function*.
 These types can cause flow to silently skip over portions of your code,
 which would have otherwise caused type errors.
 
 This rule optionally takes one argument, an object to configure which type warnings to enable. By default, all of the
 warnings are enabled. e.g. to disable the `any` warning (allowing it to exist in your code), while continuing to warn
-about `Object` and `Function`:
+about `mixed`, `Object` and `Function`:
 
 ```js
 {
     "rules": {
         "flowtype/no-weak-types": [2, {
             "any": false,
+            "mixed: true,
             "Object": true,
             "Function": true
         }]
@@ -1610,6 +1611,15 @@ function foo(thing): Promise<any> {}
 function foo(thing): Promise<Promise<any>> {}
 // Message: Unexpected use of weak type "any"
 
+function foo(thing): mixed {}
+// Message: Unexpected use of weak type "mixed"
+
+function foo(thing): Promise<mixed> {}
+// Message: Unexpected use of weak type "mixed"
+
+function foo(thing): Promise<Promise<mixed>> {}
+// Message: Unexpected use of weak type "mixed"
+
 function foo(thing): Object {}
 // Message: Unexpected use of weak type "Object"
 
@@ -1732,6 +1742,9 @@ class Foo { props: string }
 // Options: [{"Object":false,"any":false}]
 type X = any; type Y = Object
 
+// Options: [{"Object":false,"mixed":false}]
+type X = mixed; type Y = Object
+
 // Options: [{"Function":false}]
 type X = Function
 
@@ -3411,7 +3424,7 @@ The following patterns are not considered problems:
   { a: string, b: number }) => {}
 
 // Options: ["always",{"allowLineBreak":true}]
-(foo:
+(foo:
   { a: string, b: number }) => {}
 
 // Options: ["never"]

src/rules/noWeakTypes.js

@@ -10,6 +10,9 @@ const schema = [
       Function: {
         type: 'boolean'
       },
+      mixed: {
+        type: 'boolean'
+      },
       Object: {
         type: 'boolean'
       }
@@ -40,6 +43,7 @@ const genericTypeEvaluator = (context, {checkFunction, checkObject}) => {
 
 const create = (context) => {
   const checkAny = _.get(context, 'options[0].any', true) === true;
+  const checkMixed = _.get(context, 'options[0].mixed', true) === true;
   const checkFunction = _.get(context, 'options[0].Function', true) === true;
   const checkObject = _.get(context, 'options[0].Object', true) === true;
 
@@ -48,6 +52,9 @@ const create = (context) => {
   if (checkAny) {
     checks.AnyTypeAnnotation = reportWeakType(context, 'any');
   }
+  if (checkMixed) {
+    checks.MixedTypeAnnotation = reportWeakType(context, 'mixed');
+  }
 
   if (checkFunction || checkObject) {
     checks.GenericTypeAnnotation = genericTypeEvaluator(context, {

tests/rules/assertions/noWeakTypes.js

@@ -18,6 +18,24 @@ export default {
         message: 'Unexpected use of weak type "any"'
       }]
     },
+    {
+      code: 'function foo(thing): mixed {}',
+      errors: [{
+        message: 'Unexpected use of weak type "mixed"'
+      }]
+    },
+    {
+      code: 'function foo(thing): Promise<mixed> {}',
+      errors: [{
+        message: 'Unexpected use of weak type "mixed"'
+      }]
+    },
+    {
+      code: 'function foo(thing): Promise<Promise<mixed>> {}',
+      errors: [{
+        message: 'Unexpected use of weak type "mixed"'
+      }]
+    },
     {
       code: 'function foo(thing): Object {}',
       errors: [{
@@ -191,6 +209,14 @@ export default {
         any: false,
         Object: false
       }]
+    },
+    {
+      code: 'type X = mixed; type Y = Function; type Z = Object',
+      errors: [{message: 'Unexpected use of weak type "mixed"'}],
+      options: [{
+        Function: false,
+        Object: false
+      }]
     }
   ],
   misconfigured: [
@@ -215,6 +241,9 @@ export default {
               Function: {
                 type: 'boolean'
               },
+              mixed: {
+                type: 'boolean'
+              },
               Object: {
                 type: 'boolean'
               }
@@ -297,6 +326,13 @@ export default {
         Object: false
       }]
     },
+    {
+      code: 'type X = mixed; type Y = Object',
+      options: [{
+        mixed: false,
+        Object: false
+      }]
+    },
     {
       code: 'type X = Function',
       options: [{Function: false}]