nadesiko3 3.7.21 → 3.7.22

package/core/test/fixtures/parser_corpus.mjs

@@ -0,0 +1,120 @@
+/* eslint-disable no-undef */
+/**
+ * 構文解析器(NakoParser)の回帰テスト用コーパス (#2364)
+ *
+ * `core/test/nako_parser_test.mjs`(検証)と
+ * `core/test/fixtures/make_parser_ast_golden.mjs`(ゴールデン生成)の
+ * 双方から参照する。テスト本体とは分離しておかないと、
+ * 生成スクリプトを実行したときにテストまで走ってしまう。
+ *
+ * このディレクトリは `core/test/*.mjs` のテストグロブに含まれないので、
+ * テスト実行時にこのファイル自体が走ることはない。
+ */
+import { NakoCompiler } from '../../src/nako3.mjs'
+
+/** ゴールデン比較で使うファイル名(AST の file フィールドに入るので固定する) */
+export const CORPUS_FILENAME = 'main.nako3'
+
+/**
+ * 構文解析のコーパス。
+ * `core/src/nako_parser3.mts` の構文規則クラスタを一通り踏むように選んである。
+ */
+export const PARSER_CORPUS = {
+  // --- 文の骨格 (parse / ySentenceList / ySentence / yBlock / yEOL) ---
+  '文-空行とコメント': '# コメント\n\nA=1\n',
+  '文-複数文': 'A=1\nB=2\nA+Bを表示\n',
+  '文-連文': '1に2を足して3を掛けて表示\n',
+  '文-抜ける': '3回\n抜ける\nここまで\n',
+  '文-続ける': '3回\n続ける\nここまで\n',
+  '文-ここから': '3回ここから\nA=1\nここまで\n',
+  '文-ハテナ表示': '??1+2\n',
+
+  // --- モード設定・実行モード指定 (ySpeedMode / yPerformanceMonitor / yDNCLMode ほか) ---
+  'モード-DNCL': '!DNCLモード\nA=1\n',
+  'モード-速度優先': '「全て」で実行速度優先\nA=1\nここまで\n',
+  'モード-モニタ': '「全て」でパフォーマンスモニタ適用\nA=1\nここまで\n',
+  'モード-厳チェック': '!厳チェック\nA=1\n',
+  'モード-公開既定値': '!モジュール公開既定値=「非公開」\nA=1\n',
+
+  // --- 関数定義 (yDefFunc / yDefFuncCommon / yMumeiFunc / yDefTest) ---
+  '定義-関数': '●(AとBを)足すとは\nA+Bで戻る\nここまで\n',
+  '定義-関数公開': '●{公開}(Aを)倍とは\nA*2で戻る\nここまで\n',
+  '定義-カッコ引数': '●足す(AとBを)とは\nA+Bで戻る\nここまで\n',
+  '定義-ここから': '●Fとは、ここから\nA=1\nここまで\n',
+  '定義-無名関数': 'F=関数(Aを)\nAを表示\nここまで\n',
+  '定義-テスト': '●テスト:足すとは\nA=1\nここまで\n',
+
+  // --- 制御構文 (yIF / yFor / yWhile / ySwitch / yTryExcept ほか) ---
+  '制御-もし': 'もしA=1ならば\nB=1\n違えば\nB=2\nここまで\n',
+  '制御-もし単文': 'もしA=1ならばB=1\n',
+  '制御-回': '3回\nA=1\nここまで\n',
+  '制御-間': 'A<3の間\nA=A+1\nここまで\n',
+  '制御-後判定': '後判定\nA=A+1\nここまでA>3になるまで\n',
+  '制御-繰返': 'Nを1から10まで繰り返す\nNを表示\nここまで\n',
+  '制御-増繰返': 'Nを1から10まで2ずつ増やして繰り返す\nNを表示\nここまで\n',
+  '制御-減繰返': 'Nを10から1まで1ずつ減らして繰り返す\nNを表示\nここまで\n',
+  '制御-反復': '[1,2,3]を反復\n対象を表示\nここまで\n',
+  '制御-条件分岐': 'Aで条件分岐\n1ならば\nB=1\nここまで\n違えば\nB=2\nここまで\nここまで\n',
+  '制御-戻る': '●Fとは\n1で戻る\nここまで\n',
+  '制御-エラー監視': 'エラー監視\nA=1\nエラーならば\nB=2\nここまで\n',
+
+  // --- 代入・変数定義 (yLet / yDainyu / ySadameru / yIncDec) ---
+  '代入-単純': 'A=1\n',
+  '代入-代入文': 'Aに1を代入\n',
+  '代入-定める': 'Aを1に定める\n',
+  '代入-変数宣言': '変数 A=1\n',
+  '代入-定数宣言': '定数 A=1\n',
+  '代入-とは変数': 'Aとは変数=1\n',
+  '代入-複数変数': '変数 [A,B]=[1,2]\n',
+  '代入-複数代入': 'A,B=[1,2]\n',
+  '代入-増やす': 'Aを1だけ増やす\n',
+  '代入-減らす': 'Aを1だけ減らす\n',
+  '代入-プロパティ': 'A={}\nA$「b」=1\n',
+
+  // --- 配列要素への代入 (yLetArrayAt / yLetArrayBracket) ---
+  '配列-角括弧': 'A=[0]\nA[0]=1\n',
+  '配列-アット': 'A=[0]\nA@0=1\n',
+  '配列-二次元': 'A=[[0]]\nA[0][1]=1\n',
+  '配列-カンマ': 'A=[[0]]\nA[0,1]=1\n',
+
+  // --- 関数呼び出し (yCall / yCallFunc / yGetArgParen) ---
+  '呼出-単純': '「あ」を表示\n',
+  '呼出-C風': '足す(1,2)を表示\n',
+  '呼出-一語関数': 'A=1\nAを表示\n',
+
+  // --- 式・値 (yCalc / yValue / yValueKakko / yValueWord) ---
+  '式-カッコ': '(1+2)*3を表示\n',
+  '式-演算子': '1+2*3-4/5を表示\n',
+  '式-比較': 'もし1<2かつ3>2ならばA=1\n',
+  '式-範囲': 'A=1…10\n',
+  '式-単項マイナス': 'A=1\nB=-A\n',
+  '式-NOT': 'A=1\nB=!A\n',
+
+  // --- JSON/配列リテラル (yJSONArray / yJSONObject / yRefArrayValue) ---
+  'リテラル-配列': 'A=[1,2,3]\n',
+  'リテラル-辞書': 'A={"a":1,"b":2}\n',
+  'リテラル-辞書省略': 'A={a:1}\n',
+  'リテラル-空配列': 'A=[]\n',
+  'リテラル-空辞書': 'A={}\n',
+  'リテラル-入れ子': 'A=[[1,2],[3,4]]\n',
+  'リテラル-添字直接': 'A=[[1,2],[3,4]][0][1]\n',
+  'リテラル-アット直接': 'A=[1,2,3]@0\n',
+  'リテラル-プロパティ直接': 'A={a:1}$「a」\n',
+
+  // --- 非同期関数の判定 (_checkAsyncFn) ---
+  '非同期-async関数': '●Fとは\n1秒待つ\nここまで\nF\n'
+}
+
+/**
+ * AST を JSON 化可能なプレーンオブジェクトに変換する。
+ * `meta.fn` にはプラグイン関数の実体が入るため、JSON.stringify が黙って捨てて
+ * しまわないよう replacer で目印に置き換える。
+ */
+export function toPlainAst (ast) {
+  return JSON.parse(JSON.stringify(ast, (key, value) => (typeof value === 'function' ? '[fn]' : value)))
+}
+
+/** なでしこのコードを構文解析してプレーンな AST を返す */
+export function parseToPlainAst (code) {
+  return toPlainAst(new NakoCompiler().parse(code, CORPUS_FILENAME))
+}

