Attachment #456559 for bug #238732

View Details Raw Unified Return to Bug 238732



2022-04-04  Antti Koivisto  <antti@apple.com>

        [CSS Container Queries] Simplify grammar
        https://bugs.webkit.org/show_bug.cgi?id=238732

        Reviewed by NOBODY (OOPS!).

        Because size() function syntax is no longer supported, separate SizeQuery and SizeCondition productions
        are no longer needed.

        Some slightly unnecessary templatization is retained to help with future work.

        * css/ContainerQuery.cpp:
        * css/ContainerQuery.h:
        * css/ContainerQueryParser.cpp:
        (WebCore::ContainerQueryParser::consumeContainerQuery):
        (WebCore::ContainerQueryParser::consumeCondition):
        (WebCore::ContainerQueryParser::consumeSizeFeature):
        (WebCore::ContainerQueryParser::consumePlainSizeFeature):
        (WebCore::ContainerQueryParser::consumeSizeQuery): Deleted.
        * css/ContainerQueryParser.h:
        * style/ContainerQueryEvaluator.cpp:
        (WebCore::Style::ContainerQueryEvaluator::evaluateQuery const):
        * style/ContainerQueryEvaluator.h:

2022-03-30  Andres Gonzalez  <andresg_22@apple.com>

        Split streaming of AX trees from the class AXLogger.



    return { };
}

void serialize(StringBuilder&, const SizeQuery&);
void serialize(StringBuilder&, const SizeFeature&);
template<typename ConditionType> void serialize(StringBuilder&, const ConditionType&);


    });
}

void serialize(StringBuilder& builder, const SizeQuery& sizeQuery)
{
    WTF::switchOn(sizeQuery, [&](auto& node) {
        serialize(builder, node);
    });
}

void serialize(StringBuilder& builder, const SizeFeature& sizeFeature)
{
    auto serializeRangeComparisonOperator = [&](ComparisonOperator op) {



    String text;
};

using ContainerQuery = std::variant<ContainerCondition, SizeFeature, UnknownQuery>;
using ContainerQuery = std::variant<ContainerCondition, SizeQuery, UnknownQuery>;

enum class LogicalOperator : uint8_t { And, Or, Not };
enum class ComparisonOperator : uint8_t { LessThan, LessThanOrEqual, Equal, GreaterThan, GreaterThanOrEqual };

    Vector<ContainerQuery> queries;
};

struct SizeCondition {
    LogicalOperator logicalOperator { LogicalOperator::And };
    Vector<SizeQuery> queries;
};

struct Comparison {
    ComparisonOperator op { ComparisonOperator::Equal };
    RefPtr<CSSValue> value;



        blockRange.consumeWhitespace();

        // Try to parse as a size query first.
        auto blockForSizeFeature = blockRange;
        if (auto sizeFeature = consumeSizeFeature(blockForSizeFeature))
            return { *sizeFeature };

        if (auto condition = consumeCondition<CQ::ContainerCondition>(blockRange))
            return { condition };

    auto consumeQuery = [&](CSSParserTokenRange& range) {
        if constexpr (std::is_same_v<CQ::ContainerCondition, ConditionType>)
            return consumeContainerQuery(range);
        // Style query support would be here.
            if (range.peek().type() != LeftParenthesisToken)
                return std::optional<CQ::SizeQuery>();
            auto blockRange = range.consumeBlock();
            return consumeSizeQuery(blockRange);
        }
    };

    if (range.peek().type() == IdentToken) {

    return condition;
}

std::optional<CQ::SizeFeature> ContainerQueryParser::consumeSizeFeature(CSSParserTokenRange& range)
{
    auto consume = [&] {
        auto rangeCopy = range;
        if (auto sizeFeature = consumePlainSizeFeature(range))
            return sizeFeature;
        return { *sizeCondition };
    }

    auto sizeFeature = consumeSizeFeature(range);
    if (!sizeFeature)
        return { };

    m_requiredAxes.add(CQ::requiredAxesForFeature(sizeFeature->name));

        range = rangeCopy;
        return consumeRangeSizeFeature(range);
    };

    auto sizeFeature = consume();
    if (sizeFeature)
        m_requiredAxes.add(CQ::requiredAxesForFeature(sizeFeature->name));
    if (auto sizeFeature = consumePlainSizeFeature(range))
        return sizeFeature;

    return sizeFeature;
    return consumeRangeSizeFeature(range);
}

