// ソースコード
function add(a, b) { return a + b; }
 
// トークン列に変換
// Token::kFunction  → "function"
// Token::kIdentifier → "add"
// Token::kLeftParen  → "("
// Token::kIdentifier → "a"
// Token::kComma      → ","
// Token::kIdentifier → "b"
// Token::kRightParen → ")"
// Token::kLeftBrace  → "{"
// Token::kReturn     → "return"
// Token::kIdentifier → "a"
// Token::kAdd        → "+"
// Token::kIdentifier → "b"
// Token::kSemicolon  → ";"
// Token::kRightBrace → "}"

// トップレベルコード → Eager Parsing（即座に完全解析）
const config = { debug: true };
 
// 関数宣言 → Lazy Parsing（中身はスキップ）
function processData(data) {
  // この中身は最初の呼び出し時まで解析されない
  const result = data.map(item => item.value * 2);
  return result.filter(v => v > 10);
}
 
// IIFE（即時実行関数） → Eager Parsing（即座に実行されるため）
(function() {
  console.log("immediately invoked");
})();
 
// processData が呼び出された時点で初めて完全解析される
processData([{ value: 5 }, { value: 8 }, { value: 15 }]);

// アンチパターン: Lazy Parsing が裏目に出るケース
// 関数がすぐに呼ばれるのに、V8がLazy Parsingしてしまう
 
function heavyComputation() {
  // 大量のコード...
}
 
// すぐに呼ばれる → Lazy Parse + Re-parse で二重コスト
heavyComputation();
 
// 対策: V8にEager Parsingのヒントを与える
// 括弧で囲むと、V8はIIFEパターンと認識してEager Parsingする
const heavyComputation2 = (function() {
  // 大量のコード...
});

// ソースコード
function multiply(x, y) {
  return x * y;
}
 
// 対応するAST（概念的な表現）
//
//  FunctionDeclaration
//  ├── name: "multiply"
//  ├── params: ["x", "y"]
//  └── body: BlockStatement
//      └── ReturnStatement
//          └── BinaryExpression
//              ├── operator: "*"
//              ├── left: Identifier("x")
//              └── right: Identifier("y")

// JavaScriptソースコード
function add(a, b) {
  return a + b;
}
 
// Ignitionが生成するバイトコード（概念的な表現）
// ※ 実際のバイトコードは --print-bytecode フラグで確認できる
//
// Parameter count: 3 (receiver + a + b)
// Register count: 0
// Frame size: 0
//
//   Ldar a1          // レジスタa1（引数a）をアキュムレータにロード
//   Add a2, [0]      // アキュムレータにa2（引数b）を加算
//                     // [0]はフィードバックスロットのインデックス
//   Return            // アキュムレータの値を返す

# --print-bytecode フラグで Ignition のバイトコードを出力
node --print-bytecode --print-bytecode-filter="add" script.js
 
# 出力例:
# [generated bytecode for function: add (0x...)]
# Bytecode length: 6
# Parameter count 3
# Register count 0
# Frame size 0
#    0 : 25 02             Ldar a1
#    2 : 39 03 00          Add a2, [0]
#    5 : aa                Return

// 最適化のトリガー例
function hotFunction(arr) {
  let sum = 0;
  for (let i = 0; i < arr.length; i++) {
    sum += arr[i];
  }
  return sum;
}
 
// ループの反復回数やバイトコード実行回数が閾値を超えると
// TurboFanによる最適化が開始される
//
// 閾値の目安（V8内部で動的に調整される）:
// - 関数の呼び出し回数
// - ループのバックエッジカウント（ループ1回転ごとにカウント）
// - OSR（On-Stack Replacement）の判定
//
// Node.jsで最適化の状況を確認:
// node --trace-opt --trace-deopt script.js

// 最適化前
function square(x) {
  return x * x;
}
 
function sumOfSquares(a, b) {
  return square(a) + square(b);
}
 
// TurboFanによるインライン展開後（概念的）
function sumOfSquares_optimized(a, b) {
  return a * a + b * b;  // 関数呼び出しのオーバーヘッドを排除
}

