[clang] Add ability to suggest #import instead of #include.

[dgoldman]

Summary

This currently isn't used by anything, but will be used by clangd in the
future to suggest #import instead of #include for Objective-C code.

[dgoldman]

Minor changes

clang-tools-extra/clangd/CodeComplete.cpp

auto Inserted = [&](llvm::StringRef Header)
           Includes.shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
     };
     bool ShouldInsert = C.headerToInsertIfAllowed(Opts).hasValue();
     // Calculate include paths and edits for all possible headers.
     for (const auto &Inc : C.RankedIncludeHeaders) {
       if (auto ToInclude = Inserted(Inc)) {
         CodeCompletion::IncludeCandidate Include;
         Include.Header = ToInclude->first;
+        // TODO: Suggest #import here instead of #include for Objective-C code.
         if (ToInclude->second && ShouldInsert)
-          Include.Insertion = Includes.insert(ToInclude->first);
+          Include.Insertion =
+              Includes.insert(ToInclude->first, /*ViaImport=*/false);
         Completion.Includes.push_back(std::move(Include));
       } else
         log("Failed to generate include insertion edits for adding header "
             "(FileURI='{0}', IncludeHeader='{1}') into {2}: {3}",
             C.IndexResult->CanonicalDeclaration.FileURI, Inc, FileName,
             ToInclude.takeError());
     }
     // Prefer includes that do not need edits (i.e. already exist).

clang-tools-extra/clangd/Headers.h

public:
   /// \return A quoted "path" or <path> to be included, or None if it couldn't
   /// be shortened.
   llvm::Optional<std::string>
   calculateIncludePath(const HeaderFile &InsertedHeader,
                        llvm::StringRef IncludingFile) const;
 
   /// Calculates an edit that inserts \p VerbatimHeader into code. If the header
   /// is already included, this returns None.
-  llvm::Optional<TextEdit> insert(llvm::StringRef VerbatimHeader) const;
+  llvm::Optional<TextEdit> insert(llvm::StringRef VerbatimHeader,
+                                  bool ViaImport) const;
 
 private:
   StringRef FileName;
   StringRef Code;
   StringRef BuildDir;
   HeaderSearch *HeaderSearchInfo = nullptr;
   llvm::StringSet<> IncludedHeaders; // Both written and resolved.
   tooling::HeaderIncludes Inserter;  // Computers insertion replacement.

clang-tools-extra/clangd/Headers.cpp

if (llvm::sys::path::is_absolute(Suggested))
     return None;
   if (IsSystem)
     Suggested = "<" + Suggested + ">";
   else
     Suggested = "\"" + Suggested + "\"";
   return Suggested;
 }
 
