feat: auto detect this usage

Author: sxzz

README.md

@@ -110,16 +110,16 @@ Here is an example:
 
 ```ts
 import fs from 'node:fs'
-import { quansyncMacro } from 'quansync'
+import { quansync } from 'quansync/macro'
 
 // Create a quansync function by providing `sync` and `async` implementations
-const readFile = quansyncMacro({
+const readFile = quansync({
   sync: (path: string) => fs.readFileSync(path),
   async: (path: string) => fs.promises.readFile(path),
 })
 
 // Create a quansync function by providing an **async** function
-const myFunction = quansyncMacro(async function (filename) {
+const myFunction = quansync(async (filename) => {
   // Use `await` to call another quansync function
   const code = await readFile(filename, 'utf8')
 
@@ -137,23 +137,24 @@ For more details on usage, refer to [quansync's docs](https://github.com/antfu-c
 
 ## How it works
 
-`unplugin-quansync` transforms your async functions into generator functions with `quansyncMacro`,
-and transforms `await` into `yield`.
+`unplugin-quansync` transforms your async functions into generator functions
+wrapped by `quansync` from `quansync/macro`,
+replacing `await` with `yield`.
 
-The example above is transformed into:
+The example above becomes:
 
 ```ts
 import fs from 'node:fs'
-import { quansyncMacro } from 'quansync'
+import { quansync } from 'quansync/macro'
 
 // No transformations needed for objects
