Update for TS7

I am testing Typescript 7's JS support, which I've largely rewritten
during the switch to Go. The new code processes tags by converting them
into synthetic nodes just after parsing their host node. For unified,
that means that `@template` tags can't be shared between multiple
`@overload` tags like before.

This PR also has to convert function declarations with `@type` on them
to variables initialised with a function expression. TS7 doesn't
currently support this feature on function declarations--but both unified and
svelte use this feature a lot, so I think we'll need to add it before
TS7's JS features are ready. At that point the shuffling of functions in
the test files won't be needed anymore.

In addition, microsoft/typescript-go#1444 makes
it possible to have rest parameters in `@overload`, and is needed for
this change to work in TS7, so it won't compile with the nightly until
that PR is merged.

Because TS7 is quite a way off, I don't know whether you'll want to take this PR. I created it to see how hard it would be to update popular JS code that uses TS for checking.

Author: sandersn

lib/index.js

@@ -538,7 +538,6 @@ export class Processor extends CallableInstance {
    *   processor.data() // => {charlie: 'delta'}
    *   ```
    *
-   * @template {keyof Data} Key
    *
    * @overload
    * @returns {Data}
@@ -547,15 +546,18 @@ export class Processor extends CallableInstance {
    * @param {Data} dataset
    * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
    *
+   * @template {keyof Data} Key
    * @overload
    * @param {Key} key
    * @returns {Data[Key]}
    *
+   * @template {keyof Data} Key
    * @overload
    * @param {Key} key
    * @param {Data[Key]} value
    * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
    *
+   * @template {keyof Data} Key
    * @param {Data | Key} [key]
    *   Key to get or set, or entire dataset to set, or nothing to get the
    *   entire dataset (optional).
@@ -805,6 +807,14 @@ export class Processor extends CallableInstance {
     let complete = false
     /** @type {VFileWithOutput<CompileResult> | undefined} */
     let result
+    /**
+     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}
+     */
+    const realDone = (error, file) => {
+      complete = true
+      bail(error)
+      result = file
+    }
 
     this.freeze()
     assertParser('processSync', this.parser || this.Parser)
@@ -815,15 +825,6 @@ export class Processor extends CallableInstance {
     assert(result, 'we either bailed on an error or have a tree')
 
     return result
-
-    /**
-     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}
-     */
-    function realDone(error, file) {
-      complete = true
-      bail(error)
-      result = file
-    }
   }
 
   /**
@@ -940,21 +941,21 @@ export class Processor extends CallableInstance {
     let complete = false
     /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */
     let result
-
-    this.run(tree, file, realDone)
-
-    assertDone('runSync', 'run', complete)
-    assert(result, 'we either bailed on an error or have a tree')
-    return result
-
     /**
      * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}
      */
-    function realDone(error, tree) {
+    const realDone = (error, tree) => {
       bail(error)
       result = tree
       complete = true
     }
+
+    this.run(tree, file, realDone)
+
+    assertDone('runSync', 'run', complete)
+    assert(result, 'we either bailed on an error or have a tree')
+    return result
+
   }
 
   /**
@@ -1029,10 +1030,6 @@ export class Processor extends CallableInstance {
    *     .use({settings: {position: false}})
    *   ```
    *
-   * @template {Array<unknown>} [Parameters=[]]
-   * @template {Node | string | undefined} [Input=undefined]
-   * @template [Output=Input]
-   *
    * @overload
    * @param {Preset | null | undefined} [preset]
    * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
@@ -1041,6 +1038,9 @@ export class Processor extends CallableInstance {
    * @param {PluggableList} list
    * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
    *
+   * @template {Array<unknown>} [Parameters=[]]
+   * @template {Node | string | undefined} [Input=undefined]
+   * @template [Output=Input]
    * @overload
    * @param {Plugin<Parameters, Input, Output>} plugin
    * @param {...(Parameters | [boolean])} parameters

test/freeze.js

@@ -8,6 +8,22 @@ import test from 'node:test'
 import {unified} from 'unified'
 import {simpleCompiler, simpleParser} from './util/simple.js'
 
+// `this` in JS is buggy in TS.
+/**
+ * @type {Plugin<[], string, Node>}
+ */
+const parse = function () {
+  this.parser = simpleParser
+}
+
+// `this` in JS is buggy in TS.
+/**
+ * @type {Plugin<[], Node, string>}
+ */
+const compile = function () {
+  this.compiler = simpleCompiler
+}
+
 test('`freeze`', async function (t) {
   const frozen = unified().use(parse).use(compile).freeze()
 
@@ -219,19 +235,3 @@ test('`freeze`', async function (t) {
     })
   })
 })
-
-// `this` in JS is buggy in TS.
-/**
- * @type {Plugin<[], string, Node>}
- */
-function parse() {
-  this.parser = simpleParser
-}
-
-// `this` in JS is buggy in TS.
-/**
- * @type {Plugin<[], Node, string>}
- */
-function compile() {
-  this.compiler = simpleCompiler
-}

test/process-sync.js

@@ -8,6 +8,23 @@ import test from 'node:test'
 import {unified} from 'unified'
 import {simpleCompiler, simpleParser} from './util/simple.js'
 
+
+// `this` in JS is buggy in TS.
+/**
+ * @type {Plugin<[], string, Node>}
+ */
+const parse = function () {
+  this.parser = simpleParser
+}
+
+// `this` in JS is buggy in TS.
+/**
+ * @type {Plugin<[], Node, string>}
+ */
+const compile = function () {
+  this.compiler = simpleCompiler
+}
+
 test('`processSync`', async function (t) {
   await t.test('should throw w/o `parser`', async function () {
     assert.throws(function () {
@@ -63,19 +80,3 @@ test('`processSync`', async function (t) {
     }
   )
 })
-
-// `this` in JS is buggy in TS.
-/**
- * @type {Plugin<[], string, Node>}
- */
-function parse() {
-  this.parser = simpleParser
-}
-
-// `this` in JS is buggy in TS.
-/**
- * @type {Plugin<[], Node, string>}
- */
-function compile() {
-  this.compiler = simpleCompiler
-}