further modifications

Author: 4m4n-x-B4w4ne

clang-tools-extra/clang-tidy/readability/UseCppStyleCommentsCheck.cpp

@@ -10,56 +10,88 @@
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
-#include <sstream>
+#include <optional>
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::readability {
 class UseCppStyleCommentsCheck::CStyleCommentHandler : public CommentHandler {
 public:
-  CStyleCommentHandler(UseCppStyleCommentsCheck &Check, bool ExcludeDoxygen)
+  CStyleCommentHandler(UseCppStyleCommentsCheck &Check, bool ExcludeDoxygen,
+                       StringRef ExcludedComments)
       : Check(Check), ExcludeDoxygen(ExcludeDoxygen),
+        ExcludedComments(ExcludedComments),
+        ExcludedCommentMatch(ExcludedComments),
         CStyleCommentMatch(
             "^[ \t]*/\\*+[ \t\r\n]*(.*[ \t\r\n]*)*[ \t\r\n]*\\*+/[ \t\r\n]*$") {
   }
 
-  void setExcludeDoxygen(bool Exclude) { ExcludeDoxygen = Exclude; }
+  StringRef getExcludedCommentsRegex() const { return ExcludedComments; }
 
   bool isExcludeDoxygen() const { return ExcludeDoxygen; }
 
-  std::string convertToCppStyleComment(const SourceManager &SM,
-                                       const SourceRange &Range) {
-    const StringRef CommentText = Lexer::getSourceText(
+  void convertToCppStyleCommentFixes(const SourceManager &SM,
+                                     const SourceRange &Range,
+                                     SmallVectorImpl<FixItHint> &FixIts) {
+    StringRef CommentText = Lexer::getSourceText(
         CharSourceRange::getTokenRange(Range), SM, LangOptions());
 
-    std::string InnerText = CommentText.str();
-    InnerText.erase(0, 2);
-    InnerText.erase(InnerText.size() - 2, 2);
-
-    std::string Result;
-    std::istringstream Stream(InnerText);
-    std::string Line;
-
-    if (std::getline(Stream, Line)) {
-      const size_t StartPos = Line.find_first_not_of(" \t");
-      if (StartPos != std::string::npos) {
-        Line = Line.substr(StartPos);
+    CommentText = CommentText.drop_front(2).drop_back(2);
+    const SourceLocation StartLoc = Range.getBegin();
+    const FileID FID = SM.getFileID(StartLoc);
+    unsigned LineNo = SM.getSpellingLineNumber(StartLoc);
+    const unsigned StartCol = SM.getSpellingColumnNumber(StartLoc);
+    if (!CommentText.empty()) {
+      const size_t NewlinePos = CommentText.find('\n');
+
+      const StringRef Line = (NewlinePos == StringRef::npos)
+                                 ? CommentText
+                                 : CommentText.substr(0, NewlinePos);
+
+      const SourceLocation LineStart =
+          SM.translateLineCol(FID, LineNo, StartCol);
+      const SourceLocation LineEnd = SM.translateLineCol(
+          FID, LineNo, std::numeric_limits<unsigned>::max());
+
+      FixIts.push_back(FixItHint::CreateReplacement(
+          CharSourceRange::getCharRange(LineStart, LineEnd),
+          "//" + Line.str()));
+
+      if (NewlinePos != StringRef::npos) {
+        CommentText = CommentText.substr(NewlinePos + 1);
+        LineNo++;
       } else {
-        Line.clear();
+        CommentText = "";
       }
-      Result += "// " + Line;
     }
-
-    while (std::getline(Stream, Line)) {
-      const size_t StartPos = Line.find_first_not_of(" \t");
-      if (StartPos != std::string::npos) {
-        Line = Line.substr(StartPos);
+    while (!CommentText.empty()) {
+      const size_t NewlinePos = CommentText.find('\n');
+
+      StringRef Line = (NewlinePos == StringRef::npos)
+                           ? CommentText
+                           : CommentText.substr(0, NewlinePos);
+
+      const SourceLocation LineStart = SM.translateLineCol(FID, LineNo, 1);
+      const SourceLocation LineEnd = SM.translateLineCol(
+          FID, LineNo, std::numeric_limits<unsigned>::max());
+
+      if (Line.substr(0, 2) == "  ") {
+        Line = Line.drop_front(2);
+        FixIts.push_back(FixItHint::CreateReplacement(
+            CharSourceRange::getCharRange(LineStart, LineEnd),
+            "//" + Line.str()));
       } else {
-        Line.clear();
+        FixIts.push_back(FixItHint::CreateReplacement(
+            CharSourceRange::getCharRange(LineStart, LineEnd),
+            "//" + Line.str()));
+      }
+
+      if (NewlinePos == StringRef::npos) {
+        break;
       }
-      Result += "\n// " + Line;
+      CommentText = CommentText.substr(NewlinePos + 1);
+      LineNo++;
     }
-    return Result;
   }
 
   bool isDoxygenStyleComment(const StringRef &Text) {
@@ -70,23 +102,21 @@ class UseCppStyleCommentsCheck::CStyleCommentHandler : public CommentHandler {
             Trimmed.drop_front(2).starts_with("*"));
   }
 
-  bool CheckForTextAfterComment(Preprocessor &PP, SourceRange Range) {
+  bool CheckForCodeAfterComment(Preprocessor &PP, SourceRange Range) {
     const SourceManager &SM = PP.getSourceManager();
-    const SourceLocation CommentEnd = Range.getEnd();
-
-    unsigned EndLine = SM.getSpellingLineNumber(CommentEnd);
-    unsigned EndCol = SM.getSpellingColumnNumber(CommentEnd);
-
-    const SourceLocation LineBegin =
-        SM.translateLineCol(SM.getFileID(CommentEnd), EndLine, EndCol);
-    const SourceLocation LineEnd =
-        SM.translateLineCol(SM.getFileID(CommentEnd), EndLine,
-                            std::numeric_limits<unsigned>::max());
-    const StringRef AfterComment =
-        Lexer::getSourceText(CharSourceRange::getCharRange(LineBegin, LineEnd),
-                             SM, PP.getLangOpts());
-
-    return !AfterComment.trim().empty();
+    const SourceLocation CommentStart = Range.getBegin(),
+                         CommentEnd = Range.getEnd();
+    const std::optional<Token> NextTok =
+        Lexer::findNextToken(CommentStart, SM, PP.getLangOpts());
+    if (!NextTok.has_value()) {
+      return false;
+    }
+    const std::string tokenSpelling =
+        Lexer::getSpelling(*NextTok, SM, PP.getLangOpts());
+    const unsigned lineNo = SM.getSpellingLineNumber(CommentEnd);
+    const SourceLocation loc = NextTok->getLocation();
+    const unsigned tokenLine = SM.getSpellingLineNumber(loc);
+    return lineNo == tokenLine;
   }
 
   bool HandleComment(Preprocessor &PP, SourceRange Range) override {
@@ -99,6 +129,12 @@ class UseCppStyleCommentsCheck::CStyleCommentHandler : public CommentHandler {
     const StringRef Text = Lexer::getSourceText(
         CharSourceRange::getCharRange(Range), SM, PP.getLangOpts());
 
+    if (!ExcludedCommentMatch.isValid()) {
+      llvm::errs() << "Warning: Invalid regex pattern:" << ExcludedComments
+                   << ":for ExcludedComments\n";
+    } else if (ExcludedCommentMatch.match(Text)) {
+      return false;
+    }
     if (ExcludeDoxygen && isDoxygenStyleComment(Text)) {
       return false;
     }
@@ -108,30 +144,38 @@ class UseCppStyleCommentsCheck::CStyleCommentHandler : public CommentHandler {
       return false;
     }
 
-    if (CheckForTextAfterComment(PP, Range)) {
+    if (CheckForCodeAfterComment(PP, Range)) {
       return false;
     }
 
-    Check.diag(
+    SmallVector<FixItHint, 4> FixIts;
+    convertToCppStyleCommentFixes(SM, Range, FixIts);
+
+    auto D = Check.diag(
         Range.getBegin(),
-        "use C++ style comments '//' instead of C style comments '/*...*/'")
-        << clang::FixItHint::CreateReplacement(
-               Range, convertToCppStyleComment(SM, Range));
+        "use C++ style comments '//' instead of C style comments '/*...*/'");
+
+    for (const auto &Fix : FixIts) {
+      D << Fix;
+    }
 
     return false;
   }
 
 private:
   UseCppStyleCommentsCheck &Check;
   bool ExcludeDoxygen;
+  StringRef ExcludedComments;
+  llvm::Regex ExcludedCommentMatch;
   llvm::Regex CStyleCommentMatch;
 };
 
 UseCppStyleCommentsCheck::UseCppStyleCommentsCheck(StringRef Name,
                                                    ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       Handler(std::make_unique<CStyleCommentHandler>(
-          *this, Options.get("ExcludeDoxygenStyleComments", false))) {}
+          *this, Options.get("ExcludeDoxygenStyleComments", false),
+          Options.get("ExcludedComments", "^$"))) {}
 
 void UseCppStyleCommentsCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
@@ -143,6 +187,7 @@ void UseCppStyleCommentsCheck::check(const MatchFinder::MatchResult &Result) {}
 void UseCppStyleCommentsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ExcludeDoxygenStyleComments",
                 Handler->isExcludeDoxygen());
+  Options.store(Opts, "ExcludedComments", Handler->getExcludedCommentsRegex());
 }
 
 UseCppStyleCommentsCheck::~UseCppStyleCommentsCheck() = default;

clang-tools-extra/clang-tidy/readability/UseCppStyleCommentsCheck.h

@@ -15,8 +15,6 @@
 namespace clang::tidy::readability {
 /// Detects C Style comments and suggests to use C++ style comments instead.
 ///
-/// Optionally excludes Doxygen-style comments.
-///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability/use-cpp-style-comments.html
 class UseCppStyleCommentsCheck : public ClangTidyCheck {
@@ -41,6 +39,7 @@ class UseCppStyleCommentsCheck : public ClangTidyCheck {
   std::unique_ptr<CStyleCommentHandler> Handler;
   const bool ExcludeDoxygenStyleComments =
       Options.get("ExcludeDoxygenStyleComments", false);
+  const StringRef ExcludedComments = Options.get("ExcludedComments", "^$");
 };
 } // namespace clang::tidy::readability
 

clang-tools-extra/docs/clang-tidy/checks/readability/use-cpp-style-comments.rst

@@ -49,3 +49,9 @@ Options
 
    A boolean option that determines whether Doxygen-style comments should be excluded.  
    By default, this option is set to ``false``.  
+
+.. option:: ExcludedComments
+
+   A regex pattern that allows specifying certain comments to exclude from transformation.
+   By default, this option is set to "^$", which means no comments are excluded.
+   You can provide a custom regex to exclude specific comments based on your needs.

clang-tools-extra/test/clang-tidy/checkers/readability/use-cpp-style-comments.cpp

@@ -32,7 +32,7 @@ int complexCalculation = calculateSomething(); /* Result of complex calculation
 
 // Nested comments and edge cases
 void edgeCaseFunction() {
-    int x = 10 /* First value */ + 20 /* Second value */;  // Inline comments should not transform
+    int x = 10 /* First value */ + 20 /* Second value */; // Inline comments should not transform
 
     /* Comment with special characters !@#$%^&*()_+ */
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use C++ style comments '//' instead of C style comments '/*...*/' [readability-use-cpp-style-comments]
@@ -44,7 +44,7 @@ void edgeCaseFunction() {
        and should preserve indentation when converted */
 // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use C++ style comments '//' instead of C style comments '/*...*/' [readability-use-cpp-style-comments]
 // CHECK-FIXES:     // This comment is indented
-// CHECK-FIXES:     // and should preserve indentation when converted
+// CHECK-FIXES: //     and should preserve indentation when converted
 
 // Complex function with mixed comment types
 void complexFunction() {
@@ -60,9 +60,21 @@ void complexFunction() {
 /* aaa 
     bbbb
     ccc */ int z = 1;
-// There is a text after the comment ends so it should be ignored.
+// There is a token after the comment ends so it should be ignored.
 
 int y = 10;/* aaa 
     bbbb
     ccc */ int z1 = 1;
-// There is a text after the comment ends so it should be ignored.
+// There is a token after the comment ends so it should be ignored.
+
+/*  aaa
+a    //  abc
+    bbb */
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++ style comments '//' instead of C style comments '/*...*/' [readability-use-cpp-style-comments]
+// CHECK-FIXES: //  aaa
+// CHECK-FIXES: //a    //  abc
+// CHECK-FIXES: //  bbb  
+
+int k1 = 49; /* aa //bbbb aa *///
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use C++ style comments '//' instead of C style comments '/*...*/' [readability-use-cpp-style-comments]
+// CHECK-FIXES: // aa //bbbb aa