Add spell check TextSpan creation logic that doesn't rely on composing region (flutter#123481)

Fixes flutter#119534 by adding extra
logic to allow the proper `TextSpan` trees to be build with spell check
results that does not rely on the composing region.

Also, refreshes the algorithm used to correct spell check results to
improve cases where spell check results are out of date, but the
composing region line does not help smooth over this fact by giving the
framework extra time to update while a word is being composed (because a
composing region line would cover up any flashing red underlines).

## Pre-launch Checklist

- [x] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [x] I read the [Tree Hygiene] wiki page, which explains my
responsibilities.
- [x] I read and followed the [Flutter Style Guide], including [Features
we expect every widget to implement].
- [x] I signed the [CLA].
- [x] I listed at least one issue that this PR fixes in the description
above.
- [x] I updated/added relevant documentation (doc comments with `///`).
- [ ] I added new tests to check the change I am making, or this PR is
[test-exempt].
- [ ] All existing and new tests are passing.

<!-- Links -->
[Contributor Guide]:
https://github.com/flutter/flutter/wiki/Tree-hygiene#overview
[Tree Hygiene]: https://github.com/flutter/flutter/wiki/Tree-hygiene
[test-exempt]:
https://github.com/flutter/flutter/wiki/Tree-hygiene#tests
[Flutter Style Guide]:
https://github.com/flutter/flutter/wiki/Style-guide-for-Flutter-repo
[Features we expect every widget to implement]:
https://github.com/flutter/flutter/wiki/Style-guide-for-Flutter-repo#features-we-expect-every-widget-to-implement
[CLA]: https://cla.developers.google.com/
[flutter/tests]: https://github.com/flutter/tests
[breaking change policy]:
https://github.com/flutter/flutter/wiki/Tree-hygiene#handling-breaking-changes
[Discord]: https://github.com/flutter/flutter/wiki/Chat

Author: camsim99

packages/flutter/lib/src/widgets/spell_check.dart

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'package:flutter/foundation.dart' show TargetPlatform, defaultTargetPlatform;
 import 'package:flutter/painting.dart';
 import 'package:flutter/services.dart'
     show SpellCheckResults, SpellCheckService, SuggestionSpan, TextEditingValue;
