Merge branch 'main' into issue-8476

Author: chansuke

.github/workflows/pr-code-format.yml

@@ -12,6 +12,7 @@ on:
 jobs:
   code_formatter:
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     if: github.repository == 'llvm/llvm-project'
     steps:
       - name: Fetch LLVM sources

clang-tools-extra/clangd/ModulesBuilder.cpp

@@ -92,6 +92,87 @@ class FailedPrerequisiteModules : public PrerequisiteModules {
   }
 };
 
+struct ModuleFile {
+  ModuleFile(StringRef ModuleName, PathRef ModuleFilePath)
+      : ModuleName(ModuleName.str()), ModuleFilePath(ModuleFilePath.str()) {}
+
+  ModuleFile() = delete;
+
+  ModuleFile(const ModuleFile &) = delete;
+  ModuleFile operator=(const ModuleFile &) = delete;
+
+  // The move constructor is needed for llvm::SmallVector.
+  ModuleFile(ModuleFile &&Other)
+      : ModuleName(std::move(Other.ModuleName)),
+        ModuleFilePath(std::move(Other.ModuleFilePath)) {
+    Other.ModuleName.clear();
+    Other.ModuleFilePath.clear();
+  }
+
+  ModuleFile &operator=(ModuleFile &&Other) {
+    if (this == &Other)
+      return *this;
+
+    this->~ModuleFile();
+    new (this) ModuleFile(std::move(Other));
+    return *this;
+  }
+
+  ~ModuleFile() {
+    if (!ModuleFilePath.empty())
+      llvm::sys::fs::remove(ModuleFilePath);
+  }
+
+  std::string ModuleName;
+  std::string ModuleFilePath;
+};
+
+bool IsModuleFileUpToDate(
+    PathRef ModuleFilePath,
+    const PrerequisiteModules &RequisiteModules) {
+IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+      CompilerInstance::createDiagnostics(new DiagnosticOptions());
+
+  auto HSOpts = std::make_shared<HeaderSearchOptions>();
+  RequisiteModules.adjustHeaderSearchOptions(*HSOpts);
+  HSOpts->ForceCheckCXX20ModulesInputFiles = true;
+  HSOpts->ValidateASTInputFilesContent = true;
+
+  PCHContainerOperations PCHOperations;
+  std::unique_ptr<ASTUnit> Unit = ASTUnit::LoadFromASTFile(
+      ModuleFilePath.str(), PCHOperations.getRawReader(), ASTUnit::LoadASTOnly,
+      Diags, FileSystemOptions(), std::move(HSOpts));
+
+  if (!Unit)
+    return false;
+
+  auto Reader = Unit->getASTReader();
+  if (!Reader)
+    return false;
+
+  bool UpToDate = true;
+  Reader->getModuleManager().visit([&](serialization::ModuleFile &MF) -> bool {
+    Reader->visitInputFiles(
+        MF, /*IncludeSystem=*/false, /*Complain=*/false,
+        [&](const serialization::InputFile &IF, bool isSystem) {
+          if (!IF.getFile() || IF.isOutOfDate())
+            UpToDate = false;
+        });
+
+    return !UpToDate;
+  });
+
+  return UpToDate;
+}
+
+bool IsModuleFilesUpToDate(
+    llvm::SmallVector<PathRef> ModuleFilePaths,
+    const PrerequisiteModules &RequisiteModules) {
+  return llvm::all_of(ModuleFilePaths, [&RequisiteModules](auto ModuleFilePath) {
+    return IsModuleFileUpToDate(ModuleFilePath, RequisiteModules);
+  });
+}
+
 // StandalonePrerequisiteModules - stands for PrerequisiteModules for which all
 // the required modules are built successfully. All the module files
 // are owned by the StandalonePrerequisiteModules class.
@@ -135,29 +216,6 @@ class StandalonePrerequisiteModules : public PrerequisiteModules {
   }
 
 private:
