[clang-format] Adds canonical raw string delimiters support

[krasimir]

Summary

SUPERSEDED by another change.
A canonical raw string delimiter for a given language is the preferred raw string
delimiter to use for that language. For example, both 'pb' and 'proto' could
serve to indentify a raw string literal as a proto string, but 'proto' is the
preferred one.
This patch adds support for canonical raw string delimiters to clang-format,
effectively updating the delimiters to the canonical one.

[krasimir]

• Update documentation

[krasimir]

• Make 'textproto' the canonical text proto delimiter for google style

docs/ClangFormatStyleOptions.rst

**BreakConstructorInitializers** (``BreakConstructorInitializersStyle``)
 
   Possible values:
 
   * ``BCIS_BeforeColon`` (in configuration: ``BeforeColon``)
     Break constructor initializers before the colon and after the commas.
 
     .. code-block:: c++
 
-      Constructor()
-          : initializer1(),
-            initializer2()
 
   * ``BCIS_BeforeComma`` (in configuration: ``BeforeComma``)
     Break constructor initializers before the colon and commas, and align
     the commas with the colon.
 
     .. code-block:: c++
 
-      Constructor()
-          : initializer1()
-          , initializer2()
 
   * ``BCIS_AfterColon`` (in configuration: ``AfterColon``)
     Break constructor initializers after the colon and commas.
 
     .. code-block:: c++
 
-      Constructor() :
-          initializer1(),
-          initializer2()
 
 
 
 **BreakStringLiterals** (``bool``)
   Allow breaking string literals when formatting.
 
 **ColumnLimit** (``unsigned``)
   The column limit.
.. code-block:: c++
 
        #include "b.h"               into      #include "a.h"
                                               #include "b.h"
        #include <lib/main.h>                  #include <lib/main.h>
        #include "a.h"
 
   * ``IBS_Regroup`` (in configuration: ``Regroup``)
     Merge multiple ``#include`` blocks together and sort as one.
-    Then split into groups based on category priority. See ``IncludeCategories``.
+    Then split into groups based on category priority. See
+    ``IncludeCategories``.
 
     .. code-block:: c++
 
        #include "b.h"               into      #include "a.h"
                                               #include "b.h"
        #include <lib/main.h>
        #include "a.h"                         #include <lib/main.h>
 

 
 **RawStringFormats** (``std::vector<RawStringFormat>``)
   Raw string delimiters denoting that the raw string contents are
   code in a particular language and can be reformatted.
 
   A raw string with a matching delimiter will be reformatted assuming the
   specified language based on a predefined style given by 'BasedOnStyle'.
   If 'BasedOnStyle' is not found, the formatting is based on llvm style.
+  If it exists, the last canonical delimiter for a given language will be
+  used to update other delimiters for that language.
 
   To configure this in the .clang-format file, use:
 
   .. code-block:: yaml
 
     RawStringFormats:
       - Delimiter: 'pb'
         Language:  TextProto
         BasedOnStyle: llvm
+        Canonical: false
       - Delimiter: 'proto'
         Language:  TextProto
         BasedOnStyle: google
+        Canonical: true
 
 **ReflowComments** (``bool``)
   If ``true``, clang-format will attempt to re-flow comments.
 
   .. code-block:: c++
 
      false:
      // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information

include/clang/Format/Format.h

struct RawStringFormat {
     /// \brief The delimiter that this raw string format matches.
     std::string Delimiter;
     /// \brief The language of this raw string.
     LanguageKind Language;
     /// \brief The style name on which this raw string format is based on.
     /// If not specified, the raw string format is based on the style that this
     /// format is based on.
     std::string BasedOnStyle;
+    /// \brief If true, this delimiter is canonical for this language.
+    /// The canonical delimiter for a given language is the last delimiter
+    /// declared canonical in the sequence of raw string formats, if it exists.
+    /// If a canonical raw string format exists for a language, instances of
+    /// other raw string delimiters for that language will have their delimiter
+    /// updated to the canonical one.
+    bool Canonical;
     bool operator==(const RawStringFormat &Other) const {
       return Delimiter == Other.Delimiter && Language == Other.Language &&
-             BasedOnStyle == Other.BasedOnStyle;
+             BasedOnStyle == Other.BasedOnStyle && Canonical == Other.Canonical;
     }
   };
 
   /// \brief Raw string delimiters denoting that the raw string contents are
   /// code in a particular language and can be reformatted.
   ///
   /// A raw string with a matching delimiter will be reformatted assuming the
   /// specified language based on a predefined style given by 'BasedOnStyle'.
   /// If 'BasedOnStyle' is not found, the formatting is based on llvm style.