package/core/test/indent_test.mjs

@@ -292,4 +292,10 @@ describe('indent', async () => {
         '\t\t続ける\n' +
         '\tcを表示\n', '1\n0')
   })
+  it('useIndentSyntaxが正しく動作し、インデント構文が解釈されること (#2333)', async () => {
+    await cmp('!インデント構文\n' +
+        'もし1=1ならば\n' +
+        '　　「OK」と表示。\n', 'OK')
+  })
 })
+

package/core/test/nako_basic_plugins_test.mjs

@@ -0,0 +1,44 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler } from '../src/nako3.mjs'
+import { basicPlugins, registerBasicPlugins } from '../src/nako_basic_plugins.mjs'
+
+/**
+ * 基本プラグインの一覧を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_basic_plugins_test', () => {
+  it('基本プラグインの一覧を取得できる', () => {
+    assert.strictEqual(basicPlugins.length, 6)
+    const names = basicPlugins.map((po) => po.meta.value.pluginName)
+    assert.deepStrictEqual(names, [
+      'plugin_system', 'plugin_math', 'plugin_promise', 'plugin_test', 'plugin_csv', 'plugin_toml'
+    ])
+  })
+
+  it('registerBasicPluginsは一覧の順にaddPluginを呼ぶ', () => {
+    const called = []
+    registerBasicPlugins({ addPlugin: (po) => { called.push(po) } })
+    assert.deepStrictEqual(called, basicPlugins)
+  })
+
+  it('useBasicPluginがtrueなら基本プラグインの命令を使える', () => {
+    const nako = new NakoCompiler({ useBasicPlugin: true })
+    assert.ok(nako.getFunc('表示') !== undefined, 'PluginSystemの命令')
+    assert.ok(nako.getFunc('SIN') !== undefined, 'PluginMathの命令')
+  })
+
+  it('useBasicPluginがfalseなら基本プラグインは登録されない', () => {
+    const nako = new NakoCompiler({ useBasicPlugin: false })
+    assert.strictEqual(nako.getFunc('表示'), undefined)
+    assert.deepStrictEqual(Object.keys(nako.getPluginfiles()), [])
+  })
+
+  it('addBasicPluginsを後から呼んでも登録できる', () => {
+    const nako = new NakoCompiler({ useBasicPlugin: false })
+    nako.addBasicPlugins()
+    assert.ok(nako.getFunc('表示') !== undefined)
+    assert.strictEqual(Object.keys(nako.getPluginfiles()).length, basicPlugins.length)
+  })
+})

package/core/test/nako_event_test.mjs

@@ -0,0 +1,85 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler } from '../src/nako3.mjs'
+import { NakoEventEmitter } from '../src/nako_event.mjs'
+
+/**
+ * イベント機構を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_event_test', () => {
+  it('onで登録したコールバックがfireで呼ばれる', () => {
+    const emitter = new NakoEventEmitter()
+    const log = []
+    emitter.on('beforeParse', (v) => { log.push(`a:${v}`) })
+    emitter.on('beforeParse', (v) => { log.push(`b:${v}`) })
+    emitter.fire('beforeParse', 1)
+    assert.deepStrictEqual(log, ['a:1', 'b:1'])
+  })
+
+  it('登録していないイベントを発火しても何も起きない', () => {
+    const emitter = new NakoEventEmitter()
+    let called = 0
+    emitter.on('beforeParse', () => { called++ })
+    emitter.fire('finish', null)
+    assert.strictEqual(called, 0)
+  })
+
+  it('別のイベント名のコールバックは呼ばれない', () => {
+    const emitter = new NakoEventEmitter()
+    const log = []
+    emitter.on('beforeParse', () => { log.push('parse') })
+    emitter.on('finish', () => { log.push('finish') })
+    emitter.fire('finish', null)
+    assert.deepStrictEqual(log, ['finish'])
+  })
+
+  it('getEventListで登録済みのイベントを取得できる', () => {
+    const emitter = new NakoEventEmitter()
+    emitter.on('beforeRun', () => {})
+    assert.strictEqual(emitter.getEventList().length, 1)
+    assert.strictEqual(emitter.getEventList()[0].eventName, 'beforeRun')
+  })
+
+  it('clearで登録済みのイベントを削除できる', () => {
+    const emitter = new NakoEventEmitter()
+    let called = 0
+    emitter.on('finish', () => { called++ })
+    emitter.clear()
+    emitter.fire('finish', null)
+    assert.strictEqual(called, 0)
+    assert.strictEqual(emitter.getEventList().length, 0)
+  })
+
+  it('NakoCompilerのaddListenerでイベントが発火する順番', async () => {
+    const nako = new NakoCompiler()
+    const log = []
+    nako.addListener('beforeParse', () => { log.push('beforeParse') })
+    nako.addListener('beforeGenerate', () => { log.push('beforeGenerate') })
+    nako.addListener('afterGenerate', () => { log.push('afterGenerate') })
+    nako.addListener('beforeRun', () => { log.push('beforeRun') })
+    nako.addListener('finish', () => { log.push('finish') })
+    await nako.runAsync('「テスト」を表示', 'main.nako3')
+    assert.deepStrictEqual(log, ['beforeParse', 'beforeGenerate', 'afterGenerate', 'beforeRun', 'finish'])
+  })
+
+  it('beforeParseにはソースコードが渡される', async () => {
+    const nako = new NakoCompiler()
+    let received = null
+    nako.addListener('beforeParse', (code) => { received = code })
+    await nako.runAsync('1と2を足して表示', 'main.nako3')
+    assert.strictEqual(received, '1と2を足して表示')
+  })
+
+  it('beforeRunとfinishには実行環境が渡される', async () => {
+    const nako = new NakoCompiler()
+    const received = []
+    nako.addListener('beforeRun', (g) => { received.push(g) })
+    nako.addListener('finish', (g) => { received.push(g) })
+    const g = await nako.runAsync('「テスト」を表示', 'main.nako3')
+    assert.strictEqual(received.length, 2)
+    assert.strictEqual(received[0], g)
+    assert.strictEqual(received[1], g)
+  })
+})

package/core/test/nako_gen_perf_test.mjs

@@ -0,0 +1,178 @@
+/* eslint-disable no-undef */
+/**
+ * nako_gen.mts のパフォーマンスモニタ / 関数呼び出しコード生成のテスト (#2333)
+ *
+ * `「〜」にパフォーマンスモニタ適用` で生成されるコードと、
+ * 実行時に作られる `__self.__performance_monitor` の内容を検証する。
+ * nako_gen.mts のリファクタリングで生成コードが壊れていないことを保証するのが目的。
+ */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+import { NakoCompiler } from '../src/nako3.mjs'
+
+describe('nako_gen_perf_test', async () => {
+  /**
+   * なでしこコードを実行して、ログと計測結果を返す
+   * @param {string} code
+   */
+  const run = async (code) => {
+    const nako = new NakoCompiler()
+    const g = await nako.runAsync(code, 'main.nako3')
+    // 非同期命令は runAsync の完了後も動いているので待つ (func_call.mjs と同様)
+    if (code.indexOf('秒待') >= 0) { await forceWait(200) }
+    return { log: g.log, pm: g.__performance_monitor }
+  }
+
+  // 強制的にミリ秒待機
+  function forceWait (/** @type {number} */ ms) {
+    return /** @type {Promise<void>} */(new Promise((resolve) => {
+      setTimeout(() => { resolve() }, ms)
+    }))
+  }
+
+  describe('計測なしのとき', async () => {
+    it('__performance_monitor は作られない', async () => {
+      const { log, pm } = await run('「あ」と表示')
+      assert.strictEqual(log, 'あ')
+      assert.strictEqual(pm, undefined)
+    })
+  })
+
+  describe('システム関数本体の計測', async () => {
+    it('キーは『命令名_body』、typeは『sysbody』', async () => {
+      const { log, pm } = await run(
+        '「システム関数本体」にパフォーマンスモニタ適用ここから\n' +
+        '　「あ」と表示\n' +
+        '　1に2を足して表示\n' +
+        'ここまで\n')
+      assert.strictEqual(log, 'あ\n3')
+      assert.strictEqual(pm['表示_body'].type, 'sysbody')
+      assert.strictEqual(pm['表示_body'].called, 2)
+      assert.strictEqual(pm['足_body'].type, 'sysbody')
+      assert.strictEqual(pm['足_body'].called, 1)
+    })
+  })
+
+  describe('システム関数の計測', async () => {
+    it('キーは『命令名_sys』、typeは『system』', async () => {
+      const { log, pm } = await run(
+        '「システム関数」にパフォーマンスモニタ適用ここから\n' +
+        '　「あ」と表示\n' +
+        '　S=1に2を足す\n' +
+        '　Sを表示\n' +
+        'ここまで\n')
+      assert.strictEqual(log, 'あ\n3')
+      assert.strictEqual(pm['表示_sys'].type, 'system')
+      assert.strictEqual(pm['表示_sys'].called, 2)
+      assert.strictEqual(pm['足_sys'].type, 'system')
+      assert.strictEqual(pm['足_sys'].called, 1)
+    })
+
+    it('計測結果には called/totel_usec/min_usec/max_usec が入る', async () => {
+      const { pm } = await run(
+        '「システム関数」にパフォーマンスモニタ適用ここから\n' +
+        '　「あ」と表示\n' +
+        'ここまで\n')
+      const r = pm['表示_sys']
+      assert.deepStrictEqual(Object.keys(r).sort(), ['called', 'max_usec', 'min_usec', 'totel_usec', 'type'].sort())
+      assert.ok(r.min_usec <= r.max_usec)
+      assert.ok(r.totel_usec >= r.max_usec)
+    })
+
+    it('ブロックの外は計測されない', async () => {
+      const { log, pm } = await run(
+        '「システム関数」にパフォーマンスモニタ適用ここから\n' +
+        '　「あ」と表示\n' +
+        'ここまで\n' +
+        '1に2を足して表示\n')
+      assert.strictEqual(log, 'あ\n3')
+      assert.strictEqual(pm['表示_sys'].called, 1)
+      assert.strictEqual(pm['足_sys'], undefined)
+    })
+  })
+
+  describe('ユーザ関数の計測', async () => {
+    it('キーは関数名、typeは『user』 (#2333)', async () => {
+      const { log, pm } = await run(
+        '「ユーザ関数」にパフォーマンスモニタ適用ここから\n' +
+        '　●(AとBを)テスト足すとは\n' +
+        '　　AにBを足して戻す\n' +
+        '　ここまで\n' +
+        '　1と2をテスト足して表示\n' +
+        '　3と4をテスト足して表示\n' +
+        'ここまで\n')
+      assert.strictEqual(log, '3\n7')
+      assert.strictEqual(pm.main__テスト足.type, 'user')
+      assert.strictEqual(pm.main__テスト足.called, 2)
+    })
+  })
+
+  describe('非同期命令の計測 (#2333)', async () => {
+    it('システム関数本体: 構文エラーにならず、実行も完了する', async () => {
+      const { log, pm } = await run(
+        '「システム関数本体」にパフォーマンスモニタ適用ここから\n' +
+        '　0.01秒待つ\n' +
+        '　「おわり」と表示\n' +
+        'ここまで\n')
+      assert.strictEqual(log, 'おわり')
+      assert.strictEqual(pm.秒待_body.type, 'sysbody')
+      assert.strictEqual(pm.秒待_body.called, 1)
+    })
+
+    it('システム関数: 構文エラーにならず、実行も完了する', async () => {
+      const { log, pm } = await run(
+        '「システム関数」にパフォーマンスモニタ適用ここから\n' +
+        '　0.01秒待つ\n' +
+        '　「おわり」と表示\n' +
+        'ここまで\n')
+      assert.strictEqual(log, 'おわり')
+      assert.strictEqual(pm.秒待_sys.type, 'system')
+      assert.strictEqual(pm.秒待_sys.called, 1)
+    })
+  })
+
+  describe('全てのオプションを同時に適用 (#2333)', async () => {
+    it('ユーザ関数・システム関数本体・システム関数を同時に計測できる', async () => {
+      const { log, pm } = await run(
+        '「全て」にパフォーマンスモニタ適用ここから\n' +
+        '　●(Aを)テスト表示とは\n' +
+        '　　Aを表示\n' +
+        '　ここまで\n' +
+        '　「あ」をテスト表示\n' +
+        '　1に2を足して表示\n' +
+        'ここまで\n')
+      assert.strictEqual(log, 'あ\n3')
+      assert.strictEqual(pm.main__テスト表示.type, 'user')
+      assert.strictEqual(pm.足_body.type, 'sysbody')
+      assert.strictEqual(pm.足_sys.type, 'system')
+    })
+  })
+
+  describe('関数呼び出しコード生成の回帰チェック', async () => {
+    it('戻り値のある命令と『それ』', async () => {
+      const { log } = await run('1に2を足す\nそれを表示')
+      assert.strictEqual(log, '3')
+    })
+
+    it('ユーザ関数の呼び出しと戻り値', async () => {
+      const { log } = await run(
+        '●(AとBを)テスト足すとは\n' +
+        '　AにBを足して戻す\n' +
+        'ここまで\n' +
+        '1と2をテスト足して表示\n')
+      assert.strictEqual(log, '3')
+    })
+
+    it('無名関数の呼び出し', async () => {
+      const { log } = await run(
+        'F=関数(a,b)それはa+b;ここまで\n' +
+        'F(3,4)を表示\n')
+      assert.strictEqual(log, '7')
+    })
+
+    it('非同期命令の呼び出し', async () => {
+      const { log } = await run('0.01秒待つ\n「おわり」と表示')
+      assert.strictEqual(log, 'おわり')
+    })
+  })
+})

