diff --git a/pkgs/csslib/CHANGELOG.md b/pkgs/csslib/CHANGELOG.md index 3e557484b0..4b8874ccd9 100644 --- a/pkgs/csslib/CHANGELOG.md +++ b/pkgs/csslib/CHANGELOG.md @@ -14,6 +14,9 @@ - Serialize partial font styles without bogus family names, `nullpx` sizes or trailing spaces; preserve explicit line heights without font weight and keep the `px` unit on pixel line heights (a unitless value is a multiplier). +- Deep-clone selector groups, selector sequences, identifiers, functional + pseudo-selector arguments, and legacy pseudo-element flags instead of + sharing mutable AST nodes between the original and its clone. - Fix `Rgba.fromArgbValue`, `Rgba.argbValue` and `Hsla.color`, preserve alpha for grayscale colors in `Hsla.fromRgba`, and keep the exact 8-bit alpha in `Color.rgba`, `Color.hsla` and `Hsla.fromArgbValue` instead of rounding it to diff --git a/pkgs/csslib/lib/src/tree.dart b/pkgs/csslib/lib/src/tree.dart index 7fefbf4176..986ea2fcb3 100644 --- a/pkgs/csslib/lib/src/tree.dart +++ b/pkgs/csslib/lib/src/tree.dart @@ -103,7 +103,10 @@ class SelectorGroup extends TreeNode { SelectorGroup(this.selectors, SourceSpan? span) : super(span); @override - SelectorGroup clone() => SelectorGroup(selectors, span); + SelectorGroup clone() { + final cloned = selectors.map((selector) => selector.clone()).toList(); + return SelectorGroup(cloned, span); + } @override dynamic visit(VisitorBase visitor) => visitor.visitSelectorGroup(this); @@ -155,8 +158,10 @@ class SimpleSelectorSequence extends TreeNode { }; @override - SimpleSelectorSequence clone() => - SimpleSelectorSequence(simpleSelector, span, combinator); + SimpleSelectorSequence clone() { + final selector = simpleSelector.clone() as SimpleSelector; + return SimpleSelectorSequence(selector, span, combinator); + } @override dynamic visit(VisitorBase visitor) => @@ -192,7 +197,8 @@ class ElementSelector extends SimpleSelector { dynamic visit(VisitorBase visitor) => visitor.visitElementSelector(this); @override - ElementSelector clone() => ElementSelector(_name, span); + ElementSelector clone() => ElementSelector( + _name is TreeNode ? (_name as TreeNode).clone() : _name, span); @override String toString() => name; @@ -218,7 +224,7 @@ class NamespaceSelector extends SimpleSelector { @override NamespaceSelector clone() => NamespaceSelector( - _namespace, + _namespace is TreeNode ? (_namespace as TreeNode).clone() : _namespace, nameAsSimpleSelector?.clone() ?? ElementSelector(Identifier('', span), span), span); @@ -275,8 +281,11 @@ class AttributeSelector extends SimpleSelector { } @override - AttributeSelector clone() => - AttributeSelector(_name as Identifier, _op, value, span); + AttributeSelector clone() { + final copiedName = (_name as Identifier).clone(); + final copiedValue = value is TreeNode ? (value as TreeNode).clone() : value; + return AttributeSelector(copiedName, _op, copiedValue, span); + } @override dynamic visit(VisitorBase visitor) => visitor.visitAttributeSelector(this); @@ -289,7 +298,7 @@ class AttributeSelector extends SimpleSelector { class IdSelector extends SimpleSelector { IdSelector(Identifier super.name, super.span); @override - IdSelector clone() => IdSelector(_name as Identifier, span); + IdSelector clone() => IdSelector((_name as Identifier).clone(), span); @override dynamic visit(VisitorBase visitor) => visitor.visitIdSelector(this); @@ -301,7 +310,7 @@ class IdSelector extends SimpleSelector { class ClassSelector extends SimpleSelector { ClassSelector(Identifier super.name, super.span); @override - ClassSelector clone() => ClassSelector(_name as Identifier, span); + ClassSelector clone() => ClassSelector((_name as Identifier).clone(), span); @override dynamic visit(VisitorBase visitor) => visitor.visitClassSelector(this); @@ -316,7 +325,8 @@ class PseudoClassSelector extends SimpleSelector { dynamic visit(VisitorBase visitor) => visitor.visitPseudoClassSelector(this); @override - PseudoClassSelector clone() => PseudoClassSelector(_name as Identifier, span); + PseudoClassSelector clone() => + PseudoClassSelector((_name as Identifier).clone(), span); @override String toString() => ':$name'; @@ -334,8 +344,10 @@ class PseudoElementSelector extends SimpleSelector { visitor.visitPseudoElementSelector(this); @override - PseudoElementSelector clone() => - PseudoElementSelector(_name as Identifier, span); + PseudoElementSelector clone() { + final name = (_name as Identifier).clone(); + return PseudoElementSelector(name, span, isLegacy: isLegacy); + } @override String toString() => "${isLegacy ? ':' : '::'}$name"; @@ -349,8 +361,8 @@ class PseudoClassFunctionSelector extends PseudoClassSelector { : super(name, span); @override - PseudoClassFunctionSelector clone() => - PseudoClassFunctionSelector(_name as Identifier, argument, span); + PseudoClassFunctionSelector clone() => PseudoClassFunctionSelector( + (_name as Identifier).clone(), argument.clone(), span); Selector get selector => argument as Selector; SelectorExpression get expression => argument as SelectorExpression; @@ -369,8 +381,8 @@ class PseudoElementFunctionSelector extends PseudoElementSelector { : super(name, span); @override - PseudoElementFunctionSelector clone() => - PseudoElementFunctionSelector(_name as Identifier, expression, span); + PseudoElementFunctionSelector clone() => PseudoElementFunctionSelector( + (_name as Identifier).clone(), expression.clone(), span); @override dynamic visit(VisitorBase visitor) => @@ -401,7 +413,8 @@ class NegationSelector extends SimpleSelector { : super(Negation(span), span); @override - NegationSelector clone() => NegationSelector(negationArg, span); + NegationSelector clone() => + NegationSelector(negationArg?.clone() as SimpleSelector?, span); @override dynamic visit(VisitorBase visitor) => visitor.visitNegationSelector(this); diff --git a/pkgs/csslib/test/selector_clone_test.dart b/pkgs/csslib/test/selector_clone_test.dart new file mode 100644 index 0000000000..f261c6ff92 --- /dev/null +++ b/pkgs/csslib/test/selector_clone_test.dart @@ -0,0 +1,121 @@ +// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +import 'package:csslib/parser.dart'; +import 'package:csslib/visitor.dart'; +import 'package:source_span/source_span.dart'; +import 'package:test/test.dart'; + +void main() { + test('selector group clones isolate list and combinator changes', () { + final sheet = parse('div, span { color: red; }'); + final original = (sheet.topLevels.single as RuleSet).selectorGroup!; + final copy = original.clone(); + + expect(identical(original.selectors, copy.selectors), isFalse); + copy.selectors.removeLast(); + expect(original.selectors, hasLength(2)); + + final originalSequence = + original.selectors.first.simpleSelectorSequences.first; + final clonedSequence = copy.selectors.first.simpleSelectorSequences.first; + clonedSequence.combinator = TokenKind.COMBINATOR_GREATER; + expect(originalSequence.combinator, TokenKind.COMBINATOR_NONE); + }); + + test('selector names and attributes are not aliased', () { + final name = Identifier('original', null); + final original = ClassSelector(name, null); + final copy = original.clone(); + name.name = 'changed'; + expect(copy.name, 'original'); + + final attributeName = Identifier('title', null); + final attributeValue = Identifier('hello', null); + final attribute = AttributeSelector( + attributeName, + TokenKind.EQUALS, + attributeValue, + null, + ).clone(); + attributeName.name = 'other'; + attributeValue.name = 'world'; + expect(attribute.name, 'title'); + expect(attribute.valueToString(), 'hello'); + + final namespaceName = Identifier('svg', null); + final elementName = Identifier('rect', null); + final namespace = NamespaceSelector( + namespaceName, + ElementSelector(elementName, null), + null, + ).clone(); + namespaceName.name = 'other'; + elementName.name = 'circle'; + expect(namespace.toString(), 'svg|rect'); + }); + + test('legacy pseudo elements retain single-colon syntax when cloned', () { + final name = Identifier('before', null); + final original = PseudoElementSelector(name, null, isLegacy: true); + final copy = original.clone(); + name.name = 'after'; + expect(copy.isLegacy, isTrue); + expect(copy.toString(), ':before'); + }); + + test('functional pseudo-selector arguments are deeply cloned', () { + final innerName = Identifier('item', null); + final nested = Selector( + [SimpleSelectorSequence(ClassSelector(innerName, null), null)], + null, + ); + final original = + PseudoClassFunctionSelector(Identifier('host', null), nested, null); + final copy = original.clone(); + innerName.name = 'changed'; + final clonedArgument = copy.argument as Selector; + final firstSequence = clonedArgument.simpleSelectorSequences.single; + expect(firstSequence.simpleSelector.name, 'item'); + + final span = SourceFile.fromString('2').span(0, 1); + final expr = SelectorExpression([NumberTerm(2, '2', span)], span); + final pseudo = PseudoElementFunctionSelector( + Identifier('part', null), + expr, + null, + ).clone(); + expr.expressions.clear(); + expect(pseudo.expression.expressions, hasLength(1)); + }); + + test('negation argument is detached from original', () { + final name = Identifier('className', null); + final negative = NegationSelector(ClassSelector(name, null), null).clone(); + name.name = 'mutated'; + expect(negative.negationArg!.name, 'className'); + }); + + test('parsed style sheet clones print identically and share no names', () { + final sheet = parse('a:before, p::after, svg|rect, [lang|=he], ' + 'li:nth-child(2n+1):not(.x) > b ~ #i + u, :host(.a) { color: red; }'); + final copy = sheet.clone(); + + String printed(StyleSheet node) => + (CssPrinter()..visitTree(node, pretty: false)).toString(); + expect(printed(copy), printed(sheet)); + + final originalNames = (_IdentifierCollector()..visitTree(sheet)).names; + final clonedNames = (_IdentifierCollector()..visitTree(copy)).names; + expect(clonedNames, hasLength(originalNames.length)); + expect(clonedNames.where(originalNames.contains), isEmpty); + }); +} + +class _IdentifierCollector extends Visitor { + final names = Set.identity(); + + @override + void visitIdentifier(Identifier node) => names.add(node); +}