// 最適化前
const TIMEOUT = 60 * 1000;  // 60秒をミリ秒に変換
 
// TurboFanによる最適化後
const TIMEOUT = 60000;  // コンパイル時に計算済み

// 最適化前
function process(x) {
  const unused = x * 2;  // この結果は使われない
  return x + 1;
}
 
// TurboFanによる最適化後
function process_optimized(x) {
  return x + 1;  // 不要な計算を除去
}

// 最適化前
function processArray(arr, factor) {
  const results = [];
  for (let i = 0; i < arr.length; i++) {
    const multiplier = factor * 2;  // ループ内で毎回同じ計算
    results.push(arr[i] * multiplier);
  }
  return results;
}
 
// TurboFanによる最適化後（概念的）
function processArray_optimized(arr, factor) {
  const results = [];
  const multiplier = factor * 2;  // ループの外に移動
  const len = arr.length;         // 長さの取得もループ外へ
  for (let i = 0; i < len; i++) {
    results.push(arr[i] * multiplier);
  }
  return results;
}

// フィードバックベクタの情報:
// → add関数は常にSMI（Small Integer）引数で呼ばれている
 
function add(a, b) {
  return a + b;
}
 
// TurboFanが生成するマシンコード（概念的な疑似コード）:
//
// 1. a が SMI か確認（型ガード）
// 2. b が SMI か確認（型ガード）
// 3. SMI同士の整数加算（1命令で完了）
// 4. オーバーフローチェック
// 5. 結果を返す
//
// もし型ガードが失敗したら → 脱最適化

// 脱最適化が起きるシナリオ
 
function add(a, b) {
  return a + b;
}
 
// Phase 1: SMI（整数）で呼び続ける → TurboFanが整数加算に最適化
for (let i = 0; i < 100000; i++) {
  add(i, i + 1);  // 常に整数
}
 
// Phase 2: 突然文字列を渡す → 脱最適化が発生！
add("hello", " world");
// → TurboFanの最適化コードは整数加算前提なので使えない
// → Ignitionのバイトコードに戻って文字列結合を実行
// → 再度プロファイリングを行い、新たな最適化を検討

function longRunningLoop() {
  let sum = 0;
  for (let i = 0; i < 10000000; i++) {
    sum += i;
    // ループのバックエッジで最適化判定
    // 閾値を超えた時点で、ループ実行中に最適化コードに切り替え（OSR）
    // → ループ変数 i, sum の状態を最適化コードに引き継ぐ
  }
  return sum;
}
 
// この関数は1回しか呼ばれないが、ループ内で
// OSRにより最適化される
longRunningLoop();

// ケース1: 同じ順序 → Hidden Classを共有
const a = {};
a.x = 1;
a.y = 2;
 
const b = {};
b.x = 3;
b.y = 4;
// a と b は同じ Hidden Class
 
// ケース2: 異なる順序 → 別の Hidden Class
const c = {};
c.y = 2;  // まず y を追加
c.x = 1;  // 次に x を追加
// c は a, b とは異なる Hidden Class
 
// ケース3: オブジェクトリテラル → 最適化される
const d = { x: 1, y: 2 };
const e = { x: 3, y: 4 };
// d と e は同じ Hidden Class（リテラルの形状が同じ）
 
// ケース4: delete演算子 → Hidden Classが無効化
const f = { x: 1, y: 2 };
delete f.x;
// f は「遅いモード」（辞書モード）に切り替わる
// → Hidden Class の最適化が失われる

// Elements の種類（V8内部のElementsKind）
 
// PACKED_SMI_ELEMENTS: 全要素が小さな整数
const smiArray = [1, 2, 3, 4, 5];
 
// PACKED_DOUBLE_ELEMENTS: 浮動小数点数を含む
const doubleArray = [1.1, 2.2, 3.3];
 
// PACKED_ELEMENTS: オブジェクトや混合型
const mixedArray = [1, "two", { three: 3 }];
 
