Simplify Hangul composition (#2200)

Removes a premature attempt at optimization that did not really
make sense as an optimization.

Author: hsivonen

components/normalizer/src/lib.rs

@@ -1002,44 +1002,6 @@ where
                     return Some(starter);
                 }
             }
-            // Even a Hangul LVT syllable may have decomposed if followed by something that
-            // could combine backwards with some other base.
-            // `buffer_pos` may be non-zero for NFKC and parenthesized Hangul.
-            if let Some(potential) = self.decomposition.buffer.get(self.decomposition.buffer_pos) {
-                let potential_c = potential.character();
-                let v = u32::from(potential_c).wrapping_sub(HANGUL_V_BASE);
-                if v < HANGUL_V_COUNT {
-                    // Hangul vowel
-                    let l = u32::from(starter).wrapping_sub(HANGUL_L_BASE);
-                    if l < HANGUL_L_COUNT {
-                        let lv = l * HANGUL_N_COUNT + v * HANGUL_T_COUNT;
-                        // Safe, because the inputs are known to be in range.
-                        starter = unsafe { char::from_u32_unchecked(HANGUL_S_BASE + lv) };
-
-                        self.decomposition.buffer_pos += 1;
-                    }
-                }
-            }
-
-            if let Some(potential) = self.decomposition.buffer.get(self.decomposition.buffer_pos) {
-                let potential_c = potential.character();
-                if in_inclusive_range(potential_c, '\u{11A8}', '\u{11C2}') {
-                    // Hangul trail
-                    let lv = u32::from(starter).wrapping_sub(HANGUL_S_BASE);
-                    if lv < HANGUL_S_COUNT && lv % HANGUL_T_COUNT == 0 {
-                        let lvt = lv + u32::from(potential_c) - HANGUL_T_BASE;
-                        // Safe, because the inputs are known to be in range.
-                        starter = unsafe { char::from_u32_unchecked(HANGUL_S_BASE + lvt) };
-
-                        self.decomposition.buffer_pos += 1;
-                    }
-                }
-            }
-
-            // We could skip the loop based on the knowledge that we saw Hangul, but it
-            // would only be an optimization in a non-realistic case, so we'll let the loop
-            // below try composing stuff with Hangul without success.
-
             // We first loop by index to avoid moving the contents of `buffer`, but
             // if there's a discontiguous match, we'll start modifying `buffer` instead.
             loop {
@@ -1055,7 +1017,7 @@ where
                     self.decomposition.buffer_pos = 0;
                     break;
                 };
-                if let Some(composed) = self.compose_non_hangul(starter, character) {
+                if let Some(composed) = self.compose(starter, character) {
                     starter = composed;
                     self.decomposition.buffer_pos += 1;
                     continue;
@@ -1086,6 +1048,9 @@ where
                     }
                     debug_assert!(ccc >= most_recent_skipped_ccc);
                     if ccc != most_recent_skipped_ccc {
+                        // Using the non-Hangul version as a micro-optimization, since
+                        // we already rejected the case where `second` is a starter
+                        // above, and conjoining jamo are starters.
                         if let Some(composed) = self.compose_non_hangul(starter, character) {
                             self.decomposition.buffer.remove(i);
                             starter = composed;