[css-values] Short-circuit if() evaluation

[andruud]

In a world where huge trees of custom function calls and inline if()s need to be evaluated, it would be nice if we could stop evaluating once a matching condition is found:

 if(cheap-test1(): 10px;
    cheap-test2(): 42px;
    else: --expensive())

In the above, we don't want to evaluate (substitute) --expensive() if an earlier branch will do.

Relatedly, a var() function also has up to two branches: the main value produced by the custom property being referenced, and optionally the fallback value. As specified currently, we can not short-circuit this "evaluation", since we need to look for cycles in the fallback value:

--valid: 1px;
--x: var(--valid, var(--y)); /* Cycle; IACVT */
--y: var(--valid, var(--x)); /* Cycle; IACVT */

--x and --y are in a cycle above, even though the fallback paths are not taken. By default, I'd expect this to extend to the branches not taken for if() as well, otherwise we'd miss the cycle in a case like:

--x: if(test-which-is-true(): 10px;
        else: var(--y));
--y: var(--x);

So:

• Should we specify this short-circuiting behavior for if()?
• Should we avoid looking for cycles in the fallback part of var() when it's not taken? (Requires compat investigation.)
• Should we generally avoid looking for cycles in a branch not taken during any substitution? (E.g. attr()).

[andruud]

Should we generally avoid looking for cycles in a branch not taken during any substitution? (E.g. attr()).

This would extend to custom functions as well; none of the following functions are in a cycle:

@function --x() {
  @media (false) {
    result: --x();
  }
  result: 1px;
}

@function --y() {
  @if (false) { /* If added in the future */
    result: --y();
  }
  result: 1px;
}

@function --z() {
  --unused: var(--unused);
  result: 1px;
}

This probably does place --w() in a cycle, however, since we can't leave the locals unevaluated due to dynamic scoping (#10954):

@function --w() {
  --unused: --w();
  result: 1px;
}

EDIT: Added --w() example.

[tabatkins]

Yes, --x() and --y() should be non-cyclic; --z() has a cycle inside of itself (--unused is cyclic) but the function itself isn't cyclic; and --w() is cyclic.