-llvm::Optional<TextEdit>
-IncludeInserter::insert(llvm::StringRef VerbatimHeader) const {
+llvm::Optional<TextEdit> IncludeInserter::insert(llvm::StringRef VerbatimHeader,
+                                                 bool ViaImport) const {
   llvm::Optional<TextEdit> Edit = None;
-  if (auto Insertion = Inserter.insert(VerbatimHeader.trim("\"<>"),
-                                       VerbatimHeader.startswith("<")))
+  if (auto Insertion =
+          Inserter.insert(VerbatimHeader.trim("\"<>"),
+                          VerbatimHeader.startswith("<"), ViaImport))
     Edit = replacementToEdit(Code, *Insertion);
   return Edit;
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Inclusion &Inc) {
   return OS << Inc.Written << " = "
             << (!Inc.Resolved.empty() ? Inc.Resolved : "[unresolved]")
             << " at line" << Inc.HashLine;

clang-tools-extra/clangd/IncludeFixer.cpp

std::vector<Fix> IncludeFixer::fixesForSymbols(const SymbolSlab &Syms) const {
   llvm::StringSet<> InsertedHeaders;
   for (const auto &Sym : Syms) {
     for (const auto &Inc : getRankedIncludes(Sym)) {
       if (auto ToInclude = Inserted(Sym, Inc)) {
         if (ToInclude->second) {
           auto I = InsertedHeaders.try_emplace(ToInclude->first);
           if (!I.second)
             continue;
-          if (auto Edit = Inserter->insert(ToInclude->first))
+          // TODO: Suggest #import here instead of #include for Objective-C
+          // code.
+          if (auto Edit =
+                  Inserter->insert(ToInclude->first, /*ViaImport=*/false))
             Fixes.push_back(Fix{std::string(llvm::formatv(
                                     "Add include {0} for symbol {1}{2}",
                                     ToInclude->first, Sym.Scope, Sym.Name)),
                                 {std::move(*Edit)}});
         }
       } else {
         vlog("Failed to calculate include insertion for {0} into {1}: {2}", Inc,
              File, ToInclude.takeError());

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

std::string calculate(PathRef Original, PathRef Preferred = "",
     auto Inserted = ToHeaderFile(Preferred);
     if (!Inserter.shouldInsertInclude(Original, Inserted))
       return "";
     auto Path = Inserter.calculateIncludePath(Inserted, MainFile);
     Action.EndSourceFile();
     return Path.getValueOr("");
   }
 
-  llvm::Optional<TextEdit> insert(llvm::StringRef VerbatimHeader) {
+  llvm::Optional<TextEdit> insert(llvm::StringRef VerbatimHeader,
+                                  bool ViaImport) {
     Clang = setupClang();
     PreprocessOnlyAction Action;
     EXPECT_TRUE(
         Action.BeginSourceFile(*Clang, Clang->getFrontendOpts().Inputs[0]));
 
     IncludeInserter Inserter(MainFile, /*Code=*/"", format::getLLVMStyle(),
                              CDB.getCompileCommand(MainFile)->Directory,
                              &Clang->getPreprocessor().getHeaderSearchInfo());
-    auto Edit = Inserter.insert(VerbatimHeader);
+    auto Edit = Inserter.insert(VerbatimHeader, ViaImport);
     Action.EndSourceFile();
     return Edit;
   }
 
   MockFS FS;
   MockCompilationDatabase CDB;
   std::string MainFile = testPath("main.cpp");
   std::string Subdir = testPath("sub");
TEST_F(HeadersTest, DontInsertDuplicateResolved) {
   Inc.Written = "fake-bar.h";
   Inc.Resolved = testPath("sub/bar.h");
   EXPECT_EQ(calculate(Inc.Resolved, "", {Inc}), "");
   // Do not insert preferred.
   EXPECT_EQ(calculate(Inc.Resolved, "\"BAR.h\"", {Inc}), "");
 }
 
 TEST_F(HeadersTest, PreferInserted) {
-  auto Edit = insert("<y>");
+  auto Edit = insert("<y>", /*ViaImport=*/false);
   EXPECT_TRUE(Edit.hasValue());
   EXPECT_TRUE(StringRef(Edit->newText).contains("<y>"));
 }
 
+TEST_F(HeadersTest, Import) {
+  auto Edit = insert("\"y\"", /*ViaImport=*/true);
+  EXPECT_TRUE(Edit.hasValue());
+  EXPECT_TRUE(StringRef(Edit->newText).contains("#import \"y\""));
+}
+
 TEST(Headers, NoHeaderSearchInfo) {
   std::string MainFile = testPath("main.cpp");
   IncludeInserter Inserter(MainFile, /*Code=*/"", format::getLLVMStyle(),
                            /*BuildDir=*/"", /*HeaderSearchInfo=*/nullptr);
 
   auto HeaderPath = testPath("sub/bar.h");
   auto Inserting = HeaderFile{HeaderPath, /*Verbatim=*/false};
   auto Verbatim = HeaderFile{"<x>", /*Verbatim=*/true};

clang/include/clang/Tooling/Inclusions/HeaderIncludes.h

 
 /// Generates replacements for inserting or deleting #include directives in a
 /// file.
 class HeaderIncludes {
 public:
   HeaderIncludes(llvm::StringRef FileName, llvm::StringRef Code,
                  const IncludeStyle &Style);
 
-  /// Inserts an #include directive of \p Header into the code. If \p IsAngled
-  /// is true, \p Header will be quoted with <> in the directive; otherwise, it
-  /// will be quoted with "".
+  /// Inserts an #include or #import directive of \p IncludeName into the code.
+  /// If \p IsAngled is true, \p IncludeName will be quoted with <> in the
+  /// directive; otherwise, it will be quoted with "".
   ///
   /// When searching for points to insert new header, this ignores #include's
   /// after the #include block(s) in the beginning of a file to avoid inserting
   /// headers into code sections where new #include's should not be added by
   /// default. These code sections include:
   ///   - raw string literals (containing #include).
   ///   - #if blocks.
   ///   - Special #include's among declarations (e.g. functions).
   ///
   /// Returns a replacement that inserts the new header into a suitable #include
   /// block of the same category. This respects the order of the existing
   /// #includes in the block; if the existing #includes are not already sorted,
   /// this will simply insert the #include in front of the first #include of the
   /// same category in the code that should be sorted after \p IncludeName. If
   /// \p IncludeName already exists (with exactly the same spelling), this
   /// returns None.
-  llvm::Optional<tooling::Replacement> insert(llvm::StringRef Header,
-                                              bool IsAngled) const;
+  llvm::Optional<tooling::Replacement> insert(llvm::StringRef IncludeName,
+                                              bool IsAngled,
+                                              bool IsImport = false) const;
 
   /// Removes all existing #includes of \p Header quoted with <> if \p IsAngled
   /// is true or "" if \p IsAngled is false.
-  /// This doesn't resolve the header file path; it only deletes #includes with
-  /// exactly the same spelling.
+  /// This doesn't resolve the header file path; it only deletes #includes and
+  /// #imports with exactly the same spelling.
   tooling::Replacements remove(llvm::StringRef Header, bool IsAngled) const;
 
 private:
   struct Include {
     Include(StringRef Name, tooling::Range R) : Name(Name), R(R) {}
 
     // An include header quoted with either <> or "".
     std::string Name;

clang/lib/Tooling/Inclusions/HeaderIncludes.cpp

if (CurInclude.R.getOffset() <= MaxInsertOffset) {
     CategoryEndOffsets[Priority] = NextLineOffset;
     IncludesByPriority[Priority].push_back(&CurInclude);
     if (FirstIncludeOffset < 0)
       FirstIncludeOffset = CurInclude.R.getOffset();
   }
 }
 
 llvm::Optional<tooling::Replacement>
-HeaderIncludes::insert(llvm::StringRef IncludeName, bool IsAngled) const {
+HeaderIncludes::insert(llvm::StringRef IncludeName, bool IsAngled,
+                       bool IsImport) const {
   assert(IncludeName == trimInclude(IncludeName));
   // If a <header> ("header") already exists in code, "header" (<header>) with
   // different quotation will still be inserted.
   // FIXME: figure out if this is the best behavior.
   auto It = ExistingIncludes.find(IncludeName);
   if (It != ExistingIncludes.end())
     for (const auto &Inc : It->second)
       if ((IsAngled && StringRef(Inc.Name).startswith("<")) ||
for (const auto *Inc : Iter->second) {
       if (QuotedName < Inc->Name) {
         InsertOffset = Inc->R.getOffset();
         break;
       }
     }
   }
   assert(InsertOffset <= Code.size());
   std::string NewInclude =
-      std::string(llvm::formatv("#include {0}\n", QuotedName));
+      IsImport ? std::string(llvm::formatv("#import {0}\n", QuotedName))
+               : std::string(llvm::formatv("#include {0}\n", QuotedName));
   // When inserting headers at end of the code, also append '\n' to the code
   // if it does not end with '\n'.
   // FIXME: when inserting multiple #includes at the end of code, only one
   // newline should be added.
   if (InsertOffset == Code.size() && (!Code.empty() && Code.back() != '\n'))
     NewInclude = "\n" + NewInclude;
   return tooling::Replacement(FileName, InsertOffset, 0, NewInclude);
 }