// HOLEY_SMI_ELEMENTS: 穴あき配列（整数）
const holeyArray = [1, , 3];  // インデックス1が空
 
// ElementsKind の遷移（一方向のみ、逆戻りしない！）
//
// PACKED_SMI_ELEMENTS
//     │
//     ├──→ PACKED_DOUBLE_ELEMENTS
//     │        │
//     │        ├──→ PACKED_ELEMENTS
//     │        │
//     │        └──→ HOLEY_DOUBLE_ELEMENTS ──→ HOLEY_ELEMENTS
//     │
//     └──→ HOLEY_SMI_ELEMENTS
//              │
//              ├──→ HOLEY_DOUBLE_ELEMENTS ──→ HOLEY_ELEMENTS
//              │
//              └──→ HOLEY_ELEMENTS
 
// 一度でも HOLEY になると、PACKED に戻ることはない
const arr = [1, 2, 3];       // PACKED_SMI_ELEMENTS
arr.push(4.5);               // → PACKED_DOUBLE_ELEMENTS（不可逆遷移）
arr.push("hello");           // → PACKED_ELEMENTS（不可逆遷移）

function getX(obj) {
  return obj.x;  // ← このアクセス箇所にICが生成される
}
 
// 1回目の呼び出し: IC miss
// → Hidden Classを確認し、"x"のオフセットを検索
// → 結果をICにキャッシュ（Hidden Class → offset のペア）
const p1 = { x: 10, y: 20 };
getX(p1);
 
// 2回目以降: IC hit
// → Hidden Classがキャッシュと一致 → オフセットを直接使用
// → プロパティテーブルの検索をスキップ
const p2 = { x: 30, y: 40 };  // p1と同じHidden Class
getX(p2);  // 高速アクセス

// 常に同じHidden Classのオブジェクトが渡される
function getName(person) {
  return person.name;  // IC: monomorphic
}
 
// 全て同じ形状のオブジェクト
getName({ name: "Alice", age: 30 });
getName({ name: "Bob", age: 25 });
getName({ name: "Charlie", age: 35 });
// → ICは1つのHidden Classだけを記録 → 最速

// 2-4種類のHidden Classが混在
function getArea(shape) {
  return shape.area;  // IC: polymorphic
}
 
getArea({ area: 100, type: "circle" });     // Hidden Class A
getArea({ area: 200, width: 10, height: 20 }); // Hidden Class B
// → ICは2つのHidden Classを記録 → まだ十分高速
// → 線形検索でマッチするHidden Classを探す

// 5種類以上のHidden Classが混在
function getValue(obj) {
  return obj.value;  // IC: megamorphic
}
 
getValue({ value: 1 });
getValue({ value: 2, a: 1 });
getValue({ value: 3, a: 1, b: 2 });
getValue({ value: 4, a: 1, b: 2, c: 3 });
getValue({ value: 5, a: 1, b: 2, c: 3, d: 4 });
getValue({ value: 6, x: 1 });
// → ICがmegamorphic状態 → キャッシュ無効
// → 毎回Hidden Classの検索が必要 → 遅い
// → TurboFanも型特殊化を断念

// PACKED_SMI_ELEMENTS: 最も高速
// SMI = Small Integer（31ビット符号付き整数、64ビットプラットフォームでは32ビット）
const smiArray = [1, 2, 3, 4, 5];
// → 要素がunboxed（タグなし）で格納される
// → ポインタ追跡やタグチェックが不要
 
// PACKED_DOUBLE_ELEMENTS
const doubleArray = [1.1, 2.2, 3.3];
// → IEEE 754 倍精度浮動小数点数として格納
// → ヒープオブジェクトとしてのオーバーヘッドがない
 
// PACKED_ELEMENTS: 最も汎用的だが最も遅い
const objectArray = [{ x: 1 }, "hello", true];
// → 各要素がヒープオブジェクトへのポインタ
// → GCがポインタを追跡する必要がある

// 良い: 型が統一された配列
const numbers = [1, 2, 3, 4, 5];  // PACKED_SMI_ELEMENTS
numbers.push(6);  // OK: SMIのまま
 
