[css-nesting] CSSNestedDeclarations inside @scope should resolve to :where(:scope)

https://bugs.webkit.org/show_bug.cgi?id=280544
rdar://136856371

Reviewed by NOBODY (OOPS!).

w3c/csswg-drafts#10431

This patch maintains a stack during rule set building to be able
to determine whether the closest ancestor rule is a style rule or a scope rule,
and to resolve the nesting parent selector & appropriately (:is(<parent>) or :where(:scope)).

* LayoutTests/imported/w3c/web-platform-tests/css/css-nesting/nested-declarations-matching-expected.txt:
* Source/WebCore/style/RuleSetBuilder.cpp:
(WebCore::Style::RuleSetBuilder::addChildRule):
(WebCore::Style::RuleSetBuilder::resolveSelectorListWithNesting):
(WebCore::Style::RuleSetBuilder::addStyleRule):
* Source/WebCore/style/RuleSetBuilder.h:

Author: mdubet

Diff for: LayoutTests/imported/w3c/web-platform-tests/css/css-nesting/nested-declarations-matching-expected.txt

@@ -9,7 +9,7 @@ PASS Nested declarations rule has top-level specificity behavior
 PASS Nested declarations rule has top-level specificity behavior (max matching)
 PASS Bare declartaion in nested grouping rule can match pseudo-element
 PASS Nested group rules have top-level specificity behavior
-FAIL Nested @scope rules behave like :where(:scope) assert_equals: expected "PASS" but got "FAIL"
-FAIL Nested @scope rules behave like :where(:scope) (trailing) assert_equals: expected "PASS" but got "FAIL"
+PASS Nested @scope rules behave like :where(:scope)
+PASS Nested @scope rules behave like :where(:scope) (trailing)
 PASS Nested declarations rule responds to parent selector text change
 

Diff for: Source/WebCore/style/RuleSetBuilder.cpp

@@ -39,11 +39,11 @@
 #include "Document.h"
 #include "DocumentInlines.h"
 #include "MediaQueryEvaluator.h"
+#include "MutableCSSSelector.h"
 #include "StyleResolver.h"
 #include "StyleRuleImport.h"
 #include "StyleScope.h"
 #include "StyleSheetContents.h"
-#include "css/CSSSelectorList.h"
 #include <wtf/CryptographicallyRandomNumber.h>
 
 namespace WebCore {
@@ -149,7 +149,9 @@ void RuleSetBuilder::addChildRule(Ref<StyleRuleBase> rule)
         // If <scope-start> is empty, it doesn't create a nesting context (the nesting selector might eventually be replaced by :scope)
         if (!scopeStart.isEmpty())
             m_selectorListStack.append(&scopeStart);
+        m_ancestorStack.append(CSSParserEnum::NestedContextType::Scope);
         addChildRules(scopeRule->childRules());
+        m_ancestorStack.removeLast();
         if (!scopeStart.isEmpty())
             m_selectorListStack.removeLast();
 
@@ -275,7 +277,7 @@ void RuleSetBuilder::resolveSelectorListWithNesting(StyleRuleWithNesting& rule)
 {
     const CSSSelectorList* parentResolvedSelectorList = nullptr;
     if (m_selectorListStack.size())
-        parentResolvedSelectorList =  m_selectorListStack.last();
+        parentResolvedSelectorList = m_selectorListStack.last();
 
     // If it's a top-level rule without a nesting parent selector, keep the selector list as is.
     if (!rule.originalSelectorList().hasExplicitNestingParent() && !parentResolvedSelectorList)
@@ -303,13 +305,15 @@ void RuleSetBuilder::addStyleRule(StyleRuleWithNesting& rule)
     if (m_shouldResolveNesting == ShouldResolveNesting::Yes)
         resolveSelectorListWithNesting(rule);
 
-    auto& selectorList = rule.selectorList();
+    const auto& selectorList = rule.selectorList();
     addStyleRuleWithSelectorList(selectorList, rule);
 
     // Process nested rules
     m_selectorListStack.append(&selectorList);
+    m_ancestorStack.append(CSSParserEnum::NestedContextType::Style);
     for (auto& nestedRule : rule.nestedRules())
         addChildRule(nestedRule);
+    m_ancestorStack.removeLast();
     m_selectorListStack.removeLast();
 }
 
@@ -320,8 +324,26 @@ void RuleSetBuilder::addStyleRule(const StyleRule& rule)
 
 void RuleSetBuilder::addStyleRule(StyleRuleNestedDeclarations& rule)
 {
-    ASSERT(m_selectorListStack.size());
-    auto selectorList =  *m_selectorListStack.last();
+    auto whereScopeSelector = [] {
+        auto scopeSelector = makeUnique<MutableCSSSelector>();
+        scopeSelector->setMatch(CSSSelector::Match::PseudoClass);
+        scopeSelector->setPseudoClass(CSSSelector::PseudoClass::Scope);
+        auto whereSelector = makeUnique<MutableCSSSelector>();
+        whereSelector->setMatch(CSSSelector::Match::PseudoClass);
+        whereSelector->setPseudoClass(CSSSelector::PseudoClass::Where);
+        whereSelector->setSelectorList(makeUnique<CSSSelectorList>(MutableCSSSelectorList::from(WTFMove(scopeSelector))));
+        return whereSelector;
+    };
+
+    auto selectorList = [&] {
+        ASSERT(m_selectorListStack.size());
+        ASSERT(m_ancestorStack.size());
+        if (m_ancestorStack.last() == CSSParserEnum::NestedContextType::Style)
+            return *m_selectorListStack.last();
+        ASSERT(m_ancestorStack.last() == CSSParserEnum::NestedContextType::Scope);
+        return CSSSelectorList { MutableCSSSelectorList::from(whereScopeSelector()) };
+    }();
+
     rule.wrapperAdoptSelectorList(WTFMove(selectorList));
     addStyleRuleWithSelectorList(rule.selectorList(), rule);
 }

Diff for: Source/WebCore/style/RuleSetBuilder.h

@@ -21,6 +21,7 @@
 
 #pragma once
 
+#include "CSSParserEnum.h"
 #include "MediaQuery.h"
 #include "RuleSet.h"
 
@@ -87,6 +88,7 @@ class RuleSetBuilder {
     HashMap<CascadeLayerName, RuleSet::CascadeLayerIdentifier> m_cascadeLayerIdentifierMap;
     RuleSet::CascadeLayerIdentifier m_currentCascadeLayerIdentifier { 0 };
     Vector<const CSSSelectorList*> m_selectorListStack;
+    Vector<CSSParserEnum::NestedContextType> m_ancestorStack;
     const ShouldResolveNesting m_shouldResolveNesting { ShouldResolveNesting::No };
 
     RuleSet::ContainerQueryIdentifier m_currentContainerQueryIdentifier { 0 };