+  /// If it exists, the last canonical delimiter for a given language will be
+  /// used to update other delimiters for that language.
   ///
   /// To configure this in the .clang-format file, use:
   /// \code{.yaml}
   ///   RawStringFormats:
   ///     - Delimiter: 'pb'
   ///       Language:  TextProto
   ///       BasedOnStyle: llvm
+  ///       Canonical: false
   ///     - Delimiter: 'proto'
   ///       Language:  TextProto
   ///       BasedOnStyle: google
+  ///       Canonical: true
   /// \endcode
   std::vector<RawStringFormat> RawStringFormats;
 
   /// \brief If ``true``, clang-format will attempt to re-flow comments.
   /// \code
   ///    false:
   ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
   ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */

lib/Format/ContinuationIndenter.cpp

static llvm::Optional<StringRef> getRawStringDelimiter(StringRef TokenText) {
   size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
   if (TokenText[RParenPos] != ')')
     return None;
   if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
     return None;
   return Delimiter;
 }
 
+static llvm::Optional<StringRef>
+getCanonicalRawStringDelimiter(const FormatStyle &Style,
+                               FormatStyle::LanguageKind Language) {
+  for (const auto &Format : llvm::reverse(Style.RawStringFormats)) {
+    if (Format.Language == Language && Format.Canonical)
+      return StringRef(Format.Delimiter);
+  }
+  return None;
+}
+
 RawStringFormatStyleManager::RawStringFormatStyleManager(
     const FormatStyle &CodeStyle) {
   for (const auto &RawStringFormat : CodeStyle.RawStringFormats) {
     FormatStyle Style;
     if (!getPredefinedStyle(RawStringFormat.BasedOnStyle,
                             RawStringFormat.Language, &Style)) {
       Style = getLLVMStyle();
       Style.Language = RawStringFormat.Language;
if (Current.is(tok::r_brace) && Current.MatchingParen &&
         // Only strip trailing empty lines for l_braces that have children, i.e.
         // for function expressions (lambdas, arrows, etc).
         !Current.MatchingParen->Children.empty()) {
       // lambdas and arrow functions are expressions, thus their r_brace is not
       // on its own line, and thus not covered by UnwrappedLineFormatter's logic
       // about removing empty lines on closing blocks. Special case them here.
       MaxEmptyLinesToKeep = 1;
     }
-    unsigned Newlines = std::max(
-        1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));
+    unsigned Newlines =
+        std::max(1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));
     bool ContinuePPDirective =
         State.Line->InPPDirective && State.Line->Type != LT_ImportStatement;
     Whitespaces.replaceWhitespace(Current, Newlines, State.Column, State.Column,
                                   ContinuePPDirective);
   }
 
   if (!Current.isTrailingComment())
     State.Stack.back().LastSpace = State.Column;
else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0)
     State.StartOfStringLiteral = State.Column;
   else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
            !Current.isStringLiteral())
     State.StartOfStringLiteral = 0;
 
   State.Column += Current.ColumnWidth;
   State.NextToken = State.NextToken->Next;
 
-  unsigned Penalty =
-      handleEndOfLine(Current, State, DryRun, AllowBreak);
+  unsigned Penalty = handleEndOfLine(Current, State, DryRun, AllowBreak);
 
   if (Current.Role)
     Current.Role->formatFromToken(State, this, DryRun);
   // If the previous has a special role, let it consume tokens as appropriate.
   // It is necessary to start at the previous token for the only implemented
   // role (comma separated list). That way, the decision whether or not to break
   // after the "{" is already done and both options are tried and evaluated.
   // FIXME: This is ugly, find a better way.
