// parser explainer
static class Explain {
  static L<S> primitiveClasses = litlist("quoted", "identifier", "any", "int");
  
  O parseResult;
  L<S> tok;
  L e;
  new L<Explain> subs;
  
  // XXX - applies to full parse always
  L<S> fullMatchClasses() { ret (L<S>) call(parseResult, "fullMatchClasses"); }
  
  static boolean debug;
  
  *(O *parseResult, L *e) {
    tok = (L) get(parseResult, "tok");
    _makeSubExplains();
  }
  
  void _makeSubExplains() {
    for (int i = 4; i < l(e); i++) {
      L sub = cast get(e, i);
      int t1 = (int) get(sub, 0);
      int t2 = (int) get(sub, 1);
      S className = getString(sub, 2);
      L subE = sub;
      if (debug)
        print("subE first = " + sfu(subE));
      if (!primitiveClasses.contains(className))
        subE = (L) call(parseResult, "explainFull", t1, t2, className);
      if (debug)
        printF("Explaining for " + className() + ": * * * => *", t1, t2, className, subE);
      if (subE == null)
        subs.add(null);
      else
        subs.add(new Explain(parseResult, subE));
    }
  }
  
  S className() {
    ret getString(e, 2);
  }
  
  int fromToken() {
    ret (int) get(e, 0);
  }
  
  int toToken() {
    ret (int) get(e, 1);
  }
  
  // return tokens, padded with empty non-code tokens first and last
  // to make actual CNC
  L<S> tok() {
    ret concatLists(
      litlist(""),
      subList(tok, fromToken(), toToken()-1),
      litlist(""));
  }
  
  S string() {
    ret join(subList(tok, fromToken(), toToken()-1));
  }
  
  boolean containsToken(S t) {
    ret main containsToken(tok(), t);
  }
  
  void findAll(S className, L<S> out) {
    if (eq(className, className()))
      out.add(string());
    else // << this is new - don't recurse
      for (Explain e : subs)
        if (e != null)
          e.findAll(className, out);
  }
  
  L<S> findAll(S className) {
    new L<S> l;
    findAll(className, l);
    ret l;
  }
  
  // short for findFirst
  Explain find(S className) {
    ret findFirst(className);
  }
  
  Explain findFirst(S className) {
    if (eq(className, className()))
      ret this;
    ret findFirstSub(className);
  }
  
  // find class, but exclude myself
  Explain findFirstSub(S className) {
    for (Explain e : subs)
      if (e != null) {
        Explain result = e.findFirst(className);
        if (result != null) ret result;
      }
    ret null;
  }
  
  boolean is(S className) {
    ret eq(className(), className);
  }
  
  boolean has(S className) {
    ret findFirst(className) != null;
  }
  
  boolean hasSub(S className) {
    ret findFirstSub(className) != null;
  }
  
  void findAll2(S className, L<Explain> out) {
    if (is(className))
      out.add(this);
    for (Explain e : subs)
      if (e != null)
        e.findAll2(className, out);
  }
  
  L<Explain> findAll2(S className) {
    new L<Explain> l;
    findAll2(className, l);
    ret l;
  }
  
  // short for pruneSubs
  Explain prune(S className) {
    ret pruneSubs(className);
  }
  
  // returns self after pruning
  Explain pruneSubs(S className) {
    for (int i = 0; i < l(subs); ) {
      Explain e = sub(i);
      if (e == null) ++i;
      else if (eq(e.className(), className))
        subs.remove(i);
      else {
        e.pruneSubs(className);
        ++i;
      }
    }
    ret this;
  }
  
  Explain sub(int i) { ret get(subs, i); }
  S str(int i) {
    // ret sub(i).string(); // sub might be null
    L sub = cast get(e, 4+i);
    int t1 = (int) get(sub, 0);
    int t2 = (int) get(sub, 1);
    ret join(subList(tok, t1, t2-1));
  }
  
  L<Explain> subs() { ret subs; }
  
  bool singleEqualChild() {
    if (l(subs) != 1 || first(subs) == null) false;
    Explain e = first(subs);
    ret fromToken() == e.fromToken() && toToken() == e.toToken();
  }
  
  S prettierAnalysis() {
    ret (S) call(parseResult, "prettierAnalysis");
  }
}