// 悪い: 型の混在で不可逆な遷移が発生
const bad = [1, 2, 3];           // PACKED_SMI_ELEMENTS
bad.push(4.5);                   // → PACKED_DOUBLE_ELEMENTS（不可逆）
bad.push("hello");               // → PACKED_ELEMENTS（不可逆）
// 元のPACKED_SMI_ELEMENTSには二度と戻らない
 
// 良い: 事前確保
const preallocated = new Array(1000);
// ただし HOLEY_SMI_ELEMENTS になる点に注意
 
// より良い: fill で初期化
const filled = new Array(1000).fill(0);
// PACKED_SMI_ELEMENTS（穴なし）
 
// 悪い: 穴あき配列
const holey = [1, , 3];  // HOLEY_SMI_ELEMENTS
// インデックス1のアクセス時にプロトタイプチェーンの検索が必要
// → PACKED に比べて遅い

// アンチパターン1: 同じ変数に異なる型を代入
function unstable() {
  let value = 42;       // SMI
  value = 3.14;         // → Double
  value = "hello";      // → String
  value = { x: 1 };    // → Object
  return value;
}
// → TurboFanが型特殊化できない → 最適化が困難
 
// 推奨パターン: 変数の型を一貫させる
function stable() {
  const intValue = 42;
  const floatValue = 3.14;
  const strValue = "hello";
  const objValue = { x: 1 };
  return objValue;
}

// アンチパターン2: 条件付きプロパティ追加
function createUser(name, email, isAdmin) {
  const user = { name, email };
  if (isAdmin) {
    user.role = "admin";        // Hidden Classが分岐
    user.permissions = ["all"];  // さらに分岐
  }
  return user;
}
// → isAdmin=true と isAdmin=false で異なるHidden Class
// → この関数を経由するオブジェクトのICがpolymorphicに
 
// 推奨パターン: 全プロパティを初期化
function createUserOptimized(name, email, isAdmin) {
  return {
    name,
    email,
    role: isAdmin ? "admin" : null,
    permissions: isAdmin ? ["all"] : null,
  };
}
// → 全オブジェクトが同じHidden Class → ICがmonomorphic
 
// 推奨パターン: クラスを使用
class User {
  constructor(name, email, isAdmin) {
    this.name = name;
    this.email = email;
    this.role = isAdmin ? "admin" : null;
    this.permissions = isAdmin ? ["all"] : null;
  }
}
// → コンストラクタで全プロパティ初期化 → 安定したHidden Class

// アンチパターン: 多様な形状のオブジェクトを同じ関数に渡す
function processItem(item) {
  return item.name + ": " + item.value;
}
 
processItem({ name: "A", value: 1 });
processItem({ name: "B", value: 2, extra: true });       // 別のHidden Class
processItem({ name: "C", value: 3, x: 1, y: 2 });       // また別のHidden Class
processItem({ value: 4, name: "D" });                     // 順序違いで別のHidden Class
// → ICがmegamorphicに → パフォーマンス低下
 
// 推奨パターン: 統一された形状を使用
class Item {
  constructor(name, value) {
    this.name = name;
    this.value = value;
  }
}
 
processItem(new Item("A", 1));
processItem(new Item("B", 2));
processItem(new Item("C", 3));
// → 全て同じHidden Class → ICがmonomorphic → 最速

// アンチパターン: delete でプロパティを削除
const obj = { x: 1, y: 2, z: 3 };
delete obj.y;
// → オブジェクトが「辞書モード（slow mode）」に切り替わる
// → Hidden Class の最適化が完全に失われる
// → 以降のプロパティアクセスが全て遅くなる
 
// 推奨パターン: null や undefined を代入
const obj2 = { x: 1, y: 2, z: 3 };
obj2.y = undefined;
// → Hidden Class は維持される
// → プロパティアクセスの最適化は継続
 
// 推奨パターン: 新しいオブジェクトを作成
const { y, ...rest } = { x: 1, y: 2, z: 3 };
// rest = { x: 1, z: 3 }
// → 新しいオブジェクトは新しいHidden Classを持つが、
//   辞書モードにはならない