-  struct ModuleFile {
-    ModuleFile(llvm::StringRef ModuleName, PathRef ModuleFilePath)
-        : ModuleName(ModuleName.str()), ModuleFilePath(ModuleFilePath.str()) {}
-
-    ModuleFile(const ModuleFile &) = delete;
-    ModuleFile operator=(const ModuleFile &) = delete;
-
-    // The move constructor is needed for llvm::SmallVector.
-    ModuleFile(ModuleFile &&Other)
-        : ModuleName(std::move(Other.ModuleName)),
-          ModuleFilePath(std::move(Other.ModuleFilePath)) {}
-
-    ModuleFile &operator=(ModuleFile &&Other) = delete;
-
-    ~ModuleFile() {
-      if (!ModuleFilePath.empty())
-        llvm::sys::fs::remove(ModuleFilePath);
-    }
-
-    std::string ModuleName;
-    std::string ModuleFilePath;
-  };
-
   llvm::SmallVector<ModuleFile, 8> RequiredModules;
   // A helper class to speedup the query if a module is built.
   llvm::StringSet<> BuiltModuleNames;
@@ -286,50 +344,10 @@ bool StandalonePrerequisiteModules::canReuse(
   if (RequiredModules.empty())
     return true;
 
-  CompilerInstance Clang;
-
-  Clang.setInvocation(std::make_shared<CompilerInvocation>(CI));
-  IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-      CompilerInstance::createDiagnostics(new DiagnosticOptions());
-  Clang.setDiagnostics(Diags.get());
-
-  FileManager *FM = Clang.createFileManager(VFS);
-  Clang.createSourceManager(*FM);
-
-  if (!Clang.createTarget())
-    return false;
-
-  assert(Clang.getHeaderSearchOptsPtr());
-  adjustHeaderSearchOptions(Clang.getHeaderSearchOpts());
-  // Since we don't need to compile the source code actually, the TU kind here
-  // doesn't matter.
-  Clang.createPreprocessor(TU_Complete);
-  Clang.getHeaderSearchOpts().ForceCheckCXX20ModulesInputFiles = true;
-  Clang.getHeaderSearchOpts().ValidateASTInputFilesContent = true;
-
-  // Following the practice of clang's driver to suppres the checking for ODR
-  // violation in GMF.
-  // See
-  // https://clang.llvm.org/docs/StandardCPlusPlusModules.html#object-definition-consistency
-  // for example.
-  Clang.getLangOpts().SkipODRCheckInGMF = true;
-
-  Clang.createASTReader();
-  for (auto &RequiredModule : RequiredModules) {
-    llvm::StringRef BMIPath = RequiredModule.ModuleFilePath;
-    // FIXME: Loading BMI fully is too heavy considering something cheaply to
-    // check if we can reuse the BMI.
-    auto ReadResult =
-        Clang.getASTReader()->ReadAST(BMIPath, serialization::MK_MainFile,
-                                      SourceLocation(), ASTReader::ARR_None);
-
-    if (ReadResult != ASTReader::Success) {
-      elog("Can't reuse {0}: {1}", BMIPath, ReadResult);
-      return false;
-    }
-  }
-
-  return true;
+  SmallVector<StringRef> BMIPaths;
+  for (auto &MF : RequiredModules)
+    BMIPaths.push_back(MF.ModuleFilePath);
+  return IsModuleFilesUpToDate(BMIPaths, *this);
 }
 
 } // namespace clangd

clang-tools-extra/docs/clang-tidy/Contributing.rst

@@ -127,14 +127,15 @@ Writing a clang-tidy Check
 
 So you have an idea of a useful check for :program:`clang-tidy`.
 
-First, if you're not familiar with LLVM development, read through the `Getting
-Started with LLVM`_ document for instructions on setting up your workflow and
+First, if you're not familiar with LLVM development, read through the `Getting Started 
+with the LLVM System`_ document for instructions on setting up your workflow and
 the `LLVM Coding Standards`_ document to familiarize yourself with the coding
-style used in the project. For code reviews we mostly use `LLVM Phabricator`_.
+style used in the project. For code reviews we currently use `LLVM Github`_,
+though historically we used Phabricator.
 
-.. _Getting Started with LLVM: https://llvm.org/docs/GettingStarted.html
+.. _Getting Started with the LLVM System: https://llvm.org/docs/GettingStarted.html
 .. _LLVM Coding Standards: https://llvm.org/docs/CodingStandards.html
-.. _LLVM Phabricator: https://llvm.org/docs/Phabricator.html
+.. _LLVM Github: https://github.com/llvm/llvm-project
 
 Next, you need to decide which module the check belongs to. Modules
 are located in subdirectories of `clang-tidy/
