Fix issues from review

Author: armano2

docs/rules/no-async-in-computed-properties.md

@@ -1,32 +1,38 @@
 # Check if there are no asynchronous action inside computed properties (no-async-in-computed-properties)
 
-Vue.js has a basic construct which lets computed properties collects dependencies and refreshes them thats why its really important to not use any of asynchronous action inside of them.
+Computed properties should be synchronous. Asynchronous actions inside them may not work as expected and can lead to an unexpected behaviour, that's why you should avoid them.
+If you need async computed properties you might want to consider using additional plugin [vue-async-computed]
 
 ## :book: Rule Details
 
 This rule is aimed at preventing asynchronous methods from being called in computed properties.
 
-
 :-1: Examples of **incorrect** code for this rule:
 
 ```js
 export default {
   computed: {
     pro () {
-      setTimeout(() => { }, 0)
       return Promise.all([new Promise((resolve, reject) => {})])
     },
     foo: async function () {
-      setInterval(() => { }, 0)
       return await someFunc()
     },
     bar () {
-      requestAnimationFrame(() => {})
       return fetch(url).then(response => {})
     },
     yiel: function* () {
       yield 1
       yield* g1()
+    },
+    tim () {
+      setTimeout(() => { }, 0)
+    },
+    inter () {
+      setInterval(() => { }, 0)
+    },
+    anim () {
+      requestAnimationFrame(() => {})
     }
   }
 }
@@ -54,3 +60,5 @@ export default {
 ## :wrench: Options
 
 Nothing.
+
+[vue-async-computed]: https://github.com/foxbenjaminfox/vue-async-computed

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

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Check if there are no async inside computed properties.
+ * @fileoverview Check if there are no asynchronous actions inside computed properties.
  * @author Armano
  */
 'use strict'
@@ -28,21 +28,23 @@ const TIMED_FUNCTIONS = [
 
 function isTimedFunction (node) {
   return (
+    node.type === 'CallExpression' &&
     node.callee.type === 'Identifier' &&
     TIMED_FUNCTIONS.indexOf(node.callee.name) !== -1
   ) || (
+    node.type === 'CallExpression' &&
     node.callee.type === 'MemberExpression' &&
+    node.callee.object.type === 'Identifier' &&
     node.callee.object.name === 'window' && (
-      TIMED_FUNCTIONS.indexOf(node.callee.property.name) !== -1 ||
-      TIMED_FUNCTIONS.indexOf(node.callee.property.value) !== -1
+      TIMED_FUNCTIONS.indexOf(node.callee.property.name) !== -1
     )
   ) && node.arguments.length
 }
 
 function isPromise (node) {
-  if (node.type === 'CallExpression' && node.callee && node.callee.type === 'MemberExpression') {
+  if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression') {
     return ( // hello.PROMISE_FUNCTION()
-      node.callee.property &&
+      node.callee.property.type === 'Identifier' &&
       PROMISE_FUNCTIONS.indexOf(node.callee.property.name) !== -1
     ) || ( // Promise.PROMISE_METHOD()
       node.callee.object.type === 'Identifier' &&
@@ -58,6 +60,16 @@ function isPromise (node) {
 function create (context) {
   const forbiddenNodes = []
 
+  const messages = {
+    promise: 'Unexpected asynchronous action in "{{name}}" computed property.',
+    await: 'Unexpected await operator in "{{name}}" computed property.',
+    yield: 'Unexpected yield keyword in "{{name}}" computed property.',
+    generator: 'Unexpected generator function expression in "{{name}}" computed property.',
+    async: 'Unexpected async function declaration in "{{name}}" computed property.',
+    new: 'Unexpected Promise object in "{{name}}" computed property.',
+    timed: 'Unexpected timed function in "{{name}}" computed property.'
+  }
+
   function onFunctionEnter (node) {
     if (node.async) {
       forbiddenNodes.push({
@@ -68,7 +80,7 @@ function create (context) {
     if (node.generator) {
       forbiddenNodes.push({
         node: node,
-        type: 'yield*'
+        type: 'generator'
       })
     }
   }
@@ -130,25 +142,9 @@ function create (context) {
             el.node.loc.start.line >= cp.value.loc.start.line &&
             el.node.loc.end.line <= cp.value.loc.end.line
           ) {
-            let message = `Unexpected asynchronous action in "{{name}}" computed property.`
-            if (el.type === 'await') {
-              message = `Unexpected await operator in "{{name}}" computed property.`
-            } else if (el.type === 'yield') {
-              message = `Unexpected yield keyword in "{{name}}" computed property.`
-            } else if (el.type === 'yield*') {
-              message = `Unexpected yield* expression in "{{name}}" computed property.`
-            } else if (el.type === 'async') {
-              message = `Unexpected async function declaration in "{{name}}" computed property.`
-            } else if (el.type === 'promise') {
-            } else if (el.type === 'new') {
-              message = `Unexpected Promise object in "{{name}}" computed property.`
-            } else if (el.type === 'timed') {
-              message = `Unexpected timed function in "{{name}}" computed property.`
-            }
-
             context.report({
               node: el.node,
-              message,
+              message: messages[el.type],
               data: {
                 name: cp.key
               }
@@ -168,7 +164,7 @@ module.exports = {
   create,
   meta: {
     docs: {
-      description: 'Check if there are no async inside computed properties.',
+      description: 'Check if there are no asynchronous actions inside computed properties.',
       category: 'Best Practices',
       recommended: false
     },

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

@@ -276,7 +276,7 @@ ruleTester.run('no-async-in-computed-properties', rule, {
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       errors: [{
-        message: 'Unexpected yield* expression in "foo" computed property.',
+        message: 'Unexpected generator function expression in "foo" computed property.',
         line: 4
       }, {
         message: 'Unexpected yield keyword in "foo" computed property.',