Fix no-descending-specificity false positives for pseudo-classes

lib/rules/no-descending-specificity/__tests__/index.js

@@ -94,6 +94,12 @@ testRule({
 		{
 			code: ':where(a :is(b, i)) {} :where(a) {}',
 		},
+		{
+			code: 'a b :global(.foo) {} a :global(.bar) {}',
+		},
+		{
+			code: ':global(.foo) {} :global { .bar {} }',
+		},
 	],
 
 	reject: [

lib/rules/no-descending-specificity/index.js

@@ -25,6 +25,8 @@ const meta = {
 	url: 'https://stylelint.io/user-guide/rules/list/no-descending-specificity',
 };
 
+/** @typedef {{ selector: string, specificity: import('@csstools/selector-specificity').Specificity }} Entry */
+
 /** @type {import('stylelint').Rule} */
 const rule = (primary, secondaryOptions) => {
 	return (root, result) => {
@@ -63,6 +65,7 @@ const rule = (primary, secondaryOptions) => {
 				return;
 			}
 
+			/** @type {Map<string, Entry[]>} */
 			const comparisonContext = selectorContextLookup.getContext(
 				ruleNode,
 				findAtRuleContext(ruleNode),
@@ -92,23 +95,24 @@ const rule = (primary, secondaryOptions) => {
 		/**
 		 * @param {import('postcss-selector-parser').Root} selectorNode
 		 * @param {import('postcss').Rule} ruleNode
-		 * @param {Map<any, any>} comparisonContext
+		 * @param {Map<string, Entry[]>} comparisonContext
 		 */
 		function checkSelector(selectorNode, ruleNode, comparisonContext) {
 			const selector = selectorNode.toString();
-			const referenceSelectorNode = lastCompoundSelectorWithoutPseudoClasses(selectorNode);
+			const referenceSelector = lastCompoundSelectorWithoutPseudoClasses(selectorNode);
+
+			if (referenceSelector === undefined) return;
+
 			const selectorSpecificity = calculate(selectorNode);
 			const entry = { selector, specificity: selectorSpecificity };
+			const priorComparableSelectors = comparisonContext.get(referenceSelector);
 
-			if (!comparisonContext.has(referenceSelectorNode)) {
-				comparisonContext.set(referenceSelectorNode, [entry]);
+			if (priorComparableSelectors === undefined) {
+				comparisonContext.set(referenceSelector, [entry]);
 
 				return;
 			}
 
-			/** @type {Array<typeof entry>} */
-			const priorComparableSelectors = comparisonContext.get(referenceSelectorNode);
-
 			for (const priorEntry of priorComparableSelectors) {
 				if (compare(selectorSpecificity, priorEntry.specificity) < 0) {
 					report({
@@ -128,6 +132,7 @@ const rule = (primary, secondaryOptions) => {
 
 /**
  * @param {import('postcss-selector-parser').Root} selectorNode
+ * @returns {string | undefined}
  */
 function lastCompoundSelectorWithoutPseudoClasses(selectorNode) {
 	const firstChild = selectorNode.nodes[0];
@@ -137,17 +142,27 @@ function lastCompoundSelectorWithoutPseudoClasses(selectorNode) {
 	const nodesAfterLastCombinator = nodesByCombinator[nodesByCombinator.length - 1];
 
 	assert(nodesAfterLastCombinator);
-	const nodesWithoutPseudoClasses = nodesAfterLastCombinator
-		.filter((node) => {
-			return (
-				node.type !== 'pseudo' ||
-				node.value.startsWith('::') ||
-				pseudoElements.has(node.value.replace(/:/g, ''))
-			);
-		})
-		.join('');
 
-	return nodesWithoutPseudoClasses.toString();
+	const nodesWithoutPseudoClasses = nodesAfterLastCombinator.filter((node) => {
+		return (
+			isCssModulesGlobal(node) ||
+			node.type !== 'pseudo' ||
+			node.value.startsWith('::') ||
+			pseudoElements.has(node.value.replace(/:/g, ''))
+		);
+	});
+
+	if (nodesWithoutPseudoClasses.length === 0) return undefined;
+
+	return nodesWithoutPseudoClasses.join('');
+}
+
+/**
+ * @param {import('postcss-selector-parser').Node} node
+ * @returns {boolean}
+ */
+function isCssModulesGlobal(node) {
+	return node.type === 'pseudo' && node.value === ':global';
 }
 
 rule.ruleName = ruleName;