llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-tools-extra Author: None (4m4n-x-B4w4ne) <details> <summary>Changes</summary> This Pull Request is to fix issue #<!-- -->24841. I am also cherry-pick commit a3c7fca28faee679a59afd58c2e814025771ff63. @<!-- -->LegalizeAdulthood @<!-- -->PiotrZSL --- Full diff: https://github.com/llvm/llvm-project/pull/124319.diff 7 Files Affected: - (modified) clang-tools-extra/clang-tidy/modernize/CMakeLists.txt (+1) - (modified) clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp (+3) - (added) clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.cpp (+126) - (added) clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.h (+40) - (modified) clang-tools-extra/docs/ReleaseNotes.rst (+5) - (added) clang-tools-extra/docs/clang-tidy/checks/modernize/use-cpp-style-comments.rst (+38) - (added) clang-tools-extra/test/clang-tidy/checkers/modernize/use-cpp-style-comments.cpp (+68) ``````````diff diff --git a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt index bab1167fb15ff2..f07dd5efecc58e 100644 --- a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt +++ b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt @@ -31,6 +31,7 @@ add_clang_library(clangTidyModernizeModule STATIC UseAutoCheck.cpp UseBoolLiteralsCheck.cpp UseConstraintsCheck.cpp + UseCppStyleCommentsCheck.cpp UseDefaultMemberInitCheck.cpp UseDesignatedInitializersCheck.cpp UseEmplaceCheck.cpp diff --git a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp index fc46c72982fdce..1917d562f7ce8d 100644 --- a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp +++ b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp @@ -32,6 +32,7 @@ #include "UseAutoCheck.h" #include "UseBoolLiteralsCheck.h" #include "UseConstraintsCheck.h" +#include "UseCppStyleCommentsCheck.h" #include "UseDefaultMemberInitCheck.h" #include "UseDesignatedInitializersCheck.h" #include "UseEmplaceCheck.h" @@ -107,6 +108,8 @@ class ModernizeModule : public ClangTidyModule { "modernize-use-bool-literals"); CheckFactories.registerCheck<UseConstraintsCheck>( "modernize-use-constraints"); + CheckFactories.registerCheck<UseCppStyleCommentsCheck>( + "modernize-use-cpp-style-comments"); CheckFactories.registerCheck<UseDefaultMemberInitCheck>( "modernize-use-default-member-init"); CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace"); diff --git a/clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.cpp b/clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.cpp new file mode 100644 index 00000000000000..3c25c50bab759c --- /dev/null +++ b/clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.cpp @@ -0,0 +1,126 @@ +//===--- UseCppStyleCommentsCheck.cpp - clang-tidy-------------------------===// + +// +// 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 "UseCppStyleCommentsCheck.h" +#include "clang/ASTMatchers/ASTMatchFinder.h" +#include "clang/Lex/Lexer.h" +#include "clang/Lex/Preprocessor.h" +#include <iostream> +using namespace clang::ast_matchers; + +namespace clang::tidy::modernize { +class UseCppStyleCommentsCheck::CStyleCommentHandler : public CommentHandler { +public: + CStyleCommentHandler(UseCppStyleCommentsCheck &Check) + : Check(Check), + CStyleCommentMatch( + "^[ \t]*/\\*+[ \t\r\n]*(.*[ \t\r\n]*)*[ \t\r\n]*\\*+/[ \t\r\n]*$"){} + + std::string convertToCppStyleComment(const SourceManager &SM, const SourceRange &Range) { + 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)) { + size_t startPos = Line.find_first_not_of(" \t"); + if (startPos != std::string::npos) { + Line = Line.substr(startPos); + } else { + Line.clear(); + } + Result += "// " + Line; + } + + while (std::getline(Stream, Line)) { + size_t startPos = Line.find_first_not_of(" \t"); + if (startPos != std::string::npos) { + Line = Line.substr(startPos); + } else { + Line.clear(); + } + Result += "\n// " + Line; + } + return Result; + } + + bool HandleComment(Preprocessor &PP, SourceRange Range) override { + const SourceManager &SM = PP.getSourceManager(); + + if (Range.getBegin().isMacroID() || + SM.isInSystemHeader(Range.getBegin())) { + return false; + } + + const StringRef Text = + Lexer::getSourceText(CharSourceRange::getCharRange(Range), + SM, PP.getLangOpts()); + + SmallVector<StringRef> Matches; + if (!CStyleCommentMatch.match(Text, &Matches)) { + return false; + } + + SourceLocation CommentStart = Range.getBegin(); + SourceLocation CommentEnd = Range.getEnd(); + + unsigned StartLine = SM.getSpellingLineNumber(CommentStart); + unsigned EndLine = SM.getSpellingLineNumber(CommentEnd); + + + if (StartLine == EndLine) { + SourceLocation LineBegin = SM.translateLineCol( + SM.getFileID(CommentStart), StartLine, 1); + SourceLocation LineEnd = SM.translateLineCol(SM.getFileID(CommentEnd), EndLine, std::numeric_limits<unsigned>::max()); + StringRef LineContent = + Lexer::getSourceText(CharSourceRange::getCharRange(LineBegin, LineEnd), + SM, PP.getLangOpts()); + size_t CommentStartOffset = SM.getSpellingColumnNumber(CommentStart) - 1; + StringRef AfterComment = LineContent.drop_front(CommentStartOffset + Text.size()); + + if (!AfterComment.trim().empty()) { + return false; + } + } + + Check.diag( + Range.getBegin(), + "use C++ style comments '//' instead of C style comments '/*...*/'") + << clang::FixItHint::CreateReplacement( + Range, convertToCppStyleComment(SM, Range)); + + return false; +} + + +private: + UseCppStyleCommentsCheck &Check; + llvm::Regex CStyleCommentMatch; +}; + +UseCppStyleCommentsCheck::UseCppStyleCommentsCheck(StringRef Name, + ClangTidyContext *Context) + : ClangTidyCheck(Name, Context), + Handler(std::make_unique<CStyleCommentHandler>(*this)) {} + +void UseCppStyleCommentsCheck::registerPPCallbacks( + const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { + PP->addCommentHandler(Handler.get()); +} + +void UseCppStyleCommentsCheck::check(const MatchFinder::MatchResult &Result) {} + +UseCppStyleCommentsCheck::~UseCppStyleCommentsCheck() = default; +} // namespace clang::tidy::modernize diff --git a/clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.h b/clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.h new file mode 100644 index 00000000000000..3d604683de5a24 --- /dev/null +++ b/clang-tools-extra/clang-tidy/modernize/UseCppStyleCommentsCheck.h @@ -0,0 +1,40 @@ +//===--- UseCppStyleCommentsCheck.h - clang-tidy---------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_CPP_STYLE_COMMENTS_CHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_CPP_STYLE_COMMENTS_CHECK_H + +#include "../ClangTidyCheck.h" +#include <sstream> +namespace clang::tidy::modernize { +/// Detects C Style comments and suggests to use C++ style comments instead. +/// +/// For the user-facing documentation see: +/// http://clang.llvm.org/extra/clang-tidy/checks/modernize/use-cpp-style-comments.html +class UseCppStyleCommentsCheck : public ClangTidyCheck { +public: + UseCppStyleCommentsCheck(StringRef Name, ClangTidyContext *Context); + + ~UseCppStyleCommentsCheck() override; + + bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { + return LangOpts.CPlusPlus; + } + + void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, + Preprocessor *ModuleExpanderPP) override; + + void check(const ast_matchers::MatchFinder::MatchResult &Result) override; + +private: + class CStyleCommentHandler; + std::unique_ptr<CStyleCommentHandler> Handler; +}; +} // namespace clang::tidy::modernize + +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_CPP_STYLE_COMMENTS_CHECK_H diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst index cc5f64a3f9fa32..a89cd1a8b80e50 100644 --- a/clang-tools-extra/docs/ReleaseNotes.rst +++ b/clang-tools-extra/docs/ReleaseNotes.rst @@ -173,6 +173,11 @@ New checks Replace comparisons between signed and unsigned integers with their safe C++20 ``std::cmp_*`` alternative, if available. + +- New :doc:`modernize-use-cpp-style-comments + <clang-tidy/checks/modernize/use-cpp-style-comments>` check. + + Detects C Style comments and suggests to use C++ style comments instead. - New :doc:`portability-template-virtual-member-function <clang-tidy/checks/portability/template-virtual-member-function>` check. diff --git a/clang-tools-extra/docs/clang-tidy/checks/modernize/use-cpp-style-comments.rst b/clang-tools-extra/docs/clang-tidy/checks/modernize/use-cpp-style-comments.rst new file mode 100644 index 00000000000000..5eaf759a3db6d6 --- /dev/null +++ b/clang-tools-extra/docs/clang-tidy/checks/modernize/use-cpp-style-comments.rst @@ -0,0 +1,38 @@ +.. title:: clang-tidy - use-cpp-style-comments + +modernize-use-cpp-style-comments +======================= + +Replace C-style comments with C++-style comments. +C-style comments (`/* ... */`) are inherited from C, while C++ introduces +`//` as a more concise, readable, and less error-prone alternative. Modern C++ +guidelines recommend using C++-style comments for consistency and +maintainability. This check identifies and replaces C-style comments with +equivalent C++-style comments. + +Examples: + +Input: +.. code-block::c++ + /* This is a single-line comment */ + int x = 42; /* Inline comment */ + + /* This is a + multi-line comment */ + + +Output: +.. code-block::c++ + // This is a single-line comment + int x = 42; // Inline comment + + // This is a + // multi-line comment + +.. note:: + + Inline Comments are neither fixed nor warned. + Example: + .. code-block:: c++ + int a = /* this is a comment */ 5; + diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-cpp-style-comments.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-cpp-style-comments.cpp new file mode 100644 index 00000000000000..f56750591e035f --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-cpp-style-comments.cpp @@ -0,0 +1,68 @@ +// RUN: %check_clang_tidy -std=c++11 %s modernize-use-cpp-style-comments %t -- -- + +// Single-line full C-style comment +static const int CONSTANT = 42; /* Important constant value */ +// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] +// CHECK-FIXES: static const int CONSTANT = 42; // Important constant value + +// Inline comment that should NOT be transformed +int a = /* inline comment */ 5; + +// Multiline full-line comment +/* This is a multiline comment + that spans several lines + and should be converted to C++ style */ +// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] +// CHECK-FIXES: // This is a multiline comment +// CHECK-FIXES: // that spans several lines +// CHECK-FIXES: // and should be converted to C++ style +void fnWithSomeBools(bool A,bool B) {} +// Function with parameter inline comments +void processData(int data /* input data */, + bool validate /* perform validation */) { + // These inline comments should NOT be transformed + fnWithSomeBools(/*ControlsA=*/ true, /*ControlsB=*/ false); +} + +// Multiline comment with asterisk styling +/******************************* + * Block comment with asterisks + * Should be converted to C++ style + *******************************/ +// CHECK-MESSAGES: :[[@LINE-4]]:1: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] +// CHECK-FIXES: // ****************************** +// CHECK-FIXES: // * Block comment with asterisks +// CHECK-FIXES: // * Should be converted to C++ style +// CHECK-FIXES: // ****************************** +int calculateSomething() { return 1;} +// Comment at end of complex line +int complexCalculation = calculateSomething(); /* Result of complex calculation */ +// CHECK-MESSAGES: :[[@LINE-1]]:48: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] +// CHECK-FIXES: 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 + + /* Comment with special characters !@#$%^&*()_+ */ + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] + // CHECK-FIXES: // Comment with special characters !@#$%^&*()_+ +} + +// Multiline comment with various indentations + /* This comment is indented + and should preserve indentation when converted */ +// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] +// CHECK-FIXES: // This comment is indented +// CHECK-FIXES: // and should preserve indentation when converted + +// Complex function with mixed comment types +void complexFunction() { + /* Full line comment at start of block */ + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] + // CHECK-FIXES: // Full line comment at start of block + + int x = 10; /* Inline comment not to be transformed */ + // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use C++ style comments '//' instead of C style comments '/*...*/' [modernize-use-cpp-style-comments] + // CHECK-FIXES: int x = 10; // Inline comment not to be transformed +} \ No newline at end of file `````````` </details> https://github.com/llvm/llvm-project/pull/124319 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
