LLVM and LLVM-SPIRV-Translator pulldown

.arclint

@@ -2,7 +2,7 @@
   "linters": {
     "clang-format": {
       "type": "script-and-regex",
-      "script-and-regex.script": "utils/arcanist/clang-format.sh",
+      "script-and-regex.script": "bash utils/arcanist/clang-format.sh",
       "script-and-regex.regex": "/^(?P<severity>[[:alpha:]]+)\n(?P<message>[^\n]+)\n(====|(?P<line>\\d),(?P<char>\\d)\n(?P<original>.*)>>>>\n(?P<replacement>.*)<<<<\n)$/s",
       "include": [
         "(\\.(cc|cpp|h)$)"

clang-tools-extra/clang-tidy/bugprone/ParentVirtualCallCheck.cpp

@@ -76,7 +76,7 @@ static std::string getExprAsString(const clang::Expr &E,
   Text.erase(
       llvm::remove_if(
           Text,
-          [](char C) { return std::isspace(static_cast<unsigned char>(C)); }),
+          [](char C) { return llvm::isSpace(static_cast<unsigned char>(C)); }),
       Text.end());
   return Text;
 }

clang-tools-extra/clang-tidy/bugprone/SignedCharMisuseCheck.cpp

@@ -102,11 +102,31 @@ void SignedCharMisuseCheck::registerMatchers(MatchFinder *Finder) {
           .bind("comparison");
 
   Finder->addMatcher(CompareOperator, this);
+
+  // Catch array subscripts with signed char -> integer conversion.
+  // Matcher for C arrays.
+  const auto CArraySubscript =
+      arraySubscriptExpr(hasIndex(SignedCharCastExpr)).bind("arraySubscript");
+
+  Finder->addMatcher(CArraySubscript, this);
+
+  // Matcher for std arrays.
+  const auto STDArraySubscript =
+      cxxOperatorCallExpr(
+          hasOverloadedOperatorName("[]"),
+          hasArgument(0, hasType(cxxRecordDecl(hasName("::std::array")))),
+          hasArgument(1, SignedCharCastExpr))
+          .bind("arraySubscript");
+
+  Finder->addMatcher(STDArraySubscript, this);
 }
 
 void SignedCharMisuseCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *SignedCastExpression =
       Result.Nodes.getNodeAs<ImplicitCastExpr>("signedCastExpression");
+  const auto *IntegerType = Result.Nodes.getNodeAs<QualType>("integerType");
+  assert(SignedCastExpression);
+  assert(IntegerType);
 
   // Ignore the match if we know that the signed char's value is not negative.
   // The potential misinterpretation happens for negative values only.
@@ -135,14 +155,17 @@ void SignedCharMisuseCheck::check(const MatchFinder::MatchResult &Result) {
 
     diag(Comparison->getBeginLoc(),
          "comparison between 'signed char' and 'unsigned char'");
-  } else if (const auto *IntegerType =
-                 Result.Nodes.getNodeAs<QualType>("integerType")) {
+  } else if (Result.Nodes.getNodeAs<Expr>("arraySubscript")) {
+    diag(SignedCastExpression->getBeginLoc(),
+         "'signed char' to %0 conversion in array subscript; "
+         "consider casting to 'unsigned char' first.")
+        << *IntegerType;
+  } else {
     diag(SignedCastExpression->getBeginLoc(),
          "'signed char' to %0 conversion; "
          "consider casting to 'unsigned char' first.")
         << *IntegerType;
-  } else
-    llvm_unreachable("Unexpected match");
+  }
 }
 
 } // namespace bugprone

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

@@ -4,6 +4,7 @@ set(LLVM_LINK_COMPONENTS
   )
 
 add_clang_library(clangTidyLLVMLibcModule
+  CalleeNamespaceCheck.cpp
   ImplementationInNamespaceCheck.cpp
   LLVMLibcTidyModule.cpp
   RestrictSystemLibcHeadersCheck.cpp

clang-tools-extra/clang-tidy/llvmlibc/CalleeNamespaceCheck.cpp

@@ -0,0 +1,56 @@
+//===-- CalleeNamespaceCheck.cpp ------------------------------------------===//
+//
+// 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 "CalleeNamespaceCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace llvm_libc {
+
+// Gets the outermost namespace of a DeclContext, right under the Translation
+// Unit.
+const DeclContext *getOutermostNamespace(const DeclContext *Decl) {
+  const DeclContext *Parent = Decl->getParent();
+  if (Parent && Parent->isTranslationUnit())
+    return Decl;
+  return getOutermostNamespace(Parent);
+}
+
+void CalleeNamespaceCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      declRefExpr(to(functionDecl().bind("func"))).bind("use-site"), this);
+}
+
+void CalleeNamespaceCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *UsageSiteExpr = Result.Nodes.getNodeAs<DeclRefExpr>("use-site");
+  const auto *FuncDecl = Result.Nodes.getNodeAs<FunctionDecl>("func");
+
+  // Ignore compiler builtin functions.
+  if (FuncDecl->getBuiltinID() != 0)
+    return;
+
+  // If the outermost namespace of the function is __llvm_libc, we're good.
+  const auto *NS = dyn_cast<NamespaceDecl>(getOutermostNamespace(FuncDecl));
+  if (NS && NS->getName() == "__llvm_libc")
+    return;
+
+  diag(UsageSiteExpr->getBeginLoc(), "%0 must resolve to a function declared "
+                                     "within the '__llvm_libc' namespace")
+      << FuncDecl;
+
+  diag(FuncDecl->getLocation(), "resolves to this declaration",
+       clang::DiagnosticIDs::Note);
+}
+
+} // namespace llvm_libc
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/llvmlibc/CalleeNamespaceCheck.h

