clang-format: [JS] re-quote single or double quoted strings.

[mprobst]

Summary

Automatically turns "foo" into 'foo' (or vice versa, depending on configuration).
This makes it more convenient to follow the Google JavaScript style guide:
https://google.github.io/styleguide/javascriptguide.xml?showone=Strings#Strings

This functionality is behind the option "Quotes", which can be:

• "leave" (no re-quoting)
• "single" (change to single quotes)
• or "double" (change to double quotes)

This also changes single quoted JavaScript string literals to be treated as
tok::string_literal, not tok::char_literal, which fixes two unrelated tests.

[mprobst]

Fixed typo.

[djasper]

lib/Format/Format.cpp

1622

What's the reason not to do this in FormatTokenLexer, ideally at the same time when increasing the length?

1628

LLVM comes with its own string stream implementation. Use that: raw_string_ostream.

[mprobst]

• Move code closer together by piping Replacements into the FormatTokenLexer.

[mprobst]

lib/Format/Format.cpp

1622

Done. I initially wanted to avoid having FormatTokenLexer generate Replacements, but this seems cleaner indeed.

[mprobst]

• Move code closer together by piping Replacements into the FormatTokenLexer.
• remove sstream import

[djasper]

Nice, the behavior now seems nicely isolated. Is this a purely stylistic kind of change or do you think every JS developer working on any kind of codebase will want it? Generally this feels like something we should carefully enable with a dedicated style option. Where can I find more information about it?

[mprobst]

Nice, the behavior now seems nicely isolated. Is this a purely stylistic
kind of change or do you think every JS developer working on any kind of
codebase will want it? Generally this feels like something we should
carefully enable with a dedicated style option. Where can I find more
information about it?

According to Google JavaScript style, you should always use single quotes
for string literals. Outside of that, people usually prefer one over the
other (I think), some people just use both indiscriminately. We could make
it an option, and only turn it on for a specific Google style.

Martin

[djasper]

Sounds like a good plan. Should also mention the corresponding style guide reference in the commit message:

https://google.github.io/styleguide/javascriptguide.xml?showone=Strings#Strings

[mprobst]

• Move code closer together by piping Replacements into the FormatTokenLexer.
• remove sstream import
• * Treat JavaScript single quoted string literals as tok::string_literal, not

[djasper]

include/clang/Format/Format.h

606

As this only affects JavaScript and doesn't make any sense for Java or C++, I'd like to have JS/JavaScript in the option and enum name.

lib/Format/Format.cpp

76

For almost all the other enums we use upper case.

1087

Are there more than the two options? Otherwise, I would find:

Style.Quotes == FormatStyle::QS_Single && FormatTok->TokenText.startswith("\'")

more intuitive.

1094

Move this up so you can use it in the if-statement?

unittests/Format/FormatTestJS.cpp

638

Why change this test? I think this was meant to test that we always add a line break between two consecutive string literals as otherwise the user could just have written this without the "' + '".

878

I don't think this is intended.

[mprobst]

• Move code closer together by piping Replacements into the FormatTokenLexer.
• remove sstream import
• * Treat JavaScript single quoted string literals as tok::string_literal, not
• Address review comments, mostly renaming things.

lib/Format/Format.cpp

1087

I would too, but think about template strings. Added a comment. I think it's safer to specifically check for the thing that we do handle/fix below, instead of just accepting everything we think is not correct.

unittests/Format/FormatTestJS.cpp

638

This was exposed by the char_literal/string_literal test, it aligns the behaviour with what would always happen for a double quoted string. It fits the no-alignment rule.

I've changed the test to make sure it actually wraps on two lines.

878

It is. This was incorrectly handled before, the line is longer than 20 chars. It's because I switched single quoted strings from char_literal to string_literal.

[mprobst]

• Move code closer together by piping Replacements into the FormatTokenLexer.
• remove sstream import
• * Treat JavaScript single quoted string literals as tok::string_literal, not
• Address review comments, mostly renaming things.
• Fix mustBreakBefore to handle tok::string_literal

[djasper]

lib/Format/Format.cpp

1131

Maybe add a FIXME saying that we also need to modify the TokenText if we want to be able to correctly split a long string literal.

1134

Thinking about this some more, I think it would be better to have replacements just changing each of the replaced quotes. Otherwise, this can get really tricky once we want to start to automatically split up long string literals. Should not make a difference performance-wise.

[mprobst]

• Move code closer together by piping Replacements into the FormatTokenLexer.
• remove sstream import
• * Treat JavaScript single quoted string literals as tok::string_literal, not
• Address review comments, mostly renaming things.
• Fix mustBreakBefore to handle tok::string_literal
• Insert individual replacements for each character change.

