Merge from 'main' to 'sycl-web' (207 commits)

  CONFLICT (content): Merge conflict in llvm/lib/Passes/PassRegistry.def

Author: preethi-intel

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

@@ -519,9 +519,9 @@ int clangTidyMain(int argc, const char **argv) {
     std::vector<clang::tidy::ClangTidyOptionsProvider::OptionsSource>
         RawOptions = OptionsProvider->getRawOptions(FilePath);
     for (const std::string &Check : EnabledChecks) {
-      for (auto It = RawOptions.rbegin(); It != RawOptions.rend(); ++It) {
-        if (It->first.Checks && GlobList(*It->first.Checks).contains(Check)) {
-          llvm::outs() << "'" << Check << "' is enabled in the " << It->second
+      for (const auto &[Opts, Source] : llvm::reverse(RawOptions)) {
+        if (Opts.Checks && GlobList(*Opts.Checks).contains(Check)) {
+          llvm::outs() << "'" << Check << "' is enabled in the " << Source
                        << ".\n";
           break;
         }
@@ -557,20 +557,16 @@ int clangTidyMain(int argc, const char **argv) {
     NamesAndOptions Valid =
         getAllChecksAndOptions(AllowEnablingAnalyzerAlphaCheckers);
     bool AnyInvalid = false;
-    for (const std::pair<ClangTidyOptions, std::string> &OptionWithSource :
-         RawOptions) {
-      const ClangTidyOptions &Opts = OptionWithSource.first;
+    for (const auto &[Opts, Source] : RawOptions) {
       if (Opts.Checks)
-        AnyInvalid |=
-            verifyChecks(Valid.Names, *Opts.Checks, OptionWithSource.second);
+        AnyInvalid |= verifyChecks(Valid.Names, *Opts.Checks, Source);
 
       for (auto Key : Opts.CheckOptions.keys()) {
         if (Valid.Options.contains(Key))
           continue;
         AnyInvalid = true;
-        auto &Output =
-            llvm::WithColor::warning(llvm::errs(), OptionWithSource.second)
-            << "unknown check option '" << Key << '\'';
+        auto &Output = llvm::WithColor::warning(llvm::errs(), Source)
+                       << "unknown check option '" << Key << '\'';
         llvm::StringRef Closest = closest(Key, Valid.Options);
         if (!Closest.empty())
           Output << "; did you mean '" << Closest << '\'';

clang-tools-extra/clangd/CMakeLists.txt

@@ -97,7 +97,7 @@ add_clang_library(clangDaemon
   SemanticHighlighting.cpp
   SemanticSelection.cpp
   SourceCode.cpp
-  QueryDriverDatabase.cpp
+  SystemIncludeExtractor.cpp
   TidyProvider.cpp
   TUScheduler.cpp
   URI.cpp

clang-tools-extra/clangd/ClangdLSPServer.cpp

@@ -502,14 +502,14 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
     CDBOpts.ContextProvider = Opts.ContextProvider;
     BaseCDB =
         std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts);
-    BaseCDB = getQueryDriverDatabase(llvm::makeArrayRef(Opts.QueryDriverGlobs),
-                                     std::move(BaseCDB));
   }
   auto Mangler = CommandMangler::detect();
+  Mangler.SystemIncludeExtractor =
+      getSystemIncludeExtractor(llvm::makeArrayRef(Opts.QueryDriverGlobs));
   if (Opts.ResourceDir)
     Mangler.ResourceDir = *Opts.ResourceDir;
   CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,
-              tooling::ArgumentsAdjuster(std::move(Mangler)));
+              std::move(Mangler));
   {
     // Switch caller's context with LSPServer's background context. Since we
     // rather want to propagate information from LSPServer's context into the
@@ -1815,5 +1815,6 @@ void ClangdLSPServer::onSemanticsMaybeChanged(PathRef File) {
     });
   }
 }
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/CompileCommands.cpp

@@ -13,7 +13,6 @@
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/CompilerInvocation.h"
-#include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
@@ -195,8 +194,9 @@ CommandMangler CommandMangler::detect() {
 
 CommandMangler CommandMangler::forTests() { return CommandMangler(); }
 
-void CommandMangler::adjust(std::vector<std::string> &Cmd,
-                            llvm::StringRef File) const {
+void CommandMangler::operator()(tooling::CompileCommand &Command,
+                                llvm::StringRef File) const {
+  std::vector<std::string> &Cmd = Command.CommandLine;
   trace::Span S("AdjustCompileFlags");
   // Most of the modifications below assumes the Cmd starts with a driver name.
   // We might consider injecting a generic driver name like "cc" or "c++", but
@@ -301,6 +301,17 @@ void CommandMangler::adjust(std::vector<std::string> &Cmd,
   for (auto &Edit : Config::current().CompileFlags.Edits)
     Edit(Cmd);
 
+  // The system include extractor needs to run:
+  //  - AFTER transferCompileCommand(), because the -x flag it adds may be
+  //    necessary for the system include extractor to identify the file type
+  //  - AFTER applying CompileFlags.Edits, because the name of the compiler
+  //    that needs to be invoked may come from the CompileFlags->Compiler key
+  //  - BEFORE resolveDriver() because that can mess up the driver path,
+  //    e.g. changing gcc to /path/to/clang/bin/gcc
+  if (SystemIncludeExtractor) {
+    SystemIncludeExtractor(Command, File);
+  }
+
   // Check whether the flag exists, either as -flag or -flag=*
   auto Has = [&](llvm::StringRef Flag) {
     for (llvm::StringRef Arg : Cmd) {
@@ -340,16 +351,6 @@ void CommandMangler::adjust(std::vector<std::string> &Cmd,
   }
 }
 
-CommandMangler::operator clang::tooling::ArgumentsAdjuster() && {
-  // ArgumentsAdjuster is a std::function and so must be copyable.
-  return [Mangler = std::make_shared<CommandMangler>(std::move(*this))](
-             const std::vector<std::string> &Args, llvm::StringRef File) {
-    auto Result = Args;
-    Mangler->adjust(Result, File);
-    return Result;
-  };
-}
-
 // ArgStripper implementation
 namespace {
 

clang-tools-extra/clangd/CompileCommands.h

@@ -8,8 +8,8 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILECOMMANDS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILECOMMANDS_H
 
+#include "GlobalCompilationDatabase.h"
 #include "support/Threading.h"
-#include "clang/Tooling/ArgumentsAdjusters.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <deque>
@@ -32,6 +32,7 @@ struct CommandMangler {
   llvm::Optional<std::string> ResourceDir;
   // Root for searching for standard library (passed to -isysroot).
   llvm::Optional<std::string> Sysroot;
+  SystemIncludeExtractorFn SystemIncludeExtractor;
 
   // A command-mangler that doesn't know anything about the system.
   // This is hermetic for unit-tests, but won't work well in production.
@@ -42,11 +43,14 @@ struct CommandMangler {
   //  - on mac, find clang and isysroot by querying the `xcrun` launcher
   static CommandMangler detect();
 
-  void adjust(std::vector<std::string> &Cmd, llvm::StringRef File) const;
-  explicit operator clang::tooling::ArgumentsAdjuster() &&;
+  // `Cmd` may describe compilation of a different file, and will be updated
+  // for parsing `TargetFile`.
+  void operator()(tooling::CompileCommand &Cmd,
+                  llvm::StringRef TargetFile) const;
 
 private:
   CommandMangler() = default;
+
   Memoize<llvm::StringMap<std::string>> ResolvedDrivers;
   Memoize<llvm::StringMap<std::string>> ResolvedDriversNoFollow;
 };

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

@@ -740,8 +740,8 @@ DirectoryBasedGlobalCompilationDatabase::getProjectInfo(PathRef File) const {
 
 OverlayCDB::OverlayCDB(const GlobalCompilationDatabase *Base,
                        std::vector<std::string> FallbackFlags,
-                       tooling::ArgumentsAdjuster Adjuster)
-    : DelegatingCDB(Base), ArgsAdjuster(std::move(Adjuster)),
+                       CommandMangler Mangler)
+    : DelegatingCDB(Base), Mangler(std::move(Mangler)),
       FallbackFlags(std::move(FallbackFlags)) {}
 
 llvm::Optional<tooling::CompileCommand>
@@ -757,8 +757,8 @@ OverlayCDB::getCompileCommand(PathRef File) const {
     Cmd = DelegatingCDB::getCompileCommand(File);
   if (!Cmd)
     return llvm::None;
-  if (ArgsAdjuster)
-    Cmd->CommandLine = ArgsAdjuster(Cmd->CommandLine, File);
+  if (Mangler)
+    Mangler(*Cmd, File);
   return Cmd;
 }
 
@@ -767,8 +767,8 @@ tooling::CompileCommand OverlayCDB::getFallbackCommand(PathRef File) const {
   std::lock_guard<std::mutex> Lock(Mutex);
   Cmd.CommandLine.insert(Cmd.CommandLine.end(), FallbackFlags.begin(),
                          FallbackFlags.end());
-  if (ArgsAdjuster)
-    Cmd.CommandLine = ArgsAdjuster(Cmd.CommandLine, File);
+  if (Mangler)
+    Mangler(Cmd, File);
   return Cmd;
 }
 

clang-tools-extra/clangd/GlobalCompilationDatabase.h

@@ -15,6 +15,7 @@
 #include "support/ThreadsafeFS.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include <memory>
@@ -161,22 +162,28 @@ class DirectoryBasedGlobalCompilationDatabase
 };
 
 /// Extracts system include search path from drivers matching QueryDriverGlobs
-/// and adds them to the compile flags. Base may not be nullptr.
-/// Returns Base when \p QueryDriverGlobs is empty.
-std::unique_ptr<GlobalCompilationDatabase>
-getQueryDriverDatabase(llvm::ArrayRef<std::string> QueryDriverGlobs,
-                       std::unique_ptr<GlobalCompilationDatabase> Base);
+/// and adds them to the compile flags.
+/// Returns null when \p QueryDriverGlobs is empty.
+using SystemIncludeExtractorFn = llvm::unique_function<void(
+    tooling::CompileCommand &, llvm::StringRef) const>;
+SystemIncludeExtractorFn
+getSystemIncludeExtractor(llvm::ArrayRef<std::string> QueryDriverGlobs);
 
 /// Wraps another compilation database, and supports overriding the commands
 /// using an in-memory mapping.
 class OverlayCDB : public DelegatingCDB {
 public:
+  // Makes adjustments to a tooling::CompileCommand which will be used to
+  // process a file (possibly different from the one in the command).
+  using CommandMangler = llvm::unique_function<void(tooling::CompileCommand &,
+                                                    StringRef File) const>;
+
   // Base may be null, in which case no entries are inherited.
   // FallbackFlags are added to the fallback compile command.
   // Adjuster is applied to all commands, fallback or not.
   OverlayCDB(const GlobalCompilationDatabase *Base,
              std::vector<std::string> FallbackFlags = {},
-             tooling::ArgumentsAdjuster Adjuster = nullptr);
+             CommandMangler Mangler = nullptr);
 
   llvm::Optional<tooling::CompileCommand>
   getCompileCommand(PathRef File) const override;
@@ -190,7 +197,7 @@ class OverlayCDB : public DelegatingCDB {
 private:
   mutable std::mutex Mutex;
   llvm::StringMap<tooling::CompileCommand> Commands; /* GUARDED_BY(Mut) */
-  tooling::ArgumentsAdjuster ArgsAdjuster;
+  CommandMangler Mangler;
   std::vector<std::string> FallbackFlags;
 };
 

clang-tools-extra/clangd/Headers.cpp

@@ -164,7 +164,7 @@ class IncludeStructure::RecordHeaders : public PPCallbacks,
       LastPragmaKeepInMainFileLine =
           SM.getLineNumber(SM.getMainFileID(), Offset) - 1;
     } else {
-      // Memorize headers that that have export pragmas in them. Include Cleaner
+      // Memorize headers that have export pragmas in them. Include Cleaner
       // does not support them properly yet, so they will be not marked as
       // unused.
       // FIXME: Once IncludeCleaner supports export pragmas, remove this.

clang-tools-extra/clangd/Protocol.h

@@ -1700,7 +1700,7 @@ struct SemanticTokensDeltaParams {
 bool fromJSON(const llvm::json::Value &Params, SemanticTokensDeltaParams &R,
               llvm::json::Path);
 
-/// Describes a a replacement of a contiguous range of semanticTokens.
+/// Describes a replacement of a contiguous range of semanticTokens.
 struct SemanticTokensEdit {
   // LSP specifies `start` and `deleteCount` which are relative to the array
   // encoding of the previous tokens.

clang-tools-extra/clangd/Selection.cpp

@@ -395,7 +395,7 @@ class SelectionTester {
           // Implausible if upperbound(Tok) < First.
           if (auto Offset = LastAffectedToken(Tok.location()))
             return *Offset < First;
-          // A prefix of the expanded tokens may be from an an implicit
+          // A prefix of the expanded tokens may be from an implicit
           // inclusion (e.g. preamble patch, or command-line -include).
           return true;
         });