return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos),
                                          /*StartColumn=*/0, TabWidth, Encoding);
   }
 }
 
 unsigned ContinuationIndenter::reformatRawStringLiteral(
     const FormatToken &Current, LineState &State,
     const FormatStyle &RawStringStyle, bool DryRun) {
   unsigned StartColumn = State.Column - Current.ColumnWidth;
-  auto Delimiter = *getRawStringDelimiter(Current.TokenText);
+  StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText);
+  auto CanonicalDelimiter =
+      getCanonicalRawStringDelimiter(Style, RawStringStyle.Language);
+  StringRef NewDelimiter =
+      CanonicalDelimiter ? *CanonicalDelimiter : OldDelimiter;
+  bool UpdateDelimiter =
+      CanonicalDelimiter && *CanonicalDelimiter != OldDelimiter;
+
   // The text of a raw string is between the leading 'R"delimiter(' and the
   // trailing 'delimiter)"'.
-  unsigned PrefixSize = 3 + Delimiter.size();
-  unsigned SuffixSize = 2 + Delimiter.size();
+  unsigned OldPrefixSize = 3 + OldDelimiter.size();
+  unsigned NewPrefixSize =
+      UpdateDelimiter ? (3 + CanonicalDelimiter->size()) : OldPrefixSize;
+  unsigned OldSuffixSize = 2 + OldDelimiter.size();
+  unsigned NewSuffixSize =
+      UpdateDelimiter ? (2 + CanonicalDelimiter->size()) : OldSuffixSize;
 
-  // The first start column is the column the raw text starts.
-  unsigned FirstStartColumn = StartColumn + PrefixSize;
+  // The first start column is the column the raw text starts after formatting.
+  unsigned FirstStartColumn = StartColumn + NewPrefixSize;
 
   // The next start column is the intended indentation a line break inside
   // the raw string at level 0. It is determined by the following rules:
   //   - if the content starts on newline, it is one level more than the current
   //     indent, and
   //   - if the content does not start on a newline, it is the first start
   //     column.
   // These rules have the advantage that the formatted content both does not
   // violate the rectangle rule and visually flows within the surrounding
   // source.
-  bool ContentStartsOnNewline = Current.TokenText[PrefixSize] == '\n';
+  bool ContentStartsOnNewline = Current.TokenText[OldPrefixSize] == '\n';
   unsigned NextStartColumn = ContentStartsOnNewline
                                  ? State.Stack.back().Indent + Style.IndentWidth
                                  : FirstStartColumn;
 
   // The last start column is the column the raw string suffix starts if it is
   // put on a newline.
   // The last start column is the intended indentation of the raw string postfix
   // if it is put on a newline. It is determined by the following rules:
   //   - if the raw string prefix starts on a newline, it is the column where
   //     that raw string prefix starts, and
   //   - if the raw string prefix does not start on a newline, it is the current
   //     indent.
   unsigned LastStartColumn = Current.NewlinesBefore
-                                 ? FirstStartColumn - PrefixSize
+                                 ? FirstStartColumn - NewPrefixSize
                                  : State.Stack.back().Indent;
 
   std::string RawText =
-      Current.TokenText.substr(PrefixSize).drop_back(SuffixSize);
+      Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
 
   std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat(
       RawStringStyle, RawText, {tooling::Range(0, RawText.size())},
       FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>",
       /*Status=*/nullptr);
 
   auto NewCode = applyAllReplacements(RawText, Fixes.first);
   tooling::Replacements NoFixes;
   if (!NewCode) {
     State.Column += Current.ColumnWidth;
     return 0;
   }
   if (!DryRun) {
+    if (UpdateDelimiter) {
+      // In 'R"delimiter(...', the delimiter starts 2 characters after the start
+      // of the token.
+      SourceLocation PrefixDelimiterStart =
+          Current.Tok.getLocation().getLocWithOffset(2);
+      auto PrefixErr = Whitespaces.addReplacement(tooling::Replacement(
+          SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
+      if (PrefixErr) {
+        llvm::errs()
+            << "Failed to update the prefix delimiter of a raw string: "
+            << llvm::toString(std::move(PrefixErr)) << "\n";
+      }
+      // In 'R"delimiter(...)delimiter"', the suffix delimiter starts at
+      // position length - 1 - |delimiter|.
+      SourceLocation SuffixDelimiterStart =
+          Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() -
+                                                     1 - OldDelimiter.size());
+      auto SuffixErr = Whitespaces.addReplacement(tooling::Replacement(
+          SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
+      if (SuffixErr) {
+        llvm::errs()
+            << "Failed to update the suffix delimiter of a raw string: "
+            << llvm::toString(std::move(SuffixErr)) << "\n";
+      }
+    }
     SourceLocation OriginLoc =
-        Current.Tok.getLocation().getLocWithOffset(PrefixSize);
+        Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);
     for (const tooling::Replacement &Fix : Fixes.first) {
       auto Err = Whitespaces.addReplacement(tooling::Replacement(
           SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
           Fix.getLength(), Fix.getReplacementText()));
       if (Err) {
         llvm::errs() << "Failed to reformat raw string: "
                      << llvm::toString(std::move(Err)) << "\n";
       }
     }
   }
   unsigned RawLastLineEndColumn = getLastLineEndColumn(
       *NewCode, FirstStartColumn, Style.TabWidth, Encoding);
-  State.Column = RawLastLineEndColumn + SuffixSize;
+  State.Column = RawLastLineEndColumn + NewSuffixSize;
   return Fixes.second;
 }
 
 unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
                                                  LineState &State) {
   // Break before further function parameters on all levels.
   for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
     State.Stack[i].BreakBeforeParameter = true;
if (!Delimiter)
     return None;
   auto RawStringStyle = RawStringFormats.get(*Delimiter);
   if (!RawStringStyle)
     return None;
   RawStringStyle->ColumnLimit = getColumnLimit(State);
   return RawStringStyle;
 }
 