[mprobst]

unittests/Format/FormatTestJS.cpp

638–641

Reverted after some more discussion, this is the "must break before otherwise pointless string wrapping" feature.

[djasper]

Looks good.

lib/Format/Format.cpp

1140

I think this function doesn't carry its own weight.

[djasper]

Submitted as r262534.

include/clang/Format/Format.h

enum UseTabStyle {
     /// Use tabs whenever we need to fill whitespace that spans at least from
     /// one tab stop to the next one.
     UT_Always
   };
 
   /// \brief The way to use tab characters in the resulting file.
   UseTabStyle UseTab;
 
+  /// \brief Quotation styles for JavaScript strings. Does not affect template
+  /// strings.
+  enum QuoteStyle {
+    /// Leave string quotes as they are.
+    QS_Leave,
+    /// Always use single quotes.
+    QS_Single,
+    /// Always use double quotes.
+    QS_Double
+  };
+
+  /// \brief The QuoteStyle to use for JavaScript strings.
+  QuoteStyle Quotes;
+
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&
            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
            AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
            AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
            AlignEscapedNewlinesLeft == R.AlignEscapedNewlinesLeft &&
            AlignOperands == R.AlignOperands &&
            AlignTrailingComments == R.AlignTrailingComments &&
return AccessModifierOffset == R.AccessModifierOffset &&
            SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
            SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
            SpacesInAngles == R.SpacesInAngles &&
            SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
            SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
            SpacesInParentheses == R.SpacesInParentheses &&
            SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
            Standard == R.Standard && TabWidth == R.TabWidth &&
-           UseTab == R.UseTab;
+           UseTab == R.UseTab &&
+           Quotes == R.Quotes;
   }
 };
 
 /// \brief Returns a format style complying with the LLVM coding standards:
 /// http://llvm.org/docs/CodingStandards.html.
 FormatStyle getLLVMStyle();
 
 /// \brief Returns a format style complying with one of Google's style guides:

lib/Format/Format.cpp

static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
     IO.enumCase(Value, "Never", FormatStyle::UT_Never);
     IO.enumCase(Value, "false", FormatStyle::UT_Never);
     IO.enumCase(Value, "Always", FormatStyle::UT_Always);
     IO.enumCase(Value, "true", FormatStyle::UT_Always);
     IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
   }
 };
 
+template <> struct ScalarEnumerationTraits<FormatStyle::QuoteStyle> {
+  static void enumeration(IO &IO, FormatStyle::QuoteStyle &Value) {
+    IO.enumCase(Value, "leave", FormatStyle::QS_Leave);
+    IO.enumCase(Value, "single", FormatStyle::QS_Single);
+    IO.enumCase(Value, "double", FormatStyle::QS_Double);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
   static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
     IO.enumCase(Value, "None", FormatStyle::SFS_None);
     IO.enumCase(Value, "false", FormatStyle::SFS_None);
     IO.enumCase(Value, "All", FormatStyle::SFS_All);
     IO.enumCase(Value, "true", FormatStyle::SFS_All);
     IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
     IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
IO.mapOptional("SpacesInContainerLiterals",
                    Style.SpacesInContainerLiterals);
     IO.mapOptional("SpacesInCStyleCastParentheses",
                    Style.SpacesInCStyleCastParentheses);
     IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
     IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
     IO.mapOptional("Standard", Style.Standard);
     IO.mapOptional("TabWidth", Style.TabWidth);
     IO.mapOptional("UseTab", Style.UseTab);
+    IO.mapOptional("QuoteStyle", Style.Quotes);
   }
 };
 
 template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
   static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
     IO.mapOptional("AfterClass", Wrapping.AfterClass);
     IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
     IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
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.Quotes = FormatStyle::QS_Leave;
   LLVMStyle.ReflowComments = true;
   LLVMStyle.SpacesInParentheses = false;
   LLVMStyle.SpacesInSquareBrackets = false;
   LLVMStyle.SpaceInEmptyParentheses = false;
   LLVMStyle.SpacesInContainerLiterals = true;
   LLVMStyle.SpacesInCStyleCastParentheses = false;
   LLVMStyle.SpaceAfterCStyleCast = false;
   LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
if (Language == FormatStyle::LK_Java) {
     GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
     GoogleStyle.AlignOperands = false;
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
     GoogleStyle.BreakBeforeTernaryOperators = false;
     GoogleStyle.CommentPragmas = "@(export|see|visibility) ";
     GoogleStyle.MaxEmptyLinesToKeep = 3;
     GoogleStyle.SpacesInContainerLiterals = false;
+    GoogleStyle.Quotes = FormatStyle::QS_Single;
   } else if (Language == FormatStyle::LK_Proto) {
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
     GoogleStyle.SpacesInContainerLiterals = false;
   }
 
   return GoogleStyle;
 }
 