// SMI（Small Integer）: 最も効率的
// → 31ビット符号付き整数（32ビットプラットフォーム）
// → 32ビット符号付き整数（64ビットプラットフォーム）
// → タグ付きポインタとして即値で格納（ヒープ割り当て不要）
const smi = 42;
 
// HeapNumber: ヒープに割り当てられる浮動小数点数
// → SMIの範囲外の整数、または小数
// → ヒープオブジェクトとしてのオーバーヘッドがある
const heapNum = 3.14;
const bigInt = 2147483648;  // SMI範囲外
 
// 配列におけるSMI vs Doubleの影響
const smiArr = [1, 2, 3];           // PACKED_SMI_ELEMENTS（最速）
const doubleArr = [1, 2, 3.0];      // PACKED_DOUBLE_ELEMENTS
// 3.0 が含まれるだけでDouble配列になる
 
// 整数演算がオーバーフローすると型が変わる
let counter = 0;
for (let i = 0; i < 1000000; i++) {
  counter += i;
  // counter がSMIの範囲を超えた時点でHeapNumberに変更
  // → ループ内の加算が急に遅くなる可能性
}

# 最適化の追跡
node --trace-opt script.js
# → TurboFanが最適化した関数を表示
 
# 脱最適化の追跡
node --trace-deopt script.js
# → 脱最適化が発生した箇所と理由を表示
 
# バイトコードの出力
node --print-bytecode script.js
# → Ignitionが生成したバイトコードを表示
 
# 特定の関数のバイトコードのみ出力
node --print-bytecode --print-bytecode-filter="functionName" script.js
 
# GCの追跡
node --trace-gc script.js
# → GCイベントの発生タイミングと所要時間を表示
 
# 詳細なGC情報
node --trace-gc-verbose script.js
 
# Hidden Class（Map）の遷移を追跡
node --trace-maps script.js
 
# ICの状態を追跡
node --trace-ic script.js
 
# TurboFanの最適化グラフを出力（Turbolizer用）
node --trace-turbo script.js
# → turbo-*.json ファイルが生成される
# → https://v8.github.io/tools/turbolizer/ で可視化

// Node.jsで --allow-natives-syntax フラグを使用して確認
// ※ このフラグはV8の内部APIを公開するため、開発・テスト目的のみで使用
 
function testFunction(a, b) {
  return a + b;
}
 
// ウォームアップ
for (let i = 0; i < 100000; i++) {
  testFunction(i, i + 1);
}
 
// 最適化状態を確認
// %GetOptimizationStatus(testFunction) の返り値:
// 1 = 関数は最適化可能
// 2 = 関数は最適化されている
// 3 = 関数は常に最適化される
// 4 = 関数は最適化されていない
// 6 = 関数はベースラインコードの可能性

// かつてのアンチパターン（Crankshaft時代）
// → try-catchがあるだけで関数全体が最適化されなかった
function oldPattern() {
  try {
    // ホットなコード
    for (let i = 0; i < 1000000; i++) {
      // 重い処理
    }
  } catch (e) {
    console.error(e);
  }
}
 
// TurboFan時代の現状:
// → try-catch自体は最適化を阻害しない
// → ただし、catch節内のコードは最適化されにくい
//   （例外発生は稀であるべきという前提）
 
// エッジケース: try-catch内での型の不安定さ
function parseJSON(str) {
  try {
    return JSON.parse(str);
    // 返り値の型がstring, number, object, array等、不定
    // → 呼び出し側のICがpolymorphicになりやすい
  } catch (e) {
    return null;
    // さらにnullも返り値に加わる
    // → 呼び出し側のICがさらに複雑に
  }
}
 
// 推奨: 返り値の型を統一する工夫
function parseJSONSafe(str) {
  try {
    const result = JSON.parse(str);
    return { success: true, data: result };
  } catch (e) {
    return { success: false, data: null };
  }
}
// → 常に同じ形状のオブジェクトを返す → Hidden Classが安定