static String consumeFeatureName(CSSParserTokenRange& range)

    if (range.atEnd()) {
        if (op != CQ::ComparisonOperator::Equal)
            return { };

        return CQ::SizeFeature { featureName, CQ::Syntax::Boolean, { }, { } };
    }


        return { };

    auto value = consumeValue(range);

    return CQ::SizeFeature { featureName, CQ::Syntax::Colon, { }, CQ::Comparison { op, WTFMove(value) } };
}


Lines 39-45 public: a/Source/WebCore/css/ContainerQueryParser.h_sec1
- a/Source/WebCore/css/ContainerQueryParser.h -1 lines
39	private:	39	private:
40	std::optional<FilteredContainerQuery> consumeFilteredContainerQuery(CSSParserTokenRange&);	40	std::optional<FilteredContainerQuery> consumeFilteredContainerQuery(CSSParserTokenRange&);
41	std::optional<CQ::ContainerQuery> consumeContainerQuery(CSSParserTokenRange&);	41	std::optional<CQ::ContainerQuery> consumeContainerQuery(CSSParserTokenRange&);
42	std::optional<CQ::SizeQuery> consumeSizeQuery(CSSParserTokenRange&);
43	template<typename ConditionType> std::optional<ConditionType> consumeCondition(CSSParserTokenRange&);	42	template<typename ConditionType> std::optional<ConditionType> consumeCondition(CSSParserTokenRange&);
44	std::optional<CQ::SizeFeature> consumeSizeFeature(CSSParserTokenRange&);	43	std::optional<CQ::SizeFeature> consumeSizeFeature(CSSParserTokenRange&);
45	std::optional<CQ::SizeFeature> consumePlainSizeFeature(CSSParserTokenRange&);	44	std::optional<CQ::SizeFeature> consumePlainSizeFeature(CSSParserTokenRange&);



{
    return WTF::switchOn(containerQuery, [&](const CQ::ContainerCondition& containerCondition) {
        return evaluateCondition(containerCondition, container);
    }, [&](const CQ::SizeQuery& sizeQuery) {
        return evaluateQuery(sizeQuery, container);
    }, [&](const CQ::UnknownQuery&) {
        return EvaluationResult::Unknown;
    });
}

auto ContainerQueryEvaluator::evaluateQuery(const CQ::SizeQuery& sizeQuery, const SelectedContainer& container) const -> EvaluationResult
{
    return WTF::switchOn(sizeQuery, [&](const CQ::SizeCondition& sizeCondition) {
        return evaluateCondition(sizeCondition, container);
    }, [&](const CQ::SizeFeature& sizeFeature) {
        return evaluateSizeFeature(sizeFeature, container);
    }, [&](const CQ::UnknownQuery&) {
        return EvaluationResult::Unknown;
    });
}


Lines 49-55 private: a/Source/WebCore/style/ContainerQueryEvaluator.h_sec1
- a/Source/WebCore/style/ContainerQueryEvaluator.h -1 lines
49	std::optional<SelectedContainer> selectContainer(const FilteredContainerQuery&) const;	49	std::optional<SelectedContainer> selectContainer(const FilteredContainerQuery&) const;
50		50
51	EvaluationResult evaluateQuery(const CQ::ContainerQuery&, const SelectedContainer&) const;	51	EvaluationResult evaluateQuery(const CQ::ContainerQuery&, const SelectedContainer&) const;
52	EvaluationResult evaluateQuery(const CQ::SizeQuery&, const SelectedContainer&) const;
53	template<typename ConditionType> EvaluationResult evaluateCondition(const ConditionType&, const SelectedContainer&) const;	52	template<typename ConditionType> EvaluationResult evaluateCondition(const ConditionType&, const SelectedContainer&) const;
54	EvaluationResult evaluateSizeFeature(const CQ::SizeFeature&, const SelectedContainer&) const;	53	EvaluationResult evaluateSizeFeature(const CQ::SizeFeature&, const SelectedContainer&) const;
55		54

