nadesiko3 3.7.21 → 3.7.23

package/core/src/nako_global.mts

@@ -143,6 +143,19 @@ export class NakoGlobal {
     this.logger.stdout(text)
   }
 
+  /**
+   * プラグインの初期化が完了しているかどうかを調べる (#2064)
+   * @param pname プラグイン名
+   * @param po プラグイン・オブジェクト
+   */
+  private isPluginInitialized(pname: string, po: {[key: string]: any}): boolean {
+    const initKey = `!${pname}:初期化`
+    // 初期化関数を持たないプラグインは、常に初期化済みとみなす
+    if (!po[initKey]) { return true }
+    // 初期化関数は生成されたJavaScriptの中で実行され、完了すると「初期化済」が設定される
+    return this.__varslist[0].has(`${initKey}済`)
+  }
+
   /**
    * 毎プラグインの「!クリア」関数を実行
    */
@@ -152,6 +165,11 @@ export class NakoGlobal {
     const clearName = '!クリア'
     for (const pname in this.pluginfiles) {
       const po = this.__module[pname]
+      if (!po) { continue }
+      // 初期化されていないプラグインのクリア関数は呼ばない (#2064)
+      // (メモ) プラグインの初期化は生成されたJavaScriptの中で行われるため、
+      // コンパイルや実行に失敗すると初期化されないまま実行環境が残ることがある。
+      if (!this.isPluginInitialized(pname, po)) { continue }
       if (po[clearName] && po[clearName].fn) {
         try {
           po[clearName].fn(this)

package/core/src/nako_indent_inline.mts

@@ -221,7 +221,7 @@ const INDENT_MODE_KEYWORDS = ['!インデント構文', '!ここまでだるい'
 /** インデント構文 --- インデントを見て"ここまで"を自動挿入 (#596) */
 export function convertIndentSyntax(tokens: Token[]): Token[] {
   // インデント構文の変換が必要か?
-  if (!useIndentSynax(tokens)) { return tokens }
+  if (!useIndentSyntax(tokens)) { return tokens }
   // 『ここまで』があったらエラーを出す
   for (const t of tokens) {
     if (t.type === 'ここまで') {
@@ -321,7 +321,7 @@ export function convertIndentSyntax(tokens: Token[]): Token[] {
   return result
 }
 
-function useIndentSynax(tokens: Token[]) : boolean {
+function useIndentSyntax(tokens: Token[]) : boolean {
   // インデント構文が必要かチェック (最初の100個をチェック)
   for (let i = 0; i < tokens.length; i++) {
     if (i > 100) { break }

package/core/src/nako_lex_rules.mts

@@ -42,7 +42,7 @@ export const rules: NakoLexRule[] = [
   { name: 'eol', pattern: /^\n/ },
   { name: 'eol', pattern: /^;/ },
   // eslint-disable-next-line no-irregular-whitespace
-  { name: 'space', pattern: /^(\x20|\x09|　|・|⎿ |└|｜)+/ }, // #877,#1015
+  { name: 'space', pattern: /^(\x20|\t|　|・|⎿ |└|｜)+/ }, // #877,#1015
   { name: 'comma', pattern: /^,/ },
   { name: 'line_comment', pattern: /^#[^\n]*/ },
   { name: 'line_comment', pattern: /^\/\/[^\n]*/ },

package/core/src/nako_parser3.mts

@@ -1,12 +1,50 @@
  
 /**
  * nadesiko v3 parser
+ *
+ * 再帰下降パーサ。トークン列を読み進めながら構文木(Ast)を組み立てる。
+ * 各構文規則は `yXxx` という名前のメソッドで、カーソル(this.index)と
+ * 計算用スタック(this.stack)を共有しながら相互に呼び合う。
+ * カーソル操作・スタック操作・変数検索は基底クラス NakoParserBase にある。
+ *
+ * ## 構文規則の呼び出し関係 (#2364)
+ *
+ * ```
+ * parse
+ *  └ startParser → ySentenceList → ySentence ─┬ yIF / yAtohantei / yTryExcept / yDebugPrint
+ *                                             ├ yDNCLMode / ySetGenMode / ySpeedMode ...
+ *                                             ├ yLet ── yLetArrayAt / yLetArrayBracket
+ *                                             ├ yDefFunc / yDefTest → yDefFuncCommon
+ *                                             └ yCall ─┬ yDainyu / ySadameru / yIncDec
+ *                                                      ├ yRepeatTime / yWhile / yFor /
+ *                                                      │ yForEach / ySwitch / yReturn
+ *                                                      └ yCallFunc → yMumeiFunc
+ *
+ * yCalc → yGetArg ─┬ yRange
+ *                  ├ yGetArgOperator → infixToAST()      … nako_parser_operator.mts
+ *                  └ yValue ─┬ yValueKakko / yValueWord / yMumeiFunc
+ *                            └ yJSONArray / yJSONObject → yJSONArrayValue /
+ *                              yJSONObjectValue → yCalc
+ * ```
+ *
+ * 上の図は主要な流れだけを示したもので、実際には
+ * `ySentence ↔ yBlock ↔ yCall ↔ yCalc ↔ yValue ↔ yJSON*` が
+ * 大きな相互再帰を成している。この相互再帰があるため、構文規則そのものは
+ * ファイルを分けても結合が下がらない。分離してあるのは、
+ * 相互再帰の外側にあってカーソルにもスタックにも触れないものだけ。
+ *
+ * - `nako_parser_operator.mts` … 演算子の優先順位による構文木の組み立て
+ * - `nako_parser_async.mts`    … 解析後に asyncFn を伝播させる後処理パス
+ * - `nako_parser_message.mts`  … エラーメッセージの組み立て
  */
 import { opPriority, RenbunJosi, operatorList } from './nako_parser_const.mjs'
 import { NakoParserBase } from './nako_parser_base.mjs'
+import { infixToAST } from './nako_parser_operator.mjs'
+import { checkAsyncFn } from './nako_parser_async.mjs'
+import { makeStackBalanceReport } from './nako_parser_message.mjs'
 import { NakoSyntaxError } from './nako_errors.mjs'
 import { NakoLexer } from './nako_lexer.mjs'
-import { FuncListItemType, FuncArgs, NewEmptyToken, SourceMap } from './nako_types.mjs'
+import { FuncListItemType, NewEmptyToken, SourceMap } from './nako_types.mjs'
 import { NodeType, Ast, AstEol, AstBlocks, AstOperator, AstConst, AstLet, AstLetArray, AstIf, AstWhile, AstAtohantei, AstFor, AstForeach, AstSwitch, AstRepeatTimes, AstDefFunc, AstCallFunc, AstStrValue, AstDefVar, AstDefVarList } from './nako_ast.mjs'
 import { Token, TokenDefFunc, TokenCallFunc } from './nako_token.mjs'
 
@@ -27,12 +65,8 @@ export class NakoParser extends NakoParserBase {
     const result = this.startParser()
 
     // 関数毎に非同期処理が必要かどうかを判定する
-    this.isModifiedNodes = false
-    this._checkAsyncFn(result)
-    while (this.isModifiedNodes) {
-      this.isModifiedNodes = false
-      this._checkAsyncFn(result)
-    }
+    // 「非同期関数を呼ぶ関数もまた非同期」と伝播していくので、変化が無くなるまで繰り返す
+    while (checkAsyncFn(result, this.funclist)) { /* 変化が無くなるまで繰り返す */ }
 
     return result
   }
@@ -79,34 +113,13 @@ export class NakoParser extends NakoParserBase {
     return { type: 'block', blocks, josi: '', ...map, end: this.peekSourceMap() }
   }
 
-  /** 余剰スタックのレポートを作る */
+  /** 余剰スタックのレポートを作る
+   * (レポートの組み立ては nako_parser_message.mts の makeStackBalanceReport) #2364
+   */
   makeStackBalanceReport(): string {
-    const words: string[] = []
-    this.stack.forEach((t) => {
-      let w = this.nodeToStr(t, { depth: 1 }, false)
-      if (t.josi) { w += t.josi }
-      words.push(w)
-    })
-    const desc = words.join(',')
-    // 最近使った関数の使い方レポートを作る #1093
-    let descFunc = ''
-    const chA = 'A'.charCodeAt(0)
-    for (const f of this.recentlyCalledFunc) {
-      descFunc += ' - '
-      let no = 0
-      const josiA: FuncArgs | undefined = (f).josi
-      if (josiA) {
-        for (const arg of josiA) {
-          const ch = String.fromCharCode(chA + no)
-          descFunc += ch
-          if (arg.length === 1) { descFunc += arg[0] } else { descFunc += `(${arg.join('|')})` }
-          no++
-        }
-      }
-      descFunc += String(f.name) + '\n'
-    }
+    const report = makeStackBalanceReport(this.stack, this.recentlyCalledFunc)
     this.recentlyCalledFunc = []
-    return `未解決の単語があります: [${desc}]\n次の命令の可能性があります:\n${descFunc}`
+    return report
   }
 
   yEOL(): AstEol | null {
@@ -196,6 +209,10 @@ export class NakoParser extends NakoParserBase {
     return null
   }
 
+  // ---------------------------------------------------------------------------
+  // 実行モードの指定と廃止された構文
+  // ---------------------------------------------------------------------------
+
   /** [廃止] 非同期モード #11 @returns {Ast} */
   yASyncMode(): Ast {
     this.logger.error('『非同期モード』構文は廃止されました(https://nadesi.com/v3/doc/go.php?1028)。', this.peek())
@@ -240,6 +257,10 @@ export class NakoParser extends NakoParserBase {
     return { type: 'run_mode', value: mode, ...map, end: this.peekSourceMap() }
   }
 
+  // ---------------------------------------------------------------------------
+  // ブロックと関数定義
+  // ---------------------------------------------------------------------------
+
   /** @returns {AstBlocks} */
   yBlock(): AstBlocks {
     const map = this.peekSourceMap()
@@ -387,6 +408,10 @@ export class NakoParser extends NakoParserBase {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // 条件分岐(もし文)
+  // ---------------------------------------------------------------------------
+
   /** 「もし」文の条件を取得 */
   yIFCond(): Ast {
     const map = this.peekSourceMap()
@@ -534,6 +559,10 @@ export class NakoParser extends NakoParserBase {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // 実行速度・パフォーマンスの指定
+  // ---------------------------------------------------------------------------
+
   ySpeedMode(): AstBlocks | null {
     const map: SourceMap = this.peekSourceMap()
     if (!this.check2(['string', '実行速度優先'])) {
@@ -649,6 +678,10 @@ export class NakoParser extends NakoParserBase {
     return { type: 'eol', ...this.peekSourceMap(), end: this.peekSourceMap() }
   }
 
+  // ---------------------------------------------------------------------------
+  // 引数の取得と演算子
+  // ---------------------------------------------------------------------------
+
   /**
    * 1つ目の値を与え、その後に続く計算式を取得し、優先規則に沿って並び替えして戻す
    * @param {Ast} firstValue
@@ -675,7 +708,7 @@ export class NakoParser extends NakoParserBase {
     }
     if (args.length === 0) { return null }
     if (args.length === 1) { return args[0] }
-    return this.infixToAST(args)
+    return infixToAST(args, this.logger)
   }
 
   /**
@@ -743,76 +776,6 @@ export class NakoParser extends NakoParserBase {
     return this.yGetArgOperator(value1)
   }
 
-  infixToPolish(list: Ast[]): Ast[] {
-    // 中間記法から逆ポーランドに変換
-    const priority = (t: Ast) => {
-      if (opPriority[t.type]) { return opPriority[t.type] }
-      return 10
-    }
-    const stack: Ast[] = []
-    const polish: Ast[] = []
-    while (list.length > 0) {
-      const t = list.shift()
-      if (!t) { break }
-      while (stack.length > 0) { // 優先順位を見て移動する
-        const sTop = stack[stack.length - 1]
-        if (priority(t) > priority(sTop)) { break }
-        const tpop = stack.pop()
-        if (!tpop) {
-          this.logger.error('計算式に間違いがあります。', t)
-          break
-        }
-        polish.push(tpop)
-      }
-      stack.push(t)
-    }
-    // 残った要素を積み替える
-    while (stack.length > 0) {
-      const t = stack.pop()
-      if (t) { polish.push(t) }
-    }
-    return polish
-  }
-
-  /** @returns {Ast | null} */
-  infixToAST(list: Ast[]): Ast | null {
-    if (list.length === 0) { return null }
-    // 逆ポーランドを構文木に
-    const josi = list[list.length - 1].josi
-    const node = list[list.length - 1]
-    const polish = this.infixToPolish(list)
-    /** @type {Ast[]} */
-    const stack = []
-    for (const t of polish) {
-      if (!opPriority[t.type]) { // 演算子ではない
-        stack.push(t)
-        continue
-      }
-      const b:Ast|undefined = stack.pop()
-      const a:Ast|undefined = stack.pop()
-      if (a === undefined || b === undefined) {
-        this.logger.debug('--- 計算式(逆ポーランド) ---\n' + JSON.stringify(polish))
-        throw NakoSyntaxError.fromNode('計算式でエラー', node)
-      }
-      /** @type {AstOperator} */
-      const op: AstOperator = {
-        type: 'op',
-        operator: t.type,
-        blocks: [a, b],
-        josi,
-        startOffset: a.startOffset,
-        endOffset: a.endOffset,
-        line: a.line,
-        column: a.column,
-        file: a.file
-      }
-      stack.push(op)
-    }
-    const ans = stack.pop()
-    if (!ans) { return null }
-    return ans
-  }
-
   yGetArgParen(y: Ast[], funcName?: string): Ast[] { // C言語風呼び出しでカッコの中を取得
     let isClose = false
     const si = this.stack.length
@@ -867,6 +830,10 @@ export class NakoParser extends NakoParserBase {
     return node
   }
 
+  // ---------------------------------------------------------------------------
+  // 繰り返しと条件分岐の各構文
+  // ---------------------------------------------------------------------------
+
   /** @returns {AstRepeatTimes | null} */
   yRepeatTime(): AstRepeatTimes | null {
     const map = this.peekSourceMap()
@@ -1202,6 +1169,10 @@ export class NakoParser extends NakoParserBase {
     return ast
   }
 
+  // ---------------------------------------------------------------------------
+  // 無名関数
+  // ---------------------------------------------------------------------------
+
   /** 無名関数
    * @returns {AstDefFunc|null}
   */
@@ -1263,6 +1234,10 @@ export class NakoParser extends NakoParserBase {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // 代入文と増減
+  // ---------------------------------------------------------------------------
+
   /** 代入構文 */
   yDainyu(): AstBlocks | null {
     const map = this.peekSourceMap()
@@ -1380,6 +1355,10 @@ export class NakoParser extends NakoParserBase {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // 関数呼び出し
+  // ---------------------------------------------------------------------------
+
   yCall(): Ast | null {
     if (this.isEOF()) { return null }
 
@@ -1577,6 +1556,10 @@ export class NakoParser extends NakoParserBase {
     return null
   }
 
+  // ---------------------------------------------------------------------------
+  // 代入・変数定義と配列要素への代入
+  // ---------------------------------------------------------------------------
+
   /** @returns {Ast | null} */
   yLet(): AstBlocks | null {
     const map = this.peekSourceMap()
@@ -2117,7 +2100,7 @@ export class NakoParser extends NakoParserBase {
       } as AstLet
     }
     // 二次元配列 + オブジェクトプロパティ構文 --- word[a, b]$c = d
-    if (this.accept(['word', '[', this.yCalc, ',', this.yCalc, ']', '$', 'word', 'eq', this.yCalc])) {
+    if (this.accept(['word', '[', this.yCalc, 'comma', this.yCalc, ']', '$', 'word', 'eq', this.yCalc])) {
       const astValue = this.y[9]
       const astIndexes = this.checkArrayReverse([this.checkArrayIndex(this.y[2]), this.checkArrayIndex(this.y[4])])
       const astProp = this.y[7]
@@ -2157,6 +2140,10 @@ export class NakoParser extends NakoParserBase {
     return null
   }
 
+  // ---------------------------------------------------------------------------
+  // 計算式と値
+  // ---------------------------------------------------------------------------
+
   /** @returns {Ast | null} */
   yCalc(): Ast|null {
     const map = this.peekSourceMap()
@@ -2180,6 +2167,10 @@ export class NakoParser extends NakoParserBase {
     let fCalc:Ast = t1
     // それが連文か助詞を読んで確認
     if (RenbunJosi.indexOf(t1.josi || '') >= 0) {
+      // 『(式)して戻す』のように、式の途中に『戻す』文は書けない (#2064)
+      if (this.check('戻る')) {
+        throw NakoSyntaxError.fromNode('式の中で『戻す(戻る)』文は使えません。『(値)を(変数)に代入』などで一度値を受け取ってから『(変数)を戻す』と書いてください。', map)
+      }
       // 連文なら右側を読んで左側とくっつける
       const t2 = this.yCalc()
       if (t2) {
@@ -2573,6 +2564,10 @@ export class NakoParser extends NakoParserBase {
     return null
   }
 
+  // ---------------------------------------------------------------------------
+  // 変数名の解決と登録
+  // ---------------------------------------------------------------------------
+
   /** 変数を生成 */
   createVar(word: Token|Ast, isConst: boolean, isExport: boolean): Token|Ast {
     let gname: string = (word as AstStrValue).value
@@ -2630,6 +2625,10 @@ export class NakoParser extends NakoParserBase {
     return words
   }
 
+  // ---------------------------------------------------------------------------
+  // JSON/配列リテラル
+  // ---------------------------------------------------------------------------
+
   yJSONObjectValue(): Ast[] {
     // 戻り値の形式
     // Astblocks.blocks = [key1, value1, key2, value2, key3, value3 ...]
@@ -2804,6 +2803,10 @@ export class NakoParser extends NakoParserBase {
     return null
   }
 
+  // ---------------------------------------------------------------------------
+  // エラー監視
+  // ---------------------------------------------------------------------------
+
   /** エラー監視構文 */
   yTryExcept(): AstBlocks | null {
     const map = this.peekSourceMap()
@@ -2834,67 +2837,9 @@ export class NakoParser extends NakoParserBase {
     }
   }
 
-  /** 関数ごとにasyncFnが必要か確認する */
-  _checkAsyncFn(node: Ast): boolean {
-    if (!node) { return false }
-    // 関数定義があれば関数
-    if (node.type === 'def_func' || node.type === 'def_test' || node.type === 'func_obj') {
-      // 関数定義でasyncFnが指定されているならtrueを返す
-      const def: AstDefFunc = node as AstDefFunc
-      if (def.asyncFn) { return true } // 既にasyncFnが指定されている
-      // 関数定義の中身を調べてasyncFnであるならtrueに変更する
-      let isAsyncFn = false
-      for (const n of def.blocks) {
-        if (this._checkAsyncFn(n)) {
-          isAsyncFn = true
-          def.asyncFn = isAsyncFn
-          def.meta.asyncFn = isAsyncFn
-          this.isModifiedNodes = true
-          return true
-        }
-      }
-    }
-    // 関数呼び出しを調べて非同期処理が必要ならtrueを返す
-    if (node.type === 'func') {
-      // 関数呼び出し自体が非同期処理ならtrueを返す
-      const callNode: AstCallFunc = node as AstCallFunc
-      if (callNode.asyncFn) {
-        return true
-      }
-      // 続けて、以下の関数呼び出しの引数などに非同期処理があるかどうか調べる
-      // 関数の引数は、node.blocksに格納されている
-      if (callNode.blocks) {
-        for (const n of callNode.blocks) {
-          if (this._checkAsyncFn(n)) {
-            callNode.asyncFn = true
-            this.isModifiedNodes = true
-            return true
-          }
-        }
-      }
-      // さらに、関数のリンクを調べる
-      const func = this.funclist.get(callNode.name)
-      if (func && func.asyncFn) {
-        callNode.asyncFn = true
-        this.isModifiedNodes = true
-        return true
-      }
-      return false
-    }
-    // 連文 ... 現在、効率は悪いが非同期で実行することになっている
-    if (node.type === 'renbun') {
-      return true
-    }
-    // その他
-    if ((node as AstBlocks).blocks) {
-      for (const n of (node as AstBlocks).blocks) {
-        if (this._checkAsyncFn(n)) {
-          return true
-        }
-      }
-    }
-    return false
-  }
+  // ---------------------------------------------------------------------------
+  // TokenからAstへの変換
+  // ---------------------------------------------------------------------------
 
   /** TokenをそのままNodeに変換するメソッド(ただし簡単なものだけ対応)
    * @returns {Ast[]}

package/core/src/nako_parser_async.mts

@@ -0,0 +1,165 @@
+/**
+ * 構文解析後の AST を走査して、非同期処理(asyncFn)の要否を判定するモジュール
+ *
+ * NakoParser から分離した (#2364)。
+ * 構文解析が完了した後に AST 全体を走査する後処理パスであり、
+ * トークンのカーソルにも計算用スタックにも一切触れない。
+ * (実体は nako_parser3.mts の NakoParser._checkAsyncFn だった)
+ *
+ * 非同期の情報は「非同期関数を呼ぶ関数もまた非同期」という形で伝播していくため、
+ * 1 回の走査では行き渡らないことがある。呼び出し側は変化が無くなるまで
+ * `checkAsyncFn()` を繰り返し呼ぶこと。
+ */
+import { Ast, AstBlocks, AstDefFunc, AstCallFunc, AstLet } from './nako_ast.mjs'
+import { FuncList } from './nako_types.mjs'
+
+/** 走査中に AST を書き換えたかどうかを持ち回るための入れ物 */
+interface CheckContext {
+  modified: boolean
+  /**
+   * 無名関数を保持している変数名 → その無名関数が非同期かどうか
+   *
+   * `F=●()...ここまで` のように変数へ代入された無名関数は funclist に載らないため、
+   * 代入を覚えておかないと `F()` の呼び出しに asyncFn を付けられない。
+   * 変数のシャドーイングを考慮して、関数定義ごとにスコープを積む。
+   *
+   * 同期な無名関数の代入も記録する。記録しないと、内側のスコープで同名の変数へ
+   * 同期な無名関数を代入しても外側の非同期な代入が見えてしまう。
+   */
+  funcObjVarScopes: Map<string, boolean>[]
+}
+
+/**
+ * AST を走査して関数ごとに asyncFn が必要かどうかを確認し、必要なら書き換える。
+ *
+ * @param node 走査対象の AST
+ * @param funclist 関数一覧(呼び出し先が非同期かどうかの判定に使う)
+ * @returns AST を書き換えたら true。呼び出し側は false になるまで繰り返すこと
+ */
+export function checkAsyncFn (node: Ast, funclist: FuncList): boolean {
+  const ctx: CheckContext = { modified: false, funcObjVarScopes: [new Map()] }
+  checkNode(node, funclist, ctx)
+  return ctx.modified
+}
+
+/**
+ * 変数名が非同期の無名関数を指しているかどうかを、内側のスコープから順に調べる。
+ * 見つかった時点で打ち切るので、内側の代入が外側の代入をシャドーイングする。
+ */
+function isAsyncVar (ctx: CheckContext, name: string): boolean {
+  for (let i = ctx.funcObjVarScopes.length - 1; i >= 0; i--) {
+    const asyncFn = ctx.funcObjVarScopes[i].get(name)
+    if (asyncFn !== undefined) { return asyncFn }
+  }
+  return false
+}
+
+/**
+ * 変数へ無名関数を代入していたら、現在のスコープに覚えておく
+ * (`let` と `def_local_var` はどちらも blocks[0] が代入する値)
+ *
+ * 無名関数以外の代入は記録しない。`F=Gの参照` のような代入まで同期扱いにすると、
+ * 逆に await の付け漏れという、より悪い誤りになるため。
+ */
+function checkFuncObjVarAssign (node: Ast, ctx: CheckContext): void {
+  const letNode = node as AstLet
+  if (!letNode.name) { return }
+  const value = (letNode.blocks || [])[0]
+  if (!value || value.type !== 'func_obj') { return }
+  const scope = ctx.funcObjVarScopes[ctx.funcObjVarScopes.length - 1]
+  scope.set(letNode.name, !!(value as AstDefFunc).asyncFn)
+}
+
+/**
+ * ノードが非同期処理を含むかどうかを返す(必要に応じて AST を書き換える)
+ * @returns 非同期処理を含むなら true
+ */
+function checkNode (node: Ast, funclist: FuncList, ctx: CheckContext): boolean {
+  if (!node) { return false }
+  // 関数定義があれば関数
+  if (node.type === 'def_func' || node.type === 'def_test' || node.type === 'func_obj') {
+    const def: AstDefFunc = node as AstDefFunc
+    // 既に非同期と分かっていても中身の走査は省略しない。
+    // 途中で打ち切ると、それより後ろにある呼び出しに asyncFn が付かなくなる
+    ctx.funcObjVarScopes.push(new Map())
+    let isAsyncFn = false
+    for (const n of def.blocks) {
+      if (checkNode(n, funclist, ctx)) { isAsyncFn = true }
+    }
+    ctx.funcObjVarScopes.pop()
+    // 関数定義の中身が非同期であるならasyncFnをtrueに変更する
+    if (isAsyncFn && !def.asyncFn) {
+      def.asyncFn = true
+      def.meta.asyncFn = true
+      ctx.modified = true
+    }
+    if (!def.asyncFn) { return false }
+    // 後から判明した非同期情報を、呼び出し側の判定に使う関数一覧にも反映する
+    const func = funclist.get(def.name)
+    if (func && !func.asyncFn) {
+      func.asyncFn = true
+      ctx.modified = true
+    }
+    return true
+  }
+  // 変数へ代入された無名関数を覚えておく(呼び出し側の判定に使う)
+  if (node.type === 'let' || node.type === 'def_local_var') {
+    let containsAsync = false
+    for (const n of (node as AstBlocks).blocks) {
+      if (checkNode(n, funclist, ctx)) { containsAsync = true }
+    }
+    checkFuncObjVarAssign(node, ctx)
+    return containsAsync
+  }
+  // 関数呼び出しを調べて非同期処理が必要ならtrueを返す
+  if (node.type === 'func') {
+    // 関数呼び出し自体が非同期処理ならtrueを返す
+    const callNode: AstCallFunc = node as AstCallFunc
+    if (callNode.asyncFn) {
+      return true
+    }
+    // 続けて、以下の関数呼び出しの引数などに非同期処理があるかどうか調べる
+    // 関数の引数は、node.blocksに格納されている
+    // (2つ目以降の引数にも asyncFn が必要なので、最初の1つで打ち切らない)
+    if (callNode.blocks) {
+      let hasAsyncArg = false
+      for (const n of callNode.blocks) {
+        if (checkNode(n, funclist, ctx)) { hasAsyncArg = true }
+      }
+      if (hasAsyncArg) {
+        callNode.asyncFn = true
+        ctx.modified = true
+        return true
+      }
+    }
+    // さらに、関数のリンクを調べる
+    const func = funclist.get(callNode.name)
+    if (func && func.asyncFn) {
+      callNode.asyncFn = true
+      ctx.modified = true
+      return true
+    }
+    // 非同期の無名関数を保持している変数の呼び出しかどうかを調べる
+    if (isAsyncVar(ctx, callNode.name)) {
+      callNode.asyncFn = true
+      ctx.modified = true
+      return true
+    }
+    return false
+  }
+  // 連文 ... 現在、効率は悪いが非同期で実行することになっている
+  if (node.type === 'renbun') {
+    return true
+  }
+  // その他
+  if ((node as AstBlocks).blocks) {
+    let containsAsync = false
+    for (const n of (node as AstBlocks).blocks) {
+      if (checkNode(n, funclist, ctx)) {
+        containsAsync = true
+      }
+    }
+    return containsAsync
+  }
+  return false
+}