Style parsing fails for constant expression values

[jfirebaugh]

Triggered by the following style:

{
        "version": 8,
        "layers": [{
            "id": "symbol",
            "type": "symbol",
            "source": "vector",
            "layout": {
              "text-font": ["array", "string", ["literal", ["Helvetica"]]]
            }
        }]
}

cc @anandthakker

[anandthakker]

The issue here is that in Converter<DataDrivenPropertyValue<T>>, we're assuming that any expression value must be a camera, source, or composite expression.

[anandthakker]

#11282 did not fully fix this issue. The assertion in

mapbox-gl-native/include/mbgl/style/conversion/data_driven_property_value.hpp

Lines 40 to 51 in c50a74d

	if (featureConstant && !zoomConstant) {
	return DataDrivenPropertyValue<T>(CameraFunction<T>(std::move(*expression)));
	} else if (!featureConstant && zoomConstant) {
	return DataDrivenPropertyValue<T>(SourceFunction<T>(std::move(*expression)));
	} else if (!featureConstant && !zoomConstant) {
	return DataDrivenPropertyValue<T>(CompositeFunction<T>(std::move(*expression)));
	} else {
	// If an expression is neither zoom- nor feature-dependent, it
	// should have been reduced to a Literal when it was parsed.
	auto literal = dynamic_cast<Literal*>(expression->get());
	assert(literal);
	optional<T> constant = fromExpressionValue<T>(literal->getValue());

fails in the following cases:

• ["to-color", ["get", "x", ["literal", {"x": "red"}]] -- because we add the to-color annotation before checking isConstant() (and isConstant assumes that all of its argument's children have already been folded to literals if possible)
• ["let", "x", 1, ["var", "x"]] -- because we conservatively just bail out of isConstant when we see a var expression

The quick fix would be to replace the last three lines above with:

optional<T> constant;
if (auto literal = dynamic_cast<Literal*>(expression->get()) {
    // cool, it's pre-folded to a literal
    constant = fromExpressionValue<T>(literal->getValue());
} else {
    // we didn't manage to fold to a literal during parsing, so evaluate it now
    EvaluationContext params(nullptr);
    EvaluationResult evaluated((*parsed)->evaluate(params));
    assert(evaluated); // this assert really should work, since we've already checked above that the expression is zoom- & feature-constant.
    constant = fromExpressionValue<T>(*evaluated);
}

The fuller fix would be to fix constant folding during parsing to work during every case.

[anandthakker]

Fixed in #11606