TypeScript コンパイラへの Go 風

defer

構文追加の実装検証

Go の

defer

tsc

Go と TypeScript の

defer

の比較

Go の挙動

Go では、

defer

func withSemaphore(ctx context.Context, sem *semaphore.Weighted) error {
    if err := sem.Acquire(ctx, 1); err != nil {
        return err
    }
    defer sem.Release(1) // 終了時に実行
    // ... プロテクトされた処理
    return nil
}

TypeScript の現状

TypeScript には

defer

try/finally

async function readFile(path: string) {
    await sema.acquire();
    try {
        // ... リソースの利用
    } finally {
        sema.release(); // 明示的に記述が必要
    }
}

このアプローチは冗長であり、コードが「綺麗」ではありません。

コンパイラ実装の可能性と課題

defer

目標のシンタックス

async function readFile(path: string) {
    await sema.acquire();
    defer sema.release(); // 新しい構文
    // ... use resource
}

実装アプローチ：AST 変換

TypeScript コンパイラ（

tsc

defer

入力 AST:

function f() {
    defer cleanup();
    work();
}

出力 JavaScript:

function f() {
    const __defers = [];
    try {
        __defers.push(() => cleanup());
        work();
    } finally {
        // Pop して実行する
    }
}

パーサーとチェックの実装ステップ

1. シンタックス定義:

   DeferStatement

   をリストに追加し、単一の式オペランドを持つ文として定義します。
2. コンテキストチェック: 以下の条件を確認します。

   • defer

     文が関数本体内部にあること。
   • オペランドが実行可能な呼び出し式（Call Expression）であること。
   • ジェネレーター関数内では使用不可であることを保証します。

func (c *Checker) checkDeferStatement(node *ast.Node) {
    c.checkGrammarStatementInAmbientContext(node)
    
    // defer はそのを含む関数のライフサイクルと結びついている
    fn := ast.GetContainingFunction(node)
    if fn == nil || fn.Body() == nil || !ast.IsBlock(fn.Body()) {
        c.grammarErrorOnNode(node, diagnostics.Defer_statements_can_only_be_used_inside_function_bodies)
    } else if ast.GetFunctionFlags(fn) & ast.FunctionFlagsGenerator != 0 {
        c.grammarErrorOnNode(node, diagnostics.Defer_statements_cannot_be_used_in_generators)
    }
    
    // 呼び出しのみをサポートしている
    expression := ast.SkipParentheses(node.Expression())
    if !ast.IsCallExpression(expression) {
        c.grammarErrorOnNode(node.Expression(), diagnostics.The_operand_of_a_defer_statement_must_be_a_call_expression)
        c.checkExpression(node.Expression())
        return
    }
    
    // 通常の呼び出しチェックを再利用（実行可能な callee、引数の型など）
    c.checkExpression(expression)
}

注意: 実際のトランスフォームコードは冗長が多いためここでは省略します。

defer

の動作メカニズム

Go の挙動を再現するためには、呼び出し側（this）、リセーバー、引数の値を即時にキャプチャする必要があります。

キャプチャの必要性

let x = 1;
defer console.log(x);
x = 2; // defer が実行されたら 1 を出力しなければならない

メソッド再定義への耐性

メソッドが後に再定義されても、初期の状態を維持します。

const logger = {
    log(message: string) {
        console.log("old:", message);
    },
};

defer logger.log("hello");

// 以降はすべて変化します
logger.log = (message) => {
    console.log("new:", message);
};

// deferred call は依然として元のメソッドを呼び出します。

スティックとスタック処理

• defer

  を含む関数には小さなスタックが割り当てられます。
• 各

  defer

  文は到達時にクロージャをプッシュします。
• 関数終了時、スタックは**逆順（LIFO）**で排出されます。
• 登録タイミング: 関数開始時ではなく、実行が

  defer

  に到達した時に発生します。

コード変換例

入力:

async function readFile(path: string) {
    await sema.acquire();
    defer sema.release();
    return await fs.readFile(path, "utf8");
}

出力（内部実装）:

async function readFile(path) {
    const stack = [];
    try {
        await sema.acquire();
        const receiver = sema;
        const method = receiver.release;
        
        // クリーンアップは defer 文に到達した場合のみ登録される。
        stack.push(() => method.call(receiver));
        return await fs.readFile(path, "utf8");
    } catch (error) {
        // クリーンアップが実行できるように、元のエラーを保存する。
    } finally {
        // 登録されたコールバックを逆順で実行する。
        // async 関数の場合、各クリーンアップ処理は次の処理に移る前に await される。
    }
}

制限事項：

defer await

は非対応

• defer await

  の独自のセマンティクスを実装する代わりに、エラーとして拒否しています（誤推測を防ぐため）。

• async

  関数内のクリーンアップは、順次

  await

  されます。

エラー処理の課題

TypeScript ではエラーが例外（制御フロー）のため、Go のように値を返すわけではありません。コンパイルされたコードでエラーが発生した際、以下の 3 つのルールに従います：

1. 以前のエラーのスローまたはすべての

   deferred call

   の実行は続行されます。
2. 関数本体の元のエラーは保持されます。
3. 複数のエラー発生時は

   AggregateError

   で報告されます。

例:

async function f() {
    defer asyncCleanup();
    throw new Error("body");
}
// asyncCleanup() も reject/throw すると、f() は AggregateError で reject される。
// AggregateError([
//     Error("body"),
//     cleanupError
// ]);

TypeScript に

defer

defer

代替案：ECMAScript Explicit Resource Management

希望を失う必要はありません。同じ課題を異なるアプローチで解決する標準規格（ES2024+）があります。

実装例：

using

ステートメント

async function readFile(path: string) {
    using _ = await acquirePermit(sema); // リソース解放が明示的
    return await fsReadFile(path, "utf8");
}

// ヘルパー関数
async function acquirePermit(sema: Sema): Promise<Disposable> {
    await sema.acquire();
    return {
        [Symbol.dispose]() {
            sema.release();
        },
    };
}

理想的な構文（現時点では未対応）

TypeScript フォークのブランチには

defer

// サポートされていない！
async function readFile(path: string) {
    using await acquirePermit(sema); 
    return await fsReadFile(path, "utf8");
}