// arguments オブジェクトは特殊な振る舞いを持ち、
// 最適化に悪影響を与える場合がある
 
// アンチパターン: argumentsを他の関数に渡す（リーク）
function leakyFunction() {
  // arguments がクロージャに捕捉される → 最適化が困難
  return Array.prototype.slice.call(arguments);
}
 
// アンチパターン: argumentsを外部変数に代入
function badPattern() {
  const args = arguments;  // argumentsオブジェクトが「リーク」
  return function() {
    return args[0];  // クロージャ内でargumentsを参照
  };
}
 
// 推奨パターン: レストパラメータを使用
function goodPattern(...args) {
  // argsは通常の配列 → 最適化に問題なし
  return args.slice();
}
 
// 推奨パターン: ES2015+ のデストラクチャリング
function betterPattern(first, second, ...rest) {
  return [first, second, ...rest];
}

// with文は V8 の最適化を完全に阻害する
// → スコープチェーンが動的になり、変数解決が静的にできない
 
// アンチパターン: with文
function withExample(obj) {
  with (obj) {
    // x が obj.x なのか外部スコープの x なのか
    // コンパイル時に判断できない
    return x + y;
  }
}
// → 関数全体が最適化対象から除外される可能性
// → strict mode では with文は構文エラー
 
// eval も同様の問題を引き起こす
function evalExample(code) {
  eval(code);
  // eval内で変数が宣言・変更される可能性
  // → 関数のスコープ全体が動的に
  // → Hidden Classやスコープの最適化が不可能
}
 
// 間接的なeval（グローバルスコープで実行）は影響が限定的
const indirectEval = eval;
indirectEval("console.log('hello')");
// → 呼び出し元の関数スコープには影響しない

// パターン1: イベントリスナーの解除忘れ
class Component {
  constructor() {
    this.data = new Array(10000).fill("large data");
    // イベントリスナーを登録
    window.addEventListener("resize", this.handleResize);
  }
 
  handleResize = () => {
    console.log(this.data.length);
  };
 
  destroy() {
    // リスナーを解除しないと、
    // このComponentインスタンスはGCされない
    // → this.data の巨大配列もリークする
  }
}
 
// 修正版
class ComponentFixed {
  constructor() {
    this.data = new Array(10000).fill("large data");
    this.handleResize = this.handleResize.bind(this);
    window.addEventListener("resize", this.handleResize);
  }
 
  handleResize() {
    console.log(this.data.length);
  }
 
  destroy() {
    window.removeEventListener("resize", this.handleResize);
    this.data = null;  // 明示的に参照を切る
  }
}

// パターン2: クロージャによる意図しない参照保持
function createProcessor() {
  const hugeData = new Array(1000000).fill("x");  // 巨大なデータ
 
  // この関数はhugeDataへの参照を保持し続ける
  return function process(input) {
    // hugeDataを直接使っていなくても、
    // 同じスコープの変数なのでクロージャが参照を保持
    return input.toUpperCase();
  };
}
 
const processor = createProcessor();
// → processor が存在する限り hugeData はGCされない
 
// 修正版: スコープを分離
function createProcessorFixed() {
  const hugeData = new Array(1000000).fill("x");
  const result = processHugeData(hugeData);
 
  // hugeDataを使う処理を完了させてから
  // クロージャを返す
  return function process(input) {
    return input.toUpperCase() + result;
  };
}

// パターン3: タイマーのクリア忘れ
function startPolling() {
  const data = { buffer: new ArrayBuffer(1024 * 1024) }; // 1MB
 
  const intervalId = setInterval(() => {
    // data への参照が維持される
    console.log(data.buffer.byteLength);
  }, 1000);
 
  // intervalIdを返さないと、クリアする手段がない
  // → data は永久にGCされない
}
 
// 修正版
function startPollingFixed() {
  const data = { buffer: new ArrayBuffer(1024 * 1024) };
 
  const intervalId = setInterval(() => {
    console.log(data.buffer.byteLength);
  }, 1000);
 
  // クリーンアップ関数を返す
  return function stop() {
    clearInterval(intervalId);
    // intervalIdをクリアすれば、コールバックへの参照が消え、
    // data もGC対象になる
  };
}

