lib/fs: Add ASCII fastpath for normalization

lib/fs/folding.go

@@ -9,41 +9,75 @@ package fs
 import (
 	"strings"
 	"unicode"
-	"unicode/utf8"
 
 	"golang.org/x/text/unicode/norm"
 )
 
 // UnicodeLowercaseNormalized returns the Unicode lower case variant of s,
 // having also normalized it to normalization form C.
 func UnicodeLowercaseNormalized(s string) string {
-	i := firstCaseChange(s)
-	if i == -1 {
-		return norm.NFC.String(s)
+	if isASCII, isLower := isASCII(s); isASCII {
+		if isLower {
+			return s
+		}
+		return toLowerASCII(s)
 	}
 
-	var rs strings.Builder
-	// WriteRune always reserves utf8.UTFMax bytes for non-ASCII runes,
-	// even if it doesn't need all that space. Overallocate now to prevent
-	// it from ever triggering a reallocation.
-	rs.Grow(utf8.UTFMax - 1 + len(s))
-	rs.WriteString(s[:i])
+	return toLowerUnicode(s)
+}
 
-	for _, r := range s[i:] {
-		rs.WriteRune(unicode.ToLower(unicode.ToUpper(r)))
+func isASCII(s string) (bool, bool) {
+	isLower := true
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c > unicode.MaxASCII {
+			return false, isLower
+		}
+		if 'A' <= c && c <= 'Z' {
+			isLower = false
+		}
 	}
-	return norm.NFC.String(rs.String())
+	return true, isLower
 }
 
-// Byte index of the first rune r s.t. lower(upper(r)) != r.
-func firstCaseChange(s string) int {
-	for i, r := range s {
-		if r <= unicode.MaxASCII && (r < 'A' || r > 'Z') {
+func toLowerASCII(s string) string {
+	var (
+		b   strings.Builder
+		pos int
+	)
+	b.Grow(len(s))
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c < 'A' || 'Z' < c {
 			continue
 		}
-		if unicode.ToLower(unicode.ToUpper(r)) != r {
-			return i
+		if pos < i {
+			b.WriteString(s[pos:i])
+		}
+		pos = i + 1
+		c += 'a' - 'A'
+		b.WriteByte(c)
+	}
+	if pos != len(s) {
+		b.WriteString(s[pos:])
+	}
+	return b.String()
+}
+
+func toLowerUnicode(s string) string {
+	s = strings.Map(toLower, s)
+	return norm.NFC.String(s)
+}
+
+func toLower(r rune) rune {
+	if r <= unicode.MaxASCII {
+		if r < 'A' || 'Z' < r {
+			return r
 		}
+		return r + 'a' - 'A'
+	}
+	if r <= unicode.MaxLatin1 && r != 'µ' {
+		return unicode.To(unicode.LowerCase, r)
 	}
-	return -1
+	return unicode.To(unicode.LowerCase, unicode.To(unicode.UpperCase, r))
 }

lib/fs/folding_test.go

@@ -49,6 +49,18 @@ var caseCases = [][2]string{
 	{"a\xCC\x88", "\xC3\xA4"}, // ä
 }
 
+var benchmarkCases = [][2]string{
+	{"img_202401241010.jpg", "ASCII lowercase"},
+	{"IMG_202401241010.jpg", "ASCII mixedcase start"},
+	{"img_202401241010.JPG", "ASCII mixedcase end"},
+	{"wir_kinder_aus_bullerbü.epub", "Latin1 lowercase"},
+	{"Wir_Kinder_aus_Bullerbü.epub", "Latin1 mixedcase start"},
+	{"wir_kinder_aus_bullerbü.EPUB", "Latin1 mixedcase end"},
+	{"translated_ウェブの国際化.html", "Unicode lowercase"},
+	{"Translated_ウェブの国際化.html", "Unicode mixedcase start"},
+	{"translated_ウェブの国際化.HTML", "Unicode mixedcase end"},
+}
+
 func TestUnicodeLowercaseNormalized(t *testing.T) {
 	for _, tc := range caseCases {
 		res := UnicodeLowercaseNormalized(tc[0])
@@ -58,22 +70,13 @@ func TestUnicodeLowercaseNormalized(t *testing.T) {
 	}
 }
 
-func BenchmarkUnicodeLowercaseMaybeChange(b *testing.B) {
-	b.ReportAllocs()
-
-	for i := 0; i < b.N; i++ {
-		for _, s := range caseCases {
-			UnicodeLowercaseNormalized(s[0])
-		}
-	}
-}
-
-func BenchmarkUnicodeLowercaseNoChange(b *testing.B) {
-	b.ReportAllocs()
-
-	for i := 0; i < b.N; i++ {
-		for _, s := range caseCases {
-			UnicodeLowercaseNormalized(s[1])
-		}
+func BenchmarkUnicodeLowercase(b *testing.B) {
+	for _, c := range benchmarkCases {
+		b.Run(c[1], func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				UnicodeLowercaseNormalized(c[0])
+			}
+		})
 	}
 }