LLVM and SPIRV-LLVM-Translator pulldown (WW52)

LLVM: llvm/llvm-project@9c11e9528683
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@5f289ba

Author: bb-sycl

.github/workflows/llvm-bugs.yml

@@ -0,0 +1,56 @@
+name: LLVM Bugs notifier
+
+on:
+  issues:
+    types:
+      - opened
+
+jobs:
+  auto-subscribe:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 14
+      - run: npm install mailgun.js form-data
+      - name: Send notification
+        uses: actions/github-script@v5
+        env:
+          MAILGUN_API_KEY: ${{ secrets.LLVM_BUGS_KEY }}
+        with:
+          script: |
+            const Mailgun = require("mailgun.js");
+            const formData = require('form-data');
+            const mailgun = new Mailgun(formData);
+
+            const DOMAIN = "email.llvm.org";
+
+            const mg = mailgun.client({username: 'api', key: process.env.MAILGUN_API_KEY});
+
+            github.rest.issues.get({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            })
+            .then(function(issue) {
+              const payload = {
+                author : issue.data.user.login,
+                issue  : issue.data.number,
+                title  : issue.data.title,
+                url    : issue.data.html_url,
+                labels : issue.data.labels.map(label => { return label.name }),
+                assignee : issue.data.assignees.map(assignee => { return assignee.login }),
+                body   : issue.data.body
+              };
+            
+              const data = {
+                from: "LLVM Bugs <[email protected]>",
+                to: "[email protected]",
+                subject: `[Bug ${issue.data.number}] ${issue.data.title}`,
+                template: "new-github-issue",
+                'h:X-Mailgun-Variables': JSON.stringify(payload)
+              };
+
+              return mg.messages.create(DOMAIN, data)
+            })
+            .then(msg => console.log(msg));

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

@@ -24,11 +24,13 @@ void ThrowKeywordMissingCheck::registerMatchers(MatchFinder *Finder) {
       cxxConstructExpr(
           hasType(cxxRecordDecl(
               isSameOrDerivedFrom(matchesName("[Ee]xception|EXCEPTION")))),
-          unless(anyOf(hasAncestor(stmt(
-                           anyOf(cxxThrowExpr(), callExpr(), returnStmt()))),
-                       hasAncestor(decl(anyOf(varDecl(), fieldDecl()))),
-                       allOf(hasAncestor(CtorInitializerList),
-                             unless(hasAncestor(cxxCatchStmt()))))))
+          unless(anyOf(
+              hasAncestor(
+                  stmt(anyOf(cxxThrowExpr(), callExpr(), returnStmt()))),
+              hasAncestor(decl(anyOf(varDecl(), fieldDecl()))),
+              hasAncestor(expr(cxxNewExpr(hasAnyPlacementArg(anything())))),
+              allOf(hasAncestor(CtorInitializerList),
+                    unless(hasAncestor(cxxCatchStmt()))))))
           .bind("temporary-exception-not-thrown"),
       this);
 }

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

@@ -37,6 +37,8 @@ NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name,
     : ClangTidyCheck(Name, Context),
       WarnOnIntegerNarrowingConversion(
           Options.get("WarnOnIntegerNarrowingConversion", true)),
+      WarnOnIntegerToFloatingPointNarrowingConversion(
+          Options.get("WarnOnIntegerToFloatingPointNarrowingConversion", true)),
       WarnOnFloatingPointNarrowingConversion(
           Options.get("WarnOnFloatingPointNarrowingConversion", true)),
       WarnWithinTemplateInstantiation(
@@ -49,6 +51,8 @@ void NarrowingConversionsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnIntegerNarrowingConversion",
                 WarnOnIntegerNarrowingConversion);