// WeakRef: 弱参照（GCを阻害しない参照）
class Cache {
  constructor() {
    this.cache = new Map();
  }
 
  set(key, value) {
    // WeakRefで値を保持 → GCが必要なら回収可能
    this.cache.set(key, new WeakRef(value));
  }
 
  get(key) {
    const ref = this.cache.get(key);
    if (ref) {
      const value = ref.deref();  // 弱参照を解決
      if (value !== undefined) {
        return value;  // まだ生きている
      }
      // GCされていた → キャッシュエントリを削除
      this.cache.delete(key);
    }
    return undefined;
  }
}
 
// FinalizationRegistry: オブジェクトがGCされた時のコールバック
const registry = new FinalizationRegistry((heldValue) => {
  console.log(`Object with key "${heldValue}" was garbage collected`);
  // クリーンアップ処理（外部リソースの解放など）
});
 
function createManagedObject(key) {
  const obj = { data: new Array(10000) };
  registry.register(obj, key);  // objがGCされたらkeyを引数にコールバック
  return obj;
}
 
// WeakMap: キーが弱参照（キーオブジェクトがGCされるとエントリ自動削除）
const metadata = new WeakMap();
 
function attachMetadata(obj, meta) {
  metadata.set(obj, meta);
  // obj がどこからも参照されなくなれば、
  // WeakMapのエントリも自動的に削除される
}

// WebAssemblyモジュールの読み込みと実行
async function loadWasm() {
  const response = await fetch("module.wasm");
  const buffer = await response.arrayBuffer();
  const module = await WebAssembly.compile(buffer);
  const instance = await WebAssembly.instantiate(module, {
    env: {
      // JavaScriptからWasmに渡す関数
      log: (value) => console.log(value),
    },
  });
 
  // Wasmのエクスポート関数を呼び出す
  const result = instance.exports.add(10, 20);
  // → JavaScript と Wasm の呼び出しにはオーバーヘッドがある
  // → 頻繁な小さな呼び出しは避け、まとまった処理を委譲する
}
 
// パフォーマンスの考慮点:
// ・JS → Wasm 呼び出し: 約10-20ns のオーバーヘッド
// ・Wasm → JS 呼び出し: より大きなオーバーヘッド（型変換等）
// ・大きなデータ: SharedArrayBufferを使ったゼロコピー転送が理想
// ・小さな関数の頻繁な呼び出しは JS 内で完結させた方が速い

function getX(obj) {
  return obj.x;  // ← このアクセス箇所にICが生成される
}
 
// 1回目の呼び出し: IC miss
const p1 = { x: 10, y: 20 };
getX(p1);
// 1. p1のHidden Class（Map M1）を取得
// 2. M1のプロパティテーブルで "x" を検索
// 3. オフセット0を発見
// 4. ICにキャッシュ: { Map: M1, Property: "x", Offset: 0 }
 
// 2回目の呼び出し: IC hit
const p2 = { x: 30, y: 40 };  // p1と同じHidden Class M1
getX(p2);
// 1. p2のHidden ClassがM1であることを確認
// 2. ICのキャッシュから直接オフセット0を使用
// 3. プロパティテーブル検索をスキップ → 高速化

// アンチパターン: 変数の型が頻繁に変わる
function unstable(a, b) {
  return a + b;
}
 
unstable(1, 2);        // SMI + SMI
unstable(1.5, 2.5);    // Double + Double
unstable("a", "b");    // String + String
unstable({}, {});      // Object + Object
 
// → TurboFanが型特殊化できない
// → 汎用的な（遅い）加算コードを生成
// → 脱最適化のリスクが高い

// 整数専用関数
function addInt(a, b) {
  return (a | 0) + (b | 0);  // ビット演算で整数を強制
}
 
// 浮動小数点専用関数
function addFloat(a, b) {
  return +a + +b;  // 単項プラス演算子でNumber型を強制
}