-std::unique_ptr<BreakableToken> ContinuationIndenter::createBreakableToken(
-    const FormatToken &Current, LineState &State, bool AllowBreak) {
+std::unique_ptr<BreakableToken>
+ContinuationIndenter::createBreakableToken(const FormatToken &Current,
+                                           LineState &State, bool AllowBreak) {
   unsigned StartColumn = State.Column - Current.ColumnWidth;
   if (Current.isStringLiteral()) {
     // FIXME: String literal breaking is currently disabled for Java and JS, as
     // it requires strings to be merged using "+" which we don't support.
     if (Style.Language == FormatStyle::LK_Java ||
         Style.Language == FormatStyle::LK_JavaScript ||
-        !Style.BreakStringLiterals ||
-        !AllowBreak)
+        !Style.BreakStringLiterals || !AllowBreak)
       return nullptr;
 
     // Don't break string literals inside preprocessor directives (except for
     // #define directives, as their contents are stored in separate lines and
     // are not affected by this check).
     // This way we avoid breaking code with line directives and unknown
     // preprocessor directives that contain long string literals.
     if (State.Line->Type == LT_PreprocessorDirective)
while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
               Split.first + Split.second + NextSplit.first, ContentStartColumn);
         }
         // Compress the whitespace between the break and the start of the next
         // unbreakable sequence.
         ToNextSplitColumns =
             Token->getLengthAfterCompression(ToNextSplitColumns, Split);
         DEBUG(llvm::dbgs() << "    ContentStartColumn: " << ContentStartColumn
                            << "\n");
