HN 日本語サマリー

← 一覧へ戻る
プログラミング

TypeScriptコンパイラにGoのDeferを追加する

Adding Go's Defer to the TypeScript Compiler (healeycodes.com)

13 pointsby healeycodes4 コメント

要約

Go言語のdefer文をTypeScriptコンパイラに追加する試みについて解説しています。deferは関数の終了時に遅延実行される機能で、リソースの確保と解放をペアにするのに便利です。TypeScriptには直接の代替がなく、try/finallyは冗長になりがちです。この記事では、TypeScriptコンパイラのAST変換機能を利用してdefer構文を導入し、Goのようなセマンティクスを実現する過程と、その実装における設計上の考慮事項、特にエラー処理や非同期処理との兼ね合いについて掘り下げています。

全文翻訳

Goのdefer文をTypeScriptコンパイラに追加する

Go言語のdefer文をTypeScriptコンパイラに追加するのがどれほど難しいか知りたかったのですが、完了する頃には、おそらく存在すべきではないと確信していました。

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)
    // ... protected work
    return nil
}

TypeScriptにはdeferの厳密な同等物はありません。try/finallyを使用するかもしれません。

async function readFile(path: string) {
    await sema.acquire();
    try {
        // ... use resource
    } finally {
        sema.release();
    }
}

しかし、それは少し醜いです。

楽しみのために、TypeScriptコンパイラにdefer文をハックして、Goのようなセマンティクスを取得できます。deferは既存のJavaScript機能にマッピングされないため、実行時にGoと同じように機能させるJavaScriptコードを出力する必要があります。

したがって、目標は次のようなTypeScriptコードを書けるようにすることです。

async function readFile(path: string) {
  await sema.acquire();
  defer sema.release(); // New!
  // ... use resource
}

TypeScriptコンパイラ

The TypeScript compiler (tsc) is mostly a static analysis engine. Its complexity lies in type-checking a fundamentally dynamic language, and supporting extremely incremental compilation to meet latency expectations in an IDE.

幸いなことに、defer文を追加するために型やその他の分析についてあまり心配する必要はありません。tscにはすでに「構文Xを認識し、同等の構文Yに置き換える」ための仕組みがあります。

例えば、ES5用にコンパイルする場合:

class Foo {
    x = 1;
}

次のように変換されるかもしれません:

function Foo() {
    this.x = 1;
}

概念的には、deferを追加することは、別のツリー書き換えを実行することを意味します。tscはすでに多数のASTからASTへの変換(例: オプショナルチェイニング ?. は条件付き式に変換される)を実行しているため、新しいツールを追加する必要はありません。

掘り下げるべき複雑さはありますが、大まかには、deferを持つASTを次のように変換します。

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

次のようなものに変換します。

function f() {
    const __defers = [];
    try {
        __defers.push(() => cleanup());
        work();
    } finally {
        // Pop and invoke
    }
}

まず、tscのパーサーにdeferが文であることを教える必要があります。構文の種類の一覧があり、そこにDeferStatementを追加し、単一の式オペランドを取るように定義します。

defer文が関数本体内に存在すること、式が呼び出し可能であること、tscが通常の再帰チェックを実行することなど、いくつかのチェックを実行する必要があります。

func (c *Checker) checkDeferStatement(node *ast.Node) {
        c.checkGrammarStatementInAmbientContext(node)
        // A defer is tied to the lifetime of its containing function
        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)
        }
        // Only calls are supported, which keeps capture/lowering unambiguous
        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
        }
        // Reuse normal call checking (callable callee, argument types, etc.)
        c.checkExpression(expression)
}

実際の変換コードは非常に冗長なので、ここに再現する代わりに、私が下した設計上の決定を掘り下げ、変換がどのように機能するかをさらに説明します。

deferはどのように機能すべきか

Goの動作に合わせるために、呼び出し元、レシーバー、および引数の値は直ちにキャプチャされます。

let x = 1;
defersole.log(x);
x = 2;

これは1を出力する必要があります。

私たちが生き残る必要がある極端なケースは、呼び出し可能なメソッドが再定義される場合です。

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

// Everything changes after the defer
logger.log = (message) => {
  console.log("new:", message);
};

