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

  CONFLICT (modify/delete): llvm/test/ThinLTO/X86/constructor-alias.ll deleted in 885e610 and modified in HEAD. Version HEAD of llvm/test/ThinLTO/X86/constructor-alias.ll left in tree.
  CONFLICT (content): Merge conflict in llvm/test/LTO/Resolution/X86/comdat-mixed-lto.ll

Author: Fznamznon

clang-tools-extra/clangd/Hover.cpp

@@ -777,6 +777,17 @@ HoverInfo getDeducedTypeHoverContents(QualType QT, const syntax::Token &Tok,
   return HI;
 }
 
+HoverInfo getStringLiteralContents(const StringLiteral *SL,
+                                   const PrintingPolicy &PP) {
+  HoverInfo HI;
+
+  HI.Name = "string-literal";
+  HI.Size = (SL->getLength() + 1) * SL->getCharByteWidth();
+  HI.Type = SL->getType().getAsString(PP).c_str();
+
+  return HI;
+}
+
 bool isLiteral(const Expr *E) {
   // Unfortunately there's no common base Literal classes inherits from
   // (apart from Expr), therefore these exclusions.
@@ -785,7 +796,7 @@ bool isLiteral(const Expr *E) {
          llvm::isa<CXXNullPtrLiteralExpr>(E) ||
          llvm::isa<FixedPointLiteral>(E) || llvm::isa<FloatingLiteral>(E) ||
          llvm::isa<ImaginaryLiteral>(E) || llvm::isa<IntegerLiteral>(E) ||
-         llvm::isa<StringLiteral>(E) || llvm::isa<UserDefinedLiteral>(E);
+         llvm::isa<UserDefinedLiteral>(E);
 }
 
 llvm::StringLiteral getNameForExpr(const Expr *E) {
@@ -810,6 +821,9 @@ llvm::Optional<HoverInfo> getHoverContents(const Expr *E, ParsedAST &AST,
     return llvm::None;
 
   HoverInfo HI;
+  // Print the type and the size for string literals
+  if (const StringLiteral *SL = dyn_cast<StringLiteral>(E))
+    return getStringLiteralContents(SL, PP);
   // For `this` expr we currently generate hover with pointee type.
   if (const CXXThisExpr *CTE = dyn_cast<CXXThisExpr>(E))
     return getThisExprHoverContents(CTE, AST.getASTContext(), PP);

clang-tools-extra/clangd/refactor/tweaks/RemoveUsingNamespace.cpp

@@ -155,12 +155,23 @@ Expected<Tweak::Effect> RemoveUsingNamespace::apply(const Selection &Inputs) {
             if (!visibleContext(T->getDeclContext())
                      ->Equals(TargetDirective->getNominatedNamespace()))
               return;
+            auto Kind = T->getDeclName().getNameKind();
             // Avoid adding qualifiers before operators, e.g.
             //   using namespace std;
             //   cout << "foo"; // Must not changed to std::cout std:: << "foo"
-            // FIXME: User-defined literals are not handled
-            if (T->isInIdentifierNamespace(
-                    Decl::IdentifierNamespace::IDNS_NonMemberOperator))
+            if (Kind == DeclarationName::CXXOperatorName)
+              return;
+            // Avoid adding qualifiers before user-defined literals, e.g.
+            //   using namespace std;
+            //   auto s = "foo"s; // Must not changed to auto s = "foo" std::s;
+            // FIXME: Add a using-directive for user-defined literals
+            // declared in an inline namespace, e.g.
+            //   using namespace s^td;
+            //   int main() { cout << "foo"s; }
+            // change to
+            //   using namespace std::literals;
+            //   int main() { std::cout << "foo"s; }
+            if (Kind == DeclarationName::NameKind::CXXLiteralOperatorName)
               return;
           }
           SourceLocation Loc = Ref.NameLoc;

clang-tools-extra/clangd/test/system-include-extractor.test

@@ -63,7 +63,7 @@
 # CHECK:   "method": "textDocument/publishDiagnostics",
 # CHECK-NEXT:   "params": {
 # CHECK-NEXT:     "diagnostics": [],
-# CHECK-NEXT:     "uri": "file://INPUT_DIR/the-file.cpp",
+# CHECK-NEXT:     "uri": "file://{{.*}}/the-file.cpp",
 ---
 {"jsonrpc":"2.0","id":10000,"method":"shutdown"}
 ---

clang-tools-extra/clangd/unittests/HoverTests.cpp

@@ -1300,7 +1300,6 @@ TEST(Hover, NoHover) {
       "auto x = ^42.0i;",
       "auto x = ^42;",
       "auto x = ^nullptr;",
-      "auto x = ^\"asdf\";",
   };
 
   for (const auto &Test : Tests) {
@@ -1326,6 +1325,12 @@ TEST(Hover, All) {
          HI.Type = "char";
          HI.Value = "65 (0x41)";
        }},
+      {"auto s = ^[[\"Hello, world!\"]]; // string literal",
+       [](HoverInfo &HI) {
+         HI.Name = "string-literal";
+         HI.Size = 14;
+         HI.Type = "const char[14]";
+       }},
       {
           R"cpp(// Local variable
             int main() {

clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp

@@ -249,6 +249,21 @@ TEST_F(RemoveUsingNamespaceTest, All) {
         ns::Foo foo;
         foo + 10;
       }
+    )cpp"},
+      {// Does not qualify user-defined literals
+       R"cpp(
+      namespace ns {
+      long double operator "" _w(long double);
+      }
+      using namespace n^s;
+      int main() { 1.5_w; }
+    )cpp",
+       R"cpp(
+      namespace ns {
+      long double operator "" _w(long double);
+      }
+      
+      int main() { 1.5_w; }
     )cpp"}};
   for (auto C : Cases)
     EXPECT_EQ(C.second, apply(C.first)) << C.first;

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

@@ -28,14 +28,14 @@ namespace include_cleaner {
 /// that symbol may be provided by several headers.
 /// FIXME: Provide signals about the providing headers so the caller can filter
 /// and rank the results.
-using UsedSymbolCB = llvm::function_ref<void(SymbolReference SymRef,
+using UsedSymbolCB = llvm::function_ref<void(const SymbolReference &SymRef,
                                              llvm::ArrayRef<Header> Providers)>;
 
 /// Find and report all references to symbols in a region of code.
 ///
 /// The AST traversal is rooted at ASTRoots - typically top-level declarations
 /// of a single source file.
-/// FIXME: Handle macro uses.
+/// The references to macros must be recorded separately and provided.
 ///
 /// This is the main entrypoint of the include-cleaner library, and can be used:
 ///  - to diagnose missing includes: a referenced symbol is provided by
@@ -44,7 +44,9 @@ using UsedSymbolCB = llvm::function_ref<void(SymbolReference SymRef,
 ///    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, UsedSymbolCB CB);
+void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
+              llvm::ArrayRef<SymbolReference> MacroRefs, const SourceManager &,
+              UsedSymbolCB CB);
 
 } // namespace include_cleaner
 } // namespace clang

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

@@ -19,6 +19,9 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/FileSystem/UniqueID.h"
 #include "clang-include-cleaner/Types.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -35,6 +38,7 @@ class Decl;
 class FileEntry;
 class Preprocessor;
 class PPCallbacks;
+class FileManager;
 
 namespace include_cleaner {
 
@@ -61,6 +65,11 @@ class PragmaIncludes {
   /// Returns "" if there is none.
   llvm::StringRef getPublic(const FileEntry *File) const;
 
+  /// Returns all direct exporter headers for the given header file.
+  /// Returns empty if there is none.
+  llvm::SmallVector<const FileEntry *> getExporters(const FileEntry *File,
+                                                    FileManager &FM) const;
+
 private:
   class RecordPragma;
   /// 1-based Line numbers for the #include directives of the main file that
@@ -73,10 +82,21 @@ class PragmaIncludes {
   // !!NOTE: instead of using a FileEntry* to identify the physical file, we
   // deliberately use the UniqueID to ensure the result is stable across
   // FileManagers (for clangd's preamble and main-file builds).
-  llvm::DenseMap<llvm::sys::fs::UniqueID, std::string /*VerbatimSpelling*/>
+  llvm::DenseMap<llvm::sys::fs::UniqueID, llvm::StringRef /*VerbatimSpelling*/>
       IWYUPublic;
 
-  // FIXME: add other IWYU supports (export etc)
+  /// A reverse map from the underlying header to its exporter headers.
+  //
+  //  There's no way to get a FileEntry from a UniqueID, especially when it
+  //  hasn't been opened before. So store the full path and convert it to a
+  //  FileEntry by opening the file again through a FileManager.
+  llvm::DenseMap<llvm::sys::fs::UniqueID,
+                 llvm::SmallVector</*RealPathNames*/ llvm::StringRef>>
+      IWYUExportBy;
+
+  /// Owns the strings.
+  llvm::BumpPtrAllocator Arena;
+
   // FIXME: add support for clang use_instead pragma
   // FIXME: add selfcontained file.
 };

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

@@ -26,9 +26,11 @@ toHeader(llvm::ArrayRef<tooling::stdlib::Header> Headers) {
   });
   return Result;
 }
-
 } // namespace
-void walkUsed(llvm::ArrayRef<Decl *> ASTRoots, UsedSymbolCB CB) {
+
+void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
+              llvm::ArrayRef<SymbolReference> MacroRefs,
+              const SourceManager &SM, UsedSymbolCB CB) {
   tooling::stdlib::Recognizer Recognizer;
   for (auto *Root : ASTRoots) {
     auto &SM = Root->getASTContext().getSourceManager();
@@ -45,7 +47,14 @@ void walkUsed(llvm::ArrayRef<Decl *> ASTRoots, UsedSymbolCB CB) {
         return CB({Loc, Symbol(ND), RT}, {Header(FE)});
     });
   }
-  // FIXME: Handle references of macros.
+  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)});
+  }
 }
 
 } // namespace clang::include_cleaner

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

