nadesiko3 3.7.21 → 3.7.23

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/func_call.mjs

@@ -221,6 +221,24 @@ TIDのタイマー停止
 　test2`
     await cmp(code, '1\n2')
   })
+  it('並行した非同期関数の終了後にローカル変数領域を残さない #1758', async () => {
+    const nako = new NakoCompiler()
+    const code = `
+●test1():
+　xとは変数= 1
+　0.05秒待つ
+●test2():
+　xとは変数= 2
+　0.05秒待つ
+
+0.01秒後には:
+　test1
+0.03秒後には:
+　test2`
+    const g = await nako.runAsync(code, 'main.nako3')
+    await forceWait(200)
+    assert.strictEqual(g.__vars, g.__varslist[2])
+  })
   it('後方で宣言した関数がasyncFnだったときその関数が正しく実行できない(2) #1758', async () => {
     const code = `
 0.1秒後には:

package/core/test/func_test.mjs

@@ -2,6 +2,7 @@
 import { describe, it } from 'node:test'
 import assert from 'assert'
 import { NakoCompiler } from '../src/nako3.mjs'
+import { NakoSyntaxError } from '../src/nako_errors.mjs'
 
 describe('func_test', async () => {
   // nako.logger.addListener('trace', ({ browserConsole }) => { console.log(...browserConsole) })
@@ -10,6 +11,19 @@ describe('func_test', async () => {
     nako.getLogger().debug('code=' + code)
     assert.strictEqual((await nako.runAsync(code, 'main.nako3')).log, res)
   }
+  /** 文法エラー(NakoSyntaxError)になることを確認する */
+  const cmpError = async (/** @type {string} */ code) => {
+    const nako = new NakoCompiler()
+    nako.getLogger().debug('code=' + code)
+    await assert.rejects(
+      async () => { await nako.runAsync(code, 'main.nako3') },
+      (err) => {
+        assert(err instanceof NakoSyntaxError, `NakoSyntaxErrorではありません: ${err}`)
+        assert(err.message.includes('式の中で『戻す(戻る)』文は使えません'), `想定外のエラーです: ${err.message}`)
+        return true
+      }
+    )
+  }
   // --- test ---
 
   it('簡単な関数定義', async () => {
@@ -146,4 +160,18 @@ describe('func_test', async () => {
     await cmp('●(AとBを)加算処理とは\n引数[0]と引数[1]を足すこと。。。3と5を加算処理して表示。', '8')
     await cmp('●(AとBをCで)加算処理とは\nそれ=引数[0]+引数[1]+引数[2]。。。3と5を2で加算処理して表示。', '10')
   })
+  it('代入文の値の中に『戻す』は書けない #2064', async () => {
+    // 『(式)して戻す』を代入文の値に書くと不正なJavaScriptが生成されていた
+    await cmpError('●テストとは\n定数の結果は「あ」を真偽判定して戻す。\nここまで\nテストを表示。')
+    await cmpError('●テストとは\n変数の結果は「あ」を真偽判定して戻す。\nここまで\nテストを表示。')
+    await cmpError('●テストとは\n結果は「あ」を真偽判定して戻す。\nここまで\nテストを表示。')
+    // 『戻る』の書き方でも同じエラーになる
+    await cmpError('●テストとは\n定数の結果は1に2を足して戻る。\nここまで\nテストを表示。')
+  })
+  it('『戻す』の正しい書き方は動く #2064', async () => {
+    await cmp('●テストとは\n「あ」を真偽判定して戻す。\nここまで\nテストを表示。', '真')
+    await cmp('●テストとは\n定数の結果は「あ」を真偽判定。\n結果で戻す。\nここまで\nテストを表示。', '真')
+    // 『戻す』以外の連文は今まで通り動く
+    await cmp('1に2を足して3を掛けて表示。', '9')
+  })
 })

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,127 @@
+/* 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'
+import { NakoRunner } from '../src/nako_runner.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('非同期プログラムの完了後にfinishが発火する (#2384)', async () => {
+    const nako = new NakoCompiler()
+    let logAtFinish = null
+    nako.addListener('finish', (g) => { logAtFinish = g.log })
+    const g = await nako.runAsync('0.02秒待つ\n「完了」を表示', 'main.nako3')
+    assert.strictEqual(logAtFinish, '完了')
+    assert.strictEqual(g.log, '完了')
+  })
+
+  it('runSyncでは非同期プログラムでも同期的にfinishが発火する (#2384)', async () => {
+    const nako = new NakoCompiler()
+    const logsAtFinish = []
+    nako.addListener('finish', (g) => { logsAtFinish.push(g.log) })
+    const g = nako.runSync('0.02秒待つ\n「完了」を表示', 'main.nako3')
+    assert.deepStrictEqual(logsAtFinish, [''])
+    assert.strictEqual(g.log, '')
+    await new Promise((resolve) => setTimeout(resolve, 40))
+    assert.strictEqual(g.log, '完了')
+    assert.deepStrictEqual(logsAtFinish, [''])
+  })
+
+  it('thenableがrejectした後にもfinishが発火する (#2384)', async () => {
+    const events = []
+    const runner = new NakoRunner({
+      fireEvent: (name, g) => { events.push([name, g.completed]) },
+      getLogger: () => ({ error: () => {} })
+    })
+    const g = { lastJSCode: '', numFailures: 0, completed: false }
+    const result = runner.evalJS(`
+      return {
+        then: (_resolve, reject) => setTimeout(() => {
+          this.completed = true
+          reject(new Error('非同期失敗'))
+        }, 1)
+      }
+    `, g, true)
+    assert.deepStrictEqual(events, [['beforeRun', false]])
+    await assert.rejects(Promise.resolve(result), /非同期失敗/)
+    assert.deepStrictEqual(events, [['beforeRun', false], ['finish', true]])
+  })
+
+  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, 'おわり')
+    })
+  })
+})