logger.logが後で再割り当てされたとしても、遅延された呼び出しは元のメソッドを呼び出します。これはGoのセマンティクスに一致しており、deferステートメントに実行が到達したときに、関数値、レシーバー、および引数がすべて評価されます。

deferを1つ以上含む関数には小さなスタックが用意され、到達した各deferステートメントがスタックにクロージャをプッシュします。関数が終了すると、スタックは逆順(LIFO)にドレインされます。

登録は、関数が開始したときではなく、実行がdeferに到達したときに発生します。したがって、if内のdeferは、そのブランチが実行された場合にのみ実行され、ループ内のdeferはイテレーションごとに1回登録されます。

したがって、ユーザーは次のように記述します。

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;
        // Register cleanup only if execution reaches the defer statement.
        stack.push(() => method.call(receiver));
        return await fs.readFile(path, "utf8");
    } catch (error) {
        // Save the original error so cleanup can still run.
    } finally {
        // Run registered callbacks in reverse order.
        // In an async function, await each cleanup before moving to the next one.
        // If cleanup also throws, aggregate the failures.
    }
}

defer awaitのセマンティクスを新たに考案する代わりに、単にエラーとして却下しました。ユーザーがawaitが関数の残りの部分が実行される前に解決されると想定するのではないかと心配しました。さらに、包含関数が非同期の場合、すべての遅延呼び出しはクリーンアップ中に順次awaitされます。

エラーについてさらに

クリーンアップコードも失敗する可能性があるため、変換は3つのルールに従います。

  • 前のものがスローしても、すべての遅延呼び出しが実行されます。
  • 関数本体からの元のエラーが保持されます。
  • 複数のエラーが発生した場合、それらはAggregateErrorで報告されます。

Goはこのような集計ポリシーを必要としません。なぜなら、通常の(同期的な)エラーは値だからです。遅延呼び出しが返したエラーは、ユーザーが明示的にそれに対処することを決定しない限り、処理されません。JavaScriptの例外は制御フローです。したがって、コンパイルされたdeferコードがエラーをスローするとき、それは元の失敗に置き換えるか、組み合わせるか、または無視するかを決定する必要があります。

非同期関数は、スローと拒否されたawaitの両方をプロミス拒否に変換するため、変換には同期スローと非同期クリーンアップ拒否の両方に対する1つの明確なルールが必要です。

async function f() {
  defer asyncCleanup();
  throw new Error("body");
}

asyncCleanup()も拒否/スローした場合、f()はAggregateErrorで拒否されます。

AggregateError([
    Error("body"),
    cleanupError,
]);

では、出荷しますか?

皮肉なことに、deferの実装は、それがTypeScriptに属さないと私に確信させました。

エッジケースを実装すればするほど、deferがTypeScriptに属するという確信は薄れていきました。Goのdeferは、エラーが制御フローではなく値であるため、はるかに自然に感じられます。TypeScriptでは、クリーンアップがスローまたは拒否できるようになったら、Goには存在しない集計、優先順位、および非同期実行のポリシーが必要になります(パニックはGoの個別のパニックとリカバリセマンティクスを通じて処理されます)。

しかし、希望は失われていません。ECMAScript Explicit Resource Management提案は、異なる方向から同じ問題に取り組んでいます。

上記のasync-sema例を見てみましょう。deferの代わりに:

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

Disposableを使用できます。

async function readFile(path: string) {
  using _ = await acquirePermit(sema);
  return await fsReadFile(path, "utf8");
}

// The above assumes a helper like this,
// which could be embedded in the library
async function acquirePermit(sema: Sema): Promise<Disposable> {
  await sema.acquire();
  return {
    [Symbol.dispose]() {
      sema.release();
    },
  };
}

_のような未使用の変数を定義しなければならないのは避けたいですが、Disposableリソースはスコープから外れるときにクリーンアップすることで機能します。

したがって、私の好ましいが残念ながらサポートされていない構文は次のようになります。

async function readFile(path: string) {
  using await acquirePermit(sema); // Not supported!
  return await fsReadFile(path, "utf8");
}

deferのMVP実装は、私のTypeScriptフォークのこのブランチで見つけることができます。