LLVM and LLVM-SPIRV-Translator pulldown

clang-tools-extra/clang-doc/Generators.cpp

@@ -27,20 +27,6 @@ findGeneratorByName(llvm::StringRef Format) {
 
 // Enum conversion
 
-std::string getAccess(AccessSpecifier AS) {
-  switch (AS) {
-  case AccessSpecifier::AS_public:
-    return "public";
-  case AccessSpecifier::AS_protected:
-    return "protected";
-  case AccessSpecifier::AS_private:
-    return "private";
-  case AccessSpecifier::AS_none:
-    return {};
-  }
-  llvm_unreachable("Unknown AccessSpecifier");
-}
-
 std::string getTagType(TagTypeKind AS) {
   switch (AS) {
   case TagTypeKind::TTK_Class:

clang-tools-extra/clang-doc/Generators.h

@@ -42,8 +42,6 @@ typedef llvm::Registry<Generator> GeneratorRegistry;
 llvm::Expected<std::unique_ptr<Generator>>
 findGeneratorByName(llvm::StringRef Format);
 
-std::string getAccess(AccessSpecifier AS);
-
 std::string getTagType(TagTypeKind AS);
 
 } // namespace doc

clang-tools-extra/clang-doc/HTMLGenerator.cpp

@@ -402,7 +402,7 @@ genRecordMembersBlock(const llvm::SmallVector<MemberTypeInfo, 4> &Members,
   Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
   auto &ULBody = Out.back();
   for (const auto &M : Members) {
-    std::string Access = getAccess(M.Access);
+    std::string Access = getAccessSpelling(M.Access).str();
     if (Access != "")
       Access = Access + " ";
     auto LIBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
@@ -679,7 +679,7 @@ genHTML(const FunctionInfo &I, const ClangDocContext &CDCtx,
   Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));
   auto &FunctionHeader = Out.back();
 
-  std::string Access = getAccess(I.Access);
+  std::string Access = getAccessSpelling(I.Access).str();
   if (Access != "")
     FunctionHeader->Children.emplace_back(
         std::make_unique<TextNode>(Access + " "));

clang-tools-extra/clang-doc/MDGenerator.cpp

@@ -157,7 +157,7 @@ static void genMarkdown(const ClangDocContext &CDCtx, const FunctionInfo &I,
     First = false;
   }
   writeHeader(I.Name, 3, OS);
-  std::string Access = getAccess(I.Access);
+  std::string Access = getAccessSpelling(I.Access).str();
   if (Access != "")
     writeLine(genItalic(Access + " " + I.ReturnType.Type.Name + " " + I.Name +
                         "(" + Stream.str() + ")"),
@@ -250,7 +250,7 @@ static void genMarkdown(const ClangDocContext &CDCtx, const RecordInfo &I,
   if (!I.Members.empty()) {
     writeHeader("Members", 2, OS);
     for (const auto &Member : I.Members) {
-      std::string Access = getAccess(Member.Access);
+      std::string Access = getAccessSpelling(Member.Access).str();
       if (Access != "")
         writeLine(Access + " " + Member.Type.Name + " " + Member.Name, OS);
       else

clang-tools-extra/clang-query/tool/ClangQuery.cpp

@@ -35,6 +35,7 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/WithColor.h"
 #include <fstream>
 #include <string>
 
@@ -86,7 +87,14 @@ bool runCommandsInFile(const char *ExeName, std::string const &FileName,
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
-  CommonOptionsParser OptionsParser(argc, argv, ClangQueryCategory);
+  llvm::Expected<CommonOptionsParser> OptionsParser =
+      CommonOptionsParser::create(argc, argv, ClangQueryCategory,
+                                  llvm::cl::OneOrMore);
+
+  if (!OptionsParser) {
+    llvm::WithColor::error() << llvm::toString(OptionsParser.takeError());
+    return 1;
+  }
 
   if (!Commands.empty() && !CommandFiles.empty()) {
     llvm::errs() << argv[0] << ": cannot specify both -c and -f\n";
@@ -99,8 +107,8 @@ int main(int argc, const char **argv) {
     return 1;
   }
 
-  ClangTool Tool(OptionsParser.getCompilations(),
-                 OptionsParser.getSourcePathList());
+  ClangTool Tool(OptionsParser->getCompilations(),
+                 OptionsParser->getSourcePathList());
   std::vector<std::unique_ptr<ASTUnit>> ASTs;
   int Status = Tool.buildASTs(ASTs);
   int ASTStatus = 0;

clang-tools-extra/clang-tidy/abseil/AbseilTidyModule.cpp

@@ -21,8 +21,9 @@
 #include "NoInternalDependenciesCheck.h"
 #include "NoNamespaceCheck.h"
 #include "RedundantStrcatCallsCheck.h"
-#include "StringFindStartswithCheck.h"
 #include "StrCatAppendCheck.h"
+#include "StringFindStartswithCheck.h"
+#include "StringFindStrContainsCheck.h"
 #include "TimeComparisonCheck.h"
 #include "TimeSubtractionCheck.h"
 #include "UpgradeDurationConversionsCheck.h"
@@ -61,6 +62,8 @@ class AbseilModule : public ClangTidyModule {
         "abseil-str-cat-append");
     CheckFactories.registerCheck<StringFindStartswithCheck>(
         "abseil-string-find-startswith");
+    CheckFactories.registerCheck<StringFindStrContainsCheck>(
+        "abseil-string-find-str-contains");
     CheckFactories.registerCheck<TimeComparisonCheck>(
         "abseil-time-comparison");
     CheckFactories.registerCheck<TimeSubtractionCheck>(

clang-tools-extra/clang-tidy/abseil/CMakeLists.txt

@@ -20,6 +20,7 @@ add_clang_library(clangTidyAbseilModule
   RedundantStrcatCallsCheck.cpp
   StrCatAppendCheck.cpp
   StringFindStartswithCheck.cpp
+  StringFindStrContainsCheck.cpp
   TimeComparisonCheck.cpp
   TimeSubtractionCheck.cpp
   UpgradeDurationConversionsCheck.cpp
@@ -32,4 +33,5 @@ add_clang_library(clangTidyAbseilModule
   clangTidy
   clangTidyUtils
   clangTooling
+  clangTransformer
   )

clang-tools-extra/clang-tidy/abseil/StringFindStrContainsCheck.cpp

@@ -0,0 +1,110 @@
+//===--- StringFindStrContainsCheck.cc - clang-tidy------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "StringFindStrContainsCheck.h"
+
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Tooling/Transformer/RewriteRule.h"
+#include "clang/Tooling/Transformer/Stencil.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+using ::clang::transformer::applyFirst;
+using ::clang::transformer::cat;
+using ::clang::transformer::change;
+using ::clang::transformer::makeRule;
+using ::clang::transformer::node;
+
+static const char DefaultStringLikeClasses[] = "::std::basic_string;"
+                                               "::std::basic_string_view;"
+                                               "::absl::string_view";
+static const char DefaultAbseilStringsMatchHeader[] = "absl/strings/match.h";
+
+static llvm::Optional<transformer::RewriteRule>
+MakeRule(const LangOptions &LangOpts,
+         const ClangTidyCheck::OptionsView &Options) {
+  // Parse options.
+  //
+  // FIXME(tdl-g): These options are being parsed redundantly with the
+  // constructor because TransformerClangTidyCheck forces us to provide MakeRule
+  // before "this" is fully constructed, but StoreOptions requires us to store
+  // the parsed options in "this".  We need to fix TransformerClangTidyCheck and
+  // then we can clean this up.
+  const std::vector<std::string> StringLikeClassNames =
+      utils::options::parseStringList(
+          Options.get("StringLikeClasses", DefaultStringLikeClasses));
+  const std::string AbseilStringsMatchHeader =
+      Options.get("AbseilStringsMatchHeader", DefaultAbseilStringsMatchHeader);
+
+  auto StringLikeClass = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
+      StringLikeClassNames.begin(), StringLikeClassNames.end())));
+  auto StringType =
+      hasUnqualifiedDesugaredType(recordType(hasDeclaration(StringLikeClass)));
+  auto CharStarType =
+      hasUnqualifiedDesugaredType(pointerType(pointee(isAnyCharacter())));
+  auto StringNpos = declRefExpr(
+      to(varDecl(hasName("npos"), hasDeclContext(StringLikeClass))));
+  auto StringFind = cxxMemberCallExpr(
+      callee(cxxMethodDecl(
+          hasName("find"),
+          hasParameter(0, parmVarDecl(anyOf(hasType(StringType),
+                                            hasType(CharStarType)))))),
+      on(hasType(StringType)), hasArgument(0, expr().bind("parameter_to_find")),
+      anyOf(hasArgument(1, integerLiteral(equals(0))),
+            hasArgument(1, cxxDefaultArgExpr())),
+      onImplicitObjectArgument(expr().bind("string_being_searched")));
+
+  tooling::RewriteRule rule = applyFirst(
+      {makeRule(binaryOperator(hasOperatorName("=="),
+                               hasOperands(ignoringParenImpCasts(StringNpos),
+                                           ignoringParenImpCasts(StringFind))),
+                change(cat("!absl::StrContains(", node("string_being_searched"),
+                           ", ", node("parameter_to_find"), ")")),
+                cat("use !absl::StrContains instead of find() == npos")),
+       makeRule(binaryOperator(hasOperatorName("!="),
+                               hasOperands(ignoringParenImpCasts(StringNpos),
+                                           ignoringParenImpCasts(StringFind))),
+                change(cat("absl::StrContains(", node("string_being_searched"),
+                           ", ", node("parameter_to_find"), ")")),
+                cat("use absl::StrContains instead of find() != npos"))});
+  addInclude(rule, AbseilStringsMatchHeader);
+  return rule;
+}
+
+StringFindStrContainsCheck::StringFindStrContainsCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : TransformerClangTidyCheck(&MakeRule, Name, Context),
+      StringLikeClassesOption(utils::options::parseStringList(
+          Options.get("StringLikeClasses", DefaultStringLikeClasses))),
+      AbseilStringsMatchHeaderOption(Options.get(
+          "AbseilStringsMatchHeader", DefaultAbseilStringsMatchHeader)) {}
+
+bool StringFindStrContainsCheck::isLanguageVersionSupported(
+    const LangOptions &LangOpts) const {
+  return LangOpts.CPlusPlus11;
+}
+
+void StringFindStrContainsCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  TransformerClangTidyCheck::storeOptions(Opts);
+  Options.store(Opts, "StringLikeClasses",
+                utils::options::serializeStringList(StringLikeClassesOption));
+  Options.store(Opts, "AbseilStringsMatchHeader",
+                AbseilStringsMatchHeaderOption);
+}
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/abseil/StringFindStrContainsCheck.h

@@ -0,0 +1,39 @@
+//===--- StringFindStrContainsCheck.h - clang-tidy---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTRCONTAINSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTRCONTAINSCHECK_H
+
+#include "../ClangTidy.h"
+#include "../utils/TransformerClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+/// Finds s.find(...) == string::npos comparisons (for various string-like
+/// types) and suggests replacing with absl::StrContains.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-string-find-str-contains.html
+class StringFindStrContainsCheck : public utils::TransformerClangTidyCheck {
+public:
+  StringFindStrContainsCheck(StringRef Name, ClangTidyContext *Context);
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  const std::vector<std::string> StringLikeClassesOption;
+  const std::string AbseilStringsMatchHeaderOption;
+};
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTRCONTAINSCHECK_H

clang-tools-extra/clang-tidy/misc/NonPrivateMemberVariablesInClassesCheck.cpp

@@ -59,8 +59,9 @@ void NonPrivateMemberVariablesInClassesCheck::registerMatchers(
   // If we are ok with public fields, then we only want to complain about
   // protected fields, else we want to complain about all non-private fields.
   // We can ignore public member variables in structs/classes, in unions.
-  auto InterestingField = fieldDecl(
-      IgnorePublicMemberVariables ? isProtected() : unless(isPrivate()));
+  auto InterestingField = IgnorePublicMemberVariables
+                              ? fieldDecl(isProtected())
+                              : fieldDecl(unless(isPrivate()));
 
   // We only want the records that not only contain the mutable data (non-static
   // member variables), but also have some logic (non-static, non-implicit

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

@@ -23,6 +23,7 @@
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/WithColor.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::driver;
@@ -333,8 +334,14 @@ getVfsFromFile(const std::string &OverlayFile,
 
 int clangTidyMain(int argc, const char **argv) {
   llvm::InitLLVM X(argc, argv);
-  CommonOptionsParser OptionsParser(argc, argv, ClangTidyCategory,
-                                    cl::ZeroOrMore);
+  llvm::Expected<CommonOptionsParser> OptionsParser =
+      CommonOptionsParser::create(argc, argv, ClangTidyCategory,
+                                  cl::ZeroOrMore);
+  if (!OptionsParser) {
+    llvm::WithColor::error() << llvm::toString(OptionsParser.takeError());
+    return 1;
+  }
+
   llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> BaseFS(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
 
@@ -365,7 +372,7 @@ int clangTidyMain(int argc, const char **argv) {
   SmallString<256> ProfilePrefix = MakeAbsolute(StoreCheckProfile);
 
   StringRef FileName("dummy");
-  auto PathList = OptionsParser.getSourcePathList();
+  auto PathList = OptionsParser->getSourcePathList();
   if (!PathList.empty()) {
     FileName = PathList.front();
   }
@@ -433,7 +440,7 @@ int clangTidyMain(int argc, const char **argv) {
   ClangTidyContext Context(std::move(OwningOptionsProvider),
                            AllowEnablingAnalyzerAlphaCheckers);
   std::vector<ClangTidyError> Errors =
-      runClangTidy(Context, OptionsParser.getCompilations(), PathList, BaseFS,
+      runClangTidy(Context, OptionsParser->getCompilations(), PathList, BaseFS,
                    EnableCheckProfile, ProfilePrefix);
   bool FoundErrors = llvm::find_if(Errors, [](const ClangTidyError &E) {
                        return E.DiagLevel == ClangTidyError::Error;

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

@@ -73,6 +73,14 @@ class RenamerClangTidyCheckPPCallbacks : public PPCallbacks {
   /// MacroDefined calls checkMacro for macros in the main file
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override {
+    if (MD->getMacroInfo()->isBuiltinMacro())
+      return;
+    if (PP->getSourceManager().isWrittenInBuiltinFile(
+            MacroNameTok.getLocation()))
+      return;
+    if (PP->getSourceManager().isWrittenInCommandLineFile(
+            MacroNameTok.getLocation()))
+      return;
     Check->checkMacro(PP->getSourceManager(), MacroNameTok, MD->getMacroInfo());
   }
 

clang-tools-extra/clangd/ClangdServer.cpp

@@ -114,6 +114,7 @@ ClangdServer::Options ClangdServer::optsForTest() {
   Opts.StorePreamblesInMemory = true;
   Opts.AsyncThreadsCount = 4; // Consistent!
   Opts.TheiaSemanticHighlighting = true;
+  Opts.AsyncPreambleBuilds = true;
   return Opts;
 }
 
@@ -123,6 +124,7 @@ ClangdServer::Options::operator TUScheduler::Options() const {
   Opts.RetentionPolicy = RetentionPolicy;
   Opts.StorePreamblesInMemory = StorePreamblesInMemory;
   Opts.UpdateDebounce = UpdateDebounce;
+  Opts.AsyncPreambleBuilds = AsyncPreambleBuilds;
   return Opts;
 }
 

clang-tools-extra/clangd/ClangdServer.h

@@ -97,6 +97,9 @@ class ClangdServer {
 
     /// Cached preambles are potentially large. If false, store them on disk.
     bool StorePreamblesInMemory = true;
+    /// Reuse even stale preambles, and rebuild them in the background.
+    /// This improves latency at the cost of accuracy.
+    bool AsyncPreambleBuilds = false;
 
     /// If true, ClangdServer builds a dynamic in-memory index for symbols in
     /// opened files and uses the index to augment code completion results.