Ensure that the diff output of starts_with contains the last line of the actual value corresponding to the expected value when they are not equal.

Previously, the displayed diff from `starts_with` was suboptimal when the last line of the prefix differs from its corresponding line in the actual value (which occurs often):

Actual:

```
 First line
 Second line
 Third line
```

Prefix:

```
 First line
 Second
```

Diff:
```
 First line
-Second
<---- remaining lines omitted ---->
```

The line

```
+Second line
```

is missing from the diff.

This adds a hack which manually introduces the missing line to the diff in the above case. Doing this manually should not result in any incorrect output -- at worst, it could result in an additional line of output which was not strictly necessary.

PiperOrigin-RevId: 540592869

Author: hovinenb

googletest/src/matcher_support/edit_distance.rs

@@ -180,6 +180,20 @@ pub(crate) fn edit_list<T: PartialEq + Copy>(
                 .filter(|p| p.right_endpoint == right.len())
                 .max_by(|p1, p2| p1.edits.len().cmp(&p2.edits.len()))
             {
+                // We've reached the end of the right side but there could still be a
+                // corresponding line on the left which we haven't picked up into the edit list.
+                // We'll just add it manually to the edit list. There's no real harm doing so --
+                // worst case is that there's an additional line when there didn't have to be.
+                if let Some(Edit::ExtraRight(_)) = path.edits.last() {
+                    if path.left_endpoint < left.len() {
+                        // The edits from the left should come before the corresponding one from the
+                        // right, so we insert rather than push.
+                        path.edits.insert(
+                            path.edits.len() - 1,
+                            Edit::ExtraLeft(left[path.left_endpoint]),
+                        );
+                    }
+                }
                 path.edits.push(Edit::AdditionalLeft);
                 return if path.edits.iter().any(|v| !matches!(v, Edit::Both(_))) {
                     Difference::Editable(std::mem::take(&mut path.edits))
@@ -447,6 +461,20 @@ mod tests {
         )
     }
 
+    #[test]
+    fn does_not_skip_corresponding_line_on_left_when_left_and_right_differ_in_prefix_mode()
+    -> Result<()> {
+        let result = edit_list(["Left only"], ["Right only"], Mode::Prefix);
+        verify_that!(
+            result,
+            matches_pattern!(Difference::Editable(elements_are![
+                matches_pattern!(Edit::ExtraLeft(eq("Left only"))),
+                matches_pattern!(Edit::ExtraRight(eq("Right only"))),
+                matches_pattern!(Edit::AdditionalLeft),
+            ]))
+        )
+    }
+
     #[test]
     fn returns_unrelated_when_maximum_distance_exceeded() -> Result<()> {
         let result = edit_list(0..=20, 20..40, Mode::Exact);

googletest/src/matchers/str_matcher.rs

@@ -1010,6 +1010,38 @@ mod tests {
         )
     }
 
+    #[test]
+    fn match_explanation_for_starts_with_includes_both_versions_of_differing_last_line()
+    -> Result<()> {
+        let result = verify_that!(
+            indoc!(
+                "
+                    First line
+                    Second line
+                    Third line
+                "
+            ),
+            starts_with(indoc!(
+                "
+                    First line
+                    Second lines
+                "
+            ))
+        );
+
+        verify_that!(
+            result,
+            err(displays_as(contains_substring(indoc!(
+                "
+                     First line
+                    +Second line
+                    -Second lines
+                    <---- remaining lines omitted ---->
+                "
+            ))))
+        )
+    }
+
     #[test]
     fn match_explanation_for_eq_does_not_ignore_trailing_lines_in_actual_string() -> Result<()> {
         let result = verify_that!(