@@ -336,13 +337,25 @@ a starting point for your test cases.  A rough outline of the process looks like
 The quickest way to prototype your matcher is to use :program:`clang-query` to
 interactively build up your matcher.  For complicated matchers, build up a matching
 expression incrementally and use :program:`clang-query`'s ``let`` command to save named
-matching expressions to simplify your matcher.  Just like breaking up a huge function
-into smaller chunks with intention-revealing names can help you understand a complex
-algorithm, breaking up a matcher into smaller matchers with intention-revealing names
-can help you understand a complicated matcher.  Once you have a working matcher, the
-C++ API will be virtually identical to your interactively constructed matcher.  You can
-use local variables to preserve your intention-revealing names that you applied to
-nested matchers.
+matching expressions to simplify your matcher.
+
+.. code-block:: console
+
+  clang-query> let c1 cxxRecordDecl()
+  clang-query> match c1
+
+Alternatively, pressing the tab key after a previous matcher's open parentheses would also 
+show which matchers can be chained with the previous matcher, though some matchers that work 
+may not be listed.
+
+Just like breaking up a huge function into smaller chunks with intention-revealing names 
+can help you understand a complex algorithm, breaking up a matcher into smaller matchers 
+with intention-revealing names can help you understand a complicated matcher.  
+
+Once you have a working clang-query matcher, the C++ API matchers will be the same or similar 
+to your interactively constructed matcher (there can be cases where they differ slightly). 
+You can use local variables to preserve your intention-revealing names that you applied 
+to nested matchers.
 
 Creating private matchers
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -646,10 +659,13 @@ directory.  The path to this directory is available in a lit test with the varia
 Out-of-tree check plugins
 -------------------------
 
+
 Developing an out-of-tree check as a plugin largely follows the steps
-outlined above. The plugin is a shared library whose code lives outside
+outlined above, including creating a new module and doing the hacks to 
+register the module. The plugin is a shared library whose code lives outside
 the clang-tidy build system. Build and link this shared library against
-LLVM as done for other kinds of Clang plugins.
+LLVM as done for other kinds of Clang plugins. If using CMake, use the keyword
+``MODULE`` while invoking ``add_library`` or ``llvm_add_library``.
 
 The plugin can be loaded by passing `-load` to `clang-tidy` in addition to the
 names of the checks to enable.
@@ -664,6 +680,19 @@ compiled against the version of clang-tidy that will be loading the plugin.
 The plugins can use threads, TLS, or any other facilities available to in-tree
 code which is accessible from the external headers.
 
+Note that testing out-of-tree checks might involve getting ``llvm-lit`` from an LLVM 
+installation compiled from source. See `Getting Started with the LLVM System`_ for ways 
+to do so.
+
+Alternatively, get `lit`_ following the `test-suite guide`_ and get the `FileCheck`_ binary, 
+and write a version of `check_clang_tidy.py`_ to suit your needs.
+
+.. _Getting Started with the LLVM System: https://llvm.org/docs/GettingStarted.html
+.. _test-suite guide: https://llvm.org/docs/TestSuiteGuide.html
+.. _lit: https://llvm.org/docs/CommandGuide/lit.html
+.. _FileCheck: https://llvm.org/docs/CommandGuide/FileCheck.html
+.. _check_clang_tidy.py: https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/test/clang-tidy/check_clang_tidy.py
+
 Running clang-tidy on LLVM
 --------------------------
 
@@ -688,10 +717,10 @@ warnings and errors. The script provides multiple configuration flags.
 
 * To restrict the files examined you can provide one or more regex arguments
   that the file names are matched against.
-  ``run-clang-tidy.py clang-tidy/.*Check\.cpp`` will only analyze clang-tidy
+  ``run-clang-tidy.py clang-tidy/.*Check\.cpp`` will only analyze `clang-tidy`
   checks. It may also be necessary to restrict the header files that warnings
-  are displayed from using the ``-header-filter`` flag. It has the same behavior
-  as the corresponding :program:`clang-tidy` flag.
+  are displayed from by using the ``-header-filter`` and ``-exclude-header-filter`` flags. 
+  They have the same behavior as the corresponding :program:`clang-tidy` flags.
 
 * To apply suggested fixes ``-fix`` can be passed as an argument. This gathers
   all changes in a temporary directory and applies them. Passing ``-format``
