parseExpression function

Ast parseExpression(
  1. List<Token> tokens
)

lang-core parseExpression: a Pratt parser over one statement's tokens.

Implementation

Ast parseExpression(List<Token> tokens) {
  var pos = 0;
  Token cur() => pos < tokens.length ? tokens[pos] : const Token(T.eof);
  Token adv() {
    final tok = cur();
    pos++;
    return tok;
  }

  void eat(T kind) {
    if (cur().t == kind) pos++;
  }

  int infixPrec(Token tok) => switch (tok.t) {
    T.question => 1,
    T.or => 2,
    T.and => 3,
    T.eqEq || T.notEq => 4,
    T.greater || T.less || T.greaterEq || T.lessEq => 5,
    T.plus || T.minus => 6,
    T.star || T.slash || T.percent => 7,
    T.dot || T.lBracket => 9,
    _ => 0,
  };

  late Ast Function(int minPrec) parseExpr;

  Ast parseComp() {
    final name = cur().v as String;
    adv();
    eat(T.lParen);
    final args = <Ast>[];
    while (cur().t != T.rParen && cur().t != T.eof) {
      args.add(parseExpr(0));
      if (cur().t == T.comma) adv();
    }
    eat(T.rParen);
    return CompNode(name, args);
  }

  Ast parseArr() {
    adv();
    final els = <Ast>[];
    while (cur().t != T.rBracket && cur().t != T.eof) {
      els.add(parseExpr(0));
      if (cur().t == T.comma) adv();
    }
    eat(T.rBracket);
    return ArrNode(els);
  }

  String keyOf(Token kt) => switch (kt.t) {
    T.ident || T.str || T.type => kt.v as String,
    T.num => _numberKey(kt.v as num),
    T.stateVar => (kt.v as String).substring(1),
    _ => '?',
  };

  Ast parseObj() {
    adv();
    final entries = <(String, Ast)>[];
    while (cur().t != T.rBrace && cur().t != T.eof) {
      final key = keyOf(cur());
      adv();
      eat(T.colon);
      entries.add((key, parseExpr(0)));
      if (cur().t == T.comma) adv();
    }
    eat(T.rBrace);
    return ObjNode(entries);
  }

  Ast parsePrefix() {
    final tok = cur();
    switch (tok.t) {
      case T.str:
        adv();
        return StrNode(tok.v as String);
      case T.num:
        adv();
        return NumNode(tok.v as num);
      case T.trueKw:
        adv();
        return const BoolNode(true);
      case T.falseKw:
        adv();
        return const BoolNode(false);
      case T.nullKw:
        adv();
        return const NullNode();
      case T.lBracket:
        return parseArr();
      case T.lBrace:
        return parseObj();
      case T.stateVar:
        adv();
        if (cur().t == T.equals) {
          adv();
          return AssignNode(tok.v as String, parseExpr(0));
        }
        return StateRefNode(tok.v as String);
      case T.type:
        final name = tok.v as String;
        final calls = pos + 1 < tokens.length && tokens[pos + 1].t == T.lParen;
        if (calls && (!builtinNames.contains(name) || name == 'Action')) {
          return parseComp();
        }
        adv();
        return RefNode(name);
      case T.builtinCall:
        if (pos + 1 < tokens.length && tokens[pos + 1].t == T.lParen) {
          final call = parseComp() as CompNode;
          return builtinNames.contains(call.name)
              ? call
              : CompNode(call.name, call.args, isAtCall: true);
        }
        adv();
        return RefNode(tok.v as String);
      case T.ident:
        adv();
        return RefNode(tok.v as String);
      case T.not:
        adv();
        return UnaryOpNode('!', parseExpr(8));
      case T.minus:
        adv();
        return UnaryOpNode('-', parseExpr(8));
      case T.lParen:
        adv();
        final inner = parseExpr(0);
        eat(T.rParen);
        return inner;
      default:
        adv();
        return const NullNode();
    }
  }

  Ast parseInfix(Ast left) {
    final tok = cur();
    final binary = switch (tok.t) {
      T.plus => ('+', 6),
      T.minus => ('-', 6),
      T.star => ('*', 7),
      T.slash => ('/', 7),
      T.percent => ('%', 7),
      T.eqEq => ('==', 4),
      T.notEq => ('!=', 4),
      T.greater => ('>', 5),
      T.less => ('<', 5),
      T.greaterEq => ('>=', 5),
      T.lessEq => ('<=', 5),
      T.and => ('&&', 3),
      T.or => ('||', 2),
      _ => null,
    };
    if (binary != null) {
      adv();
      return BinOpNode(binary.$1, left, parseExpr(binary.$2));
    }
    switch (tok.t) {
      case T.question:
        adv();
        final then = parseExpr(0);
        eat(T.colon);
        return TernaryNode(left, then, parseExpr(0));
      case T.dot:
        adv();
        final f = cur();
        adv();
        return MemberNode(left, keyOf(f));
      case T.lBracket:
        adv();
        final index = parseExpr(0);
        eat(T.rBracket);
        return IndexNode(left, index);
      default:
        return left;
    }
  }

  parseExpr = (int minPrec) {
    var left = parsePrefix();
    while (infixPrec(cur()) > minPrec) {
      left = parseInfix(left);
    }
    return left;
  };

  return parseExpr(0);
}