@@ -0,0 +1,38 @@
+//===-- CalleeNamespaceCheck.h ----------------------------------*- 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_LLVMLIBC_CALLEENAMESPACECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVMLIBC_CALLEENAMESPACECHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace llvm_libc {
+
+/// Checks all calls resolve to functions within __llvm_libc namespace.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/llvmlibc-callee-namespace.html
+class CalleeNamespaceCheck : public ClangTidyCheck {
+public:
+  CalleeNamespaceCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus;
+  }
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace llvm_libc
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVMLIBC_CALLEENAMESPACECHECK_H

clang-tools-extra/clang-tidy/llvmlibc/LLVMLibcTidyModule.cpp

@@ -9,6 +9,7 @@
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "CalleeNamespaceCheck.h"
 #include "ImplementationInNamespaceCheck.h"
 #include "RestrictSystemLibcHeadersCheck.h"
 
@@ -19,6 +20,8 @@ namespace llvm_libc {
 class LLVMLibcModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<CalleeNamespaceCheck>(
+        "llvmlibc-callee-namespace");
     CheckFactories.registerCheck<ImplementationInNamespaceCheck>(
         "llvmlibc-implementation-in-namespace");
     CheckFactories.registerCheck<RestrictSystemLibcHeadersCheck>(

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

@@ -12,6 +12,7 @@
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Tooling/FixIt.h"
+#include "llvm/ADT/StringExtras.h"
 
 #include <cctype>
 
@@ -356,10 +357,10 @@ bool UseTrailingReturnTypeCheck::keepSpecifiers(
     unsigned int TOffsetInRT = TOffset - ReturnTypeBeginOffset - DeletedChars;
     unsigned int TLengthWithWS = CT.T.getLength();
     while (TOffsetInRT + TLengthWithWS < ReturnType.size() &&
-           std::isspace(ReturnType[TOffsetInRT + TLengthWithWS]))
+           llvm::isSpace(ReturnType[TOffsetInRT + TLengthWithWS]))
       TLengthWithWS++;
     std::string Specifier = ReturnType.substr(TOffsetInRT, TLengthWithWS);
-    if (!std::isspace(Specifier.back()))
+    if (!llvm::isSpace(Specifier.back()))
       Specifier.push_back(' ');
     Auto.insert(Auto.size() - InitialAutoLength, Specifier);
     ReturnType.erase(TOffsetInRT, TLengthWithWS);
@@ -459,7 +460,7 @@ void UseTrailingReturnTypeCheck::check(const MatchFinder::MatchResult &Result) {
                                     ReturnTypeEnd.getLocWithOffset(1)),
       SM, LangOpts);
   bool NeedSpaceAfterAuto =
-      CharAfterReturnType.empty() || !std::isspace(CharAfterReturnType[0]);
+      CharAfterReturnType.empty() || !llvm::isSpace(CharAfterReturnType[0]);
 
   std::string Auto = NeedSpaceAfterAuto ? "auto " : "auto";
   std::string ReturnType =

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

@@ -30,7 +30,10 @@ TransformerClangTidyCheck::TransformerClangTidyCheck(
                                         const OptionsView &)>
         MakeRule,
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), Rule(MakeRule(getLangOpts(), Options)) {
+    : ClangTidyCheck(Name, Context), Rule(MakeRule(getLangOpts(), Options)),
+      IncludeStyle(Options.getLocalOrGlobal("IncludeStyle",
+                                            IncludeSorter::getMapping(),
+                                            IncludeSorter::IS_LLVM)) {
   if (Rule)
     assert(llvm::all_of(Rule->Cases, hasExplanation) &&
            "clang-tidy checks must have an explanation by default;"
@@ -40,7 +43,10 @@ TransformerClangTidyCheck::TransformerClangTidyCheck(
 TransformerClangTidyCheck::TransformerClangTidyCheck(RewriteRule R,
                                                      StringRef Name,
                                                      ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), Rule(std::move(R)) {
+    : ClangTidyCheck(Name, Context), Rule(std::move(R)),
+      IncludeStyle(Options.getLocalOrGlobal("IncludeStyle",
+                                            IncludeSorter::getMapping(),
+                                            IncludeSorter::IS_LLVM)) {
   assert(llvm::all_of(Rule->Cases, hasExplanation) &&
          "clang-tidy checks must have an explanation by default;"
          " explicitly provide an empty explanation if none is desired");
@@ -53,8 +59,8 @@ void TransformerClangTidyCheck::registerPPCallbacks(
   if (Rule && llvm::any_of(Rule->Cases, [](const RewriteRule::Case &C) {
         return !C.AddedIncludes.empty();
       })) {
-    Inserter = std::make_unique<IncludeInserter>(
-        SM, getLangOpts(), utils::IncludeSorter::IS_LLVM);
+    Inserter =
+        std::make_unique<IncludeInserter>(SM, getLangOpts(), IncludeStyle);
     PP->addPPCallbacks(Inserter->CreatePPCallbacks());
   }
 }

clang-tools-extra/clang-tidy/utils/TransformerClangTidyCheck.h

@@ -10,7 +10,8 @@
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_TRANSFORMER_CLANG_TIDY_CHECK_H
 
 #include "../ClangTidy.h"
-#include "../utils/IncludeInserter.h"
+#include "IncludeInserter.h"
+#include "IncludeSorter.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Tooling/Transformer/Transformer.h"
@@ -31,6 +32,13 @@ namespace utils {
 //   MyCheck(StringRef Name, ClangTidyContext *Context)
 //       : TransformerClangTidyCheck(MyCheckAsRewriteRule, Name, Context) {}
 // };
+//
+// `TransformerClangTidyCheck` recognizes this clang-tidy option:
+//
+//  * IncludeStyle. A string specifying which file naming convention is used by
+//      the source code, 'llvm' or 'google'.  Default is 'llvm'. The naming
+//      convention influences how canonical headers are distinguished from other
+//      includes.
 class TransformerClangTidyCheck : public ClangTidyCheck {
 public:
   // \p MakeRule generates the rewrite rule to be used by the check, based on
@@ -61,7 +69,8 @@ class TransformerClangTidyCheck : public ClangTidyCheck {
 
 private:
   Optional<transformer::RewriteRule> Rule;
-  std::unique_ptr<clang::tidy::utils::IncludeInserter> Inserter;
+  const IncludeSorter::IncludeStyle IncludeStyle;
+  std::unique_ptr<IncludeInserter> Inserter;
 };
 
 } // namespace utils

clang-tools-extra/clangd/CMakeLists.txt

@@ -1,3 +1,5 @@
+add_subdirectory(support)
+
 # Configure the Features.inc file.
 if (NOT DEFINED CLANGD_BUILD_XPC)
   if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
@@ -25,27 +27,15 @@ set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   )
 
-if(CLANG_BUILT_STANDALONE)
-  # needed to get HAVE_CXX_ATOMICS64_WITHOUT_LIB defined
-  include(CheckAtomic)
-endif()
-
-set(CLANGD_ATOMIC_LIB "")
-if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB OR NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
-  list(APPEND CLANGD_ATOMIC_LIB "atomic")
-endif()
-
 add_clang_library(clangDaemon
   AST.cpp
-  Cancellation.cpp
   ClangdLSPServer.cpp
   ClangdServer.cpp
   CodeComplete.cpp
   CodeCompletionStrings.cpp
   CollectMacros.cpp
   CompileCommands.cpp
   Compiler.cpp
-  Context.cpp
   Diagnostics.cpp
   DraftStore.cpp
   ExpectedTypes.cpp
@@ -54,16 +44,13 @@ add_clang_library(clangDaemon
   FileDistance.cpp
   Format.cpp
   FS.cpp
-  FSProvider.cpp
-  FormattedString.cpp
   FuzzyMatch.cpp
   GlobalCompilationDatabase.cpp
   Headers.cpp
   HeaderSourceSwitch.cpp
   Hover.cpp
   IncludeFixer.cpp
   JSONTransport.cpp
-  Logger.cpp
   PathMapping.cpp
   Protocol.cpp
   Quality.cpp
@@ -73,11 +60,8 @@ add_clang_library(clangDaemon
   Selection.cpp
   SemanticHighlighting.cpp
   SemanticSelection.cpp
-  Shutdown.cpp
   SourceCode.cpp
   QueryDriverDatabase.cpp
-  Threading.cpp
-  Trace.cpp
   TUScheduler.cpp
   URI.cpp
   XRefs.cpp
@@ -128,8 +112,8 @@ add_clang_library(clangDaemon
   clangToolingInclusions
   clangToolingRefactoring
   clangToolingSyntax
+  clangdSupport
   ${LLVM_PTHREAD_LIB}
-  ${CLANGD_ATOMIC_LIB}
   ${ALL_CLANG_TIDY_CHECKS}
   )