An implementation for 0168-multi-line-string-literals.md

include/swift/AST/DiagnosticsParse.def

@@ -125,9 +125,15 @@ ERROR(lex_invalid_u_escape_rbrace,none,
       "expected '}' in \\u{...} escape sequence", ())
 
 ERROR(lex_invalid_unicode_scalar,none,
-       "invalid unicode scalar", ())
+      "invalid unicode scalar", ())
 ERROR(lex_unicode_escape_braces,none,
       "expected hexadecimal code in braces after unicode escape", ())
+ERROR(lex_illegal_multiline_string_start,none,
+      "invalid start of multi-line string literal", ())
+ERROR(lex_illegal_multiline_string_end,none,
+      "invalid end of multi-line string literal", ())
+ERROR(lex_ambiguous_string_indent,none,
+      "invalid mix of multi-line string literal indentation", ())
 
 
 ERROR(lex_invalid_character,none,

include/swift/Parse/Lexer.h

@@ -374,13 +374,17 @@ class Lexer {
     enum : char { Literal, Expr } Kind;
     // Loc+Length for the segment inside the string literal, without quotes.
     SourceLoc Loc;
-    unsigned Length;
-
-    static StringSegment getLiteral(SourceLoc Loc, unsigned Length) {
+    unsigned Length, Modifiers, IdentToStrip;
+
+    static StringSegment getLiteral(SourceLoc Loc, unsigned Length,
+                                    unsigned Modifiers,
+                                    unsigned IdentToStrip) {
       StringSegment Result;
       Result.Kind = Literal;
       Result.Loc = Loc;
       Result.Length = Length;
+      Result.Modifiers = Modifiers;
+      Result.IdentToStrip = IdentToStrip;
       return Result;
     }
 
@@ -389,6 +393,8 @@ class Lexer {
       Result.Kind = Expr;
       Result.Loc = Loc;
       Result.Length = Length;
+      Result.Modifiers = 0;
+      Result.IdentToStrip = 0;
       return Result;
     }
   };
@@ -397,12 +403,14 @@ class Lexer {
   /// If a copy needs to be made, it will be allocated out of the provided
   /// Buffer.
   static StringRef getEncodedStringSegment(StringRef Str,
-                                           SmallVectorImpl<char> &Buffer);
+                                           SmallVectorImpl<char> &Buffer,
+                                           unsigned Modifiers = 0,
+                                           unsigned IdentToStrip = 0);
   StringRef getEncodedStringSegment(StringSegment Segment,
                                     SmallVectorImpl<char> &Buffer) const {
     return getEncodedStringSegment(
         StringRef(getBufferPtrForSourceLoc(Segment.Loc), Segment.Length),
-        Buffer);
+        Buffer, Segment.Modifiers, Segment.IdentToStrip);
   }
 
   /// \brief Given a string literal token, separate it into string/expr segments
@@ -464,7 +472,7 @@ class Lexer {
     return diagnose(Loc, Diagnostic(DiagID, std::forward<ArgTypes>(Args)...));
   }
 
-  void formToken(tok Kind, const char *TokStart);
+  void formToken(tok Kind, const char *TokStart, unsigned Modifiers = 0);
 
   /// Advance to the end of the line but leave the current buffer pointer
   /// at that newline character.
@@ -495,8 +503,9 @@ class Lexer {
   static unsigned lexUnicodeEscape(const char *&CurPtr, Lexer *Diags);
 
   unsigned lexCharacter(const char *&CurPtr,
-                        char StopQuote, bool EmitDiagnostics);
-  void lexStringLiteral();
+                        char StopQuote, bool EmitDiagnostics,
+                        unsigned Modifiers = 0);
+  void lexStringLiteral(unsigned Modifiers = 0);
   void lexEscapedIdentifier();
 
   void tryLexEditorPlaceholder();
@@ -505,6 +514,9 @@ class Lexer {
   /// Try to lex conflict markers by checking for the presence of the start and
   /// end of the marker in diff3 or Perforce style respectively.
   bool tryLexConflictMarker();
+
+  /// Check multiline string literal is indented correctly.
+  void validateMultilineIndents(const Token &Str);
 };
 
 } // end namespace swift

include/swift/Parse/Token.h

@@ -46,6 +46,9 @@ class Token {
   /// \brief Whether this token is an escaped `identifier` token.
   unsigned EscapedIdentifier : 1;
 
+  /// Modifiers for string literals
+  unsigned StringModifiers : 1;
+
   /// Text - The actual string covered by the token in the source buffer.
   StringRef Text;
 
@@ -60,7 +63,7 @@ class Token {
             EscapedIdentifier(false) {}
   Token(tok Kind, StringRef Text)
     : Kind(Kind), AtStartOfLine(false), CommentLength(0),
-      EscapedIdentifier(false),
+      EscapedIdentifier(false), StringModifiers(0),
       Text(Text) {}
 
   tok getKind() const { return Kind; }
@@ -273,11 +276,18 @@ class Token {
   void setText(StringRef T) { Text = T; }
 
   /// \brief Set the token to the specified kind and source range.
-  void setToken(tok K, StringRef T, unsigned CommentLength = 0) {
+  void setToken(tok K, StringRef T, unsigned CommentLength = 0,
+                unsigned Modifiers = 0) {
     Kind = K;
     Text = T;
     this->CommentLength = CommentLength;
     EscapedIdentifier = false;
+    StringModifiers = Modifiers;
+    assert(StringModifiers == Modifiers && "Modifier overflow");
+  }
+
+  unsigned getStringModifiers() const {
+    return StringModifiers;
   }
 };