package/core/test/nako_parser_async_test.mjs

@@ -0,0 +1,112 @@
+/* eslint-disable no-undef */
+/**
+ * nako_parser_async.mts の単体テスト (#2364)
+ *
+ * 非同期処理(asyncFn)の判定は、これまで NakoParser の内部メソッドだったため
+ * 単体で検証できなかった。分離したことで AST を直接組み立てて確認できる。
+ */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+import { checkAsyncFn } from '../src/nako_parser_async.mjs'
+import { NakoCompiler } from '../src/nako3.mjs'
+
+/** テスト用に func ノードを作る */
+function funcNode (name, blocks = [], asyncFn = false) {
+  return { type: 'func', name, blocks, asyncFn, josi: '' }
+}
+
+/** テスト用に def_func ノードを作る */
+function defFuncNode (name, blocks = []) {
+  return { type: 'def_func', name, blocks, meta: {}, asyncFn: false, josi: '' }
+}
+
+/** テスト用に block ノードを作る */
+function blockNode (blocks) {
+  return { type: 'block', blocks, josi: '' }
+}
+
+describe('nako_parser_async_test', () => {
+  describe('checkAsyncFn', () => {
+    it('非同期処理が無ければ書き換えない', () => {
+      const ast = blockNode([funcNode('表示', [{ type: 'number', value: 1, josi: 'を' }])])
+      assert.strictEqual(checkAsyncFn(ast, new Map()), false)
+      assert.strictEqual(ast.blocks[0].asyncFn, false)
+    })
+
+    it('funclist が非同期の関数を呼ぶと asyncFn が付く', () => {
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const ast = blockNode([funcNode('待つ')])
+      assert.strictEqual(checkAsyncFn(ast, funclist), true, '書き換えたので true')
+      assert.strictEqual(ast.blocks[0].asyncFn, true)
+    })
+
+    it('書き換えが済めば false を返す(不動点に到達する)', () => {
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const ast = blockNode([funcNode('待つ')])
+      assert.strictEqual(checkAsyncFn(ast, funclist), true)
+      assert.strictEqual(checkAsyncFn(ast, funclist), false, '2回目は変化しない')
+    })
+
+    it('関数定義の中身が非同期なら関数定義自体が非同期になる', () => {
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const def = defFuncNode('F', [funcNode('待つ')])
+      assert.strictEqual(checkAsyncFn(blockNode([def]), funclist), true)
+      assert.strictEqual(def.asyncFn, true)
+      assert.strictEqual(def.meta.asyncFn, true, 'meta にも反映される')
+    })
+
+    it('引数の中に非同期があれば呼び出し自体も非同期になる', () => {
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const inner = funcNode('待つ')
+      const outer = funcNode('表示', [inner])
+      assert.strictEqual(checkAsyncFn(blockNode([outer]), funclist), true)
+      assert.strictEqual(outer.asyncFn, true)
+    })
+
+    it('連文は常に非同期として扱う', () => {
+      const def = defFuncNode('F', [{ type: 'renbun', blocks: [], josi: '' }])
+      assert.strictEqual(checkAsyncFn(blockNode([def]), new Map()), true)
+      assert.strictEqual(def.asyncFn, true)
+    })
+
+    it('[現状の挙動] block の走査は最初の非同期ノードで打ち切られる', () => {
+      // ブロックの走査は子が非同期だと分かった時点で return するため、
+      // それより後ろの兄弟はそのパスでは訪問されない。
+      // したがって G は、この走査だけでは非同期と判定されない。
+      //
+      // 実際のパーサでは yDefFuncCommon が解析中に usedAsyncFn を追跡して
+      // 関数定義に asyncFn を付けるので、この走査に頼らなくても G は非同期になる
+      // (下の「NakoParser 経由での結合確認」を参照)。
+      // 分離前からの挙動なので、そのまま固定しておく。
+      const funclist = new Map([
+        ['待つ', { type: 'func', asyncFn: true }],
+        ['F', { type: 'func', asyncFn: true }]
+      ])
+      const defF = defFuncNode('F', [funcNode('待つ')])
+      const defG = defFuncNode('G', [funcNode('F')])
+      const ast = blockNode([defF, defG])
+
+      let count = 0
+      while (checkAsyncFn(ast, funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(defF.asyncFn, true)
+      assert.strictEqual(defG.asyncFn, false, 'F の後ろにある G は訪問されない')
+    })
+  })
+
+  describe('NakoParser 経由での結合確認', () => {
+    it('非同期関数を呼ぶユーザー関数に asyncFn が伝播する', () => {
+      const ast = new NakoCompiler().parse('●Fとは\n1秒待つ\nここまで\nF\n', 'main.nako3')
+      const def = ast.blocks.find((n) => n.type === 'def_func')
+      assert.strictEqual(def.asyncFn, true)
+    })
+
+    it('非同期処理を含まない関数は asyncFn にならない', () => {
+      const ast = new NakoCompiler().parse('●Fとは\n1を表示\nここまで\nF\n', 'main.nako3')
+      const def = ast.blocks.find((n) => n.type === 'def_func')
+      assert.strictEqual(def.asyncFn, false)
+    })
+  })
+})