java import sorting PoC

lib/Format/Format.cpp

private:
   };
 
   // Tokens to be deleted.
   std::set<FormatToken *, FormatTokenLess> DeletedTokens;
 };
 
 struct IncludeDirective {
   StringRef Filename;
+  bool IsNotStatic;  // False for Java's `import static`.
   StringRef Text;
   unsigned Offset;
   int Category;
 };
 
 } // end anonymous namespace
 
 // Determines whether 'Ranges' intersects with ('Start', 'End').

 
 // Sorts and deduplicate a block of includes given by 'Includes' alphabetically
 // adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
 // source order.
 // #include directives with the same text will be deduplicated, and only the
 // first #include in the duplicate #includes remains. If the `Cursor` is
 // provided and put on a deleted #include, it will be moved to the remaining
 // #include in the duplicate #includes.
-static void sortCppIncludes(const FormatStyle &Style,
-                            const SmallVectorImpl<IncludeDirective> &Includes,
-                            ArrayRef<tooling::Range> Ranges, StringRef FileName,
-                            tooling::Replacements &Replaces, unsigned *Cursor) {
+static void
+sortCppJavaIncludes(const FormatStyle &Style,
   unsigned IncludesBeginOffset = Includes.front().Offset;
   unsigned IncludesEndOffset =
       Includes.back().Offset + Includes.back().Text.size();
   unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
   if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
     return;
   SmallVector<unsigned, 16> Indices;
   for (unsigned i = 0, e = Includes.size(); i != e; ++i)
     Indices.push_back(i);
   std::stable_sort(
       Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
-        return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
-               std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
+        return std::tie(Includes[LHSI].IsNotStatic, Includes[LHSI].Category,
+                        Includes[LHSI].Filename) <
+               std::tie(Includes[RHSI].IsNotStatic, Includes[RHSI].Category,
+                        Includes[RHSI].Filename);
       });
   // The index of the include on which the cursor will be put after
   // sorting/deduplicating.
   unsigned CursorIndex;
   // The offset from cursor to the end of line.
   unsigned CursorToEOLOffset;
   if (Cursor)
     std::tie(CursorIndex, CursorToEOLOffset) =
private:
 
   const FormatStyle &Style;
   bool IsMainFile;
   StringRef FileName;
   StringRef FileStem;
   SmallVector<llvm::Regex, 4> CategoryRegexs;
 };
 
-const char IncludeRegexPattern[] =
+// FIXME: PR34739
+const char CppIncludeRegexPattern[] =
     R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
+const char JavaIncludeRegexPattern[] =
+    R"(^ *import *(static *)?([^ ]*) *;)";
 
 } // anonymous namespace
 
-tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
-                                      ArrayRef<tooling::Range> Ranges,
-                                      StringRef FileName,
-                                      tooling::Replacements &Replaces,
-                                      unsigned *Cursor) {
+tooling::Replacements
+sortCppJavaIncludes(const FormatStyle &Style, StringRef Code,
+                    ArrayRef<tooling::Range> Ranges, StringRef FileName,
+                    tooling::Replacements &Replaces, unsigned *Cursor) {
   unsigned Prev = 0;
   unsigned SearchFrom = 0;
-  llvm::Regex IncludeRegex(IncludeRegexPattern);
+  llvm::Regex IncludeRegex(Style.Language == FormatStyle::LK_Java
+                               ? JavaIncludeRegexPattern
+                               : CppIncludeRegexPattern);
   SmallVector<StringRef, 4> Matches;
   SmallVector<IncludeDirective, 16> IncludesInBlock;
 
   // In compiled files, consider the first #include to be the main #include of
   // the file if it is not a system #include. This ensures that the header
   // doesn't have hidden dependencies
   // (http://llvm.org/docs/CodingStandards.html#include-style).
   //
for (;;) {
     StringRef Trimmed = Line.trim();
     if (Trimmed == "// clang-format off")
       FormattingOff = true;
     else if (Trimmed == "// clang-format on")
       FormattingOff = false;
 
     if (!FormattingOff && !Line.endswith("\\")) {
       if (IncludeRegex.match(Line, &Matches)) {
+        // FIXME: import static for java, in Matches[1] if present
         StringRef IncludeName = Matches[2];
+        bool IsStatic =
+            Style.Language == FormatStyle::LK_Java && !Matches[1].empty();
         int Category = Categories.getIncludePriority(
             IncludeName,
             /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
         if (Category == 0)
           MainIncludeFound = true;
-        IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
+        IncludesInBlock.push_back(
+            {IncludeName, !IsStatic, Line, Prev, Category});
       } else if (!IncludesInBlock.empty()) {
-        sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
+        sortCppJavaIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
                             Cursor);
         IncludesInBlock.clear();
         FirstIncludeBlock = false;
       }
       Prev = Pos + 1;
     }
     if (Pos == StringRef::npos || Pos + 1 == Code.size())
       break;
     SearchFrom = Pos + 1;
   }
   if (!IncludesInBlock.empty())
-    sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
+    sortCppJavaIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
+                        Cursor);
   return Replaces;
 }
 
 bool isMpegTS(StringRef Code) {
   // MPEG transport streams use the ".ts" file extension. clang-format should
   // not attempt to format those. MPEG TS' frame format starts with 0x47 every
   // 189 bytes - detect that and return.
   return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
if (!Style.SortIncludes)
     return Replaces;
   if (isLikelyXml(Code))
     return Replaces;
   if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
       isMpegTS(Code))
     return Replaces;
   if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
     return sortJavaScriptImports(Style, Code, Ranges, FileName);
-  sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
+  sortCppJavaIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
   return Replaces;
 }
 
 template <typename T>
 static llvm::Expected<tooling::Replacements>
 processReplacements(T ProcessFunc, StringRef Code,
                     const tooling::Replacements &Replaces,
                     const FormatStyle &Style) {
auto Reformat = [](const FormatStyle &Style, StringRef Code,
                      StringRef FileName) -> tooling::Replacements {
     return reformat(Style, Code, Ranges, FileName);
   };
   return processReplacements(Reformat, Code, *SortedReplaces, Style);
 }
 
 namespace {
 
-inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
+inline bool isCppHeaderInsertion(const tooling::Replacement &Replace) {
   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
-         llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText());
+         llvm::Regex(CppIncludeRegexPattern)
+             .match(Replace.getReplacementText());
 }
 
 inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
 }
 
 // Returns the offset after skipping a sequence of tokens, matched by \p
 // GetOffsetAfterSequence, from the start of the code.
fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
                         const FormatStyle &Style) {
   if (!Style.isCpp())
     return Replaces;
 
   tooling::Replacements HeaderInsertions;
   std::set<llvm::StringRef> HeadersToDelete;
   tooling::Replacements Result;
   for (const auto &R : Replaces) {
-    if (isHeaderInsertion(R)) {
+    if (isCppHeaderInsertion(R)) {
       // Replacements from \p Replaces must be conflict-free already, so we can
       // simply consume the error.
       llvm::consumeError(HeaderInsertions.add(R));
     } else if (isHeaderDeletion(R)) {
       HeadersToDelete.insert(R.getReplacementText());
     } else if (R.getOffset() == UINT_MAX) {
       llvm::errs() << "Insertions other than header #include insertion are "
                       "not supported! "
                    << R.getReplacementText() << "\n";
     } else {
       llvm::consumeError(Result.add(R));
     }
   }
   if (HeaderInsertions.empty() && HeadersToDelete.empty())
     return Replaces;
 
-  llvm::Regex IncludeRegex(IncludeRegexPattern);
+  llvm::Regex IncludeRegex(CppIncludeRegexPattern);
   llvm::Regex DefineRegex(R"(^[\t\ ]*#[\t\ ]*define[\t\ ]*[^\\]*$)");
   SmallVector<StringRef, 4> Matches;
 
   StringRef FileName = Replaces.begin()->getFilePath();
   IncludeCategoryManager Categories(Style, FileName);
 
   // Record the offset of the end of the last include in each category.
   std::map<int, int> CategoryEndOffsets;