@@ -758,4 +787,4 @@ There is only one argument that controls profile storage:
 
   * If you run :program:`clang-tidy` from within ``/foo`` directory, and specify
     ``-store-check-profile=.``, then the profile will still be saved to
-    ``/foo/<ISO8601-like timestamp>-example.cpp.json``
+    ``/foo/<ISO8601-like timestamp>-example.cpp.json``

clang/docs/ReleaseNotes.rst

@@ -285,6 +285,13 @@ Bug Fixes in This Version
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- Fix crash when atomic builtins are called with pointer to zero-size struct (#GH90330)
+
+- Clang now allows pointee types of atomic builtin arguments to be complete template types
+  that was not instantiated elsewhere.
+
+- ``__noop`` can now be used in a constant expression. (#GH102064)
+
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -326,6 +333,9 @@ Bug Fixes to C++ Support
 - Fix evaluation of the index of dependent pack indexing expressions/types specifiers (#GH105900)
 - Correctly handle subexpressions of an immediate invocation in the presence of implicit casts. (#GH105558)
 - Clang now correctly handles direct-list-initialization of a structured bindings from an array. (#GH31813)
+- Mangle placeholders for deduced types as a template-prefix, such that mangling
+  of template template parameters uses the correct production. (#GH106182)
+- Fixed an assertion failure when converting vectors to int/float with invalid expressions. (#GH105486)
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^

clang/include/clang-c/Index.h

@@ -2980,8 +2980,9 @@ enum CXTypeKind {
   CXType_Atomic = 177,
   CXType_BTFTagAttributed = 178,
 
-  // HLSL Intangible Types
-  CXType_HLSLResource = 179
+  // HLSL Types
+  CXType_HLSLResource = 179,
+  CXType_HLSLAttributedResource = 180
 };
 
 /**

clang/include/clang/AST/ASTContext.h

@@ -254,6 +254,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   mutable llvm::ContextualFoldingSet<DependentBitIntType, ASTContext &>
       DependentBitIntTypes;
   llvm::FoldingSet<BTFTagAttributedType> BTFTagAttributedTypes;
+  llvm::FoldingSet<HLSLAttributedResourceType> HLSLAttributedResourceTypes;
 
   mutable llvm::FoldingSet<CountAttributedType> CountAttributedTypes;
 
@@ -1671,6 +1672,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
   QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr,
                                    QualType Wrapped);
 
+  QualType getHLSLAttributedResourceType(
+      QualType Wrapped, QualType Contained,
+      const HLSLAttributedResourceType::Attributes &Attrs);
+
   QualType
   getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
                                unsigned Index,

clang/include/clang/AST/ASTNodeTraverser.h

@@ -439,6 +439,11 @@ class ASTNodeTraverser
   void VisitBTFTagAttributedType(const BTFTagAttributedType *T) {
     Visit(T->getWrappedType());
   }
+  void VisitHLSLAttributedResourceType(const HLSLAttributedResourceType *T) {
+    QualType Contained = T->getContainedType();
+    if (!Contained.isNull())
+      Visit(Contained);
+  }
   void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *) {}
   void
   VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -1146,6 +1146,9 @@ DEF_TRAVERSE_TYPE(CountAttributedType, {
 DEF_TRAVERSE_TYPE(BTFTagAttributedType,
                   { TRY_TO(TraverseType(T->getWrappedType())); })
 
+DEF_TRAVERSE_TYPE(HLSLAttributedResourceType,
+                  { TRY_TO(TraverseType(T->getWrappedType())); })
+
 DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); })
 
 DEF_TRAVERSE_TYPE(MacroQualifiedType,
@@ -1445,6 +1448,9 @@ DEF_TRAVERSE_TYPELOC(CountAttributedType,
 DEF_TRAVERSE_TYPELOC(BTFTagAttributedType,
                      { TRY_TO(TraverseTypeLoc(TL.getWrappedLoc())); })
 
+DEF_TRAVERSE_TYPELOC(HLSLAttributedResourceType,
+                     { TRY_TO(TraverseTypeLoc(TL.getWrappedLoc())); })
+
 DEF_TRAVERSE_TYPELOC(ElaboratedType, {
   if (TL.getQualifierLoc()) {
     TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));