-        DEBUG(llvm::dbgs() << "    ToNextSplit: " << ToNextSplitColumns << "\n");
+        DEBUG(llvm::dbgs() << "    ToNextSplit: " << ToNextSplitColumns
+                           << "\n");
         // If the whitespace compression makes us fit, continue on the current
         // line.
         bool ContinueOnLine =
             ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
         unsigned ExcessCharactersPenalty = 0;
         if (!ContinueOnLine && !Strict) {
           // Similarly, if the excess characters' penalty is lower than the
           // penalty of introducing a new break, continue on the current line.

lib/Format/Format.cpp

FormatStyle getLLVMStyle() {
   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
   LLVMStyle.ObjCBlockIndentWidth = 2;
   LLVMStyle.ObjCSpaceAfterProperty = false;
   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
   LLVMStyle.SpacesBeforeTrailingComments = 1;
   LLVMStyle.Standard = FormatStyle::LS_Cpp11;
   LLVMStyle.UseTab = FormatStyle::UT_Never;
-  LLVMStyle.RawStringFormats = {{"pb", FormatStyle::LK_TextProto, "google"}};
+  LLVMStyle.RawStringFormats = {
+      {"pb", FormatStyle::LK_TextProto, "google", /*Canonical=*/false}};
   LLVMStyle.ReflowComments = true;
   LLVMStyle.SpacesInParentheses = false;
   LLVMStyle.SpacesInSquareBrackets = false;
   LLVMStyle.SpaceInEmptyParentheses = false;
   LLVMStyle.SpacesInContainerLiterals = true;
   LLVMStyle.SpacesInCStyleCastParentheses = false;
   LLVMStyle.SpaceAfterCStyleCast = false;
   LLVMStyle.SpaceAfterTemplateKeyword = true;
FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
   GoogleStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
   GoogleStyle.IndentCaseLabels = true;
   GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
   GoogleStyle.ObjCSpaceAfterProperty = false;
   GoogleStyle.ObjCSpaceBeforeProtocolList = false;
   GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
   GoogleStyle.SpacesBeforeTrailingComments = 2;
   GoogleStyle.Standard = FormatStyle::LS_Auto;
+  GoogleStyle.RawStringFormats = {
+      {"pb", FormatStyle::LK_TextProto, "google", /*Canonical=*/false},
+      {"PB", FormatStyle::LK_TextProto, "google", /*Canonical=*/false},
+      {"PROTO", FormatStyle::LK_TextProto, "google", /*Canonical=*/false},
+      {"proto", FormatStyle::LK_TextProto, "google", /*Canonical=*/false},
+      {"TEXTPROTO", FormatStyle::LK_TextProto, "google", /*Canonical=*/false},
+      {"textproto", FormatStyle::LK_TextProto, "google", /*Canonical=*/true},
+  };
 
   GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
   GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
 
   if (Language == FormatStyle::LK_Java) {
     GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
     GoogleStyle.AlignOperands = false;
     GoogleStyle.AlignTrailingComments = false;

unittests/Format/FormatTestRawStrings.cpp

protected:
 
   int ReplacementCount;
 
   FormatStyle getRawStringPbStyleWithColumns(unsigned ColumnLimit) {
     FormatStyle Style = getLLVMStyle();
     Style.ColumnLimit = ColumnLimit;
     Style.RawStringFormats = {{/*Delimiter=*/"pb",
                                /*Kind=*/FormatStyle::LK_TextProto,
-                               /*BasedOnStyle=*/"google"}};
+                               /*BasedOnStyle=*/"google",
+                               /*Canonical=*/false}};
     return Style;
   }
 
   FormatStyle getRawStringLLVMCppStyleBasedOn(std::string BasedOnStyle) {
     FormatStyle Style = getLLVMStyle();
     Style.RawStringFormats = {{/*Delimiter=*/"cpp",
-                               /*Kind=*/FormatStyle::LK_Cpp, BasedOnStyle}};
+                               /*Kind=*/FormatStyle::LK_Cpp, BasedOnStyle,
+                               /*Canonical=*/false}};
     return Style;
   }
 
   FormatStyle getRawStringGoogleCppStyleBasedOn(std::string BasedOnStyle) {
     FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
     Style.RawStringFormats = {{/*Delimiter=*/"cpp",
-                               /*Kind=*/FormatStyle::LK_Cpp, BasedOnStyle}};
+                               /*Kind=*/FormatStyle::LK_Cpp, BasedOnStyle,
+                               /*Canonical=*/false}};
     return Style;
   }
 
   // Gcc 4.8 doesn't support raw string literals in macros, which breaks some
   // build bots. We use this function instead.
   void expect_eq(const std::string Expected, const std::string Actual) {
     EXPECT_EQ(Expected, Actual);
   }