@@ -118,14 +118,24 @@ static llvm::Optional<StringRef> parseIWYUPragma(const char *Text) {
 class PragmaIncludes::RecordPragma : public PPCallbacks, public CommentHandler {
 public:
   RecordPragma(const CompilerInstance &CI, PragmaIncludes *Out)
-      : SM(CI.getSourceManager()), Out(Out) {}
+      : SM(CI.getSourceManager()), Out(Out), UniqueStrings(Arena) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     InMainFile = SM.isWrittenInMainFile(Loc);
   }
 
+  void EndOfMainFile() override {
+    for (auto &It : Out->IWYUExportBy) {
+      llvm::sort(It.getSecond());
+      It.getSecond().erase(
+          std::unique(It.getSecond().begin(), It.getSecond().end()),
+          It.getSecond().end());
+    }
+    Out->Arena = std::move(Arena);
+  }
+
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
                           CharSourceRange /*FilenameRange*/,
@@ -134,14 +144,35 @@ class PragmaIncludes::RecordPragma : public PPCallbacks, public CommentHandler {
                           llvm::StringRef /*RelativePath*/,
                           const clang::Module * /*Imported*/,
                           SrcMgr::CharacteristicKind FileKind) override {
-    if (!InMainFile)
-      return;
-    int HashLine =
-        SM.getLineNumber(SM.getMainFileID(), SM.getFileOffset(HashLoc));
-    if (LastPragmaKeepInMainFileLine == HashLine)
+    FileID HashFID = SM.getFileID(HashLoc);
+    int HashLine = SM.getLineNumber(HashFID, SM.getFileOffset(HashLoc));
+    checkForExport(HashFID, HashLine, File ? &File->getFileEntry() : nullptr);
+
+    if (InMainFile && LastPragmaKeepInMainFileLine == HashLine)
       Out->ShouldKeep.insert(HashLine);
   }
 
+  void checkForExport(FileID IncludingFile, int HashLine,
+                      const FileEntry *IncludedHeader) {
+    if (ExportStack.empty())
+      return;
+    auto &Top = ExportStack.back();
+    if (Top.SeenAtFile != IncludingFile)
+      return;
+    // Make sure current include is covered by the export pragma.
+    if ((Top.Block && HashLine > Top.SeenAtLine) ||
+        Top.SeenAtLine == HashLine) {
+      if (IncludedHeader)
+        Out->IWYUExportBy[IncludedHeader->getUniqueID()].push_back(
+            Top.FullPath);
+      // main-file #include with export pragma should never be removed.
+      if (Top.SeenAtFile == SM.getMainFileID())
+        Out->ShouldKeep.insert(HashLine);
+    }
+    if (!Top.Block) // Pop immediately for single-line export pragma.
+      ExportStack.pop_back();
+  }
+
   bool HandleComment(Preprocessor &PP, SourceRange Range) override {
     auto &SM = PP.getSourceManager();
     auto Pragma = parseIWYUPragma(SM.getCharacterData(Range.getBegin()));
@@ -153,11 +184,32 @@ class PragmaIncludes::RecordPragma : public PPCallbacks, public CommentHandler {
       if (auto *FE = SM.getFileEntryForID(SM.getFileID(Range.getBegin())))
         Out->IWYUPublic.insert(
             {FE->getLastRef().getUniqueID(),
-             Pragma->startswith("<") || Pragma->startswith("\"")
-                 ? Pragma->str()
-                 : ("\"" + *Pragma + "\"").str()});
+             save(Pragma->startswith("<") || Pragma->startswith("\"")
+                      ? (*Pragma)
+                      : ("\"" + *Pragma + "\"").str())});
       return false;
     }