Return to Bug 238732

Lines 87-93 OptionSet<Axis> requiredAxesForFeature(const AtomString& featureName) a/Source/WebCore/css/ContainerQuery.cpp_sec1
- a/Source/WebCore/css/ContainerQuery.cpp -8 lines
87	return { };	87	return { };
88	}	88	}
89		89
90	void serialize(StringBuilder&, const SizeQuery&);
91	void serialize(StringBuilder&, const SizeFeature&);	90	void serialize(StringBuilder&, const SizeFeature&);
92	template<typename ConditionType> void serialize(StringBuilder&, const ConditionType&);	91	template<typename ConditionType> void serialize(StringBuilder&, const ConditionType&);
93		92
Lines 105-117 static void serialize(StringBuilder& builder, const ContainerQuery& containerQue a/Source/WebCore/css/ContainerQuery.cpp_sec2
105	});	104	});
106	}	105	}
107		106
108	void serialize(StringBuilder& builder, const SizeQuery& sizeQuery)
109	{
110	WTF::switchOn(sizeQuery, [&](auto& node) {
111	serialize(builder, node);
112	});
113	}
114
115	void serialize(StringBuilder& builder, const SizeFeature& sizeFeature)	107	void serialize(StringBuilder& builder, const SizeFeature& sizeFeature)
116	{	108	{
117	auto serializeRangeComparisonOperator = [&](ComparisonOperator op) {	109	auto serializeRangeComparisonOperator = [&](ComparisonOperator op) {

Lines 74-82 std::optional<CQ::ContainerQuery> ContainerQueryParser::consumeContainerQuery(CS a/Source/WebCore/css/ContainerQueryParser.cpp_sec1
- a/Source/WebCore/css/ContainerQueryParser.cpp -32 / +18 lines
74	blockRange.consumeWhitespace();	74	blockRange.consumeWhitespace();
75		75
76	// Try to parse as a size query first.	76	// Try to parse as a size query first.
77	auto blockForSizeQuery = blockRange;	77	auto blockForSizeFeature = blockRange;
78	if (auto sizeQuery = consumeSizeQuery(blockForSizeQuery))	78	if (auto sizeFeature = consumeSizeFeature(blockForSizeFeature))
79	return { *sizeQuery };	79	return { *sizeFeature };
80		80
81	if (auto condition = consumeCondition<CQ::ContainerCondition>(blockRange))	81	if (auto condition = consumeCondition<CQ::ContainerCondition>(blockRange))
82	return { condition };	82	return { condition };
Lines 91-102 std::optional<ConditionType> ContainerQueryParser::consumeCondition(CSSParserTok a/Source/WebCore/css/ContainerQueryParser.cpp_sec2
91	auto consumeQuery = [&](CSSParserTokenRange& range) {	91	auto consumeQuery = [&](CSSParserTokenRange& range) {
92	if constexpr (std::is_same_v<CQ::ContainerCondition, ConditionType>)	92	if constexpr (std::is_same_v<CQ::ContainerCondition, ConditionType>)
93	return consumeContainerQuery(range);	93	return consumeContainerQuery(range);
94	if constexpr (std::is_same_v<CQ::SizeCondition, ConditionType>) {	94	// Style query support would be here.
95	if (range.peek().type() != LeftParenthesisToken)
96	return std::optional<CQ::SizeQuery>();
97	auto blockRange = range.consumeBlock();
98	return consumeSizeQuery(blockRange);
99	}
100	};	95	};
101		96
102	if (range.peek().type() == IdentToken) {	97	if (range.peek().type() == IdentToken) {
Lines 148-179 std::optional<ConditionType> ContainerQueryParser::consumeCondition(CSSParserTok a/Source/WebCore/css/ContainerQueryParser.cpp_sec3
148	return condition;	143	return condition;
149	}	144	}
150		145
151	std::optional<CQ::SizeQuery> ContainerQueryParser::consumeSizeQuery(CSSParserTokenRange& range)	146	std::optional<CQ::SizeFeature> ContainerQueryParser::consumeSizeFeature(CSSParserTokenRange& range)
152	{	147	{
153	if (range.peek().type() == LeftParenthesisToken \|\| (range.peek().type() == IdentToken && range.peek().id() == CSSValueNot)) {	148	auto consume = [&] {
154	auto sizeCondition = consumeCondition<CQ::SizeCondition>(range);	149	auto rangeCopy = range;
155	if (!sizeCondition)	150	if (auto sizeFeature = consumePlainSizeFeature(range))
156	return { };	151	return sizeFeature;
157	return { *sizeCondition };
158	}
159
160	auto sizeFeature = consumeSizeFeature(range);
161	if (!sizeFeature)
162	return { };
163
164	m_requiredAxes.add(CQ::requiredAxesForFeature(sizeFeature->name));
165		152
166	return { *sizeFeature };	153	range = rangeCopy;
167	}	154	return consumeRangeSizeFeature(range);
		155	};
168		156
169	std::optional<CQ::SizeFeature> ContainerQueryParser::consumeSizeFeature(CSSParserTokenRange& range)	157	auto sizeFeature = consume();
170	{	158	if (sizeFeature)
171	auto rangeCopy = range;	159	m_requiredAxes.add(CQ::requiredAxesForFeature(sizeFeature->name));
172	if (auto sizeFeature = consumePlainSizeFeature(range))
173	return sizeFeature;
174		160
175	range = rangeCopy;	161	return sizeFeature;
176	return consumeRangeSizeFeature(range);
177	}	162	}
178		163
179	static String consumeFeatureName(CSSParserTokenRange& range)	164	static String consumeFeatureName(CSSParserTokenRange& range)
Lines 206-211 std::optional<CQ::SizeFeature> ContainerQueryParser::consumePlainSizeFeature(CSS a/Source/WebCore/css/ContainerQueryParser.cpp_sec4
206	if (range.atEnd()) {	191	if (range.atEnd()) {
207	if (op != CQ::ComparisonOperator::Equal)	192	if (op != CQ::ComparisonOperator::Equal)
208	return { };	193	return { };
		194
209	return CQ::SizeFeature { featureName, CQ::Syntax::Boolean, { }, { } };	195	return CQ::SizeFeature { featureName, CQ::Syntax::Boolean, { }, { } };
210	}	196	}
211		197
Lines 217-223 std::optional<CQ::SizeFeature> ContainerQueryParser::consumePlainSizeFeature(CSS a/Source/WebCore/css/ContainerQueryParser.cpp_sec5
217	return { };	203	return { };
218		204
219	auto value = consumeValue(range);	205	auto value = consumeValue(range);
220		206
221	return CQ::SizeFeature { featureName, CQ::Syntax::Colon, { }, CQ::Comparison { op, WTFMove(value) } };	207	return CQ::SizeFeature { featureName, CQ::Syntax::Colon, { }, CQ::Comparison { op, WTFMove(value) } };
222	}	208	}
223		209

Lines 147-165 auto ContainerQueryEvaluator::evaluateQuery(const CQ::ContainerQuery& containerQ a/Source/WebCore/style/ContainerQueryEvaluator.cpp_sec1
- a/Source/WebCore/style/ContainerQueryEvaluator.cpp -11 / +2 lines
147	{	147	{
148	return WTF::switchOn(containerQuery, [&](const CQ::ContainerCondition& containerCondition) {	148	return WTF::switchOn(containerQuery, [&](const CQ::ContainerCondition& containerCondition) {
149	return evaluateCondition(containerCondition, container);	149	return evaluateCondition(containerCondition, container);
150	}, [&](const CQ::SizeQuery& sizeQuery) {
151	return evaluateQuery(sizeQuery, container);
152	}, [&](const CQ::UnknownQuery&) {
153	return EvaluationResult::Unknown;
154	});
155	}
156
157	auto ContainerQueryEvaluator::evaluateQuery(const CQ::SizeQuery& sizeQuery, const SelectedContainer& container) const -> EvaluationResult
158	{
159	return WTF::switchOn(sizeQuery, [&](const CQ::SizeCondition& sizeCondition) {
160	return evaluateCondition(sizeCondition, container);
161	}, [&](const CQ::SizeFeature& sizeFeature) {	150	}, [&](const CQ::SizeFeature& sizeFeature) {
162	return evaluateSizeFeature(sizeFeature, container);	151	return evaluateSizeFeature(sizeFeature, container);
		152	}, [&](const CQ::UnknownQuery&) {
		153	return EvaluationResult::Unknown;
163	});	154	});
164	}	155	}
165		156

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +25 lines
		1	2022-04-04 Antti Koivisto <antti@apple.com>
		2
		3	[CSS Container Queries] Simplify grammar
		4	https://bugs.webkit.org/show_bug.cgi?id=238732
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Because size() function syntax is no longer supported, separate SizeQuery and SizeCondition productions
		9	are no longer needed.
		10
		11	Some slightly unnecessary templatization is retained to help with future work.
		12
		13	* css/ContainerQuery.cpp:
		14	* css/ContainerQuery.h:
		15	* css/ContainerQueryParser.cpp:
		16	(WebCore::ContainerQueryParser::consumeContainerQuery):
		17	(WebCore::ContainerQueryParser::consumeCondition):
		18	(WebCore::ContainerQueryParser::consumeSizeFeature):
		19	(WebCore::ContainerQueryParser::consumePlainSizeFeature):
		20	(WebCore::ContainerQueryParser::consumeSizeQuery): Deleted.
		21	* css/ContainerQueryParser.h:
		22	* style/ContainerQueryEvaluator.cpp:
		23	(WebCore::Style::ContainerQueryEvaluator::evaluateQuery const):
		24	* style/ContainerQueryEvaluator.h:
		25
1	2022-03-30 Andres Gonzalez <andresg_22@apple.com>	26	2022-03-30 Andres Gonzalez <andresg_22@apple.com>
2		27
3	Split streaming of AX trees from the class AXLogger.	28	Split streaming of AX trees from the class AXLogger.

Lines 44-51 struct UnknownQuery { a/Source/WebCore/css/ContainerQuery.h_sec1
- a/Source/WebCore/css/ContainerQuery.h -7 / +1 lines
44	String text;	44	String text;
45	};	45	};
46		46
47	using SizeQuery = std::variant<SizeCondition, SizeFeature>;	47	using ContainerQuery = std::variant<ContainerCondition, SizeFeature, UnknownQuery>;
48	using ContainerQuery = std::variant<ContainerCondition, SizeQuery, UnknownQuery>;
49		48
50	enum class LogicalOperator : uint8_t { And, Or, Not };	49	enum class LogicalOperator : uint8_t { And, Or, Not };
51	enum class ComparisonOperator : uint8_t { LessThan, LessThanOrEqual, Equal, GreaterThan, GreaterThanOrEqual };	50	enum class ComparisonOperator : uint8_t { LessThan, LessThanOrEqual, Equal, GreaterThan, GreaterThanOrEqual };
Lines 56-66 struct ContainerCondition { a/Source/WebCore/css/ContainerQuery.h_sec2
56	Vector<ContainerQuery> queries;	55	Vector<ContainerQuery> queries;
57	};	56	};
58		57
59	struct SizeCondition {
60	LogicalOperator logicalOperator { LogicalOperator::And };
61	Vector<SizeQuery> queries;
62	};
63
64	struct Comparison {	58	struct Comparison {
65	ComparisonOperator op { ComparisonOperator::Equal };	59	ComparisonOperator op { ComparisonOperator::Equal };
66	RefPtr<CSSValue> value;	60	RefPtr<CSSValue> value;