+  Options.store(Opts, "WarnOnIntegerToFloatingPointNarrowingConversion",
+                WarnOnIntegerToFloatingPointNarrowingConversion);
   Options.store(Opts, "WarnOnFloatingPointNarrowingConversion",
                 WarnOnFloatingPointNarrowingConversion);
   Options.store(Opts, "WarnWithinTemplateInstantiation",
@@ -425,19 +429,21 @@ void NarrowingConversionsCheck::handleIntegralToBoolean(
 void NarrowingConversionsCheck::handleIntegralToFloating(
     const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
     const Expr &Rhs) {
-  const BuiltinType *ToType = getBuiltinType(Lhs);
-  llvm::APSInt IntegerConstant;
-  if (getIntegerConstantExprValue(Context, Rhs, IntegerConstant)) {
-    if (!isWideEnoughToHold(Context, IntegerConstant, *ToType))
-      diagNarrowIntegerConstant(SourceLoc, Lhs, Rhs, IntegerConstant);
-    return;
-  }
+  if (WarnOnIntegerToFloatingPointNarrowingConversion) {
+    const BuiltinType *ToType = getBuiltinType(Lhs);
+    llvm::APSInt IntegerConstant;
+    if (getIntegerConstantExprValue(Context, Rhs, IntegerConstant)) {
+      if (!isWideEnoughToHold(Context, IntegerConstant, *ToType))
+        diagNarrowIntegerConstant(SourceLoc, Lhs, Rhs, IntegerConstant);
+      return;
+    }
 
-  const BuiltinType *FromType = getBuiltinType(Rhs);
-  if (isWarningInhibitedByEquivalentSize(Context, *FromType, *ToType))
-    return;
-  if (!isWideEnoughToHold(Context, *FromType, *ToType))
-    diagNarrowType(SourceLoc, Lhs, Rhs);
+    const BuiltinType *FromType = getBuiltinType(Rhs);
+    if (isWarningInhibitedByEquivalentSize(Context, *FromType, *ToType))
+      return;
+    if (!isWideEnoughToHold(Context, *FromType, *ToType))
+      diagNarrowType(SourceLoc, Lhs, Rhs);
+  }
 }
 
 void NarrowingConversionsCheck::handleFloatingToIntegral(

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.h

@@ -98,6 +98,7 @@ class NarrowingConversionsCheck : public ClangTidyCheck {
                                           const BuiltinType &ToType) const;
 
   const bool WarnOnIntegerNarrowingConversion;
+  const bool WarnOnIntegerToFloatingPointNarrowingConversion;
   const bool WarnOnFloatingPointNarrowingConversion;
   const bool WarnWithinTemplateInstantiation;
   const bool WarnOnEquivalentBitWidth;

clang-tools-extra/clangd/ClangdLSPServer.cpp

@@ -555,7 +555,7 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
        }},
       {"signatureHelpProvider",
        llvm::json::Object{
-           {"triggerCharacters", {"(", ","}},
+           {"triggerCharacters", {"(", ",", ")"}},
        }},
       {"declarationProvider", true},
       {"definitionProvider", true},

clang-tools-extra/clangd/ClangdServer.cpp

@@ -71,10 +71,10 @@ struct UpdateIndexCallbacks : public ParsingCallbacks {
       : FIndex(FIndex), ServerCallbacks(ServerCallbacks) {}
 
   void onPreambleAST(PathRef Path, llvm::StringRef Version, ASTContext &Ctx,
-                     std::shared_ptr<clang::Preprocessor> PP,
+                     Preprocessor &PP,
                      const CanonicalIncludes &CanonIncludes) override {
     if (FIndex)
-      FIndex->updatePreamble(Path, Version, Ctx, std::move(PP), CanonIncludes);
+      FIndex->updatePreamble(Path, Version, Ctx, PP, CanonIncludes);
   }
 
   void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) override {

clang-tools-extra/clangd/ParsedAST.cpp

@@ -395,7 +395,8 @@ ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
           if (IsInsideMainFile &&
               tidy::shouldSuppressDiagnostic(DiagLevel, Info, *CTContext,
                                              TidySuppressedErrors,
-                                             /*AllowIO=*/false)) {
+                                             /*AllowIO=*/false,
+                                             /*EnableNolintBlocks=*/false)) {
             // FIXME: should we expose the suppression error (invalid use of
             // NOLINT comments)?
             return DiagnosticsEngine::Ignored;

clang-tools-extra/clangd/Preamble.cpp

@@ -84,8 +84,7 @@ class CppFilePreambleCallbacks : public PreambleCallbacks {
   void AfterExecute(CompilerInstance &CI) override {
     if (ParsedCallback) {
       trace::Span Tracer("Running PreambleCallback");
-      ParsedCallback(CI.getASTContext(), CI.getPreprocessorPtr(),
-                     CanonIncludes);
+      ParsedCallback(CI.getASTContext(), CI.getPreprocessor(), CanonIncludes);
     }
 
     const SourceManager &SM = CI.getSourceManager();

clang-tools-extra/clangd/Preamble.h

@@ -72,9 +72,8 @@ struct PreambleData {
   bool MainIsIncludeGuarded = false;
 };
 
-using PreambleParsedCallback =
-    std::function<void(ASTContext &, std::shared_ptr<clang::Preprocessor>,
-                       const CanonicalIncludes &)>;
+using PreambleParsedCallback = std::function<void(ASTContext &, Preprocessor &,
+                                                  const CanonicalIncludes &)>;
 
 /// Build a preamble for the new inputs unless an old one can be reused.
 /// If \p PreambleCallback is set, it will be run on top of the AST while

clang-tools-extra/clangd/TUScheduler.cpp

@@ -977,11 +977,9 @@ void PreambleThread::build(Request Req) {
 
   LatestBuild = clang::clangd::buildPreamble(
       FileName, *Req.CI, Inputs, StoreInMemory,
-      [this, Version(Inputs.Version)](ASTContext &Ctx,
-                                      std::shared_ptr<clang::Preprocessor> PP,
+      [this, Version(Inputs.Version)](ASTContext &Ctx, Preprocessor &PP,
                                       const CanonicalIncludes &CanonIncludes) {
-        Callbacks.onPreambleAST(FileName, Version, Ctx, std::move(PP),
-                                CanonIncludes);
+        Callbacks.onPreambleAST(FileName, Version, Ctx, PP, CanonIncludes);
       });
   if (LatestBuild && isReliable(LatestBuild->CompileCommand))
     HeaderIncluders.update(FileName, LatestBuild->Includes.allHeaders());

clang-tools-extra/clangd/TUScheduler.h

@@ -134,8 +134,7 @@ class ParsingCallbacks {
   /// contains only AST nodes from the #include directives at the start of the
   /// file. AST node in the current file should be observed on onMainAST call.
   virtual void onPreambleAST(PathRef Path, llvm::StringRef Version,
-                             ASTContext &Ctx,
-                             std::shared_ptr<clang::Preprocessor> PP,
+                             ASTContext &Ctx, Preprocessor &PP,
                              const CanonicalIncludes &) {}
 
   /// The argument function is run under the critical section guarding against

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

@@ -45,7 +45,7 @@ namespace clang {
 namespace clangd {
 namespace {
 
-SlabTuple indexSymbols(ASTContext &AST, std::shared_ptr<Preprocessor> PP,
+SlabTuple indexSymbols(ASTContext &AST, Preprocessor &PP,
                        llvm::ArrayRef<Decl *> DeclsToIndex,
                        const MainFileMacros *MacroRefsToIndex,
                        const CanonicalIncludes &Includes, bool IsIndexMainAST,
@@ -77,7 +77,7 @@ SlabTuple indexSymbols(ASTContext &AST, std::shared_ptr<Preprocessor> PP,
 
   SymbolCollector Collector(std::move(CollectorOpts));
   Collector.setPreprocessor(PP);
-  index::indexTopLevelDecls(AST, *PP, DeclsToIndex, Collector, IndexOpts);
+  index::indexTopLevelDecls(AST, PP, DeclsToIndex, Collector, IndexOpts);
   if (MacroRefsToIndex)
     Collector.handleMacros(*MacroRefsToIndex);
 
@@ -219,18 +219,18 @@ FileShardedIndex::getShard(llvm::StringRef Uri) const {
 
 SlabTuple indexMainDecls(ParsedAST &AST) {
   return indexSymbols(
-      AST.getASTContext(), AST.getPreprocessorPtr(),
-      AST.getLocalTopLevelDecls(), &AST.getMacros(), AST.getCanonicalIncludes(),
+      AST.getASTContext(), AST.getPreprocessor(), AST.getLocalTopLevelDecls(),
+      &AST.getMacros(), AST.getCanonicalIncludes(),
       /*IsIndexMainAST=*/true, AST.version(), /*CollectMainFileRefs=*/true);
 }
 
 SlabTuple indexHeaderSymbols(llvm::StringRef Version, ASTContext &AST,
-                             std::shared_ptr<Preprocessor> PP,
+                             Preprocessor &PP,
                              const CanonicalIncludes &Includes) {
   std::vector<Decl *> DeclsToIndex(
       AST.getTranslationUnitDecl()->decls().begin(),
       AST.getTranslationUnitDecl()->decls().end());
-  return indexSymbols(AST, std::move(PP), DeclsToIndex,
+  return indexSymbols(AST, PP, DeclsToIndex,
                       /*MainFileMacros=*/nullptr, Includes,
                       /*IsIndexMainAST=*/false, Version,
                       /*CollectMainFileRefs=*/false);
@@ -424,12 +424,11 @@ FileIndex::FileIndex()
       MainFileIndex(std::make_unique<MemIndex>()) {}
 
 void FileIndex::updatePreamble(PathRef Path, llvm::StringRef Version,
-                               ASTContext &AST,
-                               std::shared_ptr<Preprocessor> PP,
+                               ASTContext &AST, Preprocessor &PP,
                                const CanonicalIncludes &Includes) {
   IndexFileIn IF;
   std::tie(IF.Symbols, std::ignore, IF.Relations) =
-      indexHeaderSymbols(Version, AST, std::move(PP), Includes);
+      indexHeaderSymbols(Version, AST, PP, Includes);
   FileShardedIndex ShardedIndex(std::move(IF));
   for (auto Uri : ShardedIndex.getAllSources()) {
     auto IF = ShardedIndex.getShard(Uri);

clang-tools-extra/clangd/index/FileIndex.h

@@ -115,8 +115,7 @@ class FileIndex : public MergedIndex {
   /// Update preamble symbols of file \p Path with all declarations in \p AST
   /// and macros in \p PP.
   void updatePreamble(PathRef Path, llvm::StringRef Version, ASTContext &AST,
-                      std::shared_ptr<Preprocessor> PP,
-                      const CanonicalIncludes &Includes);
+                      Preprocessor &PP, const CanonicalIncludes &Includes);
 
   /// Update symbols and references from main file \p Path with
   /// `indexMainDecls`.
@@ -163,7 +162,7 @@ SlabTuple indexMainDecls(ParsedAST &AST);
 /// Index declarations from \p AST and macros from \p PP that are declared in
 /// included headers.
 SlabTuple indexHeaderSymbols(llvm::StringRef Version, ASTContext &AST,
-                             std::shared_ptr<Preprocessor> PP,
+                             Preprocessor &PP,
                              const CanonicalIncludes &Includes);
 
 /// Takes slabs coming from a TU (multiple files) and shards them per

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

@@ -186,7 +186,7 @@ class SymbolCollector::HeaderFileURICache {
   // Weird double-indirect access to PP, which might not be ready yet when
   // HeaderFiles is created but will be by the time it's used.
   // (IndexDataConsumer::setPreprocessor can happen before or after initialize)
-  const std::shared_ptr<Preprocessor> &PP;
+  Preprocessor *&PP;
   const SourceManager &SM;
   const CanonicalIncludes *Includes;
   llvm::StringRef FallbackDir;
@@ -195,8 +195,7 @@ class SymbolCollector::HeaderFileURICache {
   llvm::DenseMap<FileID, llvm::StringRef> CacheFIDToInclude;
 
 public:
-  HeaderFileURICache(const std::shared_ptr<Preprocessor> &PP,
-                     const SourceManager &SM,
+  HeaderFileURICache(Preprocessor *&PP, const SourceManager &SM,
                      const SymbolCollector::Options &Opts)
       : PP(PP), SM(SM), Includes(Opts.Includes), FallbackDir(Opts.FallbackDir) {
   }
@@ -304,7 +303,7 @@ SymbolCollector::~SymbolCollector() = default;
 void SymbolCollector::initialize(ASTContext &Ctx) {
   ASTCtx = &Ctx;
   HeaderFileURIs = std::make_unique<HeaderFileURICache>(
-      PP, ASTCtx->getSourceManager(), Opts);
+      this->PP, ASTCtx->getSourceManager(), Opts);
   CompletionAllocator = std::make_shared<GlobalCodeCompletionAllocator>();
   CompletionTUInfo =
       std::make_unique<CodeCompletionTUInfo>(CompletionAllocator);
@@ -365,7 +364,7 @@ bool SymbolCollector::handleDeclOccurrence(
     const Decl *D, index::SymbolRoleSet Roles,
     llvm::ArrayRef<index::SymbolRelation> Relations, SourceLocation Loc,
     index::IndexDataConsumer::ASTNodeInfo ASTNode) {
-  assert(ASTCtx && PP.get() && HeaderFileURIs);
+  assert(ASTCtx && PP && HeaderFileURIs);
   assert(CompletionAllocator && CompletionTUInfo);
   assert(ASTNode.OrigD);
   // Indexing API puts canonical decl into D, which might not have a valid
@@ -486,7 +485,7 @@ bool SymbolCollector::handleDeclOccurrence(
 }
 
 void SymbolCollector::handleMacros(const MainFileMacros &MacroRefsToIndex) {
-  assert(HeaderFileURIs && PP.get());
+  assert(HeaderFileURIs && PP);
   const auto &SM = PP->getSourceManager();
   const auto *MainFileEntry = SM.getFileEntryForID(SM.getMainFileID());
   assert(MainFileEntry);
@@ -533,7 +532,7 @@ bool SymbolCollector::handleMacroOccurrence(const IdentifierInfo *Name,
                                             const MacroInfo *MI,
                                             index::SymbolRoleSet Roles,
                                             SourceLocation Loc) {
-  assert(PP.get());
+  assert(PP);
   // Builtin macros don't have useful locations and aren't needed in completion.
   if (MI->isBuiltinMacro())
     return true;
@@ -805,7 +804,7 @@ const Symbol *SymbolCollector::addDeclaration(const NamedDecl &ND, SymbolID ID,
 
   // Add completion info.
   // FIXME: we may want to choose a different redecl, or combine from several.
-  assert(ASTCtx && PP.get() && "ASTContext and Preprocessor must be set.");
+  assert(ASTCtx && PP && "ASTContext and Preprocessor must be set.");
   // We use the primary template, as clang does during code completion.
   CodeCompletionResult SymbolCompletion(&getTemplateOrThis(ND), 0);
   const auto *CCS = SymbolCompletion.CreateCodeCompletionString(

clang-tools-extra/clangd/index/SymbolCollector.h

@@ -100,8 +100,9 @@ class SymbolCollector : public index::IndexDataConsumer {
   void initialize(ASTContext &Ctx) override;
 
   void setPreprocessor(std::shared_ptr<Preprocessor> PP) override {
-    this->PP = std::move(PP);
+    this->PP = PP.get();
   }
+  void setPreprocessor(Preprocessor &PP) { this->PP = &PP; }
 
   bool
   handleDeclOccurrence(const Decl *D, index::SymbolRoleSet Roles,
@@ -153,7 +154,7 @@ class SymbolCollector : public index::IndexDataConsumer {
   // All relations collected from the AST.
   RelationSlab::Builder Relations;
   ASTContext *ASTCtx;
-  std::shared_ptr<Preprocessor> PP;
+  Preprocessor *PP = nullptr;
   std::shared_ptr<GlobalCodeCompletionAllocator> CompletionAllocator;
   std::unique_ptr<CodeCompletionTUInfo> CompletionTUInfo;
   Options Opts;

clang-tools-extra/clangd/index/dex/Trigram.cpp

@@ -28,6 +28,7 @@ namespace dex {
 // Produce trigrams (including duplicates) and pass them to Out().
 template <typename Func>
 static void identifierTrigrams(llvm::StringRef Identifier, Func Out) {
+  assert(!Identifier.empty());
   // Apply fuzzy matching text segmentation.
   llvm::SmallVector<CharRole> Roles(Identifier.size());
   calculateRoles(Identifier,
@@ -104,6 +105,9 @@ void generateIdentifierTrigrams(llvm::StringRef Identifier,
   // The magic number was tuned by running IndexBenchmark.DexBuild.
   constexpr unsigned ManyTrigramsIdentifierThreshold = 14;
   Result.clear();
+  if (Identifier.empty())
+    return;
+
   if (Identifier.size() < ManyTrigramsIdentifierThreshold) {
     identifierTrigrams(Identifier, [&](Trigram T) {
       if (!llvm::is_contained(Result, T))