t = R"pb(item: 1)pb";)test",
             format(R"test(
 s = R"PB(item:1)PB";
 t = R"pb(item:1)pb";)test",
                    getRawStringPbStyleWithColumns(40)));
 
   FormatStyle MixedStyle = getLLVMStyle();
   MixedStyle.RawStringFormats = {
       {/*Delimiter=*/"cpp", /*Kind=*/FormatStyle::LK_Cpp,
-       /*BasedOnStyle=*/"llvm"},
+       /*BasedOnStyle=*/"llvm", /*Canonical=*/false},
       {/*Delimiter=*/"CPP", /*Kind=*/FormatStyle::LK_Cpp,
-       /*BasedOnStyle=*/"google"}};
+       /*BasedOnStyle=*/"google", /*Canonical=*/false}};
 
   // Format the 'cpp' raw string with '*' on the right.
   // Format the 'CPP' raw string with '*' on the left.
   // Do not format the 'Cpp' raw string.
   // Do not format non-raw strings.
   expect_eq(R"test(
 a = R"cpp(int *i = 0;)cpp";
 b = R"CPP(int* j = 0;)CPP";
TPPPPPPPPPPPPPPP(
             format(R"test(
 P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2, item_3: 3)pb");)test",
                    getRawStringPbStyleWithColumns(40)));
 
   expect_eq(R"test(
 P p = TP(R"pb(item_1 <1>
               item_2: <2>
               item_3 {})pb");)test",
             format(R"test(
 P p = TP(R"pb(item_1<1> item_2:<2> item_3{ })pb");)test",
                    getRawStringPbStyleWithColumns(40)));
 
   expect_eq(
       R"test(
 P p = TP(R"pb(item_1: 1,
               item_2: 2,
               item_3: 3,
               item_4: 4)pb");)test",
       format(
ASSERT_TRUE(ParseFromString(R"pb(item_1: 1, item_2: 2)pb"), ptr);)test",
   expect_eq(R"test(
 ASSERT_TRUE(
     ParseFromString(
         R"pb(item_1: 1 item_2: 2)pb"),
     ptr);)test",
             format(R"test(
 ASSERT_TRUE(ParseFromString(R"pb(item_1: 1 item_2: 2)pb"), ptr);)test",
                    getRawStringPbStyleWithColumns(40)));
-
 }
 
 TEST_F(FormatTestRawStrings, RawStringsInOperands) {
   // Formats the raw string first operand of a binary operator expression.
   expect_eq(R"test(auto S = R"pb(item_1: 1)pb" + rest;)test",
             format(R"test(auto S = R"pb(item_1:1)pb" + rest;)test",
                    getRawStringPbStyleWithColumns(40)));
 
auto S =
     (count < 3)
         ? R"pb(item_1: 1)pb"
         : R"pb(item_2: 2, item_3: 3)pb";
 )test",
             format(R"test(
 auto S=(count<3)?R"pb(item_1:1)pb":R"pb(item_2:2,item_3:3)pb";
 )test",
                    getRawStringPbStyleWithColumns(40)));
-
 }
 
 TEST_F(FormatTestRawStrings, PrefixAndSuffixAlignment) {
   // Keep the suffix at the end of line if not on newline.
   expect_eq(R"test(
 int s() {
   auto S = PTP(
       R"pb(

 }
 
 TEST_F(FormatTestRawStrings, DontFormatNonRawStrings) {
   expect_eq(R"test(a = R"pb(key:value)";)test",
             format(R"test(a = R"pb(key:value)";)test",
                    getRawStringPbStyleWithColumns(20)));
 }
 
+TEST_F(FormatTestRawStrings, UpdatesToCanonicalDelimiters) {
+  FormatStyle Style = getRawStringPbStyleWithColumns(25);
+  Style.RawStringFormats.push_back({/*Delimiter=*/"proto",
+                                    /*Kind=*/FormatStyle::LK_TextProto,
+                                    /*BasedOnStyle=*/"google",
+                                    /*Canonical=*/true});
+  expect_eq(R"test(a = R"proto(key: value)proto";)test",
+            format(R"test(a = R"pb(key:value)pb";)test", Style));
+  expect_eq(R"test(a = R"proto(key: value)proto";)test",
+            format(R"test(a = R"proto(key:value)proto";)test", Style));
+  expect_eq(R"test(
+f(a,
+  R"proto(item {
+            key: value
+            key: value
+          })proto");
+)test",
+            format(R"test(
+f(a,
+  R"pb(item {
+         key: value
+         key: value
+       })pb");
+)test",
+                   Style));
+  // The last canonical delimiter for a language is the canonical delimiter for
+  // that language.
+  Style.RawStringFormats.push_back({/*Delimiter=*/"cproto",
+                                    /*Kind=*/FormatStyle::LK_TextProto,
+                                    /*BasedOnStyle=*/"google",
+                                    /*Canonical=*/true});
+  expect_eq(R"test(
+f(a,
+  R"cproto(item {
+             key: value
+             key: value
+           })cproto");
+)test",
+            format(R"test(
+f(a,
+  R"proto(item {
+         key: value
+         key: value
+       })proto");
+)test",
+                   Style));
+}
+
 } // end namespace
 } // end namespace format
 } // end namespace clang