LLVM and SPIRV-LLVM-Translator pulldown (WW44)

LLVM: llvm/llvm-project@850217686e21
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@89ecd25

Author: bb-sycl

.github/lockdown.yml

@@ -0,0 +1,18 @@
+name: 'Repo Lockdown'
+on:
+  pull_request_target:
+    types: opened
+
+permissions:
+  pull-requests: write
+
+jobs:
+  action:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/repo-lockdown@v2
+        with:
+          process-only: 'prs'
+          pr-comment: >
+            This repository does not accept pull requests.
+            Please follow http://llvm.org/docs/Contributing.html#how-to-submit-a-patch for contribution to LLVM.

.github/workflows/repo-lockdown.yml

@@ -35,6 +35,7 @@
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Regex.h"
 #include <tuple>
+#include <utility>
 #include <vector>
 using namespace clang;
 using namespace tidy;
@@ -321,11 +322,11 @@ void ClangTidyDiagnosticConsumer::finalizeLastError() {
 
 static bool isNOLINTFound(StringRef NolintDirectiveText, StringRef CheckName,
                           StringRef Line, size_t *FoundNolintIndex = nullptr,
-                          bool *SuppressionIsSpecific = nullptr) {
+                          StringRef *FoundNolintChecksStr = nullptr) {
   if (FoundNolintIndex)
     *FoundNolintIndex = StringRef::npos;
-  if (SuppressionIsSpecific)
-    *SuppressionIsSpecific = false;
+  if (FoundNolintChecksStr)
+    *FoundNolintChecksStr = StringRef();
 
   size_t NolintIndex = Line.find(NolintDirectiveText);
   if (NolintIndex == StringRef::npos)
@@ -345,18 +346,13 @@ static bool isNOLINTFound(StringRef NolintDirectiveText, StringRef CheckName,
     if (BracketEndIndex != StringRef::npos) {
       StringRef ChecksStr =
           Line.substr(BracketIndex, BracketEndIndex - BracketIndex);
-      // Allow disabling all the checks with "*".
-      if (ChecksStr != "*") {
-        // Allow specifying a few check names, delimited with comma.
-        SmallVector<StringRef, 1> Checks;
-        ChecksStr.split(Checks, ',', -1, false);
-        llvm::transform(Checks, Checks.begin(),
-                        [](StringRef S) { return S.trim(); });
-        if (llvm::find(Checks, CheckName) == Checks.end())
-          return false;
-        if (SuppressionIsSpecific)
-          *SuppressionIsSpecific = true;
-      }
+      if (FoundNolintChecksStr)
+        *FoundNolintChecksStr = ChecksStr;
+      // Allow specifying a few checks with a glob expression, ignoring
+      // negative globs (which would effectively disable the suppression).
+      GlobList Globs(ChecksStr, /*KeepNegativeGlobs=*/false);
+      if (!Globs.contains(CheckName))
+        return false;
     }
   }
 
@@ -388,28 +384,27 @@ static ClangTidyError createNolintError(const ClangTidyContext &Context,
   return Error;
 }
 
-static Optional<ClangTidyError>
-tallyNolintBegins(const ClangTidyContext &Context, const SourceManager &SM,
-                  StringRef CheckName, SmallVector<StringRef> Lines,
-                  SourceLocation LinesLoc,
-                  SmallVector<SourceLocation> &SpecificNolintBegins,
-                  SmallVector<SourceLocation> &GlobalNolintBegins) {
-  // Keep a running total of how many NOLINT(BEGIN...END) blocks are active.
+static Optional<ClangTidyError> tallyNolintBegins(
+    const ClangTidyContext &Context, const SourceManager &SM,
+    StringRef CheckName, SmallVector<StringRef> Lines, SourceLocation LinesLoc,
+    SmallVector<std::pair<SourceLocation, StringRef>> &NolintBegins) {
+  // Keep a running total of how many NOLINT(BEGIN...END) blocks are active, as
+  // well as the bracket expression (if any) that was used in the NOLINT
+  // expression.
   size_t NolintIndex;
-  bool SuppressionIsSpecific;
-  auto List = [&]() -> SmallVector<SourceLocation> * {
-    return SuppressionIsSpecific ? &SpecificNolintBegins : &GlobalNolintBegins;
-  };
+  StringRef NolintChecksStr;
   for (const auto &Line : Lines) {
     if (isNOLINTFound("NOLINTBEGIN", CheckName, Line, &NolintIndex,
-                      &SuppressionIsSpecific)) {
+                      &NolintChecksStr)) {
       // Check if a new block is being started.
-      List()->emplace_back(LinesLoc.getLocWithOffset(NolintIndex));
+      NolintBegins.emplace_back(std::make_pair(
+          LinesLoc.getLocWithOffset(NolintIndex), NolintChecksStr));
     } else if (isNOLINTFound("NOLINTEND", CheckName, Line, &NolintIndex,
-                             &SuppressionIsSpecific)) {
+                             &NolintChecksStr)) {
       // Check if the previous block is being closed.
-      if (!List()->empty()) {
-        List()->pop_back();
+      if (!NolintBegins.empty() &&
+          NolintBegins.back().second == NolintChecksStr) {
+        NolintBegins.pop_back();
       } else {
         // Trying to close a nonexistent block. Return a diagnostic about this
         // misuse that can be displayed along with the original clang-tidy check
@@ -432,42 +427,33 @@ lineIsWithinNolintBegin(const ClangTidyContext &Context,
                         StringRef TextAfterDiag) {
   Loc = SM.getExpansionRange(Loc).getBegin();
   SourceLocation FileStartLoc = SM.getLocForStartOfFile(SM.getFileID(Loc));
+  SmallVector<std::pair<SourceLocation, StringRef>> NolintBegins;
 
   // Check if there's an open NOLINT(BEGIN...END) block on the previous lines.
   SmallVector<StringRef> PrevLines;
   TextBeforeDiag.split(PrevLines, '\n');
-  SmallVector<SourceLocation> SpecificNolintBegins;
-  SmallVector<SourceLocation> GlobalNolintBegins;
-  auto Error =
-      tallyNolintBegins(Context, SM, CheckName, PrevLines, FileStartLoc,
-                        SpecificNolintBegins, GlobalNolintBegins);
+  auto Error = tallyNolintBegins(Context, SM, CheckName, PrevLines,
+                                 FileStartLoc, NolintBegins);
   if (Error) {
     SuppressionErrors.emplace_back(Error.getValue());
-    return false;
   }
-  bool WithinNolintBegin =
-      !SpecificNolintBegins.empty() || !GlobalNolintBegins.empty();
+  bool WithinNolintBegin = !NolintBegins.empty();
 
   // Check that every block is terminated correctly on the following lines.
   SmallVector<StringRef> FollowingLines;
   TextAfterDiag.split(FollowingLines, '\n');
   Error = tallyNolintBegins(Context, SM, CheckName, FollowingLines, Loc,
-                            SpecificNolintBegins, GlobalNolintBegins);
+                            NolintBegins);
   if (Error) {
     SuppressionErrors.emplace_back(Error.getValue());
-    return false;
   }
 
   // The following blocks were never closed. Return diagnostics for each
   // instance that can be displayed along with the original clang-tidy check
   // that the user was attempting to suppress.
-  for (const auto NolintBegin : SpecificNolintBegins) {
-    auto Error = createNolintError(Context, SM, NolintBegin, true);
-    SuppressionErrors.emplace_back(Error);
-  }
-  for (const auto NolintBegin : GlobalNolintBegins) {
-    auto Error = createNolintError(Context, SM, NolintBegin, true);
-    SuppressionErrors.emplace_back(Error);
+  for (const auto &NolintBegin : NolintBegins) {
+    SuppressionErrors.emplace_back(
+        createNolintError(Context, SM, NolintBegin.first, true));
   }
 
   return WithinNolintBegin && SuppressionErrors.empty();

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

@@ -42,13 +42,14 @@ static llvm::Regex consumeGlob(StringRef &GlobList) {
   return llvm::Regex(RegexText);
 }
 
-GlobList::GlobList(StringRef Globs) {
+GlobList::GlobList(StringRef Globs, bool KeepNegativeGlobs /* =true */) {
   Items.reserve(Globs.count(',') + 1);
   do {
     GlobListItem Item;
     Item.IsPositive = !consumeNegativeIndicator(Globs);
     Item.Regex = consumeGlob(Globs);
-    Items.push_back(std::move(Item));
+    if (Item.IsPositive || KeepNegativeGlobs)
+      Items.push_back(std::move(Item));
   } while (!Globs.empty());
 }
 

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

@@ -29,7 +29,10 @@ class GlobList {
   ///
   /// An empty \p Globs string is interpreted as one glob that matches an empty
   /// string.
-  GlobList(StringRef Globs);
+  ///
+  /// \p KeepNegativeGlobs a bool flag indicating whether to keep negative
+  /// globs from \p Globs or not. When false, negative globs are simply ignored.
+  GlobList(StringRef Globs, bool KeepNegativeGlobs = true);
 
   /// Returns \c true if the pattern matches \p S. The result is the last
   /// matching glob's Positive flag.

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

@@ -542,7 +542,7 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
              "^", "&",  "#", "?", ".", "=", "\"", "'", "|"}},
            {"resolveProvider", false},
            // We do extra checks, e.g. that > is part of ->.
-           {"triggerCharacters", {".", "<", ">", ":", "\"", "/"}},
+           {"triggerCharacters", {".", "<", ">", ":", "\"", "/", "*"}},
        }},
       {"semanticTokensProvider",
        llvm::json::Object{

clang-tools-extra/clangd/ClangdLSPServer.cpp

@@ -1098,6 +1098,50 @@ class SignatureHelpCollector final : public CodeCompleteConsumer {
   const SymbolIndex *Index;
 }; // SignatureHelpCollector
 
+// Used only for completion of C-style comments in function call (i.e.
+// /*foo=*/7). Similar to SignatureHelpCollector, but needs to do less work.
+class ParamNameCollector final : public CodeCompleteConsumer {
+public:
+  ParamNameCollector(const clang::CodeCompleteOptions &CodeCompleteOpts,
+                     std::set<std::string> &ParamNames)
+      : CodeCompleteConsumer(CodeCompleteOpts),
+        Allocator(std::make_shared<clang::GlobalCodeCompletionAllocator>()),
+        CCTUInfo(Allocator), ParamNames(ParamNames) {}
+
+  void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
+                                 OverloadCandidate *Candidates,
+                                 unsigned NumCandidates,
+                                 SourceLocation OpenParLoc) override {
+    assert(CurrentArg <= (unsigned)std::numeric_limits<int>::max() &&
+           "too many arguments");
+
+    for (unsigned I = 0; I < NumCandidates; ++I) {
+      OverloadCandidate Candidate = Candidates[I];
+      auto *Func = Candidate.getFunction();
+      if (!Func || Func->getNumParams() <= CurrentArg)
+        continue;
+      auto *PVD = Func->getParamDecl(CurrentArg);
+      if (!PVD)
+        continue;
+      auto *Ident = PVD->getIdentifier();
+      if (!Ident)
+        continue;
+      auto Name = Ident->getName();
+      if (!Name.empty())
+        ParamNames.insert(Name.str());
+    }
+  }
+
+private:
+  GlobalCodeCompletionAllocator &getAllocator() override { return *Allocator; }
+
+  CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
+
+  std::shared_ptr<clang::GlobalCodeCompletionAllocator> Allocator;
+  CodeCompletionTUInfo CCTUInfo;
+  std::set<std::string> &ParamNames;
+};
+
 struct SemaCompleteInput {
   PathRef FileName;
   size_t Offset;
@@ -1860,6 +1904,59 @@ CompletionPrefix guessCompletionPrefix(llvm::StringRef Content,
   return Result;
 }
 
+// Code complete the argument name on "/*" inside function call.
+// Offset should be pointing to the start of the comment, i.e.:
+// foo(^/*, rather than foo(/*^) where the cursor probably is.
+CodeCompleteResult codeCompleteComment(PathRef FileName, unsigned Offset,
+                                       llvm::StringRef Prefix,
+                                       const PreambleData *Preamble,
+                                       const ParseInputs &ParseInput) {
+  if (Preamble == nullptr) // Can't run without Sema.
+    return CodeCompleteResult();
+
+  clang::CodeCompleteOptions Options;
+  Options.IncludeGlobals = false;
+  Options.IncludeMacros = false;
+  Options.IncludeCodePatterns = false;
+  Options.IncludeBriefComments = false;
+  std::set<std::string> ParamNames;
+  // We want to see signatures coming from newly introduced includes, hence a
+  // full patch.
+  semaCodeComplete(
+      std::make_unique<ParamNameCollector>(Options, ParamNames), Options,
+      {FileName, Offset, *Preamble,
+       PreamblePatch::createFullPatch(FileName, ParseInput, *Preamble),
+       ParseInput});
+  if (ParamNames.empty())
+    return CodeCompleteResult();
+
+  CodeCompleteResult Result;
+  Result.Context = CodeCompletionContext::CCC_NaturalLanguage;
+  for (llvm::StringRef Name : ParamNames) {
+    if (!Name.startswith(Prefix))
+      continue;
+    CodeCompletion Item;
+    Item.Name = Name.str() + "=";
+    Item.Kind = CompletionItemKind::Text;
+    Result.Completions.push_back(Item);
+  }
+
+  return Result;
+}
+
+// If Offset is inside what looks like argument comment (e.g.
+// "/*^" or "/* foo^"), returns new offset pointing to the start of the /*
+// (place where semaCodeComplete should run).
+llvm::Optional<unsigned>
+maybeFunctionArgumentCommentStart(llvm::StringRef Content) {
+  while (!Content.empty() && isAsciiIdentifierContinue(Content.back()))
+    Content = Content.drop_back();
+  Content = Content.rtrim();
+  if (Content.endswith("/*"))
+    return Content.size() - 2;
+  return None;
+}
+
 CodeCompleteResult codeComplete(PathRef FileName, Position Pos,
                                 const PreambleData *Preamble,
                                 const ParseInputs &ParseInput,
@@ -1870,6 +1967,19 @@ CodeCompleteResult codeComplete(PathRef FileName, Position Pos,
     elog("Code completion position was invalid {0}", Offset.takeError());
     return CodeCompleteResult();
   }
+
+  auto Content = llvm::StringRef(ParseInput.Contents).take_front(*Offset);
+  if (auto OffsetBeforeComment = maybeFunctionArgumentCommentStart(Content)) {
+    // We are doing code completion of a comment, where we currently only
+    // support completing param names in function calls. To do this, we
+    // require information from Sema, but Sema's comment completion stops at
+    // parsing, so we must move back the position before running it, extract
+    // information we need and construct completion items ourselves.
+    auto CommentPrefix = Content.substr(*OffsetBeforeComment + 2).trim();
+    return codeCompleteComment(FileName, *OffsetBeforeComment, CommentPrefix,
+                               Preamble, ParseInput);
+  }
+
   auto Flow = CodeCompleteFlow(
       FileName, Preamble ? Preamble->Includes : IncludeStructure(),
       SpecFuzzyFind, Opts);
@@ -2053,7 +2163,8 @@ bool allowImplicitCompletion(llvm::StringRef Content, unsigned Offset) {
     Content = Content.substr(Pos + 1);
 
   // Complete after scope operators.
-  if (Content.endswith(".") || Content.endswith("->") || Content.endswith("::"))
+  if (Content.endswith(".") || Content.endswith("->") ||
+      Content.endswith("::") || Content.endswith("/*"))
     return true;
   // Complete after `#include <` and #include `<foo/`.
   if ((Content.endswith("<") || Content.endswith("\"") ||

clang-tools-extra/clangd/CodeComplete.cpp

@@ -266,4 +266,4 @@ std::vector<const NamedDecl *> HeuristicResolver::resolveDependentMember(
 }
 
 } // namespace clangd
-} // namespace clang
+} // namespace clang

clang-tools-extra/clangd/HeuristicResolver.cpp

@@ -286,8 +286,12 @@ class TUScheduler::HeaderIncluderCache {
   void remove(PathRef MainFile) {
     std::lock_guard<std::mutex> Lock(Mu);
     Association *&First = MainToFirst[MainFile];
-    if (First)
+    if (First) {
       invalidate(First);
+      First = nullptr;
+    }
+    // MainToFirst entry should stay alive, as Associations might be pointing at
+    // its key.
   }
 
   /// Get the mainfile associated with Header, or the empty string if none.
@@ -901,15 +905,17 @@ void ASTWorker::runWithAST(
 void PreambleThread::build(Request Req) {
   assert(Req.CI && "Got preamble request with null compiler invocation");
   const ParseInputs &Inputs = Req.Inputs;
+  bool ReusedPreamble = false;
 
   Status.update([&](TUStatus &Status) {
     Status.PreambleActivity = PreambleAction::Building;
   });
-  auto _ = llvm::make_scope_exit([this, &Req] {
+  auto _ = llvm::make_scope_exit([this, &Req, &ReusedPreamble] {
     ASTPeer.updatePreamble(std::move(Req.CI), std::move(Req.Inputs),
                            LatestBuild, std::move(Req.CIDiags),
                            std::move(Req.WantDiags));
-    Callbacks.onPreamblePublished(FileName);
+    if (!ReusedPreamble)
+      Callbacks.onPreamblePublished(FileName);
   });
 
   if (!LatestBuild || Inputs.ForceRebuild) {
@@ -918,6 +924,7 @@ void PreambleThread::build(Request Req) {
   } else if (isPreambleCompatible(*LatestBuild, Inputs, FileName, *Req.CI)) {
     vlog("Reusing preamble version {0} for version {1} of {2}",
          LatestBuild->Version, Inputs.Version, FileName);
+    ReusedPreamble = true;
     return;
   } else {
     vlog("Rebuilding invalidated preamble for {0} version {1} (previous was "