Method simplify

basex-core/src/main/java/org/basex/query/expr/path/Path.java:304–350

Simplifies the path expression. @param cc compilation context @return original or optimized expression @throws QueryException query exception

(final CompileContext cc)

   * @throws QueryException query exception
   */
  private Expr simplify(final CompileContext cc) throws QueryException {
    // root yields no result
    if(root != null && root.seqType().zero()) return cc.emptySeq(this);

    // find empty results, remove redundant steps
    final int sl = steps.length;
    boolean removed = false;
    final ExprList list = new ExprList(sl);
    for(int s = 0; s < sl; s++) {
      final Expr step = steps[s];
      final Expr prev = list.isEmpty() ? root != null ? root : cc.qc.focus.value : list.peek();
      if(prev != null) {
        final SeqType seqType = prev.seqType();
        if(seqType.type instanceof NodeType && (step instanceof ContextValue ||
            step instanceof final Step stp && stp.remove(seqType))) {
          removed = true;
          continue;
        }
      }

      // step is empty sequence. example: $doc/NON-EXISTING-STEP → $doc/() → ()
      final Expr expr = steps[s];
      if(expr == Empty.VALUE) return cc.emptySeq(this);

      // add step to list
      list.add(expr);

      // ignore remaining steps if step yields no results
      // example: A/void(.)/B → A/void(.)
      if(expr.seqType().zero() && s + 1 < sl) {
        cc.info(QueryText.OPTSIMPLE_X_X, (Supplier<?>) this::description, this);
        break;
      }
    }

    // self step was removed: ensure that result will be in distinct document order
    if(removed && (list.isEmpty() || !(list.get(0).seqType().type instanceof NodeType))) {
      if(root == null) root = ContextValue.get(cc, info);
      if(!root.ddo() && !root.seqType().mayBeWrapped()) {
        root = cc.replaceWith(root, cc.function(Function.DISTINCT_ORDERED_NODES, info, root));
      }
    }

    // no steps left: return root
    steps = list.finish();
    return cc.replaceWith(this, steps.length == 0 ? root : this);
  }

  /**
   * Returns the path nodes that will result from this path.