fix #2936: compare url() tokens by import record

evanw · evanw · commit 47e54feebaef · 2023-02-20T00:25:24.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,26 @@
 # Changelog
 
+## Unreleased
+
+* Fix cross-file CSS rule deduplication involving `url()` tokens ([#2936](https://github.com/evanw/esbuild/issues/2936))
+
+    Previously cross-file CSS rule deduplication didn't handle `url()` tokens correctly. These tokens contain references to import paths which may be internal (i.e. in the bundle) or external (i.e. not in the bundle). When comparing two `url()` tokens for equality, the underlying import paths should be compared instead of their references. This release of esbuild fixes `url()` token comparisons. One side effect is that `@font-face` rules should now be deduplicated correctly across files:
+
+    ```css
+    /* Original code */
+    @import "data:text/css, \
+      @import 'http://example.com/style.css'; \
+      @font-face { src: url(http://example.com/font.ttf) }";
+    @import "data:text/css, \
+      @font-face { src: url(http://example.com/font.ttf) }";
+
+    /* Old output (with --bundle --minify) */
+    @import"http://example.com/style.css";@font-face{src:url(http://example.com/font.ttf)}@font-face{src:url(http://example.com/font.ttf)}
+
+    /* New output (with --bundle --minify) */
+    @import"http://example.com/style.css";@font-face{src:url(http://example.com/font.ttf)}
+    ```
+
 ## 0.17.9
 
 * Parse rest bindings in TypeScript types ([#2937](https://github.com/evanw/esbuild/issues/2937))
diff --git a/internal/bundler_tests/bundler_css_test.go b/internal/bundler_tests/bundler_css_test.go
@@ -775,6 +775,11 @@ func TestDeduplicateRules(t *testing.T) {
 			"/across-files-0.css": "a { color: red; color: red }",
 			"/across-files-1.css": "a { color: green }",
 			"/across-files-2.css": "a { color: red }",
+
+			"/across-files-url.css":   "@import 'across-files-url-0.css'; @import 'across-files-url-1.css'; @import 'across-files-url-2.css';",
+			"/across-files-url-0.css": "@import 'http://example.com/some.css'; @font-face { src: url(http://example.com/some.font); }",
+			"/across-files-url-1.css": "@font-face { src: url(http://example.com/some.other.font); }",
+			"/across-files-url-2.css": "@font-face { src: url(http://example.com/some.font); }",
 		},
 		entryPaths: []string{
 			"/yes0.css",
@@ -790,6 +795,7 @@ func TestDeduplicateRules(t *testing.T) {
 			"/no6.css",
 
 			"/across-files.css",
+			"/across-files-url.css",
 		},
 		options: config.Options{
 			Mode:         config.ModeBundle,
diff --git a/internal/bundler_tests/snapshots/snapshots_css.txt b/internal/bundler_tests/snapshots/snapshots_css.txt
@@ -327,6 +327,23 @@ a {
 
 /* across-files.css */
 
+---------- /out/across-files-url.css ----------
+@import "http://example.com/some.css";
+
+/* across-files-url-0.css */
+
+/* across-files-url-1.css */
+@font-face {
+  src: url(http://example.com/some.other.font);
+}
+
+/* across-files-url-2.css */
+@font-face {
+  src: url(http://example.com/some.font);
+}
+
+/* across-files-url.css */
+
 ================================================================================
 TestExternalImportURLInCSS
 ---------- /out/entry.css ----------
diff --git a/internal/css_ast/css_ast.go b/internal/css_ast/css_ast.go
@@ -79,26 +79,55 @@ const (
 	WhitespaceAfter
 )
 
-func (a Token) Equal(b Token) bool {
-	if a.Kind == b.Kind && a.Text == b.Text && a.ImportRecordIndex == b.ImportRecordIndex && a.Whitespace == b.Whitespace {
+// This is necessary when comparing tokens between two different files
+type CrossFileEqualityCheck struct {
+	ImportRecordsA []ast.ImportRecord
+	ImportRecordsB []ast.ImportRecord
+}
+
+func (a Token) Equal(b Token, check *CrossFileEqualityCheck) bool {
+	if a.Kind == b.Kind && a.Text == b.Text && a.Whitespace == b.Whitespace {
+		// URLs should be compared based on the text of the associated import record
+		// (which is what will actually be printed) instead of the original text
+		if a.Kind == css_lexer.TURL {
+			if check == nil {
+				// If both tokens are in the same file, just compare the index
+				if a.ImportRecordIndex != b.ImportRecordIndex {
+					return false
+				}
+			} else {
+				// If the tokens come from separate files, compare the import records
+				// themselves instead of comparing the indices. This can happen when
+				// the linker runs a "DuplicateRuleRemover" during bundling. This
+				// doesn't compare the source indices because at this point during
+				// linking, paths inside the bundle (e.g. due to the "copy" loader)
+				// should have already been converted into text (e.g. the "unique key"
+				// string).
+				if check.ImportRecordsA[a.ImportRecordIndex].Path.Text !=
+					check.ImportRecordsB[b.ImportRecordIndex].Path.Text {
+					return false
+				}
+			}
+		}
+
 		if a.Children == nil && b.Children == nil {
 			return true
 		}
 
-		if a.Children != nil && b.Children != nil && TokensEqual(*a.Children, *b.Children) {
+		if a.Children != nil && b.Children != nil && TokensEqual(*a.Children, *b.Children, check) {
 			return true
 		}
 	}
 
 	return false
 }
 
-func TokensEqual(a []Token, b []Token) bool {
+func TokensEqual(a []Token, b []Token, check *CrossFileEqualityCheck) bool {
 	if len(a) != len(b) {
 		return false
 	}
-	for i, c := range a {
-		if !c.Equal(b[i]) {
+	for i, ai := range a {
+		if !ai.Equal(b[i], check) {
 			return false
 		}
 	}
@@ -110,7 +139,9 @@ func HashTokens(hash uint32, tokens []Token) uint32 {
 
 	for _, t := range tokens {
 		hash = helpers.HashCombine(hash, uint32(t.Kind))
-		hash = helpers.HashCombineString(hash, t.Text)
+		if t.Kind != css_lexer.TURL {
+			hash = helpers.HashCombineString(hash, t.Text)
+		}
 		if t.Children != nil {
 			hash = HashTokens(hash, *t.Children)
 		}
@@ -262,16 +293,16 @@ type Rule struct {
 }
 
 type R interface {
-	Equal(rule R) bool
+	Equal(rule R, check *CrossFileEqualityCheck) bool
 	Hash() (uint32, bool)
 }
 
-func RulesEqual(a []Rule, b []Rule) bool {
+func RulesEqual(a []Rule, b []Rule, check *CrossFileEqualityCheck) bool {
 	if len(a) != len(b) {
 		return false
 	}
-	for i, c := range a {
-		if !c.Data.Equal(b[i].Data) {
+	for i, ai := range a {
+		if !ai.Data.Equal(b[i].Data, check) {
 			return false
 		}
 	}
@@ -294,7 +325,7 @@ type RAtCharset struct {
 	Encoding string
 }
 
-func (a *RAtCharset) Equal(rule R) bool {
+func (a *RAtCharset) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RAtCharset)
 	return ok && a.Encoding == b.Encoding
 }
@@ -310,7 +341,7 @@ type RAtImport struct {
 	ImportRecordIndex uint32
 }
 
-func (*RAtImport) Equal(rule R) bool {
+func (*RAtImport) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	return false
 }
 
@@ -329,7 +360,7 @@ type KeyframeBlock struct {
 	Rules     []Rule
 }
 
-func (a *RAtKeyframes) Equal(rule R) bool {
+func (a *RAtKeyframes) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	if b, ok := rule.(*RAtKeyframes); ok && a.AtToken == b.AtToken && a.Name == b.Name && len(a.Blocks) == len(b.Blocks) {
 		for i, ai := range a.Blocks {
 			bi := b.Blocks[i]
@@ -341,7 +372,7 @@ func (a *RAtKeyframes) Equal(rule R) bool {
 					return false
 				}
 			}
-			if !RulesEqual(ai.Rules, bi.Rules) {
+			if !RulesEqual(ai.Rules, bi.Rules, check) {
 				return false
 			}
 		}
@@ -371,9 +402,9 @@ type RKnownAt struct {
 	Rules   []Rule
 }
 
-func (a *RKnownAt) Equal(rule R) bool {
+func (a *RKnownAt) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RKnownAt)
-	return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude) && RulesEqual(a.Rules, b.Rules)
+	return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude, check) && RulesEqual(a.Rules, b.Rules, check)
 }
 
 func (r *RKnownAt) Hash() (uint32, bool) {
@@ -390,9 +421,9 @@ type RUnknownAt struct {
 	Block   []Token
 }
 
-func (a *RUnknownAt) Equal(rule R) bool {
+func (a *RUnknownAt) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RUnknownAt)
-	return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude) && TokensEqual(a.Block, b.Block)
+	return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude, check) && TokensEqual(a.Block, b.Block, check)
 }
 
 func (r *RUnknownAt) Hash() (uint32, bool) {
@@ -409,15 +440,15 @@ type RSelector struct {
 	HasAtNest bool
 }
 
-func (a *RSelector) Equal(rule R) bool {
+func (a *RSelector) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RSelector)
 	if ok && len(a.Selectors) == len(b.Selectors) && a.HasAtNest == b.HasAtNest {
-		for i, sel := range a.Selectors {
-			if !sel.Equal(b.Selectors[i]) {
+		for i, ai := range a.Selectors {
+			if !ai.Equal(b.Selectors[i], check) {
 				return false
 			}
 		}
-		return RulesEqual(a.Rules, b.Rules)
+		return RulesEqual(a.Rules, b.Rules, check)
 	}
 
 	return false
@@ -450,9 +481,9 @@ type RQualified struct {
 	Rules   []Rule
 }
 
-func (a *RQualified) Equal(rule R) bool {
+func (a *RQualified) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RQualified)
-	return ok && TokensEqual(a.Prelude, b.Prelude) && RulesEqual(a.Rules, b.Rules)
+	return ok && TokensEqual(a.Prelude, b.Prelude, check) && RulesEqual(a.Rules, b.Rules, check)
 }
 
 func (r *RQualified) Hash() (uint32, bool) {
@@ -470,9 +501,9 @@ type RDeclaration struct {
 	Important bool
 }
 
-func (a *RDeclaration) Equal(rule R) bool {
+func (a *RDeclaration) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RDeclaration)
-	return ok && a.KeyText == b.KeyText && TokensEqual(a.Value, b.Value) && a.Important == b.Important
+	return ok && a.KeyText == b.KeyText && TokensEqual(a.Value, b.Value, check) && a.Important == b.Important
 }
 
 func (r *RDeclaration) Hash() (uint32, bool) {
@@ -500,9 +531,9 @@ type RBadDeclaration struct {
 	Tokens []Token
 }
 
-func (a *RBadDeclaration) Equal(rule R) bool {
+func (a *RBadDeclaration) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RBadDeclaration)
-	return ok && TokensEqual(a.Tokens, b.Tokens)
+	return ok && TokensEqual(a.Tokens, b.Tokens, check)
 }
 
 func (r *RBadDeclaration) Hash() (uint32, bool) {
@@ -515,7 +546,7 @@ type RComment struct {
 	Text string
 }
 
-func (a *RComment) Equal(rule R) bool {
+func (a *RComment) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	b, ok := rule.(*RComment)
 	return ok && a.Text == b.Text
 }
@@ -531,7 +562,7 @@ type RAtLayer struct {
 	Rules []Rule
 }
 
-func (a *RAtLayer) Equal(rule R) bool {
+func (a *RAtLayer) Equal(rule R, check *CrossFileEqualityCheck) bool {
 	if b, ok := rule.(*RAtLayer); ok && len(a.Names) == len(b.Names) && len(a.Rules) == len(b.Rules) {
 		for i, ai := range a.Names {
 			bi := b.Names[i]
@@ -544,7 +575,7 @@ func (a *RAtLayer) Equal(rule R) bool {
 				}
 			}
 		}
-		if !RulesEqual(a.Rules, b.Rules) {
+		if !RulesEqual(a.Rules, b.Rules, check) {
 			return false
 		}
 	}
@@ -568,7 +599,7 @@ type ComplexSelector struct {
 	Selectors []CompoundSelector
 }
 
-func (a ComplexSelector) Equal(b ComplexSelector) bool {
+func (a ComplexSelector) Equal(b ComplexSelector, check *CrossFileEqualityCheck) bool {
 	if len(a.Selectors) != len(b.Selectors) {
 		return false
 	}
@@ -589,7 +620,7 @@ func (a ComplexSelector) Equal(b ComplexSelector) bool {
 			return false
 		}
 		for j, aj := range ai.SubclassSelectors {
-			if !aj.Equal(bi.SubclassSelectors[j]) {
+			if !aj.Equal(bi.SubclassSelectors[j], check) {
 				return false
 			}
 		}
@@ -632,15 +663,15 @@ func (a NamespacedName) Equal(b NamespacedName) bool {
 }
 
 type SS interface {
-	Equal(ss SS) bool
+	Equal(ss SS, check *CrossFileEqualityCheck) bool
 	Hash() uint32
 }
 
 type SSHash struct {
 	Name string
 }
 
-func (a *SSHash) Equal(ss SS) bool {
+func (a *SSHash) Equal(ss SS, check *CrossFileEqualityCheck) bool {
 	b, ok := ss.(*SSHash)
 	return ok && a.Name == b.Name
 }
@@ -655,7 +686,7 @@ type SSClass struct {
 	Name string
 }
 
-func (a *SSClass) Equal(ss SS) bool {
+func (a *SSClass) Equal(ss SS, check *CrossFileEqualityCheck) bool {
 	b, ok := ss.(*SSClass)
 	return ok && a.Name == b.Name
 }
@@ -673,7 +704,7 @@ type SSAttribute struct {
 	MatcherModifier byte // Either 0 or one of: 'i' 'I' 's' 'S'
 }
 
-func (a *SSAttribute) Equal(ss SS) bool {
+func (a *SSAttribute) Equal(ss SS, check *CrossFileEqualityCheck) bool {
 	b, ok := ss.(*SSAttribute)
 	return ok && a.NamespacedName.Equal(b.NamespacedName) && a.MatcherOp == b.MatcherOp &&
 		a.MatcherValue == b.MatcherValue && a.MatcherModifier == b.MatcherModifier
@@ -693,9 +724,9 @@ type SSPseudoClass struct {
 	IsElement bool // If true, this is prefixed by "::" instead of ":"
 }
 
-func (a *SSPseudoClass) Equal(ss SS) bool {
+func (a *SSPseudoClass) Equal(ss SS, check *CrossFileEqualityCheck) bool {
 	b, ok := ss.(*SSPseudoClass)
-	return ok && a.Name == b.Name && TokensEqual(a.Args, b.Args) && a.IsElement == b.IsElement
+	return ok && a.Name == b.Name && TokensEqual(a.Args, b.Args, check) && a.IsElement == b.IsElement
 }
 
 func (ss *SSPseudoClass) Hash() uint32 {
diff --git a/internal/css_parser/css_parser.go b/internal/css_parser/css_parser.go
diff --git a/internal/linker/linker.go b/internal/linker/linker.go

Original file line number	Diff line number	Diff line change
`@@ -79,26 +79,55 @@ const (`
`79`	`79`	`WhitespaceAfter`
`80`	`80`	`)`
`81`	`81`
`82`		`-func (a Token) Equal(b Token) bool {`
`83`		`- if a.Kind == b.Kind && a.Text == b.Text && a.ImportRecordIndex == b.ImportRecordIndex && a.Whitespace == b.Whitespace {`
	`82`	`+// This is necessary when comparing tokens between two different files`
	`83`	`+type CrossFileEqualityCheck struct {`
	`84`	`+ ImportRecordsA []ast.ImportRecord`
	`85`	`+ ImportRecordsB []ast.ImportRecord`
	`86`	`+}`
	`87`	`+`
	`88`	`+func (a Token) Equal(b Token, check *CrossFileEqualityCheck) bool {`
	`89`	`+ if a.Kind == b.Kind && a.Text == b.Text && a.Whitespace == b.Whitespace {`
	`90`	`+ // URLs should be compared based on the text of the associated import record`
	`91`	`+ // (which is what will actually be printed) instead of the original text`
	`92`	`+ if a.Kind == css_lexer.TURL {`
	`93`	`+ if check == nil {`
	`94`	`+ // If both tokens are in the same file, just compare the index`
	`95`	`+ if a.ImportRecordIndex != b.ImportRecordIndex {`
	`96`	`+ return false`
	`97`	`+ }`
	`98`	`+ } else {`
	`99`	`+ // If the tokens come from separate files, compare the import records`
	`100`	`+ // themselves instead of comparing the indices. This can happen when`
	`101`	`+ // the linker runs a "DuplicateRuleRemover" during bundling. This`
	`102`	`+ // doesn't compare the source indices because at this point during`
	`103`	`+ // linking, paths inside the bundle (e.g. due to the "copy" loader)`
	`104`	`+ // should have already been converted into text (e.g. the "unique key"`
	`105`	`+ // string).`
	`106`	`+ if check.ImportRecordsA[a.ImportRecordIndex].Path.Text !=`
	`107`	`+ check.ImportRecordsB[b.ImportRecordIndex].Path.Text {`
	`108`	`+ return false`
	`109`	`+ }`
	`110`	`+ }`
	`111`	`+ }`
	`112`	`+`
`84`	`113`	`if a.Children == nil && b.Children == nil {`
`85`	`114`	`return true`
`86`	`115`	`}`
`87`	`116`
`88`		`- if a.Children != nil && b.Children != nil && TokensEqual(a.Children, b.Children) {`
	`117`	`+ if a.Children != nil && b.Children != nil && TokensEqual(a.Children, b.Children, check) {`
`89`	`118`	`return true`
`90`	`119`	`}`
`91`	`120`	`}`
`92`	`121`
`93`	`122`	`return false`
`94`	`123`	`}`
`95`	`124`
`96`		`-func TokensEqual(a []Token, b []Token) bool {`
	`125`	`+func TokensEqual(a []Token, b []Token, check *CrossFileEqualityCheck) bool {`
`97`	`126`	`if len(a) != len(b) {`
`98`	`127`	`return false`
`99`	`128`	`}`
`100`		`- for i, c := range a {`
`101`		`- if !c.Equal(b[i]) {`
	`129`	`+ for i, ai := range a {`
	`130`	`+ if !ai.Equal(b[i], check) {`
`102`	`131`	`return false`
`103`	`132`	`}`
`104`	`133`	`}`
`@@ -110,7 +139,9 @@ func HashTokens(hash uint32, tokens []Token) uint32 {`
`110`	`139`
`111`	`140`	`for _, t := range tokens {`
`112`	`141`	`hash = helpers.HashCombine(hash, uint32(t.Kind))`
`113`		`- hash = helpers.HashCombineString(hash, t.Text)`
	`142`	`+ if t.Kind != css_lexer.TURL {`
	`143`	`+ hash = helpers.HashCombineString(hash, t.Text)`
	`144`	`+ }`
`114`	`145`	`if t.Children != nil {`
`115`	`146`	`hash = HashTokens(hash, *t.Children)`
`116`	`147`	`}`
`@@ -262,16 +293,16 @@ type Rule struct {`
`262`	`293`	`}`
`263`	`294`
`264`	`295`	`type R interface {`
`265`		`- Equal(rule R) bool`
	`296`	`+ Equal(rule R, check *CrossFileEqualityCheck) bool`
`266`	`297`	`Hash() (uint32, bool)`
`267`	`298`	`}`
`268`	`299`
`269`		`-func RulesEqual(a []Rule, b []Rule) bool {`
	`300`	`+func RulesEqual(a []Rule, b []Rule, check *CrossFileEqualityCheck) bool {`
`270`	`301`	`if len(a) != len(b) {`
`271`	`302`	`return false`
`272`	`303`	`}`
`273`		`- for i, c := range a {`
`274`		`- if !c.Data.Equal(b[i].Data) {`
	`304`	`+ for i, ai := range a {`
	`305`	`+ if !ai.Data.Equal(b[i].Data, check) {`
`275`	`306`	`return false`
`276`	`307`	`}`
`277`	`308`	`}`
`@@ -294,7 +325,7 @@ type RAtCharset struct {`
`294`	`325`	`Encoding string`
`295`	`326`	`}`
`296`	`327`
`297`		`-func (a *RAtCharset) Equal(rule R) bool {`
	`328`	`+func (a RAtCharset) Equal(rule R, check CrossFileEqualityCheck) bool {`
`298`	`329`	`b, ok := rule.(*RAtCharset)`
`299`	`330`	`return ok && a.Encoding == b.Encoding`
`300`	`331`	`}`
`@@ -310,7 +341,7 @@ type RAtImport struct {`
`310`	`341`	`ImportRecordIndex uint32`
`311`	`342`	`}`
`312`	`343`
`313`		`-func (*RAtImport) Equal(rule R) bool {`
	`344`	`+func (RAtImport) Equal(rule R, check CrossFileEqualityCheck) bool {`
`314`	`345`	`return false`
`315`	`346`	`}`
`316`	`347`
`@@ -329,7 +360,7 @@ type KeyframeBlock struct {`
`329`	`360`	`Rules []Rule`
`330`	`361`	`}`
`331`	`362`
`332`		`-func (a *RAtKeyframes) Equal(rule R) bool {`
	`363`	`+func (a RAtKeyframes) Equal(rule R, check CrossFileEqualityCheck) bool {`
`333`	`364`	`if b, ok := rule.(*RAtKeyframes); ok && a.AtToken == b.AtToken && a.Name == b.Name && len(a.Blocks) == len(b.Blocks) {`
`334`	`365`	`for i, ai := range a.Blocks {`
`335`	`366`	`bi := b.Blocks[i]`
`@@ -341,7 +372,7 @@ func (a *RAtKeyframes) Equal(rule R) bool {`
`341`	`372`	`return false`
`342`	`373`	`}`
`343`	`374`	`}`
`344`		`- if !RulesEqual(ai.Rules, bi.Rules) {`
	`375`	`+ if !RulesEqual(ai.Rules, bi.Rules, check) {`
`345`	`376`	`return false`
`346`	`377`	`}`
`347`	`378`	`}`
`@@ -371,9 +402,9 @@ type RKnownAt struct {`
`371`	`402`	`Rules []Rule`
`372`	`403`	`}`
`373`	`404`
`374`		`-func (a *RKnownAt) Equal(rule R) bool {`
	`405`	`+func (a RKnownAt) Equal(rule R, check CrossFileEqualityCheck) bool {`
`375`	`406`	`b, ok := rule.(*RKnownAt)`
`376`		`- return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude) && RulesEqual(a.Rules, b.Rules)`
	`407`	`+ return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude, check) && RulesEqual(a.Rules, b.Rules, check)`
`377`	`408`	`}`
`378`	`409`
`379`	`410`	`func (r *RKnownAt) Hash() (uint32, bool) {`
`@@ -390,9 +421,9 @@ type RUnknownAt struct {`
`390`	`421`	`Block []Token`
`391`	`422`	`}`
`392`	`423`
`393`		`-func (a *RUnknownAt) Equal(rule R) bool {`
	`424`	`+func (a RUnknownAt) Equal(rule R, check CrossFileEqualityCheck) bool {`
`394`	`425`	`b, ok := rule.(*RUnknownAt)`
`395`		`- return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude) && TokensEqual(a.Block, b.Block)`
	`426`	`+ return ok && a.AtToken == b.AtToken && TokensEqual(a.Prelude, b.Prelude, check) && TokensEqual(a.Block, b.Block, check)`
`396`	`427`	`}`
`397`	`428`
`398`	`429`	`func (r *RUnknownAt) Hash() (uint32, bool) {`
`@@ -409,15 +440,15 @@ type RSelector struct {`
`409`	`440`	`HasAtNest bool`
`410`	`441`	`}`
`411`	`442`
`412`		`-func (a *RSelector) Equal(rule R) bool {`
	`443`	`+func (a RSelector) Equal(rule R, check CrossFileEqualityCheck) bool {`
`413`	`444`	`b, ok := rule.(*RSelector)`
`414`	`445`	`if ok && len(a.Selectors) == len(b.Selectors) && a.HasAtNest == b.HasAtNest {`
`415`		`- for i, sel := range a.Selectors {`
`416`		`- if !sel.Equal(b.Selectors[i]) {`
	`446`	`+ for i, ai := range a.Selectors {`
	`447`	`+ if !ai.Equal(b.Selectors[i], check) {`
`417`	`448`	`return false`
`418`	`449`	`}`
`419`	`450`	`}`
`420`		`- return RulesEqual(a.Rules, b.Rules)`
	`451`	`+ return RulesEqual(a.Rules, b.Rules, check)`
`421`	`452`	`}`
`422`	`453`
`423`	`454`	`return false`
`@@ -450,9 +481,9 @@ type RQualified struct {`
`450`	`481`	`Rules []Rule`
`451`	`482`	`}`
`452`	`483`
`453`		`-func (a *RQualified) Equal(rule R) bool {`
	`484`	`+func (a RQualified) Equal(rule R, check CrossFileEqualityCheck) bool {`
`454`	`485`	`b, ok := rule.(*RQualified)`
`455`		`- return ok && TokensEqual(a.Prelude, b.Prelude) && RulesEqual(a.Rules, b.Rules)`
	`486`	`+ return ok && TokensEqual(a.Prelude, b.Prelude, check) && RulesEqual(a.Rules, b.Rules, check)`
`456`	`487`	`}`
`457`	`488`
`458`	`489`	`func (r *RQualified) Hash() (uint32, bool) {`
`@@ -470,9 +501,9 @@ type RDeclaration struct {`
`470`	`501`	`Important bool`
`471`	`502`	`}`
`472`	`503`
`473`		`-func (a *RDeclaration) Equal(rule R) bool {`
	`504`	`+func (a RDeclaration) Equal(rule R, check CrossFileEqualityCheck) bool {`
`474`	`505`	`b, ok := rule.(*RDeclaration)`
`475`		`- return ok && a.KeyText == b.KeyText && TokensEqual(a.Value, b.Value) && a.Important == b.Important`
	`506`	`+ return ok && a.KeyText == b.KeyText && TokensEqual(a.Value, b.Value, check) && a.Important == b.Important`
`476`	`507`	`}`
`477`	`508`
`478`	`509`	`func (r *RDeclaration) Hash() (uint32, bool) {`
`@@ -500,9 +531,9 @@ type RBadDeclaration struct {`
`500`	`531`	`Tokens []Token`
`501`	`532`	`}`
`502`	`533`
`503`		`-func (a *RBadDeclaration) Equal(rule R) bool {`
	`534`	`+func (a RBadDeclaration) Equal(rule R, check CrossFileEqualityCheck) bool {`
`504`	`535`	`b, ok := rule.(*RBadDeclaration)`
`505`		`- return ok && TokensEqual(a.Tokens, b.Tokens)`
	`536`	`+ return ok && TokensEqual(a.Tokens, b.Tokens, check)`
`506`	`537`	`}`
`507`	`538`
`508`	`539`	`func (r *RBadDeclaration) Hash() (uint32, bool) {`
`@@ -515,7 +546,7 @@ type RComment struct {`
`515`	`546`	`Text string`
`516`	`547`	`}`
`517`	`548`
`518`		`-func (a *RComment) Equal(rule R) bool {`
	`549`	`+func (a RComment) Equal(rule R, check CrossFileEqualityCheck) bool {`
`519`	`550`	`b, ok := rule.(*RComment)`
`520`	`551`	`return ok && a.Text == b.Text`
`521`	`552`	`}`
`@@ -531,7 +562,7 @@ type RAtLayer struct {`
`531`	`562`	`Rules []Rule`
`532`	`563`	`}`
`533`	`564`
`534`		`-func (a *RAtLayer) Equal(rule R) bool {`
	`565`	`+func (a RAtLayer) Equal(rule R, check CrossFileEqualityCheck) bool {`
`535`	`566`	`if b, ok := rule.(*RAtLayer); ok && len(a.Names) == len(b.Names) && len(a.Rules) == len(b.Rules) {`
`536`	`567`	`for i, ai := range a.Names {`
`537`	`568`	`bi := b.Names[i]`
`@@ -544,7 +575,7 @@ func (a *RAtLayer) Equal(rule R) bool {`
`544`	`575`	`}`
`545`	`576`	`}`
`546`	`577`	`}`
`547`		`- if !RulesEqual(a.Rules, b.Rules) {`
	`578`	`+ if !RulesEqual(a.Rules, b.Rules, check) {`
`548`	`579`	`return false`
`549`	`580`	`}`
`550`	`581`	`}`
`@@ -568,7 +599,7 @@ type ComplexSelector struct {`
`568`	`599`	`Selectors []CompoundSelector`
`569`	`600`	`}`
`570`	`601`
`571`		`-func (a ComplexSelector) Equal(b ComplexSelector) bool {`
	`602`	`+func (a ComplexSelector) Equal(b ComplexSelector, check *CrossFileEqualityCheck) bool {`
`572`	`603`	`if len(a.Selectors) != len(b.Selectors) {`
`573`	`604`	`return false`
`574`	`605`	`}`
`@@ -589,7 +620,7 @@ func (a ComplexSelector) Equal(b ComplexSelector) bool {`
`589`	`620`	`return false`
`590`	`621`	`}`
`591`	`622`	`for j, aj := range ai.SubclassSelectors {`
`592`		`- if !aj.Equal(bi.SubclassSelectors[j]) {`
	`623`	`+ if !aj.Equal(bi.SubclassSelectors[j], check) {`
`593`	`624`	`return false`
`594`	`625`	`}`
`595`	`626`	`}`
`@@ -632,15 +663,15 @@ func (a NamespacedName) Equal(b NamespacedName) bool {`
`632`	`663`	`}`
`633`	`664`
`634`	`665`	`type SS interface {`
`635`		`- Equal(ss SS) bool`
	`666`	`+ Equal(ss SS, check *CrossFileEqualityCheck) bool`
`636`	`667`	`Hash() uint32`
`637`	`668`	`}`
`638`	`669`
`639`	`670`	`type SSHash struct {`
`640`	`671`	`Name string`
`641`	`672`	`}`
`642`	`673`
`643`		`-func (a *SSHash) Equal(ss SS) bool {`
	`674`	`+func (a SSHash) Equal(ss SS, check CrossFileEqualityCheck) bool {`
`644`	`675`	`b, ok := ss.(*SSHash)`
`645`	`676`	`return ok && a.Name == b.Name`
`646`	`677`	`}`
`@@ -655,7 +686,7 @@ type SSClass struct {`
`655`	`686`	`Name string`
`656`	`687`	`}`
`657`	`688`
`658`		`-func (a *SSClass) Equal(ss SS) bool {`
	`689`	`+func (a SSClass) Equal(ss SS, check CrossFileEqualityCheck) bool {`
`659`	`690`	`b, ok := ss.(*SSClass)`
`660`	`691`	`return ok && a.Name == b.Name`
`661`	`692`	`}`
`@@ -673,7 +704,7 @@ type SSAttribute struct {`
`673`	`704`	`MatcherModifier byte // Either 0 or one of: 'i' 'I' 's' 'S'`
`674`	`705`	`}`
`675`	`706`
`676`		`-func (a *SSAttribute) Equal(ss SS) bool {`
	`707`	`+func (a SSAttribute) Equal(ss SS, check CrossFileEqualityCheck) bool {`
`677`	`708`	`b, ok := ss.(*SSAttribute)`
`678`	`709`	`return ok && a.NamespacedName.Equal(b.NamespacedName) && a.MatcherOp == b.MatcherOp &&`
`679`	`710`	`a.MatcherValue == b.MatcherValue && a.MatcherModifier == b.MatcherModifier`
`@@ -693,9 +724,9 @@ type SSPseudoClass struct {`
`693`	`724`	`IsElement bool // If true, this is prefixed by "::" instead of ":"`
`694`	`725`	`}`
`695`	`726`
`696`		`-func (a *SSPseudoClass) Equal(ss SS) bool {`
	`727`	`+func (a SSPseudoClass) Equal(ss SS, check CrossFileEqualityCheck) bool {`
`697`	`728`	`b, ok := ss.(*SSPseudoClass)`
`698`		`- return ok && a.Name == b.Name && TokensEqual(a.Args, b.Args) && a.IsElement == b.IsElement`
	`729`	`+ return ok && a.Name == b.Name && TokensEqual(a.Args, b.Args, check) && a.IsElement == b.IsElement`
`699`	`730`	`}`
`700`	`731`
`701`	`732`	`func (ss *SSPseudoClass) Hash() uint32 {`