Add AwaitExpression & YieldExpression & node.async

Author: armano2

lib/rules/no-async-in-computed-properties.js

@@ -6,47 +6,77 @@
 
 const utils = require('../utils')
 
-const methodNames = [
-  'then',
-  'catch'
-]
+// const methodNames = [
+//   'then',
+//   'catch'
+// ]
 
 /**
  * Checks if a node has a promise method called.
  */
-function hasPromiseMethod (node) {
-  if (node.type === 'CallExpression' && node.callee) {
-    var property = node.callee.property
-    if (property && methodNames.indexOf(property.name) >= 0) {
-      return property.name
-    }
-  }
-  return false
-}
-
-function checkAsync (data, context) {
-
-}
+// function hasPromiseMethod (node) {
+//   if (node.type === 'CallExpression' && node.callee) {
+//     var property = node.callee.property
+//     if (property && methodNames.indexOf(property.name) >= 0) {
+//       return property.name
+//     }
+//   }
+//   return false
+// }
 
 function create (context) {
   const forbiddenNodes = []
 
+  function onFunctionExit (node) {
+  }
+
+  function onFunctionEnter (node) {
+    if (node.async) {
+      forbiddenNodes.push({
+        node: node,
+        type: 'async'
+      })
+    }
+  }
+
   return Object.assign({},
     {
+      FunctionDeclaration: onFunctionEnter,
+      'FunctionDeclaration:exit': onFunctionExit,
+
+      FunctionExpression: onFunctionEnter,
+      'FunctionExpression:exit': onFunctionExit,
 
+      ArrowFunctionExpression: onFunctionEnter,
+      'ArrowFunctionExpression:exit': onFunctionExit,
+
+      YieldExpression (node) {
+        // await nodes are YieldExpression's with babel-eslint < 7.0.0
+        forbiddenNodes.push({
+          node: node,
+          type: 'yield'
+        })
+      },
+
+      AwaitExpression (node) {
+        forbiddenNodes.push({
+          node: node,
+          type: 'await'
+        })
+      }
     },
     utils.executeOnVueComponent(context, (properties) => {
       const computedProperties = utils.getComputedProperties(properties)
 
       computedProperties.forEach(cp => {
-        forbiddenNodes.forEach(node => {
+        forbiddenNodes.forEach(({ type, node }) => {
           if (
             node.loc.start.line >= cp.value.loc.start.line &&
             node.loc.end.line <= cp.value.loc.end.line
           ) {
             context.report({
               node: node,
-              message: `Unexpected async effect in "${cp.key}" computed property.`
+              message: `Unexpected ${type} effect in "${cp.key}" computed property.`
             })
           }
         })

tests/lib/rules/no-async-in-computed-properties.js

@@ -17,7 +17,7 @@ const rule = require('../../../lib/rules/no-async-in-computed-properties')
 
 const ruleTester = new RuleTester({
   parser: 'vue-eslint-parser',
-  parserOptions: { ecmaVersion: 2015 }
+  parserOptions: { ecmaVersion: 2015, sourceType: 'module' }
 })
 
 ruleTester.run('no-async-in-computed-properties', rule, {
@@ -30,18 +30,18 @@ ruleTester.run('no-async-in-computed-properties', rule, {
     {
       filename: 'test.vue',
       code: `
-      computed: {
-        foo: function () {
-          var bar = 0
-          try {
-            bar = bar / 0
-          } catch (e) {
-            return e
-          } finally {
-            return bar
+        computed: {
+          foo: function () {
+            var bar = 0
+            try {
+              bar = bar / 0
+            } catch (e) {
+              return e
+            } finally {
+              return bar
+            }
           }
         }
-      }
       `
     }
   ],
@@ -50,78 +50,78 @@ ruleTester.run('no-async-in-computed-properties', rule, {
     {
       filename: 'test.vue',
       code: `
-      export default {
-        computed: {
-          foo: async function () {
-            return await someFunc()
+        export default {
+          computed: {
+            foo: async function () {
+              return await someFunc()
+            }
           }
         }
-      }
       `,
       errors: ['Computed properies cannot have side effect.']
     },
     {
       filename: 'test.vue',
       code: `
-      export default {
-        computed: {
-          foo: async function () {
-            return new Promise((resolve, reject) => {}) }
+        export default {
+          computed: {
+            foo: async function () {
+              return new Promise((resolve, reject) => {}) }
+            }
           }
         }
-      }
       `,
       errors: ['Computed properies cannot have side effect.']
     },
     {
       filename: 'test.vue',
       code: `
-      export default {
-        computed: {
-          foo: function () {
-            return bar.then(response => {})
+        export default {
+          computed: {
+            foo: function () {
+              return bar.then(response => {})
+            }
           }
         }
-      }
       `,
       errors: ['Computed properies cannot have side effect.']
     },
     {
       filename: 'test.vue',
       code: `
-      export default {
-        computed: {
-          foo: function () {
-            return bar.catch(e => {})
+        export default {
+          computed: {
+            foo: function () {
+              return bar.catch(e => {})
+            }
           }
         }
-      }
       `,
       errors: ['Computed properies cannot have side effect.']
     },
     {
       filename: 'test.vue',
       code: `
-      export default {
-        computed: {
-          foo: function () {
-            return Promise.all([])
+        export default {
+          computed: {
+            foo: function () {
+              return Promise.all([])
+            }
           }
         }
-      }
       `,
       errors: ['Computed properies cannot have side effect.']
     },
     {
       filename: 'test.vue',
       code: `
-      export default {
-        computed: {
-          foo: function () {
-            return bar.finally(res => {})
+        export default {
+          computed: {
+            foo: function () {
+              return bar.finally(res => {})
+            }
           }
         }
-      }
       `,
       errors: ['Computed properies cannot have side effect.']
     },