-const readFile = quansyncMacro({
+const readFile = quansync({
   sync: (path: string) => fs.readFileSync(path),
   async: (path: string) => fs.promises.readFile(path),
 })
 
 // `async function` is transformed into a generator function
-const myFunction = quansyncMacro(function* (filename) {
+const myFunction = quansync(function* (filename) {
   // `await` is transformed into `yield ...`
   const code = yield readFile(filename, 'utf8')
 
@@ -169,24 +170,22 @@ Both arrow functions and generators have been available since ES2015,
 but a "generator arrow function" syntax does not exist
 [yet](https://github.com/tc39/proposal-generator-arrow-functions).
 
-You can still use arrow functions with `quansyncMacro`,
+You can still use arrow functions and `this` with `quansync` macro,
 but they will be transformed into generator functions,
 retaining `this` binding and omitting the `arguments` object.
 
 ```ts
-const echoNewLine = quansyncMacro(() => 42)
+const fn = quansync(() => this)
 
 // Transforms to:
 
-const echoNewLine = quansyncMacro((v) => {
+const fn = quansync((v) => {
   return function* () {
-    return 42
+    return this
   }.call(this)
 })
 ```
 
-To minimize runtime overhead, prioritize using regular functions.
-
 ## Sponsors
 
 <p align="center">

package.json

@@ -70,7 +70,7 @@
     "prepublishOnly": "pnpm run build"
   },
   "peerDependencies": {
-    "quansync": ">=0.2.0"
+    "quansync": ">=0.2.2"
   },
   "dependencies": {
     "ast-kit": "^1.4.0",
@@ -88,7 +88,7 @@
     "eslint": "^9.21.0",
     "oxc-transform": "^0.52.0",
     "prettier": "^3.5.2",
-    "quansync": "^0.2.0",
+    "quansync": "^0.2.2",
     "tsdown": "^0.6.0",
     "tsx": "^4.19.3",
     "typescript": "^5.7.3",

pnpm-lock.yaml

@@ -15,6 +15,7 @@ import {
 } from 'magic-string-ast'
 import type * as t from '@babel/types'
 
+const THIS_REGEX = /\bthis\b/
 const ARROW_FN_START = `\nreturn function* () {`
 const ARROW_FN_END = `}.call(this)\n`
 
@@ -90,27 +91,17 @@ export function transformQuansync(
       if (!inMacroFunction || !node.async) return
 
       const name = 'id' in node && node.id ? node.id.name : ''
-      const firstParam = node.params[0]
       const isArrowFunction = node.type === 'ArrowFunctionExpression'
 
-      if (isArrowFunction) {
-        if (firstParam) {
-          s.overwrite(node.start!, firstParam.start!, `(`)
-        } else {
-          s.overwrite(node.start!, node.body.start!, `() => `)
-        }
+      const body = s.slice(node.body.start!, node.body.end!)
+      const hasParentThis = isArrowFunction && THIS_REGEX.test(body)
 
-        if (node.body.type === 'BlockStatement') {
-          s.appendLeft(node.body.start! + 1, ARROW_FN_START)
-          s.appendLeft(node.body.end! - 1, ARROW_FN_END)
-        } else {
-          s.appendLeft(node.body.start!, `{${ARROW_FN_START}\nreturn `)
-          s.appendLeft(node.body.end!, `\n${ARROW_FN_END}}`)
-        }
-      } else if (firstParam) {
-        s.overwrite(node.start!, firstParam.start!, `function* ${name}(`)
+      if (hasParentThis) {
+        rewriteFunctionSignature(node, '(', ') => ')
+        rewriteFunctionBody(node, ARROW_FN_START, ARROW_FN_END)
       } else {
-        s.overwrite(node.start!, node.body.start!, `function* ${name}()`)
+        rewriteFunctionSignature(node, `function* ${name}(`, ') ')
+        rewriteFunctionBody(node)
       }
     },
     leave(node) {
@@ -122,4 +113,30 @@ export function transformQuansync(
   })
 
   return generateTransform(s, id)
+
+  function rewriteFunctionSignature(
+    node: t.Function,
+    start: string,
+    end: string,
+  ) {
+    const firstParam = node.params[0]
+    if (firstParam) {
+      s.overwrite(node.start!, firstParam.start!, start)
+      s.overwrite(node.params.at(-1)!.end!, node.body.start!, end)
+    } else {
+      s.overwrite(node.start!, node.body.start!, start + end)
+    }
+  }
+
+  function rewriteFunctionBody(node: t.Function, prefix = '', suffix = '') {
+    if (node.body.type === 'BlockStatement') {
+      s.appendLeft(node.body.start! + 1, prefix)
+      s.appendLeft(node.body.end! - 1, suffix)
+    } else {
+      // prepend `{[prefix]return ` in body
+      s.appendLeft(node.body.start!, `{\n${prefix}return `)
+      // append `[suffix]}` in
+      s.appendLeft(node.body.end!, `${suffix}\n}`)
+    }
+  }
 }

src/core/index.ts

@@ -39,7 +39,7 @@ export const getNumber = quansync({
   async: (id) => Promise.resolve(id),
 })
 
-const inc1 = quansync(function* (){
+const inc1 = quansync(function* () {
   const value = yield getNumber(1)
   return value + 1
 })
@@ -49,7 +49,7 @@ const inc2 = quansync(function* (id) {
   return value + 1
 })
 
-const inc3 = quansync(function* named(){
+const inc3 = quansync(function* named() {
   const value = yield getNumber(1)
   return value + 1
 })
@@ -59,22 +59,17 @@ const inc4 = quansync(function* named(id) {
   return value + 1
 })
 
-const inc5 = quansync(() => {
-return function* () {
+const inc5 = quansync(function* () {
   const value = yield getNumber(1)
   return value + 1
-}.call(this)
 })
 
-const inc6 = quansync((id) => {
-return function* () {
+const inc6 = quansync(function* (id) {
   const value = yield getNumber(1)
   return value + 1
-}.call(this)
 })
 
-export const fn7 = quansync(() => {
-return function* () {
+export const fn7 = quansync(function* () {
   yield 1
   yield 2
   const fn = async () => {
@@ -91,18 +86,15 @@ return function* () {
       await 10
     }
   }
-}.call(this)
 })
 
-quansync(() => {
-return function* () {
+quansync(function* () {
   ;!(yield 1)
   ;'' + (yield 1)
   ;false && (yield 1)
   fn7()
   ;(yield 1) < (yield 10)
   const x = (yield 1) < (yield 10)
-}.call(this)
 })
 
 export default async () => {
@@ -116,6 +108,40 @@ export default async () => {
 "
 `;
 
+exports[`transform > ./fixtures/bind-this.js 1`] = `
+"// @ts-check
+import { quansync } from 'quansync/macro'
+import { expect } from 'vitest'
+
+const globalThis = this
+
+const arrowFn = quansync(() => {
+return function* () {
+  return this
+}.call(this)
+})
+
+const normalFunction = quansync(function* () {
+  return this
+})
+
+class Cls {
+  arrowFn() {
+    return arrowFn.call(this)
+  }
+  normalFunction() {
+    return normalFunction.call(this)
+  }
+}
+
+export default async () => {
+  const cls = new Cls()
+  expect(await cls.arrowFn()).toBe(globalThis)
+  expect(await cls.normalFunction()).instanceOf(Cls)
+}
+"
+`;
+
 exports[`transform > ./fixtures/inlined-arrow.js 1`] = `
 "// @ts-check
 import { quansync } from 'quansync/macro'
@@ -127,11 +153,8 @@ export const echo = quansync({
 })
 
 const echoNewLine = quansync(
-  /** @param {string|Promise<string>} v */ (v) =>
-    {
-return function* () {
+  /** @param {string|Promise<string>} v */ function* (v) {
 return ((yield echo(yield v))) + '\\n'
-}.call(this)
 },
 )
 

tests/__snapshots__/transform.test.ts.snap

@@ -0,0 +1,28 @@
+// @ts-check
+import { quansync } from 'quansync/macro'
+import { expect } from 'vitest'
+
+const globalThis = this
+
+const arrowFn = quansync(async () => {
+  return this
+})
+
+const normalFunction = quansync(async function () {
+  return this
+})
+
+class Cls {
+  arrowFn() {
+    return arrowFn.call(this)
+  }
+  normalFunction() {
+    return normalFunction.call(this)
+  }
+}
+
+export default async () => {
+  const cls = new Cls()
+  expect(await cls.arrowFn()).toBe(globalThis)
+  expect(await cls.normalFunction()).instanceOf(Cls)
+}