better handling of lazy usages

__tests__/__fixtures__/complex/async-await/code.js

@@ -0,0 +1,5 @@
+import { find } from '../../../../src/inline-loops.macro';
+
+async function getStuff(promises) {
+  return await find(promises, (promise) => !!promise);
+}

__tests__/__fixtures__/complex/async-await/output.js

@@ -0,0 +1,16 @@
+async function getStuff(promises) {
+  let _match;
+  for (
+    let _key = 0, _length = promises.length, _promise, _result;
+    _key < _length;
+    ++_key
+  ) {
+    _promise = promises[_key];
+    _result = !!_promise;
+    if (_result) {
+      _match = _promise;
+      break;
+    }
+  }
+  return await _match;
+}

__tests__/__fixtures__/complex/binary-expression/output.js

@@ -0,0 +1,8 @@
+function getStuff(array) {
+  let _a = array[0];
+  for (let _key = 1, _length = array.length, _v; _key < _length; ++_key) {
+    _v = array[_key];
+    _a = _a + _v * 2;
+  }
+  return array ** _a;
+}

__tests__/__fixtures__/complex/default-param/code.js

@@ -0,0 +1,5 @@
+import { map } from '../../../../src/inline-loops.macro';
+
+function getStuff(array, doubled = map(array, (v) => v * 2)) {
+  return doubled;
+}

__tests__/__fixtures__/complex/default-param/output.js

@@ -0,0 +1,14 @@
+function getStuff(
+  array,
+  doubled = (() => {
+    const _length = array.length;
+    const _results = Array(_length);
+    for (let _key = 0, _v; _key < _length; ++_key) {
+      _v = array[_key];
+      _results[_key] = _v * 2;
+    }
+    return _results;
+  })(),
+) {
+  return doubled;
+}

__tests__/__fixtures__/complex/logical-expression-left/code.js

@@ -0,0 +1,5 @@
+import { reduce } from '../../../../src/inline-loops.macro';
+
+function getStuff(array) {
+  return reduce(array, (a, v) => a + v * 2, 0) || 1;
+}

__tests__/__fixtures__/complex/logical-expression-left/output.js

@@ -0,0 +1,8 @@
+function getStuff(array) {
+  let _a = 0;
+  for (let _key = 0, _length = array.length, _v; _key < _length; ++_key) {
+    _v = array[_key];
+    _a = _a + _v * 2;
+  }
+  return _a || 1;
+}

__tests__/__fixtures__/complex/ternary-alternative/code.js

@@ -0,0 +1,5 @@
+import { map } from '../../../../src/inline-loops.macro';
+
+function getStuff(array, foo) {
+  return foo === 'bar' ? array : map(array, (v) => v * 2);
+}

__tests__/__fixtures__/complex/ternary-alternative/output.js

@@ -0,0 +1,13 @@
+function getStuff(array, foo) {
+  return foo === 'bar'
+    ? array
+    : (() => {
+        const _length = array.length;
+        const _results = Array(_length);
+        for (let _key = 0, _v; _key < _length; ++_key) {
+          _v = array[_key];
+          _results[_key] = _v * 2;
+        }
+        return _results;
+      })();
+}

__tests__/__fixtures__/complex/ternary-condition/code.js

@@ -0,0 +1,5 @@
+import { reduce } from '../../../../src/inline-loops.macro';
+
+function getStuff(array, foo) {
+  return reduce(array, (a, v) => a + v * 2, 0) ? 'stuff' : null;
+}

__tests__/__fixtures__/complex/ternary-condition/output.js

@@ -0,0 +1,8 @@
+function getStuff(array, foo) {
+  let _a = 0;
+  for (let _key = 0, _length = array.length, _v; _key < _length; ++_key) {
+    _v = array[_key];
+    _a = _a + _v * 2;
+  }
+  return _a ? 'stuff' : null;
+}

__tests__/__fixtures__/complex/unary-expression/output.js

@@ -0,0 +1,8 @@
+function getStuff(array) {
+  let _a = array[0];
+  for (let _key = 1, _length = array.length, _v; _key < _length; ++_key) {
+    _v = array[_key];
+    _a = _a + _v * 2;
+  }
+  return array + +_a;
+}

src/utils.ts

@@ -128,16 +128,33 @@ export function handleInvalidUsage(
   }
 }
 
-export function isConditionalUsage(path: Path<CallExpression>): boolean {
+export function isLazyUsage(path: Path<CallExpression>): boolean {
   const parentPath = path.parentPath;
 
-  return (
-    parentPath.isAwaitExpression() ||
-    parentPath.isBinaryExpression() ||
-    parentPath.isConditionalExpression() ||
-    parentPath.isLogicalExpression() ||
-    parentPath.isUnaryExpression()
-  );
+  if (parentPath.isPattern()) {
+    return true;
+  }
+
+  if (!parentPath.isExpression()) {
+    return false;
+  }
+
+  const grandparentPath = parentPath.parentPath;
+  const maybeNestedConditional =
+    grandparentPath.isPattern() ||
+    (grandparentPath.isExpression() && !grandparentPath.isBinaryExpression());
+
+  if (parentPath.isLogicalExpression()) {
+    return (
+      !maybeNestedConditional && parentPath.get('right').node === path.node
+    );
+  }
+
+  if (parentPath.isConditionalExpression()) {
+    return !maybeNestedConditional && parentPath.get('test').node !== path.node;
+  }
+
+  return maybeNestedConditional;
 }
 
 export function isMacroHandlerName(
@@ -183,7 +200,7 @@ export function replaceOrRemove(
     functionParent &&
     ((Array.isArray(contents) && contents.length > 1) ||
       local.contents.length > 1 ||
-      isConditionalUsage(path));
+      isLazyUsage(path));
 
   if (shouldWrapInIife) {
     if (!t.isIdentifier(replacement, { name: 'undefined' })) {