コンパイラとインタプリタ：コードが実行される仕組み — 開発者が知るべき言語処理のすべて

ソースコード → [レキサー] → トークン → [パーサー] → AST → [意味解析] → IR → [最適化] → [コード生成] → 実行

# 入力: "let x = 42 + y;"
# 出力トークン:
# [LET, "let"] [IDENT, "x"] [ASSIGN, "="] [NUMBER, "42"]
# [PLUS, "+"] [IDENT, "y"] [SEMICOLON, ";"]

import re
from enum import Enum, auto
from dataclasses import dataclass
from typing import List

class TokenType(Enum):
    NUMBER = auto()
    PLUS = auto()
    MINUS = auto()
    STAR = auto()
    SLASH = auto()
    LPAREN = auto()
    RPAREN = auto()
    IDENT = auto()
    ASSIGN = auto()
    LET = auto()
    EOF = auto()

@dataclass
class Token:
    type: TokenType
    value: str
    line: int
    col: int

KEYWORDS = {"let": TokenType.LET}

TOKEN_PATTERNS = [
    (r'\d+(\.\d+)?', TokenType.NUMBER),
    (r'[a-zA-Z_]\w*', TokenType.IDENT),
    (r'\+', TokenType.PLUS),
    (r'-', TokenType.MINUS),
    (r'\*', TokenType.STAR),
    (r'/', TokenType.SLASH),
    (r'\(', TokenType.LPAREN),
    (r'\)', TokenType.RPAREN),
    (r'=', TokenType.ASSIGN),
]

def tokenize(source: str) -> List[Token]:
    tokens = []
    pos = 0
    line = 1
    col = 1

    while pos < len(source):
        if source[pos] in ' \t':
            pos += 1
            col += 1
            continue
        if source[pos] == '\n':
            pos += 1
            line += 1
            col = 1
            continue

        matched = False
        for pattern, token_type in TOKEN_PATTERNS:
            regex = re.compile(pattern)
            match = regex.match(source, pos)
            if match:
                value = match.group()
                actual_type = KEYWORDS.get(value, token_type)
                tokens.append(Token(actual_type, value, line, col))
                pos = match.end()
                col += len(value)
                matched = True
                break

        if not matched:
            raise SyntaxError(
                f"Unexpected char '{source[pos]}' at {line}:{col}"
            )

    tokens.append(Token(TokenType.EOF, "", line, col))
    return tokens

# テスト
source = "let x = 42 + y"
for tok in tokenize(source):
    print(f"{tok.type.name:8} | {tok.value}")

LET      | let
IDENT    | x
ASSIGN   | =
NUMBER   | 42
PLUS     | +
IDENT    | y
EOF      |

@dataclass
class NumberNode:
    value: float

@dataclass
class BinaryOpNode:
    left: any
    op: str
    right: any

@dataclass
class AssignNode:
    name: str
    value: any

class Parser:
    def __init__(self, tokens: List[Token]):
        self.tokens = tokens
        self.pos = 0

    def current(self) -> Token:
        return self.tokens[self.pos]

    def eat(self, token_type: TokenType) -> Token:
        token = self.current()
        if token.type != token_type:
            raise SyntaxError(
                f"Expected {token_type}, got {token.type}"
            )
        self.pos += 1
        return token

    def parse_expression(self):
        left = self.parse_term()
        while self.current().type in (TokenType.PLUS, TokenType.MINUS):
            op = self.eat(self.current().type).value
            right = self.parse_term()
            left = BinaryOpNode(left, op, right)
        return left

    def parse_term(self):
        left = self.parse_factor()
        while self.current().type in (TokenType.STAR, TokenType.SLASH):
            op = self.eat(self.current().type).value
            right = self.parse_factor()
            left = BinaryOpNode(left, op, right)
        return left

    def parse_factor(self):
        token = self.current()
        if token.type == TokenType.NUMBER:
            self.eat(TokenType.NUMBER)
            return NumberNode(float(token.value))
        elif token.type == TokenType.LPAREN:
            self.eat(TokenType.LPAREN)
            node = self.parse_expression()
            self.eat(TokenType.RPAREN)
            return node
        elif token.type == TokenType.IDENT:
            self.eat(TokenType.IDENT)
            return token.value
        raise SyntaxError(f"Unexpected token: {token}")

    AssignNode
    ├── name: "x"
    └── value: BinaryOpNode(+)
              ├── NumberNode(42)
              └── BinaryOpNode(*)
                        ├── "y"
                        └── NumberNode(2)

