[clang-tools-extra] New check for static_cast of an enum class type (PR #167212)

[via cfe-commits]

llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-clang-tools-extra

Author: None (arjunkonidala)

<details>
<summary>Changes</summary>

It warns the user to use to_underlying function in the utility header (which is introduced in c++23 )instead of static_cast with a hard coded tyep to prevent truncation errors.

---
Full diff: https://github.com/llvm/llvm-project/pull/167212.diff


3 Files Affected:

- (added) clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.cpp (+77) 
- (added) clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.h (+37) 
- (added) clang-tools-extra/test/clang-tidy/checkers/modernize/use-to-underlying.cpp (+42) 


``````````diff
diff --git a/clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.cpp b/clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.cpp
new file mode 100644
index 0000000000000..4ef2305d2d210
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "UseToUnderlyingCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::modernize {
+
+UseToUnderlyingCheck::UseToUnderlyingCheck(StringRef Name,
+                                           ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      Inserter(Options.getLocalOrGlobal("IncludeStyle",
+                                        utils::IncludeSorter::IS_LLVM),
+               areDiagsSelfContained()) {}
+//
+void UseToUnderlyingCheck::registerPPCallbacks(const SourceManager &SM,
+                                               Preprocessor *PP,
+                                               Preprocessor *ModuleExpanderPP) {
+  Inserter.registerPreprocessor(PP);
+}
+
+void UseToUnderlyingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
+}
+
+bool UseToUnderlyingCheck::isLanguageVersionSupported(
+    const LangOptions &LangOpts) const {
+  return LangOpts.CPlusPlus23;
+}
+
+void UseToUnderlyingCheck::registerMatchers(MatchFinder *Finder) {
+  // FIXME: Add matchers.
+  Finder->addMatcher(
+      cxxStaticCastExpr( // C++ cast
+          hasDestinationType(
+              isInteger()),    // casting to any type of integer (int,long,etc)
+          hasSourceExpression( // is an enum class
+              expr(hasType(enumType(hasDeclaration(enumDecl(isScoped())))))
+                  .bind("enumExpr"))) // giving the name enumExpr
+          .bind("castExpr"),          // giving the name castExpr
+      this);
+}
+
+void UseToUnderlyingCheck::check(const MatchFinder::MatchResult &Result) {
+  // Acquiring the enumExpr and castExpr using getNodeAS
+  const auto *Enum = Result.Nodes.getNodeAs<Expr>("enumExpr");
+  const auto *Cast = Result.Nodes.getNodeAs<CXXStaticCastExpr>("castExpr");
+
+  // getting contents of that node using getsourcetext
+  StringRef EnumExprText = Lexer::getSourceText(
+      CharSourceRange::getTokenRange(Enum->getSourceRange()),
+      *Result.SourceManager, getLangOpts());
+  // Suggestion to the user regarding the cast expr
+  std::string Replacement = ("std::to_underlying(" + EnumExprText + ")").str();
+  // gives and warning message if static cast is used instead to_underlying
+  auto Diag = diag(
+      Cast->getBeginLoc(),
+      "use 'std::to_underlying' instead of 'static_cast' for 'enum class'");
+  // suggest and hint for fixing it.
+  Diag << FixItHint::CreateReplacement(Cast->getSourceRange(), Replacement);
+
+  Diag << Inserter.createIncludeInsertion(
+      Result.Context->getSourceManager().getFileID(Cast->getBeginLoc()),
+      "<utility>");
+}
+
+} // namespace clang::tidy::modernize
diff --git a/clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.h b/clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.h
new file mode 100644
index 0000000000000..823bae6115cc7
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/modernize/UseToUnderlyingCheck.h
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_USETOUNDERLYINGCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETOUNDERLYINGCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include "../utils/IncludeInserter.h"
+
+namespace clang::tidy::modernize {
+
+/// Warns user to use to_underlying function from utility header instead of static_cast<T> for a enum class type
+///
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-to-underlying.html
+class UseToUnderlyingCheck : public ClangTidyCheck {
+public:
+  UseToUnderlyingCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
+                           Preprocessor *ModuleExpanderPP) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  utils::IncludeInserter Inserter;
+};
+
+} // namespace clang::tidy::modernize
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETOUNDERLYINGCHECK_H
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-to-underlying.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-to-underlying.cpp
new file mode 100644
index 0000000000000..8eb4fa0c67921
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-to-underlying.cpp
@@ -0,0 +1,42 @@
+// RUN: %check_clang_tidy -std=c++23 %s modernize-use-to-underlying %t
+
+namespace std {
+template<typename T>
+constexpr auto to_underlying(T value) noexcept {
+  return static_cast<__underlying_type(T)>(value);
+}
+}
+
+
+enum class MyEnum { A = 1, B = 2 };
+
+void test_basic_cast() {
+  int value = static_cast<int>(MyEnum::A);
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use 'std::to_underlying' instead of 'static_cast' for 'enum class' [modernize-use-to-underlying]
+  // CHECK-FIXES: int value = std::to_underlying(MyEnum::A);
+}
+
+
+void test_long_cast() {
+  long value = static_cast<long>(MyEnum::B);
+  // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use 'std::to_underlying' instead of 'static_cast' for 'enum class' [modernize-use-to-underlying]
+  // CHECK-FIXES: long value = std::to_underlying(MyEnum::B);
+}
+
+
+void test_expression() {
+  int result = static_cast<int>(MyEnum::A) + 10;
+  // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use 'std::to_underlying' instead of 'static_cast' for 'enum class' [modernize-use-to-underlying]
+  // CHECK-FIXES: int result = std::to_underlying(MyEnum::A) + 10;
+}
+
+void test_already_correct() {
+  int value = std::to_underlying(MyEnum::B);
+  // No warning expected
+}
+
+void test_float_cast() {
+  float y = 8.34;
+  int z = static_cast<int>(y);
+  // No warning expected
+}

``````````

</details>


https://github.com/llvm/llvm-project/pull/167212