std::string configurationAsText(const FormatStyle &Style) {
   return Stream.str();
 }
 
 namespace {
 
 class FormatTokenLexer {
 public:
   FormatTokenLexer(SourceManager &SourceMgr, FileID ID, FormatStyle &Style,
-                   encoding::Encoding Encoding)
+                   encoding::Encoding Encoding, tooling::Replacements &Replaces)
       : FormatTok(nullptr), IsFirstToken(true), GreaterStashed(false),
         LessStashed(false), Column(0), TrailingWhitespace(0),
         SourceMgr(SourceMgr), ID(ID), Style(Style),
         IdentTable(getFormattingLangOpts(Style)), Keywords(IdentTable),
-        Encoding(Encoding), FirstInLineIndex(0), FormattingDisabled(false),
-        MacroBlockBeginRegex(Style.MacroBlockBegin),
+        Encoding(Encoding), Replaces(Replaces), FirstInLineIndex(0),
+        FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
         MacroBlockEndRegex(Style.MacroBlockEnd) {
     Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
                         getFormattingLangOpts(Style)));
     Lex->SetKeepWhitespaceMode(true);
 
     for (const std::string &ForEachMacro : Style.ForEachMacros)
       ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
     std::sort(ForEachMacros.begin(), ForEachMacros.end());
   }
 
   ArrayRef<FormatToken *> lex() {
     assert(Tokens.empty());
     assert(FirstInLineIndex == 0);
     do {
       Tokens.push_back(getNextToken());
       if (Style.Language == FormatStyle::LK_JavaScript)
         tryParseJSRegexLiteral();
       tryMergePreviousTokens();
+      if (Style.Language == FormatStyle::LK_JavaScript)
+        tryRequoteJSStringLiteral();
       if (Tokens.back()->NewlinesBefore > 0 || Tokens.back()->IsMultiline)
         FirstInLineIndex = Tokens.size() - 1;
     } while (Tokens.back()->Tok.isNot(tok::eof));
     return Tokens;
   }
 
   const AdditionalKeywords &getKeywords() { return Keywords; }
 
for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; I++) {
         Tokens.back()->ColumnWidth =
             EndOriginalColumn - Tokens.back()->OriginalColumn + 1;
       }
       return true;
     }
     return false;
   }
 
