nadesiko3 3.7.21 → 3.7.23

package/core/test/nako_parser_async_test.mjs

@@ -0,0 +1,385 @@
+/* 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: '' }
+}
+
+/** テスト用に func_obj(無名関数) ノードを作る */
+function funcObjNode (blocks = [], asyncFn = false) {
+  return { type: 'func_obj', name: '', blocks, meta: {}, asyncFn, josi: '' }
+}
+
+/** テスト用に let(代入) ノードを作る */
+function letNode (name, value) {
+  return { type: 'let', name, blocks: [value], josi: '' }
+}
+
+/**
+ * なでしこのプログラムを実行してログを得る
+ *
+ * runAsync は生成コードの実行完了を待ってから戻る。
+ */
+async function runAndGetLog (code) {
+  const g = await new NakoCompiler().runAsync(code, 'main.nako3')
+  return g.log
+}
+
+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 funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const arg1 = funcNode('待つ')
+      const arg2 = funcNode('待つ')
+      const outer = funcNode('足', [arg1, arg2])
+      const ast = blockNode([outer])
+
+      let count = 0
+      while (checkAsyncFn(ast, funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(outer.asyncFn, true)
+      assert.strictEqual(arg1.asyncFn, true)
+      assert.strictEqual(arg2.asyncFn, true, '2つ目の引数も訪問される')
+    })
+
+    it('連文は常に非同期として扱う', () => {
+      const def = defFuncNode('F', [{ type: 'renbun', blocks: [], josi: '' }])
+      assert.strictEqual(checkAsyncFn(blockNode([def]), new Map()), true)
+      assert.strictEqual(def.asyncFn, true)
+    })
+
+    it('block 内の複数の非同期関数をすべて走査する', () => {
+      const funclist = new Map([
+        ['待つ', { type: 'func', asyncFn: true }],
+        ['F', { type: 'func', asyncFn: false }],
+        ['G', { type: 'func', asyncFn: false }]
+      ])
+      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, true, 'F の後ろにある G も訪問される')
+      assert.strictEqual(funclist.get('F').asyncFn, true)
+      assert.strictEqual(funclist.get('G').asyncFn, true)
+    })
+
+    it('関数定義の本体も最初の非同期ノードで打ち切らない', () => {
+      // 本体の1文目が非同期でも、2文目以降を走査しないと
+      // そこにある呼び出しに asyncFn が付かない
+      const funclist = new Map([
+        ['待つ', { type: 'func', asyncFn: true }],
+        ['G', { type: 'func', asyncFn: true }],
+        ['F', { type: 'func', asyncFn: false }]
+      ])
+      const callG = funcNode('G')
+      const def = defFuncNode('F', [funcNode('待つ'), callG])
+
+      let count = 0
+      while (checkAsyncFn(blockNode([def]), funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(def.asyncFn, true)
+      assert.strictEqual(callG.asyncFn, true, '1文目より後ろの呼び出しも訪問される')
+    })
+
+    it('非同期な無名関数を保持する変数の呼び出しも非同期になる', () => {
+      // F=●()...ここまで のように変数へ代入された無名関数は funclist に載らないため、
+      // 代入を追跡しないと呼び出し側に asyncFn が付かない
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const anon = funcObjNode([funcNode('待つ')])
+      const callF = funcNode('F')
+      const ast = blockNode([letNode('F', anon), callF])
+
+      let count = 0
+      while (checkAsyncFn(ast, funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(anon.asyncFn, true)
+      assert.strictEqual(callF.asyncFn, true, '変数経由の呼び出しにも asyncFn が付く')
+    })
+
+    it('同期な無名関数を保持する変数は非同期にならない', () => {
+      const anon = funcObjNode([funcNode('表示')])
+      const callF = funcNode('F')
+      const ast = blockNode([letNode('F', anon), callF])
+      assert.strictEqual(checkAsyncFn(ast, new Map()), false)
+      assert.strictEqual(callF.asyncFn, false)
+    })
+
+    it('無名関数の変数はその関数スコープの外へ漏れない', () => {
+      // 関数 F の中のローカル変数 X と、外側の変数 X は別物として扱う
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const innerAnon = funcObjNode([funcNode('待つ')])
+      const defF = defFuncNode('F', [letNode('X', innerAnon)])
+      const outerCallX = funcNode('X')
+      const ast = blockNode([defF, outerCallX])
+
+      let count = 0
+      while (checkAsyncFn(ast, funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(innerAnon.asyncFn, true)
+      assert.strictEqual(outerCallX.asyncFn, false, '関数の外の X は非同期にならない')
+    })
+
+    it('内側で同名の同期な無名関数を代入すると外側の非同期をシャドーイングする', () => {
+      // 外側の X は非同期だが、内側の関数で同名の同期な無名関数を代入しているので、
+      // 内側の X() は非同期にならない
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const outerAnon = funcObjNode([funcNode('待つ')])
+      const innerAnon = funcObjNode([funcNode('表示')])
+      const innerCallX = funcNode('X')
+      const defG = defFuncNode('G', [letNode('X', innerAnon), innerCallX])
+      const ast = blockNode([letNode('X', outerAnon), defG])
+
+      let count = 0
+      while (checkAsyncFn(ast, funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(outerAnon.asyncFn, true)
+      assert.strictEqual(innerAnon.asyncFn, false)
+      assert.strictEqual(innerCallX.asyncFn, false, '内側の同期な X が優先される')
+      assert.strictEqual(defG.asyncFn, false, 'G も非同期にならない')
+    })
+
+    it('内側で同名の変数を使っていなければ外側の非同期が見える', () => {
+      // 上のシャドーイングと対になる確認。内側に代入が無ければ外側の X を参照する
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const outerAnon = funcObjNode([funcNode('待つ')])
+      const innerCallX = funcNode('X')
+      const defG = defFuncNode('G', [innerCallX])
+      const ast = blockNode([letNode('X', outerAnon), defG])
+
+      let count = 0
+      while (checkAsyncFn(ast, funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(innerCallX.asyncFn, true, '外側の非同期な X が見える')
+    })
+
+    it('同じスコープで同期な無名関数へ代入し直すと非同期でなくなる', () => {
+      const funclist = new Map([['待つ', { type: 'func', asyncFn: true }]])
+      const callBefore = funcNode('X')
+      const callAfter = funcNode('X')
+      const ast = blockNode([
+        letNode('X', funcObjNode([funcNode('待つ')])),
+        callBefore,
+        letNode('X', funcObjNode([funcNode('表示')])),
+        callAfter
+      ])
+
+      let count = 0
+      while (checkAsyncFn(ast, funclist)) {
+        count++
+        assert.ok(count < 10, '不動点に収束しない')
+      }
+      assert.strictEqual(callBefore.asyncFn, true, '代入し直す前は非同期')
+      assert.strictEqual(callAfter.asyncFn, false, '代入し直した後は同期')
+    })
+  })
+
+  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)
+    })
+
+    it('連文を代入する関数が複数続いてもすべてawaitされる (#2170)', async () => {
+      const code = `Aを表示。
+Bを表示。
+
+●A
+    a=30に5を足して2を掛ける。
+    「A関数内：」&aを表示。
+    aを戻す。
+ここまで。
+
+●B
+    b=30に5を足して2を掛ける。
+    「B関数内：」&bを表示。
+    bを戻す。
+ここまで。`
+      assert.strictEqual(await runAndGetLog(code), 'A関数内：70\n70\nB関数内：70\n70')
+    })
+  })
+
+  describe('無名関数(関数オブジェクト)の非同期判定', () => {
+    it('連文を含む無名関数の呼び出しがawaitされる', async () => {
+      const code = `F=●()
+    b=1に2を足して3を掛ける。
+    bを戻す。
+ここまで。
+F()を表示。`
+      assert.strictEqual(await runAndGetLog(code), '9')
+    })
+
+    it('「変数」で宣言した無名関数の呼び出しもawaitされる', async () => {
+      const code = `変数 F=●()
+    b=1に2を足して3を掛ける。
+    bを戻す。
+ここまで。
+F()を表示。`
+      assert.strictEqual(await runAndGetLog(code), '9')
+    })
+
+    it('非同期のユーザー関数を呼ぶ無名関数もawaitされる', async () => {
+      const code = `●B
+    b=1に2を足して3を掛ける。
+    bを戻す。
+ここまで。
+F=●()
+    Bを戻す。
+ここまで。
+F()を表示。`
+      assert.strictEqual(await runAndGetLog(code), '9')
+    })
+
+    it('関数の中で定義した無名関数の呼び出しもawaitされる', async () => {
+      const code = `Aを実行。
+●A
+    F=●()
+        b=1に2を足して3を掛ける。
+        bを戻す。
+    ここまで。
+    F()を表示。
+ここまで。`
+      assert.strictEqual(await runAndGetLog(code), '9')
+    })
+
+    it('非同期の文より後ろで定義した無名関数の呼び出しもawaitされる', async () => {
+      // 関数本体の走査が1文目で打ち切られていると F() に asyncFn が付かない
+      const code = `Aを実行。
+●A
+    a=30に5を足して2を掛ける。
+    aを表示。
+    F=●()
+        b=1に2を足して3を掛ける。
+        bを戻す。
+    ここまで。
+    F()を表示。
+ここまで。`
+      assert.strictEqual(await runAndGetLog(code), '70\n9')
+    })
+
+    it('引数が2つとも非同期の無名関数でもすべてawaitされる', async () => {
+      // 引数の走査が1つ目で打ち切られていると G() に asyncFn が付かない
+      const code = `F=●()
+    b=1に2を足して3を掛ける。
+    bを戻す。
+ここまで。
+G=●()
+    c=2に2を足して2を掛ける。
+    cを戻す。
+ここまで。
+F()とG()を足して表示。`
+      assert.strictEqual(await runAndGetLog(code), '17')
+    })
+
+    it('内側で同名の同期な無名関数を代入しても実行結果が変わらない', async () => {
+      // 外側の F は非同期、内側の F は同期。取り違えると値が壊れる
+      const code = `●A
+    Fとは変数
+    F=●()
+        b=1に2を足して3を掛ける。
+        bを戻す。
+    ここまで。
+    G=●()
+        Fとは変数
+        F=●()
+            5を戻す。
+        ここまで。
+        F()を戻す。
+    ここまで。
+    G()を表示。
+    F()を表示。
+ここまで。
+Aを実行。`
+      assert.strictEqual(await runAndGetLog(code), '5\n9')
+    })
+
+    it('非同期処理を含まない無名関数はawaitされない', async () => {
+      const code = `F=●()
+    b=1に2を足す。
+    bを戻す。
+ここまで。
+F()を表示。`
+      assert.strictEqual(await runAndGetLog(code), '3')
+    })
+  })
+})

package/core/test/nako_parser_test.mjs

@@ -0,0 +1,160 @@
+/* eslint-disable no-undef */
+/**
+ * 構文解析器(NakoParser)の回帰テスト (#2364)
+ *
+ * `core/src/nako_parser3.mts` は 2,900 行を超える大きなファイルで、
+ * これまでパーサを直接検証するテストが無く、回帰は実行結果(runAsync)経由でしか
+ * 検出できなかった。パーサの内部構造に手を入れる際の安全網として、
+ * 構文解析の結果である AST そのものを検証する。
+ *
+ * 2 段構えで検証している。
+ *
+ *  1. 構造アサーション … パーサの仕様を人間が読める形で固定する
+ *  2. ゴールデン比較   … AST の全キー・全値・キーの並び順まで含めて完全一致を確認する
+ *
+ * コーパスとゴールデンファイルの更新方法は `fixtures/README.md` を参照。
+ */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+import fs from 'node:fs'
+import { PARSER_CORPUS, parseToPlainAst } from './fixtures/parser_corpus.mjs'
+
+/** ブロック直下のノード種別を並べる(構造アサーション用) */
+function blockTypes (ast) {
+  return ast.blocks.filter((n) => n.type !== 'eol').map((n) => n.type)
+}
+
+/** 最初の(eol 以外の)文を取り出す */
+function firstSentence (ast) {
+  return ast.blocks.find((n) => n.type !== 'eol')
+}
+
+describe('nako_parser_test', () => {
+  // -------------------------------------------------------------------------
+  // 1. 構造アサーション … パーサの仕様を人間が読める形で固定する
+  // -------------------------------------------------------------------------
+  describe('構造アサーション', () => {
+    it('文の並びが block になる', () => {
+      const ast = parseToPlainAst('A=1\nB=2\n')
+      assert.strictEqual(ast.type, 'block')
+      assert.deepStrictEqual(blockTypes(ast), ['let', 'let'])
+    })
+
+    it('代入は let になり変数名にモジュール名が付く', () => {
+      const let1 = firstSentence(parseToPlainAst('A=1\n'))
+      assert.strictEqual(let1.type, 'let')
+      assert.strictEqual(let1.name, 'main__A')
+      assert.strictEqual(let1.blocks[0].type, 'number')
+      assert.strictEqual(let1.blocks[0].value, 1)
+    })
+
+    it('関数呼び出しは func になり助詞で引数が結び付く', () => {
+      const func = firstSentence(parseToPlainAst('「あ」を表示\n'))
+      assert.strictEqual(func.type, 'func')
+      assert.strictEqual(func.name, '表示')
+      assert.strictEqual(func.blocks.length, 1)
+      assert.strictEqual(func.blocks[0].value, 'あ')
+      assert.strictEqual(func.blocks[0].josi, 'を')
+    })
+
+    it('演算子の優先順位が AST の入れ子に反映される', () => {
+      // 1+2*3 は 1+(2*3) になる
+      const func = firstSentence(parseToPlainAst('1+2*3を表示\n'))
+      const op = func.blocks[0]
+      assert.strictEqual(op.type, 'op')
+      assert.strictEqual(op.operator, '+')
+      assert.strictEqual(op.blocks[0].value, 1)
+      assert.strictEqual(op.blocks[1].operator, '*')
+      assert.strictEqual(op.blocks[1].blocks[0].value, 2)
+      assert.strictEqual(op.blocks[1].blocks[1].value, 3)
+    })
+
+    it('カッコが優先順位を上書きする', () => {
+      // (1+2)*3 は (1+2) が先
+      const func = firstSentence(parseToPlainAst('(1+2)*3を表示\n'))
+      const op = func.blocks[0]
+      assert.strictEqual(op.operator, '*')
+      assert.strictEqual(op.blocks[0].operator, '+')
+      assert.strictEqual(op.blocks[1].value, 3)
+    })
+
+    it('もし文は if になり blocks が [条件, 真, 偽] の順になる', () => {
+      const ifAst = firstSentence(parseToPlainAst('もしA=1ならば\nB=1\n違えば\nB=2\nここまで\n'))
+      assert.strictEqual(ifAst.type, 'if')
+      assert.strictEqual(ifAst.blocks.length, 3)
+      assert.strictEqual(ifAst.blocks[0].type, 'op')
+      assert.strictEqual(ifAst.blocks[0].operator, 'eq')
+    })
+
+    it('関数定義は def_func になり引数リストを持つ', () => {
+      // 『足す』は送り仮名が落ちて『足』になる
+      const def = firstSentence(parseToPlainAst('●(AとBを)足すとは\nA+Bで戻る\nここまで\n'))
+      assert.strictEqual(def.type, 'def_func')
+      assert.strictEqual(def.name, 'main__足')
+      assert.deepStrictEqual(def.meta.varnames, ['A', 'B'])
+      assert.deepStrictEqual(def.meta.josi, [['と'], ['を']])
+    })
+
+    it('配列リテラルは json_array になる', () => {
+      const let1 = firstSentence(parseToPlainAst('A=[1,2,3]\n'))
+      assert.strictEqual(let1.blocks[0].type, 'json_array')
+      assert.deepStrictEqual(let1.blocks[0].blocks.map((n) => n.value), [1, 2, 3])
+    })
+
+    it('辞書リテラルは json_obj になりキーと値が交互に並ぶ', () => {
+      const let1 = firstSentence(parseToPlainAst('A={"a":1,"b":2}\n'))
+      const obj = let1.blocks[0]
+      assert.strictEqual(obj.type, 'json_obj')
+      assert.deepStrictEqual(obj.blocks.map((n) => n.value), ['a', 1, 'b', 2])
+    })
+
+    it('配列要素への代入は let_array になる', () => {
+      const ast = parseToPlainAst('A=[0]\nA[0]=1\n')
+      assert.deepStrictEqual(blockTypes(ast), ['let', 'let_array'])
+    })
+
+    it('繰り返し文は for になる', () => {
+      const forAst = firstSentence(parseToPlainAst('Nを1から10まで繰り返す\nNを表示\nここまで\n'))
+      assert.strictEqual(forAst.type, 'for')
+      assert.strictEqual(forAst.blocks[0].value, 1)
+      assert.strictEqual(forAst.blocks[1].value, 10)
+    })
+
+    it('連文は block として接続される', () => {
+      const renbun = firstSentence(parseToPlainAst('1に2を足して3を掛けて表示\n'))
+      assert.strictEqual(renbun.type, 'block')
+    })
+
+    it('非同期関数を呼ぶ関数には asyncFn が伝播する', () => {
+      const ast = parseToPlainAst('●Fとは\n1秒待つ\nここまで\nF\n')
+      const def = ast.blocks.find((n) => n.type === 'def_func')
+      assert.ok(def, 'def_func が見つかりません')
+      assert.strictEqual(def.asyncFn, true, '『待つ』を呼ぶ関数Fは非同期になる')
+    })
+
+    it('エラー監視は try_except になる', () => {
+      const tryAst = firstSentence(parseToPlainAst('エラー監視\nA=1\nエラーならば\nB=2\nここまで\n'))
+      assert.strictEqual(tryAst.type, 'try_except')
+      assert.strictEqual(tryAst.blocks.length, 2)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // 2. ゴールデン比較 … AST が 1 バイトも変わらないことを確認する
+  // -------------------------------------------------------------------------
+  describe('ゴールデン比較', () => {
+    const goldenPath = new URL('./fixtures/parser_ast_golden.json', import.meta.url)
+    const golden = JSON.parse(fs.readFileSync(goldenPath, 'utf8'))
+
+    it('ゴールデンとコーパスの項目が一致する', () => {
+      assert.deepStrictEqual(Object.keys(golden), Object.keys(PARSER_CORPUS),
+        'コーパスを変更したらゴールデンを再生成すること (fixtures/README.md 参照)')
+    })
+
+    for (const [name, code] of Object.entries(PARSER_CORPUS)) {
+      it(name, () => {
+        assert.deepStrictEqual(parseToPlainAst(code), golden[name])
+      })
+    }
+  })
+})