PRECEDENCE = {
    TokenType.PLUS: 10,
    TokenType.MINUS: 10,
    TokenType.STAR: 20,
    TokenType.SLASH: 20,
}

def pratt_parse(parser, min_bp=0):
    left = parser.parse_factor()

    while True:
        op = parser.current()
        bp = PRECEDENCE.get(op.type, 0)
        if bp <= min_bp:
            break
        parser.eat(op.type)
        right = pratt_parse(parser, bp)
        left = BinaryOpNode(left, op.value, right)

    return left

JavaScriptソース
    ↓
  パーサー → AST
    ↓
  Ignition（バイトコードインタプリタ）
    ↓ （プロファイリングデータ収集）
  TurboFan（最適化JITコンパイラ）
    ↓
  最適化されたマシンコード
    ↓ （Deoptimization — 仮定が破られた場合に戻る）
  Ignitionに復帰

// 良いパターン — 同じHidden Classを共有
function Point(x, y) {
  this.x = x;  // Hidden Class C0 → C1
  this.y = y;  // Hidden Class C1 → C2
}
const p1 = new Point(1, 2);  // Shape: C2
const p2 = new Point(3, 4);  // Shape: C2（同じ！）

// 悪いパターン — Hidden Classの不一致
const a = {};
a.x = 1;
a.y = 2;  // Shape: S1

const b = {};
b.y = 2;  // 順序が違う！
b.x = 1;  // Shape: S2（異なるShape！）

function getX(obj) {
  return obj.x;  // Inline Cacheがここに生成
}

// Monomorphic（1つのShape）— 最速
getX(p1);  // Shape C2でキャッシュ
getX(p2);  // Shape C2 — キャッシュヒット！

// Polymorphic（2-4つのShape）— やや遅い
// Megamorphic（5つ以上のShape）— 遅い、汎用パス使用

import dis

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# バイトコード確認
dis.dis(fibonacci)

  2           0 LOAD_FAST                0 (n)
              2 LOAD_CONST               1 (1)
              4 COMPARE_OP               1 (<=)
              6 POP_JUMP_IF_FALSE       12

  3           8 LOAD_FAST                0 (n)
             10 RETURN_VALUE

  4     >>   12 LOAD_GLOBAL              0 (fibonacci)
             14 LOAD_FAST                0 (n)
             16 LOAD_CONST               2 (1)
             18 BINARY_SUBTRACT
             20 CALL_FUNCTION            1
             ...

# GILのためCPUバウンドタスクでマルチスレッドが非効率
import threading
import time

def cpu_bound(n):
    count = 0
    for i in range(n):
        count += i
    return count

# シングルスレッド
start = time.time()
cpu_bound(50_000_000)
cpu_bound(50_000_000)
print(f"Single: {time.time() - start:.2f}s")

