Merge from 'master' to 'sycl-web' (#1)

  CONFLICT (content): Merge conflict in llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

Author: aelovikov-intel

clang-tools-extra/clang-tidy/GlobList.cpp

@@ -34,7 +34,7 @@ static llvm::Regex ConsumeGlob(StringRef &GlobList) {
   for (char C : Glob) {
     if (C == '*')
       RegexText.push_back('.');
-    else if (MetaChars.find(C) != StringRef::npos)
+    else if (MetaChars.contains(C))
       RegexText.push_back('\\');
     RegexText.push_back(C);
   }
@@ -43,6 +43,7 @@ static llvm::Regex ConsumeGlob(StringRef &GlobList) {
 }
 
 GlobList::GlobList(StringRef Globs) {
+  Items.reserve(Globs.count(',') + 1);
   do {
     GlobListItem Item;
     Item.IsPositive = !ConsumeNegativeIndicator(Globs);
@@ -52,10 +53,11 @@ GlobList::GlobList(StringRef Globs) {
 }
 
 bool GlobList::contains(StringRef S) {
-  bool Contains = false;
-  for (const GlobListItem &Item : Items) {
+  // Iterating the container backwards as the last match determins if S is in
+  // the list.
+  for (const GlobListItem &Item : llvm::reverse(Items)) {
     if (Item.Regex.match(S))
-      Contains = Item.IsPositive;
+      return Item.IsPositive;
   }
-  return Contains;
+  return false;
 }

clang-tools-extra/clang-tidy/GlobList.h

@@ -10,9 +10,9 @@
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GLOBLIST_H
 
 #include "clang/Basic/LLVM.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Regex.h"
-#include <vector>
 
 namespace clang {
 namespace tidy {
@@ -39,9 +39,9 @@ class GlobList {
 
   struct GlobListItem {
     bool IsPositive;
-    mutable llvm::Regex Regex;
+    llvm::Regex Regex;
   };
-  std::vector<GlobListItem> Items;
+  SmallVector<GlobListItem, 0> Items;
 };
 
 } // end namespace tidy

clang-tools-extra/clangd/index/Serialization.cpp

@@ -418,7 +418,7 @@ readCompileCommand(Reader CmdReader, llvm::ArrayRef<llvm::StringRef> Strings) {
 // The current versioning scheme is simple - non-current versions are rejected.
 // If you make a breaking change, bump this version number to invalidate stored
 // data. Later we may want to support some backward compatibility.
-constexpr static uint32_t Version = 13;
+constexpr static uint32_t Version = 14;
 
 llvm::Expected<IndexFileIn> readRIFF(llvm::StringRef Data) {
   auto RIFF = riff::readFile(Data);

clang-tools-extra/clangd/index/remote/README.md

@@ -22,19 +22,20 @@ tools you will need to set this CMake flag — `-DCLANGD_ENABLE_REMOTE=On`.
 On Debian-like systems gRPC and Protobuf can be installed from apt:
 
 ```bash
-apt install libgrpc++-dev libprotobuf-dev protobuf-compiler protobuf-compiler-grpc
+apt install libgrpc++-dev libprotobuf-dev protobuf-compiler-grpc
 ```
 
 ### Building from sources
 
 Another way of installing gRPC and Protobuf is building from sources using
-CMake. The easiest way of doing that would be to choose a directory where you
-want to install so that the installation files are not copied to system root and
-you can uninstall gRPC or use different versions of the library.
+CMake (we need CMake config files to find necessary libraries in LLVM). The
+easiest way of doing that would be to choose a directory where you want to
+install so that the installation files are not copied to system root and you
+can easily uninstall gRPC or use different versions.
 
 ```bash
 # Get source code.
-$ git clone -b v1.28.1 https://github.com/grpc/grpc
+$ git clone -b v1.33.2 https://github.com/grpc/grpc
 $ cd grpc
 $ git submodule update --init
 # Choose directory where you want gRPC installation to live.
@@ -55,5 +56,5 @@ flag will inform build system that you chose this option —
 
 ## Running
 
-The remote index isn't usable with Clangd yet, but you can try the
-proof-of-concept tools in `client/` and `server/` subdirectories.
+You can run `clangd-index-server` and connect `clangd` instance to it using
+`--remote-index-address` and `--project-root` flags.

clang-tools-extra/clangd/refactor/Rename.cpp

@@ -254,6 +254,84 @@ std::vector<SourceLocation> findOccurrencesWithinFile(ParsedAST &AST,
   return Results;
 }
 
+// Lookup the declarations (if any) with the given Name in the context of
+// RenameDecl.
+const NamedDecl *lookupSiblingWithName(const ASTContext &Ctx,
+                                       const NamedDecl &RenamedDecl,
+                                       llvm::StringRef Name) {
+  const auto &II = Ctx.Idents.get(Name);
+  DeclarationName LookupName(&II);
+  DeclContextLookupResult LookupResult;
+  const auto *DC = RenamedDecl.getDeclContext();
+  while (DC && DC->isTransparentContext())
+    DC = DC->getParent();
+  switch (DC->getDeclKind()) {
+  // The enclosing DeclContext may not be the enclosing scope, it might have
+  // false positives and negatives, so we only choose "confident" DeclContexts
+  // that don't have any subscopes that are neither DeclContexts nor
+  // transparent.
+  //
+  // Notably, FunctionDecl is excluded -- because local variables are not scoped
+  // to the function, but rather to the CompoundStmt that is its body. Lookup
+  // will not find function-local variables.
+  case Decl::TranslationUnit:
+  case Decl::Namespace:
+  case Decl::Record:
+  case Decl::Enum:
+  case Decl::CXXRecord:
+    LookupResult = DC->lookup(LookupName);
+    break;
+  default:
+    break;
+  }
+  // Lookup may contain the RenameDecl itself, exclude it.
+  for (const auto *D : LookupResult)
+    if (D->getCanonicalDecl() != RenamedDecl.getCanonicalDecl())
+      return D;
+  return nullptr;
+}
+
+struct InvalidName {
+  enum Kind {
+    Keywords,
+    Conflict,
+  };
+  Kind K;
+  std::string Details;
+};
+
+llvm::Error makeError(InvalidName Reason) {
+  auto Message = [](InvalidName Reason) {
+    switch (Reason.K) {
+    case InvalidName::Keywords:
+      return llvm::formatv("the chosen name \"{0}\" is a keyword",
+                           Reason.Details);
+    case InvalidName::Conflict:
+      return llvm::formatv("conflict with the symbol in {0}", Reason.Details);
+    }
+    llvm_unreachable("unhandled InvalidName kind");
+  };
+  return error("invalid name: {0}", Message(Reason));
+}
+
+// Check if we can rename the given RenameDecl into NewName.
+// Return details if the rename would produce a conflict.
+llvm::Optional<InvalidName> checkName(const NamedDecl &RenameDecl,
+                                      llvm::StringRef NewName) {
+  auto &ASTCtx = RenameDecl.getASTContext();
+  if (isKeyword(NewName, ASTCtx.getLangOpts()))
+    return InvalidName{InvalidName::Keywords, NewName.str()};
+  // Name conflict detection.
+  // Function conflicts are subtle (overloading), so ignore them.
+  if (RenameDecl.getKind() != Decl::Function) {
+    if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
+      return InvalidName{
+          InvalidName::Conflict,
+          Conflict->getLocation().printToString(ASTCtx.getSourceManager())};
+  }
+  return llvm::None;
+}
+
 // AST-based rename, it renames all occurrences in the main file.
 llvm::Expected<tooling::Replacements>
 renameWithinFile(ParsedAST &AST, const NamedDecl &RenameDecl,
@@ -476,11 +554,12 @@ llvm::Expected<RenameResult> rename(const RenameInputs &RInputs) {
     return makeError(ReasonToReject::NoSymbolFound);
   if (DeclsUnderCursor.size() > 1)
     return makeError(ReasonToReject::AmbiguousSymbol);
-  if (isKeyword(RInputs.NewName, AST.getLangOpts()))
-    return makeError(ReasonToReject::RenameToKeywords);
-
   const auto &RenameDecl =
       llvm::cast<NamedDecl>(*(*DeclsUnderCursor.begin())->getCanonicalDecl());
+  auto Invalid = checkName(RenameDecl, RInputs.NewName);
+  if (Invalid)
+    return makeError(*Invalid);
+
   auto Reject = renameable(RenameDecl, RInputs.MainFilePath, RInputs.Index,
                            Opts.AllowCrossFile);
   if (Reject)