+  // If the last token is a double/single-quoted string literal, generates a
+  // replacement with a single/double quoted string literal, re-escaping the
+  // contents in the process.
+  void tryRequoteJSStringLiteral() {
+    if (Style.Quotes == FormatStyle::QS_Leave)
+      return;
+    FormatToken *FormatTok = Tokens.back();
+
+    if (!FormatTok->isStringLiteral() ||
+        (Style.Quotes == FormatStyle::QS_Single &&
+         !FormatTok->TokenText.startswith("\"")) ||
+        (Style.Quotes == FormatStyle::QS_Double &&
+         !FormatTok->TokenText.startswith("\'")))
+      return;
+
+    char Quote = Style.Quotes == FormatStyle::QS_Single ? '\'' : '\"';
+
+    StringRef Input = FormatTok->TokenText;
+    size_t ColumnWidth = FormatTok->TokenText.size();
+    std::string Res(1, Quote);
+    llvm::raw_string_ostream Out(Res);
+    bool Escaped = false;
+    for (size_t i = 1; i < Input.size() - 1; i++) {
+      switch (Input[i]) {
+      case '\\':
+        if (!Escaped && i + 1 < Input.size() &&
+            ((Quote == '\'' && Input[i + 1] == '"') ||
+             (Quote == '"' && Input[i + 1] == '\''))) {
+          // Skip this \, it's escaping a " or ' that no longer needs escaping.
+          ColumnWidth--;
+          continue;
+        }
+        Escaped = !Escaped;
+        break;
+      case '\"':
+      case '\'':
+        if (Input[i] == Quote && !Escaped) {
+          Out << '\\';
+          ColumnWidth++;
+        }
+        Escaped = false;
+        break;
+      default:
+        Escaped = false;
+        break;
+      }
+      Out << Input[i];
+    }
+    Out << Quote;
+
+    // For formatting, count the number of non-escaped single quotes in them
+    // and adjust ColumnWidth to take the added escapes into account.
+    FormatTok->ColumnWidth = ColumnWidth;
+
+    SourceRange Range(FormatTok->Tok.getLocation(), FormatTok->Tok.getEndLoc());
+    Replaces.insert(tooling::Replacement(
+        SourceMgr, CharSourceRange::getCharRange(Range), Out.str()));
+  }
+
   bool tryMerge_TMacro() {
     if (Tokens.size() < 4)
       return false;
     FormatToken *Last = Tokens.back();
     if (!Last->is(tok::r_paren))
       return false;
 
     FormatToken *String = Tokens[Tokens.size() - 2];
     if (!String->is(tok::string_literal) || String->IsMultiline)
       return false;
 
     if (!Tokens[Tokens.size() - 3]->is(tok::l_paren))
       return false;
private:
   unsigned TrailingWhitespace;
   std::unique_ptr<Lexer> Lex;
   SourceManager &SourceMgr;
   FileID ID;
   FormatStyle &Style;
   IdentifierTable IdentTable;
   AdditionalKeywords Keywords;
   encoding::Encoding Encoding;
+  tooling::Replacements &Replaces;
   llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
   // Index (in 'Tokens') of the last token that starts a new line.
   unsigned FirstInLineIndex;
   SmallVector<FormatToken *, 16> Tokens;
   SmallVector<IdentifierInfo *, 8> ForEachMacros;
 
   bool FormattingDisabled;
 
   llvm::Regex MacroBlockBeginRegex;
   llvm::Regex MacroBlockEndRegex;
 
   void readRawToken(FormatToken &Tok) {
     Lex->LexFromRawLexer(Tok.Tok);
     Tok.TokenText = StringRef(SourceMgr.getCharacterData(Tok.Tok.getLocation()),
                               Tok.Tok.getLength());
     // For formatting, treat unterminated string literals like normal string
     // literals.
     if (Tok.is(tok::unknown)) {
       if (!Tok.TokenText.empty() && Tok.TokenText[0] == '"') {
         Tok.Tok.setKind(tok::string_literal);
         Tok.IsUnterminatedLiteral = true;
       } else if (Style.Language == FormatStyle::LK_JavaScript &&
                  Tok.TokenText == "''") {
-        Tok.Tok.setKind(tok::char_constant);
+        Tok.Tok.setKind(tok::string_literal);
       }
     }
 
+    if (Style.Language == FormatStyle::LK_JavaScript &&
+        Tok.is(tok::char_constant)) {
+      Tok.Tok.setKind(tok::string_literal);
+    }
+
     if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format on" ||
                                  Tok.TokenText == "/* clang-format on */")) {
       FormattingDisabled = false;
     }
 
     Tok.Finalized = FormattingDisabled;
 
     if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" ||