@@ -108,71 +109,63 @@ class SpellCheckConfiguration {
 List<SuggestionSpan> _correctSpellCheckResults(
     String newText, String resultsText, List<SuggestionSpan> results) {
   final List<SuggestionSpan> correctedSpellCheckResults = <SuggestionSpan>[];
-
   int spanPointer = 0;
   int offset = 0;
-  int foundIndex;
-  int spanLength;
-  SuggestionSpan currentSpan;
-  SuggestionSpan adjustedSpan;
-  String currentSpanText;
-  String newSpanText = '';
-  bool currentSpanValid = false;
-  RegExp regex;
 
   // Assumes that the order of spans has not been jumbled for optimization
   // purposes, and will only search since the previously found span.
   int searchStart = 0;
 
   while (spanPointer < results.length) {
-    // Try finding SuggestionSpan from old results (currentSpan) in new text.
-    currentSpan = results[spanPointer];
-    currentSpanText =
+    final SuggestionSpan currentSpan = results[spanPointer];
+    final String currentSpanText =
         resultsText.substring(currentSpan.range.start, currentSpan.range.end);
+    final int spanLength = currentSpan.range.end - currentSpan.range.start;
 
-    try {
-      // currentSpan was found and can be applied to new text.
-      newSpanText = newText.substring(
-          currentSpan.range.start + offset, currentSpan.range.end + offset);
-      currentSpanValid = true;
-    } catch (e) {
-      // currentSpan is invalid and needs to be searched for in newText.
-      currentSpanValid = false;
-    }
+    // Try finding SuggestionSpan from resultsText in new text.
+    final RegExp currentSpanTextRegexp = RegExp('\\b$currentSpanText\\b');
+    final int foundIndex = newText.substring(searchStart).indexOf(currentSpanTextRegexp);
+
+    // Check whether word was found exactly where expected or elsewhere in the newText.
+    final bool currentSpanFoundExactly = currentSpan.range.start == foundIndex + searchStart;
+    final bool currentSpanFoundExactlyWithOffset = currentSpan.range.start + offset == foundIndex + searchStart;
+    final bool currentSpanFoundElsewhere = foundIndex >= 0;
 
-    if (currentSpanValid && newSpanText == currentSpanText) {
-      // currentSpan was found at the same index in new text and old text
-      // (resultsText), so apply it to new text by adding it to the list of
+    if (currentSpanFoundExactly || currentSpanFoundExactlyWithOffset) {
+      // currentSpan was found at the same index in newText and resutsText
+      // or at the same index with the previously calculated adjustment by
+      // the offset value, so apply it to new text by adding it to the list of
       // corrected results.
-      searchStart = currentSpan.range.end + offset;
-      adjustedSpan = SuggestionSpan(
-          TextRange(
-              start: currentSpan.range.start + offset, end: searchStart),
-          currentSpan.suggestions
+      final SuggestionSpan adjustedSpan = SuggestionSpan(
+        TextRange(
+          start: currentSpan.range.start + offset,
+          end: currentSpan.range.end + offset,
+        ),
+        currentSpan.suggestions,
       );
+
+      // Start search for the next misspelled word at the end of currentSpan.
+      searchStart = currentSpan.range.end + 1 + offset;
       correctedSpellCheckResults.add(adjustedSpan);
-    } else {
-      // Search for currentSpan in new text and if found, apply it to new text
-      // by adding it to the list of corrected results.
-      regex = RegExp('\\b$currentSpanText\\b');
-      foundIndex = newText.substring(searchStart).indexOf(regex);
-
-      if (foundIndex >= 0) {
-        foundIndex += searchStart;
-        spanLength = currentSpan.range.end - currentSpan.range.start;
-        searchStart = foundIndex + spanLength;
-        adjustedSpan = SuggestionSpan(
-            TextRange(start: foundIndex, end: searchStart),
-            currentSpan.suggestions
-        );
-        offset = foundIndex - currentSpan.range.start;
+    } else if (currentSpanFoundElsewhere) {
+      // Word was pushed forward but not modified.
+      final int adjustedSpanStart = searchStart + foundIndex;
+      final int adjustedSpanEnd = adjustedSpanStart + spanLength;
+      final SuggestionSpan adjustedSpan = SuggestionSpan(
+        TextRange(start: adjustedSpanStart, end: adjustedSpanEnd),
+        currentSpan.suggestions,
+      );
 
-        correctedSpellCheckResults.add(adjustedSpan);
-      }
+      // Start search for the next misspelled word at the end of the
+      // adjusted currentSpan.
+      searchStart = adjustedSpanEnd + 1;
+      // Adjust offset to reflect the difference between where currentSpan
+      // was positioned in resultsText versus in newText.
+      offset = adjustedSpanStart - currentSpan.range.start;
+      correctedSpellCheckResults.add(adjustedSpan);
     }
     spanPointer++;
   }
-
   return correctedSpellCheckResults;
 }
 
@@ -201,31 +194,121 @@ TextSpan buildTextSpanWithSpellCheckSuggestions(
         value.text, spellCheckResultsText, spellCheckResultsSpans);
   }
 
-  return TextSpan(
+  // We will draw the TextSpan tree based on the composing region, if it is
+  // available.
+  // TODO(camsim99): The two separate stratgies for building TextSpan trees
+  // based on the availability of a composing region should be merged:
+  // https://github.com/flutter/flutter/issues/124142.
+  final bool shouldConsiderComposingRegion = defaultTargetPlatform == TargetPlatform.android;
+  if (shouldConsiderComposingRegion) {
+    return TextSpan(
       style: style,
-      children: _buildSubtreesWithMisspelledWordsIndicated(
+      children: _buildSubtreesWithComposingRegion(
           spellCheckResultsSpans,
           value,
           style,
           misspelledTextStyle,
-          composingWithinCurrentTextRange
+          composingWithinCurrentTextRange,
+      ),
+    );
+  }
+
+  return TextSpan(
+    style: style,
+    children: _buildSubtreesWithoutComposingRegion(
+      spellCheckResultsSpans,
+      value,
+      style,
+      misspelledTextStyle,
+      value.selection.baseOffset,
+    ),
+  );
+}
+
+/// Builds the [TextSpan] tree for spell check without considering the composing
+/// region. Instead, uses the cursor to identify the word that's actively being
+/// edited and shouldn't be spell checked. This is useful for platforms and IMEs
+/// that don't use the composing region for the active word.
+List<TextSpan> _buildSubtreesWithoutComposingRegion(
+    List<SuggestionSpan>? spellCheckSuggestions,
+    TextEditingValue value,
+    TextStyle? style,
+    TextStyle misspelledStyle,
+    int cursorIndex,
+) {
+  final List<TextSpan> textSpanTreeChildren = <TextSpan>[];
+
+  int textPointer = 0;
+  int currentSpanPointer = 0;
+  int endIndex;
+  final String text = value.text;
+  final TextStyle misspelledJointStyle =
+      style?.merge(misspelledStyle) ?? misspelledStyle;
+  bool cursorInCurrentSpan = false;
+
+  // Add text interwoven with any misspelled words to the tree.
+  if (spellCheckSuggestions != null) {
+    while (textPointer < text.length &&
+      currentSpanPointer < spellCheckSuggestions.length) {
+      final SuggestionSpan currentSpan = spellCheckSuggestions[currentSpanPointer];
+
+      if (currentSpan.range.start > textPointer) {
+        endIndex = currentSpan.range.start < text.length
+            ? currentSpan.range.start
+            : text.length;
+        textSpanTreeChildren.add(
+          TextSpan(
+            style: style,
+            text: text.substring(textPointer, endIndex),
+          )
+        );
+        textPointer = endIndex;
+      } else {
+        endIndex =
+            currentSpan.range.end < text.length ? currentSpan.range.end : text.length;
+        cursorInCurrentSpan = currentSpan.range.start <= cursorIndex && currentSpan.range.end >= cursorIndex;
+        textSpanTreeChildren.add(
+          TextSpan(
+            style: cursorInCurrentSpan
+                ? style
+                : misspelledJointStyle,
+            text: text.substring(currentSpan.range.start, endIndex),
+          )
+        );
+
+        textPointer = endIndex;
+        currentSpanPointer++;
+      }
+    }
+  }
+
+  // Add any remaining text to the tree if applicable.
+  if (textPointer < text.length) {
+    textSpanTreeChildren.add(
+      TextSpan(
+        style: style,
+        text: text.substring(textPointer, text.length),
       )
     );
+  }
+
+  return textSpanTreeChildren;
 }
 
-/// Builds [TextSpan] subtree for text with misspelled words.
-List<TextSpan> _buildSubtreesWithMisspelledWordsIndicated(
+/// Builds [TextSpan] subtree for text with misspelled words with logic based on
+/// a valid composing region.
+List<TextSpan> _buildSubtreesWithComposingRegion(
     List<SuggestionSpan>? spellCheckSuggestions,
     TextEditingValue value,
     TextStyle? style,
     TextStyle misspelledStyle,
     bool composingWithinCurrentTextRange) {
-  final List<TextSpan> tsTreeChildren = <TextSpan>[];
+  final List<TextSpan> textSpanTreeChildren = <TextSpan>[];
 
   int textPointer = 0;
-  int currSpanPointer = 0;
+  int currentSpanPointer = 0;
   int endIndex;
-  SuggestionSpan currSpan;
+  SuggestionSpan currentSpan;
   final String text = value.text;
   final TextRange composingRegion = value.composing;
   final TextStyle composingTextStyle =
@@ -234,59 +317,59 @@ List<TextSpan> _buildSubtreesWithMisspelledWordsIndicated(
   final TextStyle misspelledJointStyle =
       style?.merge(misspelledStyle) ?? misspelledStyle;
   bool textPointerWithinComposingRegion = false;
-  bool currSpanIsComposingRegion = false;
+  bool currentSpanIsComposingRegion = false;
 
   // Add text interwoven with any misspelled words to the tree.
   if (spellCheckSuggestions != null) {
     while (textPointer < text.length &&
-      currSpanPointer < spellCheckSuggestions.length) {
-      currSpan = spellCheckSuggestions[currSpanPointer];
+      currentSpanPointer < spellCheckSuggestions.length) {
+      currentSpan = spellCheckSuggestions[currentSpanPointer];
 
-      if (currSpan.range.start > textPointer) {
-        endIndex = currSpan.range.start < text.length
-            ? currSpan.range.start
+      if (currentSpan.range.start > textPointer) {
+        endIndex = currentSpan.range.start < text.length
+            ? currentSpan.range.start
             : text.length;
         textPointerWithinComposingRegion =
             composingRegion.start >= textPointer &&
                 composingRegion.end <= endIndex &&
                 !composingWithinCurrentTextRange;
 
         if (textPointerWithinComposingRegion) {
-          _addComposingRegionTextSpans(tsTreeChildren, text, textPointer,
+          _addComposingRegionTextSpans(textSpanTreeChildren, text, textPointer,
               composingRegion, style, composingTextStyle);
-          tsTreeChildren.add(
+          textSpanTreeChildren.add(
             TextSpan(
               style: style,
-              text: text.substring(composingRegion.end, endIndex)
+              text: text.substring(composingRegion.end, endIndex),
             )
           );
         } else {
-          tsTreeChildren.add(
+          textSpanTreeChildren.add(
             TextSpan(
               style: style,
-              text: text.substring(textPointer, endIndex)
+              text: text.substring(textPointer, endIndex),
             )
           );
         }
 
         textPointer = endIndex;
       } else {
         endIndex =
-            currSpan.range.end < text.length ? currSpan.range.end : text.length;
-        currSpanIsComposingRegion = textPointer >= composingRegion.start &&
+            currentSpan.range.end < text.length ? currentSpan.range.end : text.length;
+        currentSpanIsComposingRegion = textPointer >= composingRegion.start &&
             endIndex <= composingRegion.end &&
             !composingWithinCurrentTextRange;
-        tsTreeChildren.add(
+        textSpanTreeChildren.add(
           TextSpan(
-            style: currSpanIsComposingRegion
+            style: currentSpanIsComposingRegion
                 ? composingTextStyle
                 : misspelledJointStyle,
-            text: text.substring(currSpan.range.start, endIndex)
+            text: text.substring(currentSpan.range.start, endIndex),
           )
         );
 
         textPointer = endIndex;
-        currSpanPointer++;
+        currentSpanPointer++;
       }
     }
   }
@@ -295,27 +378,27 @@ List<TextSpan> _buildSubtreesWithMisspelledWordsIndicated(
   if (textPointer < text.length) {
     if (textPointer < composingRegion.start &&
         !composingWithinCurrentTextRange) {
-      _addComposingRegionTextSpans(tsTreeChildren, text, textPointer,
+      _addComposingRegionTextSpans(textSpanTreeChildren, text, textPointer,
           composingRegion, style, composingTextStyle);
 
       if (composingRegion.end != text.length) {
-        tsTreeChildren.add(
+        textSpanTreeChildren.add(
           TextSpan(
             style: style,
-            text: text.substring(composingRegion.end, text.length)
+            text: text.substring(composingRegion.end, text.length),
           )
         );
       }
     } else {
-      tsTreeChildren.add(
+      textSpanTreeChildren.add(
         TextSpan(
-          style: style, text: text.substring(textPointer, text.length)
+          style: style, text: text.substring(textPointer, text.length),
         )
       );
     }
   }
 
-  return tsTreeChildren;
+  return textSpanTreeChildren;
 }
 
 /// Helper method to create [TextSpan] tree children for specified range of
@@ -330,13 +413,13 @@ void _addComposingRegionTextSpans(
   treeChildren.add(
     TextSpan(
       style: style,
-      text: text.substring(start, composingRegion.start)
+      text: text.substring(start, composingRegion.start),
     )
   );
   treeChildren.add(
     TextSpan(
       style: composingTextStyle,
-      text: text.substring(composingRegion.start, composingRegion.end)
+      text: text.substring(composingRegion.start, composingRegion.end),
     )
   );
 }