# マルチスレッド（GILのため遅くなる可能性あり）
start = time.time()
t1 = threading.Thread(target=cpu_bound, args=(50_000_000,))
t2 = threading.Thread(target=cpu_bound, args=(50_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
print(f"Multi:  {time.time() - start:.2f}s")

# 解決策: multiprocessingを使用
from multiprocessing import Pool
start = time.time()
with Pool(2) as p:
    p.map(cpu_bound, [50_000_000, 50_000_000])
print(f"Multi-process: {time.time() - start:.2f}s")

CPython:  fibonacci(35) → 約4.5秒
PyPy:     fibonacci(35) → 約0.3秒（約15倍速い）

// Hello.java
public class Hello {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 1000; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

# コンパイル
javac Hello.java

# バイトコード確認
javap -c Hello.class

public static void main(java.lang.String[]);
  Code:
     0: iconst_0
     1: istore_1        // sum = 0
     2: iconst_0
     3: istore_2        // i = 0
     4: iload_2
     5: sipush  1000
     8: if_icmpge  21   // if i >= 1000 goto 21
    11: iload_1
    12: iload_2
    13: iadd
    14: istore_1        // sum += i
    15: iinc    2, 1    // i++
    18: goto    4
    21: ...             // println

バイトコード実行（インタプリタ）
    ↓ （メソッド実行回数カウント）
  C1コンパイラ（高速コンパイル、基本最適化）
    ↓ （より多く実行されると）
  C2コンパイラ（低速コンパイル、積極的最適化）
    ↓
  最適化されたマシンコード

# GraalVM Native Image — AOTコンパイル
native-image -jar myapp.jar -o myapp

# 結果: 起動時間数十ミリ秒のネイティブバイナリ
# JVM: 約2秒起動 → GraalVM Native: 約20ms起動

フロントエンド       ミドルエンド            バックエンド
（言語別）          （共通）               （ターゲット別）
                                    ┌→ x86_64
Clang ─┐         ┌→ 最適化パス ────┤→ ARM
       ├→ LLVM IR ┤              └→ WASM
rustc ─┤         └→ 解析パス
       │
swiftc ┘

; 関数: add(a, b) = a + b
define i32 @add(i32 %a, i32 %b) {
entry:
  %result = add i32 %a, %b
  ret i32 %result
}

; 関数: factorial(n)
define i64 @factorial(i64 %n) {
entry:
  %cmp = icmp sle i64 %n, 1
  br i1 %cmp, label %base, label %recurse

base:
  ret i64 1

recurse:
  %n_minus_1 = sub i64 %n, 1
  %sub_result = call i64 @factorial(i64 %n_minus_1)
  %result = mul i64 %n, %sub_result
  ret i64 %result
}

# LLVM最適化パスの適用
opt -O2 input.ll -o optimized.ll

# 主要な最適化パス:
# -mem2reg     : メモリアクセスをレジスタに昇格
# -inline      : 関数インライニング
# -gvn         : Global Value Numbering（冗長な計算の除去）
# -licm        : Loop Invariant Code Motion（ループ外への移動）
# -loop-unroll : ループアンロール
# -sccp        : Sparse Conditional Constant Propagation
# -dce         : Dead Code Elimination

// 最適化前
int x = 3 + 4;
int y = x * 2;

// 定数畳み込み後
int x = 7;
int y = 14;

1. Markフェーズ: ルートから到達可能なすべてのオブジェクトをマーキング
2. Sweepフェーズ: マーキングされていないオブジェクトのメモリ解放

ルート（Root）:
  - グローバル変数
  - スタックのローカル変数
  - レジスタ

[A] → [B] → [C]
       ↓
      [D]

[E] → [F]  （ルートから到達不可 → 回収対象）

Young Generation（Minor GC — 頻繁、高速）
  ├── Eden Space（新しいオブジェクト割り当て）
  ├── Survivor 0
  └── Survivor 1

Old Generation（Major GC — まれ、低速）
  └── 長寿命のオブジェクト

GC過程:
1. 新オブジェクト → Edenに割り当て
2. Edenが満杯 → Minor GC
3. 生存オブジェクト → Survivor空間に移動
4. N回生存 → Old Generationに昇格
5. Old Generationが満杯 → Major GC

従来のGC:     Stop-the-World → Mark → Compact → Resume
              （長い停止時間）

ZGC:          アプリケーション実行とGCが同時に実行
              （ポインターカラーリング + ロードバリアで一貫性維持）

ポインターカラーリング:
  64ビットポインタの上位ビットをGCメタデータに使用
  [metadata bits][actual address bits]

  - Marked0ビット: 第1マーキングサイクル
  - Marked1ビット: 第2マーキングサイクル
  - Remappedビット: オブジェクトが再配置済み
  - Finalizableビット: ファイナライザ保留中

// 入力: ES2022+
const greet = (name) => `Hello, ${name}!`;
const items = [1, 2, 3];
const doubled = items.map(x => x * 2);

// Babel変換後: ES5
"use strict";
var greet = function greet(name) {
  return "Hello, " + name + "!";
};
var items = [1, 2, 3];
var doubled = items.map(function (x) {
  return x * 2;
});

TypeScriptソース
    ↓
  パーサー → AST
    ↓
  バインダー → シンボルテーブル
    ↓
  タイプチェッカー → 型エラー報告
    ↓
  エミッター → JavaScript + .d.ts + .map

# esbuildベンチマーク例
# 10,000モジュールのバンドリング:
# Webpack:   40秒
# esbuild:    0.4秒