fix: ignore simple chains with <= links

Author: jedwards1211

src/asyncify.ts

@@ -10,7 +10,7 @@ import codeLength from './util/codeLength'
 import babelBugWorkarounds from './util/babelBugWorkarounds'
 
 function asyncifyFunction(path: NodePath<t.Function>): void {
-  if (returnsOrAwaitsPromises(path) || isPromiseHandler(path)) {
+  if (returnsOrAwaitsPromises(path)) {
     path.node.async = true
   }
   const chains = findPromiseChains(path)

src/util/iterateChain.ts

@@ -0,0 +1,17 @@
+import * as t from '@babel/types'
+import { NodePath } from '@babel/traverse'
+import { isPromiseMethodCall } from './predicates'
+
+export default function* iterateChain(
+  path: NodePath<t.CallExpression>
+): Iterable<NodePath<t.CallExpression>> {
+  while (isPromiseMethodCall(path.node)) {
+    yield path
+    const callee = path.get('callee')
+    if (callee.isMemberExpression()) {
+      const object = (callee as NodePath<t.MemberExpression>).get('object')
+      if (object.isCallExpression()) path = object
+      else break
+    }
+  }
+}

src/util/shouldIgnoreChain.ts

@@ -1,10 +1,47 @@
 import * as t from '@babel/types'
 import { NodePath } from '@babel/traverse'
 import generate from '@babel/generator'
+import iterateChain from './iterateChain'
+import getThenHandler from './getThenHandler'
+import getCatchHandler from './getCatchHandler'
+import getFinallyHandler from './getFinallyHandler'
+
+function chainLength(path: NodePath<t.CallExpression>): number {
+  let length = 0
+  for (const link of iterateChain(path)) length++
+  return length
+}
+
+function isComplexHandler(path: NodePath<t.Expression> | null): boolean {
+  if (!path || !path.isFunction()) return false
+  const body = (path as NodePath<t.Function>).get('body')
+  if (!body.isBlockStatement()) return false
+  return (body as NodePath<t.BlockStatement>).node.body.length > 1
+}
+
+function hasComplexHandlers(path: NodePath<t.CallExpression>): boolean {
+  for (const link of iterateChain(path)) {
+    if (
+      isComplexHandler(getThenHandler(path)) ||
+      isComplexHandler(getCatchHandler(path)) ||
+      isComplexHandler(getFinallyHandler(path))
+    )
+      return true
+  }
+  return false
+}
 
 export default function shouldIgnoreChain(
   path: NodePath<t.CallExpression>
 ): boolean {
+  const { parentPath } = path
+  if (
+    !parentPath.isReturnStatement() &&
+    !parentPath.isAwaitExpression() &&
+    !parentPath.isFunction()
+  ) {
+    if (chainLength(path) <= 2 && !hasComplexHandlers(path)) return true
+  }
   const { ignoreChainsShorterThan } = path.state
   return (
     ignoreChainsShorterThan != null &&

src/util/unwindCatch.ts

@@ -39,6 +39,7 @@ export default function unwindCatch(
     ) as any
   }
   const handlerFunction = handler as NodePath<t.Function>
+  handlerFunction.node.async = true
   const body = handlerFunction.get('body')
   if (
     body.isBlockStatement() &&

src/util/unwindFinally.ts

@@ -27,6 +27,7 @@ export default function unwindFinally(
     ) as any
   }
   const handlerFunction = handler as NodePath<t.Function>
+  handlerFunction.node.async = true
   const body = handlerFunction.get('body')
   if (body.isBlockStatement() && !convertConditionalReturns(body)) {
     return getPreceedingLink(link)

src/util/unwindThen.ts

@@ -22,6 +22,7 @@ export function unwindThen(
   }
 
   if (handler.isFunction()) {
+    handler.node.async = true
     const handlerFunction = handler as NodePath<t.Function>
     const input = handlerFunction.get('params')[0]
     const body = handlerFunction.get('body')

test/fixtures/ignoredSimpleChain.ts

@@ -0,0 +1,11 @@
+export const input = `
+function foo() {
+  const bar = baz.then(x => x * 2).catch(err => {
+    console.error(err.stack)
+  })
+}
+`
+
+export const options = {}
+
+export const expected = input

test/fixtures/nonAwaitedChain.ts

@@ -1,18 +1,24 @@
 export const input = `
 function foo() {
-  const bar = baz.then(x => x * 2)
+  const bar = baz.then(x => x * 2).catch(err => {
+    console.error(err.stack)
+    return 2
+  })
 }
 `
 
-export const options = {
-  ignoreChainsShorterThan: 10,
-}
+export const options = {}
 
 export const expected = `
 function foo() {
   const bar = (async () => {
-    const x = await baz
-    return x * 2
+    try {
+      const x = await baz
+      return x * 2
+    } catch (err) {
+      console.error(err.stack)
+      return 2
+    }
   })()
 }
 `