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

  CONFLICT (content): Merge conflict in llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp

Author: Fznamznon

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Analysis.h

@@ -11,6 +11,7 @@
 #ifndef CLANG_INCLUDE_CLEANER_ANALYSIS_H
 #define CLANG_INCLUDE_CLEANER_ANALYSIS_H
 
+#include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
@@ -42,11 +43,9 @@ using UsedSymbolCB = llvm::function_ref<void(const SymbolReference &SymRef,
 ///    headers which don't match any #include in the main file
 ///  - to diagnose unused includes: an #include in the main file does not match
 ///    the headers for any referenced symbol
-/// FIXME: Take in an include structure to improve location to header mappings
-/// (e.g. IWYU pragmas).
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
-              llvm::ArrayRef<SymbolReference> MacroRefs, const SourceManager &,
-              UsedSymbolCB CB);
+              llvm::ArrayRef<SymbolReference> MacroRefs,
+              const PragmaIncludes &PI, const SourceManager &, UsedSymbolCB CB);
 
 } // namespace include_cleaner
 } // namespace clang

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

@@ -85,6 +85,7 @@ enum class RefType {
   /// Target's use can't be proven, e.g. a candidate for an unresolved overload.
   Ambiguous,
 };
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, RefType);
 
 /// Indicates that a piece of code refers to a symbol.
 struct SymbolReference {
@@ -105,10 +106,14 @@ struct Header {
     Physical,
     /// A recognized standard library header, like <string>.
     Standard,
+    /// A verbatim header spelling, a string quoted with <> or "" that can be
+    /// #included directly.
+    Verbatim,
   };
 
   Header(const FileEntry *FE) : Storage(FE) {}
   Header(tooling::stdlib::Header H) : Storage(H) {}
+  Header(StringRef VerbatimSpelling) : Storage(VerbatimSpelling) {}
 
   Kind kind() const { return static_cast<Kind>(Storage.index()); }
   bool operator==(const Header &RHS) const { return Storage == RHS.Storage; }
@@ -117,11 +122,13 @@ struct Header {
   tooling::stdlib::Header standard() const {
     return std::get<Standard>(Storage);
   }
+  StringRef verbatim() const {
+    return std::get<Verbatim>(Storage);
+  }
 
 private:
-  // FIXME: Handle verbatim spellings.
   // Order must match Kind enum!
-  std::variant<const FileEntry *, tooling::stdlib::Header> Storage;
+  std::variant<const FileEntry *, tooling::stdlib::Header, StringRef> Storage;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Header &);
 

clang-tools-extra/include-cleaner/lib/Analysis.cpp

@@ -13,47 +13,31 @@
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace clang::include_cleaner {
-namespace {
-llvm::SmallVector<Header>
-toHeader(llvm::ArrayRef<tooling::stdlib::Header> Headers) {
-  llvm::SmallVector<Header> Result;
-  llvm::for_each(Headers, [&](tooling::stdlib::Header H) {
-    Result.emplace_back(Header(H));
-  });
-  return Result;
-}
-} // namespace
 
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
               llvm::ArrayRef<SymbolReference> MacroRefs,
-              const SourceManager &SM, UsedSymbolCB CB) {
+              const PragmaIncludes &PI, const SourceManager &SM,
+              UsedSymbolCB CB) {
   tooling::stdlib::Recognizer Recognizer;
   for (auto *Root : ASTRoots) {
     auto &SM = Root->getASTContext().getSourceManager();
     walkAST(*Root, [&](SourceLocation Loc, NamedDecl &ND, RefType RT) {
       if (auto SS = Recognizer(&ND)) {
         // FIXME: Also report forward decls from main-file, so that the caller
         // can decide to insert/ignore a header.
-        return CB({Loc, Symbol(*SS), RT}, toHeader(SS->headers()));
+        return CB({Loc, Symbol(*SS), RT}, findHeaders(*SS, SM, PI));
       }
       // FIXME: Extract locations from redecls.
-      // FIXME: Handle IWYU pragmas, non self-contained files.
-      // FIXME: Handle macro locations.
-      if (auto *FE = SM.getFileEntryForID(SM.getFileID(ND.getLocation())))
-        return CB({Loc, Symbol(ND), RT}, {Header(FE)});
+      return CB({Loc, Symbol(ND), RT}, findHeaders(ND.getLocation(), SM, PI));
     });
   }
   for (const SymbolReference &MacroRef : MacroRefs) {
     assert(MacroRef.Target.kind() == Symbol::Macro);
-    // FIXME: Handle IWYU pragmas, non self-contained files.
-    // FIXME: Handle macro locations.
-    if (auto *FE = SM.getFileEntryForID(
-            SM.getFileID(MacroRef.Target.macro().Definition)))
-      CB(MacroRef, {Header(FE)});
+    return CB(MacroRef,
+              findHeaders(MacroRef.Target.macro().Definition, SM, PI));
   }
 }
 

clang-tools-extra/include-cleaner/lib/AnalysisInternal.h

@@ -21,6 +21,7 @@
 #ifndef CLANG_INCLUDE_CLEANER_ANALYSISINTERNAL_H
 #define CLANG_INCLUDE_CLEANER_ANALYSISINTERNAL_H
 
+#include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
@@ -46,6 +47,42 @@ namespace include_cleaner {
 void walkAST(Decl &Root,
              llvm::function_ref<void(SourceLocation, NamedDecl &, RefType)>);
 
+/// A place where a symbol can be provided.
+/// It is either a physical file of the TU (SourceLocation) or a logical
+/// location in the standard library (stdlib::Symbol).
+struct SymbolLocation {
+  enum Kind {
+    /// A position within a source file (or macro expansion) parsed by clang.
+    Physical,
+    /// A recognized standard library symbol, like std::string.
+    Standard,
+  };
+
+  SymbolLocation(SourceLocation S) : Storage(S) {}
+  SymbolLocation(tooling::stdlib::Symbol S) : Storage(S) {}
+
+  Kind kind() const { return static_cast<Kind>(Storage.index()); }
+  bool operator==(const SymbolLocation &RHS) const {
+    return Storage == RHS.Storage;
+  }
+
+  SourceLocation physical() const { return std::get<Physical>(Storage); }
+  tooling::stdlib::Symbol standard() const {
+    return std::get<Standard>(Storage);
+  }
+
+private:
+  // Order must match Kind enum!
+  std::variant<SourceLocation, tooling::stdlib::Symbol> Storage;
+};
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Header &);
+
+/// Finds the headers that provide the symbol location.
+// FIXME: expose signals
+llvm::SmallVector<Header> findHeaders(const SymbolLocation &Loc,
+                                      const SourceManager &SM,
+                                      const PragmaIncludes &PI);
+
 /// Write an HTML summary of the analysis to the given stream.
 /// FIXME: Once analysis has a public API, this should be public too.
 void writeHTMLReport(FileID File, llvm::ArrayRef<Decl *> Roots, ASTContext &Ctx,

clang-tools-extra/include-cleaner/lib/CMakeLists.txt

@@ -2,7 +2,9 @@ set(LLVM_LINK_COMPONENTS Support)
 
 add_clang_library(clangIncludeCleaner
   Analysis.cpp
+  FindHeaders.cpp
   HTMLReport.cpp
+  LocateSymbol.cpp
   Record.cpp
   Types.cpp
   WalkAST.cpp

clang-tools-extra/include-cleaner/lib/FindHeaders.cpp

@@ -0,0 +1,51 @@
+//===--- FindHeaders.cpp --------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "AnalysisInternal.h"
+#include "clang-include-cleaner/Record.h"
+#include "clang/Basic/SourceManager.h"
+
+namespace clang::include_cleaner {
+
+llvm::SmallVector<Header> findHeaders(const SymbolLocation &Loc,
+                                      const SourceManager &SM,
+                                      const PragmaIncludes &PI) {
+  llvm::SmallVector<Header> Results;
+  switch (Loc.kind()) {
+  case SymbolLocation::Physical: {
+    // FIXME: Handle macro locations.
+    // FIXME: Handle non self-contained files.
+    FileID FID = SM.getFileID(Loc.physical());
+    const auto *FE = SM.getFileEntryForID(FID);
+    if (!FE)
+      return {};
+
+    // We treat the spelling header in the IWYU pragma as the final public
+    // header.
+    // FIXME: look for exporters if the public header is exported by another
+    // header.
+    llvm::StringRef VerbatimSpelling = PI.getPublic(FE);
+    if (!VerbatimSpelling.empty())
+      return {Header(VerbatimSpelling)};
+
+    Results = {Header(FE)};
+    // FIXME: compute transitive exporter headers.
+    for (const auto *Export : PI.getExporters(FE, SM.getFileManager()))
+      Results.push_back(Export);
+    return Results;
+  }
+  case SymbolLocation::Standard: {
+    for (const auto &H : Loc.standard().headers())
+      Results.push_back(H);
+    return Results;
+  }
+  }
+  llvm_unreachable("unhandled SymbolLocation kind!");
+}
+
+} // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/lib/LocateSymbol.cpp

@@ -0,0 +1,31 @@
+//===--- LocateSymbol.cpp -------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "AnalysisInternal.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace clang::include_cleaner {
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolLocation &S) {
+  switch (S.kind()) {
+  case SymbolLocation::Physical:
+    // We can't decode the Location without SourceManager. Its raw
+    // representation isn't completely useless (and distinguishes
+    // SymbolReference from Symbol).
+    return OS << "@0x"
+              << llvm::utohexstr(
+                     S.physical().getRawEncoding(), /*LowerCase=*/false,
+                     /*Width=*/CHAR_BIT * sizeof(SourceLocation::UIntTy));
+  case SymbolLocation::Standard:
+    return OS << S.standard().scope() << S.standard().name();
+  }
+  llvm_unreachable("Unhandled Symbol kind");
+}
+
+} // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/lib/Record.cpp

@@ -225,9 +225,9 @@ class PragmaIncludes::RecordPragma : public PPCallbacks, public CommentHandler {
       // 2. handleCommentInMainFile("// IWYU pragma: keep")
       // 3. InclusionDirective("bar.h")
       //
-      // This code stores the last location of "IWYU pragma: keep" (or export)
-      // comment in the main file, so that when next InclusionDirective is
-      // called, it will know that the next inclusion is behind the IWYU pragma.
+      // This code stores the last location of "IWYU pragma: keep" comment in
+      // the main file, so that when next InclusionDirective is called, it will
+      // know that the next inclusion is behind the IWYU pragma.
       LastPragmaKeepInMainFileLine = CommentLine;
     }
     return false;
@@ -332,6 +332,10 @@ RecordedPP::RecordedIncludes::match(Header H) const {
     for (unsigned I : BySpelling.lookup(H.standard().name().trim("<>")))
       Result.push_back(&All[I]);
     break;
+  case Header::Verbatim:
+    for (unsigned I : BySpelling.lookup(H.verbatim().trim("\"<>")))
+      Result.push_back(&All[I]);
+    break;
   }
   return Result;
 }

clang-tools-extra/include-cleaner/lib/Types.cpp

@@ -34,6 +34,8 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Header &H) {
     return OS << H.physical()->getName();
   case Header::Standard:
     return OS << H.standard().name();
+  case Header::Verbatim:
+    return OS << H.verbatim();
   }
   llvm_unreachable("Unhandled Header kind");
 }
@@ -52,4 +54,16 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolReference &R) {
                    /*Width=*/CHAR_BIT * sizeof(SourceLocation::UIntTy));
 }
 
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, RefType T) {
+  switch (T) {
+  case RefType::Explicit:
+    return OS << "explicit";
+  case RefType::Implicit:
+    return OS << "implicit";
+  case RefType::Ambiguous:
+    return OS << "ambiguous";
+  }
+  llvm_unreachable("Unexpected RefType");
+}
+
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "AnalysisInternal.h"
-#include "clang-include-cleaner/Analysis.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"