DEBUG(llvm::dbgs() << "File encoding: "
                                                                : "unknown")
                        << "\n");
     DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
                        << "\n");
   }
 
   tooling::Replacements format(bool *IncompleteFormat) {
     tooling::Replacements Result;
-    FormatTokenLexer Tokens(SourceMgr, ID, Style, Encoding);
+    FormatTokenLexer Tokens(SourceMgr, ID, Style, Encoding, Result);
 
     UnwrappedLineParser Parser(Style, Tokens.getKeywords(), Tokens.lex(),
                                *this);
     Parser.parse();
     assert(UnwrappedLines.rbegin()->empty());
     for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE;
          ++Run) {
       DEBUG(llvm::dbgs() << "Run " << Run << "...\n");
while (I != E) {
       ++I;
     }
     return SomeLineAffected;
   }
 
   // Determines whether 'Line' is affected by the SourceRanges given as input.
   // Returns \c true if line or one if its children is affected.
   bool nonPPLineAffected(AnnotatedLine *Line,
                          const AnnotatedLine *PreviousLine) {
     bool SomeLineAffected = false;
     Line->ChildrenAffected =
         computeAffectedLines(Line->Children.begin(), Line->Children.end());
     if (Line->ChildrenAffected)
       SomeLineAffected = true;
 
     // Stores whether one of the line's tokens is directly affected.
     bool SomeTokenAffected = false;
     // Stores whether we need to look at the leading newlines of the next token
     // in order to determine whether it was affected.
     bool IncludeLeadingNewlines = false;
 
     // Stores whether the first child line of any of this line's tokens is
     // affected.

unittests/Format/FormatTest.cpp

verifyFormat(
       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
 
   // No column layout should be used here.
   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
 
   verifyNoCrash("a<,");
-  
   // No braced initializer here.
   verifyFormat("void f() {\n"
                "  struct Dummy {};\n"
                "  f(v);\n"
                "}");
 
   // Long lists should be formatted in columns even if they are nested.
   verifyFormat(

unittests/Format/FormatTestJS.cpp

verifyFormat("var object_literal_with_long_name = {\n"
                "  b: 'bbbbbbbbbbbbbbbbbb'\n"
                "};");
 
   verifyFormat("f({a: 1, b: 2, c: 3});",
                getChromiumStyle(FormatStyle::LK_JavaScript));
   verifyFormat("f({'a': [{}]});");
 }
 
-TEST_F(FormatTestJS, SingleQuoteStrings) {
+TEST_F(FormatTestJS, SingleQuotedStrings) {
   verifyFormat("this.function('', true);");
 }
 
 TEST_F(FormatTestJS, GoogScopes) {
   verifyFormat("goog.scope(function() {\n"
                "var x = a.b;\n"
                "var y = c.d;\n"
                "});  // goog.scope");
TEST_F(FormatTestJS, TryCatch) {
 
   // But, of course, "catch" is a perfectly fine function name in JavaScript.
   verifyFormat("someObject.catch();");
   verifyFormat("someObject.new();");
   verifyFormat("someObject.delete();");
 }
 
 TEST_F(FormatTestJS, StringLiteralConcatenation) {
-  verifyFormat("var literal = 'hello ' +\n"
-               "    'world';");
+  verifyFormat("var literal =\n"
+               "    'hello ' + 'world';",
+               getGoogleJSStyleWithColumns(30));
 }
 
 TEST_F(FormatTestJS, RegexLiteralClassification) {
   // Regex literals.
   verifyFormat("var regex = /abc/;");
   verifyFormat("f(/abc/);");
   verifyFormat("f(abc, /abc/);");
   verifyFormat("some_map[/abc/];");
   verifyFormat("var x = a ? /abc/ : /abc/;");
verifyFormat("import {\n"
                "} from 'some/module.js';");
   verifyFormat("import {\n"
                "  X,\n"
                "  Y,\n"
                "} from 'some/module.js';");
   verifyFormat("import {\n"
                "  X,\n"
                "  Y,\n"
-               "} from 'some/long/module.js';",
+               "} from\n    'some/long/module.js';",
                getGoogleJSStyleWithColumns(20));
   verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
   verifyFormat("import * as lib from 'some/module.js';");
   verifyFormat("var x = {import: 1};\nx.import = 2;");
 
   verifyFormat("export function fn() {\n"
                "  return 'fn';\n"
                "}");
EXPECT_EQ("/**\n"
             " * @export {this.is.a.long.path.to.a.Type}\n"
             " */",
             format("/**\n"
                    " * @export {this.is.a.long.path.to.a.Type}\n"
                    " */",
                    getGoogleJSStyleWithColumns(20)));
 }
 
+TEST_F(FormatTestJS, RequoteStringsSingle) {
+  EXPECT_EQ("var x = 'foo';", format("var x = \"foo\";"));
+  EXPECT_EQ("var x = 'fo\\'o\\'';", format("var x = \"fo'o'\";"));
+  EXPECT_EQ("var x = 'fo\\'o\\'';", format("var x = \"fo\\'o'\";"));
+  EXPECT_EQ("var x =\n"
+            "    'foo\\'';",
+            // Code below is 15 chars wide, doesn't fit into the line with the
+            // \ escape added.
+            format("var x = \"foo'\";", getGoogleJSStyleWithColumns(15)));
+  // Removes no-longer needed \ escape from ".
+  EXPECT_EQ("var x = 'fo\"o';", format("var x = \"fo\\\"o\";"));
+  // Code below fits into 15 chars *after* removing the \ escape.
+  EXPECT_EQ("var x = 'fo\"o';",
+            format("var x = \"fo\\\"o\";", getGoogleJSStyleWithColumns(15)));
+}
+
+TEST_F(FormatTestJS, RequoteStringsDouble) {
+  FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
+  DoubleQuotes.Quotes = FormatStyle::QS_Double;
+  verifyFormat("var x = \"foo\";", DoubleQuotes);
+  EXPECT_EQ("var x = \"foo\";", format("var x = 'foo';", DoubleQuotes));
+  EXPECT_EQ("var x = \"fo'o\";", format("var x = 'fo\\'o';", DoubleQuotes));
+}
+
+TEST_F(FormatTestJS, RequoteStringsLeave) {
+  FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
+  LeaveQuotes.Quotes = FormatStyle::QS_Leave;
+  verifyFormat("var x = \"foo\";", LeaveQuotes);
+  verifyFormat("var x = 'foo';", LeaveQuotes);
+}
+
 } // end namespace tooling
 } // end namespace clang