From 31581ffdbb5c6116fa978ea1ce2032a087a31b1a Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 30 Aug 2026 15:21:05 +0200 Subject: [PATCH] Implement full Unicode case mapping and options for String case methods MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit String#upcase/#downcase/#swapcase/#capitalize (and their bang variants and the matching Symbol methods) previously delegated to Go's simple, single-rune case mapping and ignored their option arguments. This diverged from MRI in several ways: - Full Unicode case mapping was not applied, so multi-character expansions were missing: "ß".upcase gave "ß" instead of "SS", "ß".capitalize gave "ß" instead of "Ss", and "İ".downcase did not expand to "i̇" (i + U+0307). - The :ascii option was ignored, so non-ASCII characters were still mapped (e.g. "CÅR".downcase(:ascii) should keep "Å"). - The :turkic option was ignored (i <-> İ, I <-> ı dotted/dotless semantics). - The :lithuanian option was ignored (currently equivalent to full mapping, but still combinable with :turkic). - The :fold option (downcase-only full case folding, "ß" -> "ss") was ignored. - Invalid or improperly combined options did not raise ArgumentError. - Non-ASCII-compatible encodings (e.g. UTF-16LE) were mangled because the bytes were treated as UTF-8 instead of being transcoded. This adds a shared case-mapping engine (internal/vm/string_casemap.go) that parses the option symbols exactly as MRI's check_case_options does, applies per-rune up/down/title/swap mappings with the special-casing rules for ß and the dotted/dotless I, expands multi-character results, and transcodes through UTF-8 for non-ASCII-compatible encodings. All four String methods, their bang variants, and the four Symbol methods now route through it. The bang variants return nil when unchanged and raise FrozenError on a frozen receiver. Every behavior is verified byte-for-byte against MRI 4.0. rubyspec pass counts: upcase 12->32, downcase 19->32, swapcase 12->32, capitalize 15->34 (+72 total), with no regressions elsewhere in core/string. Co-Authored-By: Claude Opus 4.8 --- internal/vm/builtins.go | 72 ++---- internal/vm/string_case_conformance_test.go | 134 ++++++++++ internal/vm/string_casemap.go | 268 ++++++++++++++++++++ 3 files changed, 426 insertions(+), 48 deletions(-) create mode 100644 internal/vm/string_case_conformance_test.go create mode 100644 internal/vm/string_casemap.go diff --git a/internal/vm/builtins.go b/internal/vm/builtins.go index f620f7a6..72b97fbc 100644 --- a/internal/vm/builtins.go +++ b/internal/vm/builtins.go @@ -1423,17 +1423,17 @@ func (vm *VM) bootstrap() { vm.cSymbol.define("empty?", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { return object.Bool(symStr(self) == "") }) - vm.cSymbol.define("upcase", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return object.Symbol(strings.ToUpper(symStr(self))) + vm.cSymbol.define("upcase", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return object.Symbol(caseMapUTF8(symStr(self), caseUpcase, parseCaseOptions(caseUpcase, args))) }) - vm.cSymbol.define("downcase", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return object.Symbol(strings.ToLower(symStr(self))) + vm.cSymbol.define("downcase", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return object.Symbol(caseMapUTF8(symStr(self), caseDowncase, parseCaseOptions(caseDowncase, args))) }) - vm.cSymbol.define("capitalize", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return object.Symbol(capitalizeStr(symStr(self))) + vm.cSymbol.define("capitalize", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return object.Symbol(caseMapUTF8(symStr(self), caseCapitalize, parseCaseOptions(caseCapitalize, args))) }) - vm.cSymbol.define("swapcase", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return object.Symbol(swapcaseStr(symStr(self))) + vm.cSymbol.define("swapcase", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return object.Symbol(caseMapUTF8(symStr(self), caseSwapcase, parseCaseOptions(caseSwapcase, args))) }) symSucc := func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { return object.Symbol(succString(symStr(self))) @@ -1544,11 +1544,11 @@ func (vm *VM) bootstrap() { vm.cString.define("undump", func(vm *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { return vm.stringUndump(self.(*object.String)) }) - vm.cString.define("upcase", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return strEncOf(self, strings.ToUpper(strOf(self))) + vm.cString.define("upcase", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMap(self, caseUpcase, args) }) - vm.cString.define("downcase", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return strEncOf(self, strings.ToLower(strOf(self))) + vm.cString.define("downcase", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMap(self, caseDowncase, args) }) vm.cString.define("casecmp", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { o, ok := args[0].(*object.String) @@ -1564,11 +1564,11 @@ func (vm *VM) bootstrap() { } return object.Bool(strings.EqualFold(strOf(self), o.Str())) }) - vm.cString.define("capitalize", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return strEncOf(self, capitalizeStr(strOf(self))) + vm.cString.define("capitalize", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMap(self, caseCapitalize, args) }) - vm.cString.define("swapcase", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return strEncOf(self, swapcaseStr(strOf(self))) + vm.cString.define("swapcase", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMap(self, caseSwapcase, args) }) vm.cString.define("reverse", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { return strEncOf(self, reverseStr(strOf(self))) @@ -2123,17 +2123,17 @@ func (vm *VM) bootstrap() { s.SetBytes(nil) return s }) - vm.cString.define("upcase!", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return vm.strBang(self, strings.ToUpper) + vm.cString.define("upcase!", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMapBang(self, caseUpcase, args) }) - vm.cString.define("downcase!", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return vm.strBang(self, strings.ToLower) + vm.cString.define("downcase!", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMapBang(self, caseDowncase, args) }) - vm.cString.define("capitalize!", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return vm.strBang(self, capitalizeStr) + vm.cString.define("capitalize!", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMapBang(self, caseCapitalize, args) }) - vm.cString.define("swapcase!", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { - return vm.strBang(self, swapcaseStr) + vm.cString.define("swapcase!", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + return vm.stringCaseMapBang(self, caseSwapcase, args) }) vm.cString.define("reverse!", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { s := self.(*object.String) @@ -5503,30 +5503,6 @@ func nativeP(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value // Ruby (space, tab, newline, carriage return, form feed, vertical tab, NUL). const wsCutset = " \t\n\r\f\v\x00" -func capitalizeStr(s string) string { - if s == "" { - return "" - } - r := []rune(strings.ToLower(s)) - r[0] = unicode.ToUpper(r[0]) - return string(r) -} - -func swapcaseStr(s string) string { - out := make([]rune, 0, len(s)) - for _, r := range s { - switch { - case unicode.IsUpper(r): - out = append(out, unicode.ToLower(r)) - case unicode.IsLower(r): - out = append(out, unicode.ToUpper(r)) - default: - out = append(out, r) - } - } - return string(out) -} - func reverseStr(s string) string { r := []rune(s) for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 { diff --git a/internal/vm/string_case_conformance_test.go b/internal/vm/string_case_conformance_test.go new file mode 100644 index 00000000..bf0a3a28 --- /dev/null +++ b/internal/vm/string_case_conformance_test.go @@ -0,0 +1,134 @@ +package vm_test + +import ( + "strings" + "testing" +) + +// TestStringCaseMapping locks in MRI 4.0.x String#upcase/#downcase/#swapcase/ +// #capitalize behaviour, including full (multi-character) Unicode case mapping +// and the :ascii, :fold, :turkic and :lithuanian options. Every expected value +// below was verified byte-for-byte against MRI. +func TestStringCaseMapping(t *testing.T) { + tests := []struct { + name, src, want string + }{ + // Full Unicode case mapping producing multi-character sequences. + {"upcase_sharp_s", `p "aßet".upcase`, "\"ASSET\"\n"}, + {"upcase_umlauts", `p "äöü".upcase`, "\"ÄÖÜ\"\n"}, + {"upcase_dotted_I_unchanged", `p "İ".upcase`, "\"İ\"\n"}, + {"downcase_sharp_s_stays", `p "ß".downcase`, "\"ß\"\n"}, + {"downcase_dotted_I_full", `p "İS".downcase`, "\"i̇s\"\n"}, + {"swapcase_sharp_s", `p "Aßet".swapcase`, "\"aSSET\"\n"}, + {"swapcase_mixed", `p "cYbEr_PuNk11".swapcase`, "\"CyBeR_pUnK11\"\n"}, + {"capitalize_sharp_s", `p "ß".capitalize`, "\"Ss\"\n"}, + {"capitalize_sharp_s_tail", `p "ßeT".capitalize`, "\"Sset\"\n"}, + {"capitalize_empty", `p "".capitalize`, "\"\"\n"}, + {"capitalize_digit_first", `p "1a".capitalize`, "\"1a\"\n"}, + + // :ascii option — only ASCII letters are mapped. + {"upcase_ascii", `p "aßet".upcase(:ascii)`, "\"AßET\"\n"}, + {"downcase_ascii", `p "CÅR".downcase(:ascii)`, "\"cÅr\"\n"}, + {"swapcase_ascii", `p "aßet".swapcase(:ascii)`, "\"AßET\"\n"}, + {"swapcase_ascii_upper", `p "AbC".swapcase(:ascii)`, "\"aBc\"\n"}, + {"capitalize_ascii_nonascii_first", `p "ßet".capitalize(:ascii)`, "\"ßet\"\n"}, + {"capitalize_ascii_substr", `p "garçon"[1...-1].capitalize(:ascii)`, "\"Arço\"\n"}, + + // :turkic option — dotted/dotless I semantics. + {"upcase_turkic_i", `p "i".upcase(:turkic)`, "\"İ\"\n"}, + {"upcase_turkic_dotless", `p "ı".upcase(:turkic)`, "\"I\"\n"}, + {"downcase_turkic_dotted", `p "İ".downcase(:turkic)`, "\"i\"\n"}, + {"downcase_turkic_I", `p "I".downcase(:turkic)`, "\"ı\"\n"}, + {"swapcase_turkic", `p "aiS".swapcase(:turkic)`, "\"Aİs\"\n"}, + {"capitalize_turkic", `p "iSa".capitalize(:turkic)`, "\"İsa\"\n"}, + {"capitalize_turkic_dotless", `p "ısa".capitalize(:turkic)`, "\"Isa\"\n"}, + + // :lithuanian option — currently the same as full mapping, unless it is + // combined with :turkic (in which case Turkic semantics apply). + {"upcase_lithuanian", `p "iß".upcase(:lithuanian)`, "\"ISS\"\n"}, + {"upcase_lithuanian_turkic", `p "iß".upcase(:lithuanian, :turkic)`, "\"İSS\"\n"}, + {"downcase_lithuanian", `p "İS".downcase(:lithuanian)`, "\"i̇s\"\n"}, + {"downcase_lithuanian_turkic", `p "İS".downcase(:lithuanian, :turkic)`, "\"is\"\n"}, + {"swapcase_lithuanian", `p "Iß".swapcase(:lithuanian)`, "\"iSS\"\n"}, + {"swapcase_lithuanian_turkic", `p "iS".swapcase(:lithuanian, :turkic)`, "\"İs\"\n"}, + {"capitalize_lithuanian", `p "iß".capitalize(:lithuanian)`, "\"Iß\"\n"}, + {"capitalize_lithuanian_turkic", `p "iß".capitalize(:lithuanian, :turkic)`, "\"İß\"\n"}, + {"upcase_turkic_lithuanian", `p "i".upcase(:turkic, :lithuanian)`, "\"İ\"\n"}, + + // :fold option — full case folding, downcase only. + {"downcase_fold_sharp_s", `p "ß".downcase(:fold)`, "\"ss\"\n"}, + + // Non-ASCII-compatible encodings are transcoded through UTF-8. + {"upcase_utf16le", `p "äöü".encode("utf-16le").upcase.bytes`, "[196, 0, 214, 0, 220, 0]\n"}, + {"swapcase_utf16le", `p "äÖü".encode("utf-16le").swapcase.bytes`, "[196, 0, 246, 0, 220, 0]\n"}, + + // Invalid bytes in a binary string pass through untouched. + {"upcase_invalid_byte", `p "A\xFFb".b.upcase.bytes`, "[65, 255, 66]\n"}, + + // Bang variants: in place, nil when unchanged, otherwise the receiver. + {"upcase_bang_changed", `p "abc".dup.upcase!`, "\"ABC\"\n"}, + {"upcase_bang_unchanged", `p "HELLO".dup.upcase!`, "nil\n"}, + {"downcase_bang_fold", `s = "ß".dup; s.downcase!(:fold); p s`, "\"ss\"\n"}, + {"capitalize_bang_multi", `s = "ß".dup; s.capitalize!; p s`, "\"Ss\"\n"}, + {"swapcase_bang_turkic", `s = "aiS".dup; s.swapcase!(:turkic); p s`, "\"Aİs\"\n"}, + + // Metadata after a multi-character expansion. + {"upcase_metadata_size", `p "aßet".upcase.size`, "5\n"}, + {"upcase_metadata_ascii_only", `p "aßet".upcase.ascii_only?`, "true\n"}, + + // Symbol case methods share the same full-mapping engine. + {"symbol_upcase", `p :aßet.upcase`, ":ASSET\n"}, + {"symbol_capitalize", `p :ßet.capitalize`, ":Sset\n"}, + {"symbol_swapcase", `p :Aßet.swapcase`, ":aSSET\n"}, + {"symbol_downcase", `p :ÄÖÜ.downcase.to_s`, "\"äöü\"\n"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := eval(t, tc.src); got != tc.want { + t.Errorf("src=%q\n got=%q\nwant=%q", tc.src, got, tc.want) + } + }) + } +} + +// TestStringCaseMappingErrors locks in the ArgumentError/FrozenError paths of +// the case-mapping option parser and the bang methods. +func TestStringCaseMappingErrors(t *testing.T) { + tests := []struct { + name, src, want string + }{ + // :fold is only valid for downcasing. + {"upcase_fold", `"abc".upcase(:fold)`, "ArgumentError"}, + {"swapcase_fold", `"abc".swapcase(:fold)`, "ArgumentError"}, + {"capitalize_fold", `"abc".capitalize(:fold)`, "ArgumentError"}, + {"upcase_bang_fold", `"abc".dup.upcase!(:fold)`, "ArgumentError"}, + + // Unknown / invalid options. + {"invalid_option", `"abc".upcase(:invalid_option)`, "ArgumentError"}, + {"non_symbol_option", `"abc".upcase(5)`, "ArgumentError"}, + + // :ascii cannot be combined with another option. + {"ascii_plus_turkic", `"abc".upcase(:ascii, :turkic)`, "ArgumentError"}, + + // Only :turkic+:lithuanian may be combined; the second must match. + {"turkic_bad_second", `"abc".upcase(:turkic, :ascii)`, "ArgumentError"}, + {"turkic_nonsym_second", `"abc".upcase(:turkic, 5)`, "ArgumentError"}, + {"lithuanian_bad_second", `"abc".upcase(:lithuanian, :ascii)`, "ArgumentError"}, + {"lithuanian_nonsym_second", `"abc".upcase(:lithuanian, 5)`, "ArgumentError"}, + + // More than two options. + {"too_many_options", `"abc".upcase(:turkic, :lithuanian, :ascii)`, "ArgumentError"}, + + // Frozen receiver raises even when no change would be made. + {"frozen_mixed", `"HeLlo".freeze.upcase!`, "FrozenError"}, + {"frozen_no_change", `"HELLO".freeze.upcase!`, "FrozenError"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + err := runErr(t, tc.src) + if err == nil || !strings.Contains(err.Error(), tc.want) { + t.Errorf("src=%q: got err=%v, want containing %q", tc.src, err, tc.want) + } + }) + } +} diff --git a/internal/vm/string_casemap.go b/internal/vm/string_casemap.go new file mode 100644 index 00000000..0d508e78 --- /dev/null +++ b/internal/vm/string_casemap.go @@ -0,0 +1,268 @@ +package vm + +import ( + "bytes" + "strings" + "unicode" + "unicode/utf8" + + "github.com/go-embedded-ruby/ruby/internal/object" +) + +// This file implements the shared case-mapping engine behind String#upcase, +// #downcase, #swapcase, #capitalize and their bang variants (plus the matching +// Symbol methods), matching MRI 4.0.x semantics including the option arguments +// :ascii, :fold, :turkic and :lithuanian and full (multi-character) Unicode +// case mapping such as "ß".upcase == "SS". + +// caseMode selects which of the four case transforms to apply per character. +type caseMode int + +const ( + caseUpcase caseMode = iota + caseDowncase + caseSwapcase + caseCapitalize +) + +// caseFlags holds the parsed option arguments. At most turkic+lithuanian may be +// combined; ascii and fold are mutually exclusive with everything else. fold is +// only ever set for downcasing. +type caseFlags struct { + ascii bool + fold bool + turkic bool + lithuanian bool +} + +// Runes referenced by the special-casing rules below. +const ( + runeSharpS = 0x00DF // ß LATIN SMALL LETTER SHARP S + runeDotlessI = 0x0131 // ı LATIN SMALL LETTER DOTLESS I + runeDottedI = 0x0130 // İ LATIN CAPITAL LETTER I WITH DOT ABOVE + runeDotAbove = 0x0307 // ◌̇ COMBINING DOT ABOVE + runeCapitalSS = 'S' +) + +// parseCaseOptions mirrors MRI's rb_str_check_case_options: it validates the +// symbol option arguments for mode and returns the resulting flags, raising +// ArgumentError for any combination MRI rejects. +func parseCaseOptions(mode caseMode, args []object.Value) caseFlags { + var f caseFlags + if len(args) == 0 { + return f + } + if len(args) > 2 { + raise("ArgumentError", "too many options") + } + sym := func(v object.Value) (string, bool) { + s, ok := v.(object.Symbol) + return string(s), ok + } + first, _ := sym(args[0]) + switch first { + case "turkic": + f.turkic = true + if len(args) == 2 { + if s, ok := sym(args[1]); ok && s == "lithuanian" { + f.lithuanian = true + } else { + raise("ArgumentError", "invalid second option") + } + } + case "lithuanian": + f.lithuanian = true + if len(args) == 2 { + if s, ok := sym(args[1]); ok && s == "turkic" { + f.turkic = true + } else { + raise("ArgumentError", "invalid second option") + } + } + default: + if len(args) > 1 { + raise("ArgumentError", "too many options") + } + switch first { + case "ascii": + f.ascii = true + case "fold": + if mode == caseDowncase { + f.fold = true + } else { + raise("ArgumentError", "option :fold only allowed for downcasing") + } + default: + raise("ArgumentError", "invalid option") + } + } + return f +} + +// upRune returns the uppercase mapping of r under flags f. +func upRune(r rune, f caseFlags) []rune { + if f.ascii { + if r >= 'a' && r <= 'z' { + return []rune{r - 32} + } + return []rune{r} + } + if f.turkic { + switch r { + case 'i': + return []rune{runeDottedI} + case runeDotlessI: + return []rune{'I'} + } + } + if r == runeSharpS { + return []rune{runeCapitalSS, runeCapitalSS} + } + return []rune{unicode.ToUpper(r)} +} + +// downRune returns the lowercase (or, with f.fold, case-folded) mapping of r. +func downRune(r rune, f caseFlags) []rune { + if f.ascii { + if r >= 'A' && r <= 'Z' { + return []rune{r + 32} + } + return []rune{r} + } + if f.turkic { + switch r { + case 'I': + return []rune{runeDotlessI} + case runeDottedI: + return []rune{'i'} + } + } + if f.fold && r == runeSharpS { + return []rune{'s', 's'} + } + if r == runeDottedI { + // Full Unicode mapping: İ lowercases to "i" + combining dot above. + return []rune{'i', runeDotAbove} + } + return []rune{unicode.ToLower(r)} +} + +// titleRune returns the titlecase mapping of r, used for the first character of +// #capitalize. +func titleRune(r rune, f caseFlags) []rune { + if f.ascii { + if r >= 'a' && r <= 'z' { + return []rune{r - 32} + } + return []rune{r} + } + if f.turkic { + switch r { + case 'i': + return []rune{runeDottedI} + case runeDotlessI: + return []rune{'I'} + } + } + if r == runeSharpS { + return []rune{runeCapitalSS, 's'} + } + return []rune{unicode.ToTitle(r)} +} + +// swapRune upcases a lowercase r and downcases an uppercase r, leaving anything +// else untouched. +func swapRune(r rune, f caseFlags) []rune { + if f.ascii { + switch { + case r >= 'a' && r <= 'z': + return []rune{r - 32} + case r >= 'A' && r <= 'Z': + return []rune{r + 32} + } + return []rune{r} + } + switch { + case unicode.IsUpper(r): + return downRune(r, f) + case unicode.IsLower(r): + return upRune(r, f) + } + return []rune{r} +} + +// caseMapUTF8 applies mode/flags to a UTF-8 string, expanding multi-character +// mappings (e.g. ß→SS). Invalid bytes are copied through unchanged. +func caseMapUTF8(s string, mode caseMode, f caseFlags) string { + var b strings.Builder + b.Grow(len(s)) + first := true + for i := 0; i < len(s); { + r, size := utf8.DecodeRuneInString(s[i:]) + if r == utf8.RuneError && size <= 1 { + b.WriteByte(s[i]) + i++ + first = false + continue + } + i += size + var out []rune + switch mode { + case caseUpcase: + out = upRune(r, f) + case caseDowncase: + out = downRune(r, f) + case caseSwapcase: + out = swapRune(r, f) + case caseCapitalize: + if first { + out = titleRune(r, f) + } else { + out = downRune(r, f) + } + } + first = false + for _, o := range out { + b.WriteRune(o) + } + } + return b.String() +} + +// caseMapBytes applies mode/flags to bytes carrying the named encoding. An +// encoding that is not ASCII-compatible (e.g. UTF-16LE) is decoded to UTF-8, +// mapped, and re-encoded so multi-byte characters are transformed correctly. +func (vm *VM) caseMapBytes(src []byte, enc string, mode caseMode, f caseFlags) []byte { + if e, ok := vm.findEncoding(enc); ok && !e.asciiCompat { + u := vm.decodeToUTF8(src, enc, transcodeOpts{}, "") + mapped := caseMapUTF8(u, mode, f) + return vm.encodeFromUTF8(mapped, enc, transcodeOpts{}, "") + } + return []byte(caseMapUTF8(string(src), mode, f)) +} + +// stringCaseMap implements the non-bang String case methods: it parses options, +// applies the transform in the receiver's encoding, and returns a fresh String +// carrying that same encoding. +func (vm *VM) stringCaseMap(self object.Value, mode caseMode, args []object.Value) object.Value { + s := self.(*object.String) + f := parseCaseOptions(mode, args) + out := vm.caseMapBytes(s.Bytes(), s.EncName(), mode, f) + return object.NewStringBytesEnc(out, s.Enc) +} + +// stringCaseMapBang implements the bang String case methods: it mutates the +// receiver in place, returning nil when no change was made (and raising +// FrozenError on a frozen receiver even then). +func (vm *VM) stringCaseMapBang(self object.Value, mode caseMode, args []object.Value) object.Value { + s := self.(*object.String) + f := parseCaseOptions(mode, args) + vm.checkFrozen(s) + orig := s.Bytes() + out := vm.caseMapBytes(orig, s.EncName(), mode, f) + if bytes.Equal(orig, out) { + return object.NilV + } + s.SetBytes(out) + return s +}