Normalize line ending to \n in StringLiteralExprSyntax.representedLiteralValue

This matches the specification of multi-line string literal handling:

From https://docs.swift.org/swift-book/documentation/the-swift-programming-language/lexicalstructure/#String-Literals:
> Line breaks in a multiline string literal are normalized to use the line feed character. Even if your source file has a mix of carriage returns and line feeds, all of the line breaks in the string will be the same.

From https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20170417/035923.html:

> The quoted string should normalize newlines to \n in the value of the literal, regardless of whether the source file uses \n (Unix), \r\n (Windows), or \r (classic Mac) line endings. Likewise, when the compiler strips the initial and final newline from the literal value, it will strip one of any of the \n, \r\n, or \r line-ending sequences from both ends of the literal.

Author: ahoppen

Diff for: Sources/SwiftParser/Lexer/Cursor.swift

@@ -1594,7 +1594,7 @@ extension Lexer.Cursor {
 // MARK: Lexing a character in a string literal
 
 extension Lexer.Cursor {
-  enum CharacterLex {
+  enum CharacterLex: Equatable {
     /// A normal character as it occurs in the source file
     case success(Unicode.Scalar)
 

Diff for: Sources/SwiftParser/StringLiteralRepresentedLiteralValue.swift

@@ -83,8 +83,8 @@ extension StringSegmentSyntax {
     precondition(!hasError, "appendUnescapedLiteralValue relies on properly parsed literals")
 
     let rawText = content.rawText
-    if !rawText.contains("\\") {
-      // Fast path. No escape sequence.
+    if !rawText.contains(where: { $0 == "\\" || $0 == "\r" }) {
+      // Fast path. No escape sequence that need to be interpreted or line endings that need to be normalized to \n.
       output.append(String(syntaxText: rawText))
       return
     }
@@ -105,6 +105,18 @@ extension StringSegmentSyntax {
         )
 
         switch lex {
+        case .success(Unicode.Scalar("\r")):
+          // Line endings in multi-line string literals are normalized to line feeds even if the source file has a
+          // different encoding for new lines.
+          output.append("\n")
+          if cursor.peek() == "\n" {
+            // If we have \r\n, eat the \n as well and leave
+            let consumed = cursor.lexCharacterInStringLiteral(
+              stringLiteralKind: stringLiteralKind,
+              delimiterLength: delimiterLength
+            )
+            assert(consumed == .success(Unicode.Scalar("\n")))
+          }
         case .success(let scalar),
           .validatedEscapeSequence(let scalar):
           output.append(Character(scalar))