实现 Pratt 解析器：Token 的“绑定力” ​

// file: src/tokentype.js

export class TokenType {
  constructor(label, conf = {}) {
    this.label = label;
    // 关键属性：
    this.binop = conf.binop ?? -1; // 中缀绑定力
    this.prefix = conf.prefix ?? false; // 是否为前缀
    this.postfix = conf.postfix ?? false; // 是否为后缀
    this.rightAssociative = conf.rightAssociative ?? false; // 是否右结合

    // ... 其他属性，如 startsExpr, isLoop 等
  }
}

// ...

// 我们为所有运算符定义绑定力
// 优先级数字越大，绑定力越强
export const tt = {
  // ... (num, string, name 等原子类型)

  // 赋值与三元，右结合
  eq: new TokenType("=", { binop: 2, rightAssociative: true }),
  question: new TokenType("?", { binop: 3, rightAssociative: true }),

  // 逻辑运算符
  logicalOR: new TokenType("||", { binop: 4 }),
  logicalAND: new TokenType("&&", { binop: 5 }),

  // 位运算符
  bitwiseOR: new TokenType("|", { binop: 6 }),
  bitwiseXOR: new TokenType("^", { binop: 7 }),
  bitwiseAND: new TokenType("&", { binop: 8 }),

  // 等式运算符
  equality: new TokenType("==/!=", { binop: 9 }),

  // 关系运算符
  relational: new TokenType("</>", { binop: 10 }),

  // 位移运算符
  bitShift: new TokenType("<</>>", { binop: 11 }),

  // 加减法
  plus: new TokenType("+", { binop: 12, prefix: true }),
  minus: new TokenType("-", { binop: 12, prefix: true }),

  // 乘除模
  modulo: new TokenType("%", { binop: 13 }),
  star: new TokenType("*", { binop: 13 }),
  slash: new TokenType("/", { binop: 13 }),

  // 前缀/后缀自增自减
  incDec: new TokenType("++/--", { prefix: true, postfix: true }),

  // 其他前缀运算符
  bang: new TokenType("!", { prefix: true }),
  tilde: new TokenType("~", { prefix: true }),

  // ... (parenL, parenR, braceL, etc.)
};

// file: src/parser/expression.js

// 表达式解析的统一入口
parseExpression() {
  // 初始调用，传入的 left 是第一个原子表达式，最低绑定力为 0
  return this.parseExprOp(this.parseMaybeUnary(), 0);
}

// file: src/parser/expression.js

// 解析一元前缀表达式 或 原子表达式
parseMaybeUnary() {
  // 检查当前 Token 是否被标记为前缀运算符
  if (this.type.prefix) {
    const node = this.startNode();
    const op = this.type;
    node.operator = op.label;
    this.next(); // 消费掉前缀运算符

    // 关键：递归调用 parseExprOp 来解析运算符后面的表达式
    // 我们需要为一元运算设置一个绑定力，这里我们用一个较高的值（例如 14）
    // 来确保一元运算符紧密绑定其操作数。例如，在 `-a * b` 中，`-` 的优先级高于 `*`。
    node.argument = this.parseExprOp(this.parseMaybeUnary(), 14);
    node.prefix = true; // 明确这是一个前缀表达式

    // 根据运算符类型，确定是 UnaryExpression 还是 UpdateExpression
    const nodeType = op === tt.incDec ? "UpdateExpression" : "UnaryExpression";
    return this.finishNode(node, nodeType);
  }

  // 如果不是前缀运算符，那它必须是一个原子表达式
  return this.parseExprAtom(); // 我们将在下一章实现它
}

// file: src/parser/expression.js

// Pratt 解析器的核心循环，处理中缀表达式
// left: 已经解析好的左侧表达式
// minPrec: 当前上下文要求的最低绑定力
parseExprOp(left, minPrec) {
  let prec = this.type.binop; // 获取当前 Token 的中缀绑定力

  // 循环条件：
  // 1. 当前 Token 是一个中缀运算符 (prec > -1)
  // 2. 它的绑定力高于我们要求的最低绑定力 (prec > minPrec)
  while (prec > -1 && prec > minPrec) {
    const op = this.type;
    this.next(); // 消费掉中缀运算符

    // 关键的递归调用！
    // 我们需要解析右侧的表达式 (right-hand side)。
    // 传递给下一层的绑定力是多少？这决定了结合性！
    // - 左结合 (a + b + c): 传入与当前运算符相同的绑定力 `prec`。
    //   这样，下一个 `+` (绑定力12) 就不会大于 `minPrec` (12)，循环会停止，(a+b) 会先被组合。
    // - 右结合 (a = b = c): 传入 `prec - 1`。
    //   这样，下一个 `=` (绑定力2) 仍然大于 `minPrec` (1)，循环会继续，b=c 会被优先组合。
    const right = this.parseExprOp(this.parseMaybeUnary(), op.rightAssociative ? prec - 1 : prec);

    // 将左右两部分组合成一个新的、更大的 left
    const node = this.startNodeAtNode(left);
    node.left = left;
    node.operator = op.label;
    node.right = right;
    left = this.finishNode(node, "BinaryExpression");

    // 为下一次循环更新 prec，看看后面还有没有更强的运算符
    prec = this.type.binop;
  }
  return left;
}