clang-tools  11.0.0
RawStringLiteralCheck.cpp
Go to the documentation of this file.
1 //===--- RawStringLiteralCheck.cpp - clang-tidy----------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "clang/AST/ASTContext.h"
11 #include "clang/ASTMatchers/ASTMatchFinder.h"
12 #include "clang/Lex/Lexer.h"
13 
14 using namespace clang::ast_matchers;
15 
16 namespace clang {
17 namespace tidy {
18 namespace modernize {
19 
20 namespace {
21 
22 bool containsEscapes(StringRef HayStack, StringRef Escapes) {
23  size_t BackSlash = HayStack.find('\\');
24  if (BackSlash == StringRef::npos)
25  return false;
26 
27  while (BackSlash != StringRef::npos) {
28  if (Escapes.find(HayStack[BackSlash + 1]) == StringRef::npos)
29  return false;
30  BackSlash = HayStack.find('\\', BackSlash + 2);
31  }
32 
33  return true;
34 }
35 
36 bool isRawStringLiteral(StringRef Text) {
37  // Already a raw string literal if R comes before ".
38  const size_t QuotePos = Text.find('"');
39  assert(QuotePos != StringRef::npos);
40  return (QuotePos > 0) && (Text[QuotePos - 1] == 'R');
41 }
42 
43 bool containsEscapedCharacters(const MatchFinder::MatchResult &Result,
44  const StringLiteral *Literal,
45  const CharsBitSet &DisallowedChars) {
46  // FIXME: Handle L"", u8"", u"" and U"" literals.
47  if (!Literal->isAscii())
48  return false;
49 
50  for (const unsigned char C : Literal->getBytes())
51  if (DisallowedChars.test(C))
52  return false;
53 
54  CharSourceRange CharRange = Lexer::makeFileCharRange(
55  CharSourceRange::getTokenRange(Literal->getSourceRange()),
56  *Result.SourceManager, Result.Context->getLangOpts());
57  StringRef Text = Lexer::getSourceText(CharRange, *Result.SourceManager,
58  Result.Context->getLangOpts());
59  if (isRawStringLiteral(Text))
60  return false;
61 
62  return containsEscapes(Text, R"('\"?x01)");
63 }
64 
65 bool containsDelimiter(StringRef Bytes, const std::string &Delimiter) {
66  return Bytes.find(Delimiter.empty()
67  ? std::string(R"lit()")lit")
68  : (")" + Delimiter + R"(")")) != StringRef::npos;
69 }
70 
71 std::string asRawStringLiteral(const StringLiteral *Literal,
72  const std::string &DelimiterStem) {
73  const StringRef Bytes = Literal->getBytes();
74  std::string Delimiter;
75  for (int I = 0; containsDelimiter(Bytes, Delimiter); ++I) {
76  Delimiter = (I == 0) ? DelimiterStem : DelimiterStem + std::to_string(I);
77  }
78 
79  if (Delimiter.empty())
80  return (R"(R"()" + Bytes + R"lit()")lit").str();
81 
82  return (R"(R")" + Delimiter + "(" + Bytes + ")" + Delimiter + R"(")").str();
83 }
84 
85 } // namespace
86 
87 RawStringLiteralCheck::RawStringLiteralCheck(StringRef Name,
88  ClangTidyContext *Context)
89  : ClangTidyCheck(Name, Context),
90  DelimiterStem(Options.get("DelimiterStem", "lit")),
91  ReplaceShorterLiterals(Options.get("ReplaceShorterLiterals", false)) {
92  // Non-printing characters are disallowed:
93  // \007 = \a bell
94  // \010 = \b backspace
95  // \011 = \t horizontal tab
96  // \012 = \n new line
97  // \013 = \v vertical tab
98  // \014 = \f form feed
99  // \015 = \r carriage return
100  // \177 = delete
101  for (const unsigned char C : StringRef("\000\001\002\003\004\005\006\a"
102  "\b\t\n\v\f\r\016\017"
103  "\020\021\022\023\024\025\026\027"
104  "\030\031\032\033\034\035\036\037"
105  "\177",
106  33))
107  DisallowedChars.set(C);
108 
109  // Non-ASCII are disallowed too.
110  for (unsigned int C = 0x80u; C <= 0xFFu; ++C)
111  DisallowedChars.set(static_cast<unsigned char>(C));
112 }
113 
115  Options.store(Opts, "DelimiterStem", DelimiterStem);
116  Options.store(Opts, "ReplaceShorterLiterals", ReplaceShorterLiterals);
117 }
118 
119 void RawStringLiteralCheck::registerMatchers(MatchFinder *Finder) {
120  Finder->addMatcher(
121  stringLiteral(unless(hasParent(predefinedExpr()))).bind("lit"), this);
122 }
123 
124 void RawStringLiteralCheck::check(const MatchFinder::MatchResult &Result) {
125  const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("lit");
126  if (Literal->getBeginLoc().isMacroID())
127  return;
128 
129  if (containsEscapedCharacters(Result, Literal, DisallowedChars)) {
130  std::string Replacement = asRawStringLiteral(Literal, DelimiterStem);
131  if (ReplaceShorterLiterals ||
132  Replacement.length() <=
133  Lexer::MeasureTokenLength(Literal->getBeginLoc(),
134  *Result.SourceManager, getLangOpts()))
135  replaceWithRawStringLiteral(Result, Literal, Replacement);
136  }
137 }
138 
139 void RawStringLiteralCheck::replaceWithRawStringLiteral(
140  const MatchFinder::MatchResult &Result, const StringLiteral *Literal,
141  StringRef Replacement) {
142  CharSourceRange CharRange = Lexer::makeFileCharRange(
143  CharSourceRange::getTokenRange(Literal->getSourceRange()),
144  *Result.SourceManager, getLangOpts());
145  diag(Literal->getBeginLoc(),
146  "escaped string literal can be written as a raw string literal")
147  << FixItHint::CreateReplacement(CharRange, Replacement);
148 }
149 
150 } // namespace modernize
151 } // namespace tidy
152 } // namespace clang
clang::tidy::modernize::CharsBitSet
std::bitset< 1<< CHAR_BIT > CharsBitSet
Definition: RawStringLiteralCheck.h:19
Text
std::string Text
Definition: HTMLGenerator.cpp:80
clang::tidy::ClangTidyCheck
Base class for all clang-tidy checks.
Definition: ClangTidyCheck.h:114
clang::tidy::ClangTidyCheck::getLangOpts
const LangOptions & getLangOpts() const
Returns the language options from the context.
Definition: ClangTidyCheck.h:475
clang::ast_matchers
Definition: AbseilMatcher.h:14
clang::tidy::modernize::RawStringLiteralCheck::storeOptions
void storeOptions(ClangTidyOptions::OptionMap &Options) override
Should store all options supported by this check with their current values or default values for opti...
Definition: RawStringLiteralCheck.cpp:114
RawStringLiteralCheck.h
clang::tidy::ClangTidyCheck::Options
OptionsView Options
Definition: ClangTidyCheck.h:471
clang::tidy::ClangTidyContext
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
Definition: ClangTidyDiagnosticConsumer.h:76
Name
static constexpr llvm::StringLiteral Name
Definition: UppercaseLiteralSuffixCheck.cpp:27
clang::tidy::ClangTidyCheck::diag
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
Definition: ClangTidyCheck.cpp:55
clang::tidy::modernize::RawStringLiteralCheck::check
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
Definition: RawStringLiteralCheck.cpp:124
clang::tidy::modernize::RawStringLiteralCheck::registerMatchers
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
Definition: RawStringLiteralCheck.cpp:119
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::tidy::ClangTidyCheck::OptionsView::store
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, StringRef Value) const
Stores an option with the check-local name LocalName with string value Value to Options.
Definition: ClangTidyCheck.cpp:152
clang::tidy::ClangTidyOptions::OptionMap
std::map< std::string, ClangTidyValue > OptionMap
Definition: ClangTidyOptions.h:111