ICU-23143 Fix regex bug with unpaired surrogates

Fix a regex bug that occured when a pattern contained an unpaired leading
surrogate. It could, incorrectly, match half of a valid supplementary char,
leaving an invalid match position, and leading to subsequent assertion
failures.

Author: aheninger

icu4c/source/i18n/rematch.cpp

@@ -4420,6 +4420,14 @@ void RegexMatcher::MatchChunkAt(int32_t startIdx, UBool toEnd, UErrorCode &statu
                     }
                 }
 
+                // If the pattern string ends with an unpaired lead surrogate that
+                // matched the lead surrogate of a valid pair in the input text,
+                // this does not count as a match.
+                if (success && U16_IS_LEAD(*(pInp-1)) &&
+                        pInp < pInpLimit && U16_IS_TRAIL(*(pInp))) {
+                    success = false;
+                }
+
                 if (success) {
                     fp->fInputIdx += stringLen;
                 } else {

icu4c/source/test/intltest/regextst.cpp

@@ -28,6 +28,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <iterator>
 
 #include "unicode/localpointer.h"
 #include "unicode/regex.h"
@@ -107,6 +108,7 @@ void RegexTest::runIndexedTest( int32_t index, UBool exec, const char* &name, ch
     TESTCASE_AUTO(TestBug13632);
     TESTCASE_AUTO(TestBug20359);
     TESTCASE_AUTO(TestBug20863);
+    TESTCASE_AUTO(TestBug23143);
     TESTCASE_AUTO_END;
 }
 
@@ -5815,6 +5817,32 @@ void RegexTest::TestBug20359() {
 }
 
 
+void RegexTest::TestBug23143() {
+    // Test pattern with unpaired surrogate matching against text
+    // with a valid surrogate pair. Originally caused an assertion failure
+    // in the implementation.
+
+    // Note: can't use normal C++ string literals because unpaired surrogates are illegal in them.
+    const char16_t regex_array[] = {u'a', 0xD805, u'.', u'*', u'b'};
+    UnicodeString regex(regex_array, std::size(regex_array));
+
+    const char16_t haystack_array[] = {u'a', 0xD805, 0xDF20};
+    UnicodeString haystack(haystack_array, std::size(haystack_array));
+
+    UErrorCode status = U_ZERO_ERROR;
+    std::unique_ptr<icu::RegexPattern> re(icu::RegexPattern::compile(regex, 0, status));
+    if (!assertSuccess(WHERE, status)) {
+        return;
+    }
+    // re->dumpPattern();
+    std::unique_ptr<icu::RegexMatcher> regex_matcher(re->matcher(haystack, status));
+    if (!assertSuccess(WHERE, status)) {
+        return;
+    }
+    assertFalse(WHERE, regex_matcher->find(0, status));
+    assertSuccess(WHERE, status);
+}
+
 void RegexTest::TestBug20863() {
     // Test that patterns with a large number of named capture groups work correctly.
     //

icu4c/source/test/intltest/regextst.h

@@ -61,6 +61,7 @@ class RegexTest: public IntlTest {
     virtual void TestBug13632();
     virtual void TestBug20359();
     virtual void TestBug20863();
+    virtual void TestBug23143();
 
     // The following functions are internal to the regexp tests.
     virtual void assertUText(const char *expected, UText *actual, const char *file, int line);