// アンチパターン: 条件付きプロパティ追加
function createConfig(enableCache) {
  const config = { baseUrl: "/" };
  if (enableCache) {
    config.cache = true;  // Hidden Classが分岐
  }
  return config;
}
 
// → 2つの異なるHidden Classが生成される
// → この関数を使う箇所のICがPolymorphicに

function createConfig(enableCache) {
  return {
    baseUrl: "/",
    cache: enableCache || null,  // 常に全プロパティを初期化
  };
}

// アンチパターン: deleteでプロパティ削除
const obj = { x: 1, y: 2, z: 3 };
delete obj.y;
 
// → オブジェクトが「slow mode（辞書モード）」に
// → Hidden Classの最適化が完全に失われる
// → 以降のアクセスがハッシュテーブル検索になる

// undefinedを代入
obj.y = undefined;
 
// または新しいオブジェクトを作成
const { y, ...newObj } = obj;

// アンチパターン: 穴あき配列
const arr = [1, 2, , 4];  // インデックス2が空
 
// → HOLEY_SMI_ELEMENTS に遷移
// → アクセス時にプロトタイプチェーンの検索が必要
// → PACKED配列より遅い

const arr = [1, 2, 0, 4];  // 穴を埋める
// または
const arr = new Array(4).fill(0);
arr[0] = 1;
arr[1] = 2;
arr[3] = 4;

// アンチパターン: argumentsを外部に公開
function leaky() {
  const args = arguments;
  return function() { return args[0]; };
}
 
// → クロージャがargumentsを捕捉
// → 最適化が困難

function optimized(...args) {
  return function() { return args[0]; };
}

// アンチパターン: eval、with文
function dynamic(code) {
  eval(code);  // スコープが動的になる
}
 
// → 変数解決が静的にできない
// → 関数全体が最適化対象外

// アンチパターン: 1000行の巨大関数
function huge() {
  // ... 大量のコード ...
}
 
// → TurboFanがインライン展開できない
// → 呼び出しオーバーヘッドが残る

// 小さな関数に分割（10-50行が目安）
function small1() { /* ... */ }
function small2() { /* ... */ }

// アンチパターン: try-catch内で複数の型を返す
function parse(str) {
  try {
    return JSON.parse(str);  // Object, Array, String, Number等
  } catch (e) {
    return null;  // さらにnull
  }
}
 
// → 返り値の型が多態的
// → 呼び出し側のICがMegamorphicに

function parse(str) {
  try {
    return { success: true, data: JSON.parse(str) };
  } catch (e) {
    return { success: false, data: null };
  }
}
// → 常に同じ形状のオブジェクトを返す

// プロパティ追加順序が重要
const obj1 = {};
obj1.x = 1;  // Map M0 → M1
obj1.y = 2;  // Map M1 → M2
 
// 順序が違うと別のMap
const obj2 = {};
obj2.y = 2;  // Map M0 → M3
obj2.x = 1;  // Map M3 → M4

// ✅ Good: 型が一貫している
function addNumbers(a, b) {
  return (a | 0) + (b | 0);  // 整数に強制
}
 
// ❌ Bad: 型が変わる
function addAny(a, b) {
  return a + b;  // 整数、浮動小数点、文字列が混在
}

// ✅ Good: 全オブジェクトが同じ形状
class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}
 
// ❌ Bad: オブジェクトごとに形状が異なる
function createPoint(x, y, hasZ) {
  const p = { x, y };
  if (hasZ) p.z = 0;  // Hidden Class分岐
  return p;
}

// ✅ Good: 常に同じHidden Classのオブジェクトを処理
function process(items) {
  for (const item of items) {
    console.log(item.name);  // IC: monomorphic
  }
}
const items = [
  new Item("A"),
  new Item("B"),
  new Item("C"),
];
 
// ❌ Bad: 異なるHidden Classが混在
const mixed = [
  { name: "A" },
  { name: "B", value: 1 },
  { value: 2, name: "C" },  // 順序違い
];
process(mixed);  // IC: megamorphic