+    FileID CommentFID = SM.getFileID(Range.getBegin());
+    int CommentLine = SM.getLineNumber(SM.getFileID(Range.getBegin()),
+                                       SM.getFileOffset(Range.getBegin()));
+    // Record export pragma.
+    if (Pragma->startswith("export")) {
+      ExportStack.push_back(
+          {CommentLine, CommentFID,
+           save(SM.getFileEntryForID(CommentFID)->tryGetRealPathName()),
+           false});
+    } else if (Pragma->startswith("begin_exports")) {
+      ExportStack.push_back(
+          {CommentLine, CommentFID,
+           save(SM.getFileEntryForID(CommentFID)->tryGetRealPathName()), true});
+    } else if (Pragma->startswith("end_exports")) {
+      // FIXME: be robust on unmatching cases. We should only pop the stack if
+      // the begin_exports and end_exports is in the same file.
+      if (!ExportStack.empty()) {
+        assert(ExportStack.back().Block);
+        ExportStack.pop_back();
+      }
+    }
 
     if (InMainFile) {
       if (!Pragma->startswith("keep"))
@@ -176,18 +228,35 @@ class PragmaIncludes::RecordPragma : public PPCallbacks, public CommentHandler {
       // 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.
-      LastPragmaKeepInMainFileLine = SM.getLineNumber(
-          SM.getMainFileID(), SM.getFileOffset(Range.getBegin()));
+      LastPragmaKeepInMainFileLine = CommentLine;
     }
     return false;
   }
 
 private:
+  StringRef save(llvm::StringRef S) { return UniqueStrings.save(S); }
+
   bool InMainFile = false;
   const SourceManager &SM;
   PragmaIncludes *Out;
+  llvm::BumpPtrAllocator Arena;
+  /// Intern table for strings. Contents are on the arena.
+  llvm::StringSaver UniqueStrings;
   // Track the last line "IWYU pragma: keep" was seen in the main file, 1-based.
   int LastPragmaKeepInMainFileLine = -1;
+  struct ExportPragma {
+    // The line number where we saw the begin_exports or export pragma.
+    int SeenAtLine = 0; // 1-based line number.
+    // The file where we saw the pragma.
+    FileID SeenAtFile;
+    // FullPath of the file SeenAtFile.
+    StringRef FullPath;
+    // true if it is a block begin/end_exports pragma; false if it is a
+    // single-line export pragma.
+    bool Block = false;
+  };
+  // A stack for tracking all open begin_exports or single-line export.
+  std::vector<ExportPragma> ExportStack;
 };
 
 void PragmaIncludes::record(const CompilerInstance &CI) {
@@ -203,6 +272,21 @@ llvm::StringRef PragmaIncludes::getPublic(const FileEntry *F) const {
   return It->getSecond();
 }
 
+llvm::SmallVector<const FileEntry *>
+PragmaIncludes::getExporters(const FileEntry *File, FileManager &FM) const {
+  auto It = IWYUExportBy.find(File->getUniqueID());
+  if (It == IWYUExportBy.end())
+    return {};
+
+  llvm::SmallVector<const FileEntry *> Results;
+  for (auto Export : It->getSecond()) {
+    // FIMXE: log the failing cases?
+    if (auto FE = expectedToOptional(FM.getFileRef(Export)))
+      Results.push_back(*FE);
+  }
+  return Results;
+}
+
 std::unique_ptr<ASTConsumer> RecordedAST::record() {
   class Recorder : public ASTConsumer {
     RecordedAST *Out;