Introduce misc-fix-type-conversion check

Author: Yaraslau Tamashevich

clang-tools-extra/clang-tidy/misc/CMakeLists.txt

@@ -23,6 +23,7 @@ add_clang_library(clangTidyMiscModule STATIC
   DefinitionsInHeadersCheck.cpp
   ConfusableIdentifierCheck.cpp
   FixStdstringDataAccessCheck.cpp
+  FixTypeConversionCheck.cpp
   HeaderIncludeCycleCheck.cpp
   IncludeCleanerCheck.cpp
   MiscTidyModule.cpp

clang-tools-extra/clang-tidy/misc/FixTypeConversionCheck.cpp

@@ -0,0 +1,95 @@
+//===--- FixStdstringDataAccessCheck.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 "FixTypeConversionCheck.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+#include <iostream>
+
+
+
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::misc {
+
+void FixTypeConversionCheck::registerMatchers(MatchFinder *Finder) {
+
+  const auto rnStringTypeMatch = qualType(anyOf(asString("RNString"),
+                                                  asString("const RNString")));
+
+
+  const auto cStringTypeMatch = qualType(anyOf(asString("CString"),
+                                                  asString("const CString")));
+
+
+  Finder->addMatcher(
+      declStmt(unless(isExpansionInSystemHeader()),
+               has(varDecl(
+                   hasType(cStringTypeMatch),
+                   hasDescendant(
+                       cxxBindTemporaryExpr(
+                           hasType(rnStringTypeMatch),
+                           unless(hasAncestor(cxxMemberCallExpr(
+                               callee(cxxMethodDecl(hasName("GetString"))))))
+
+                               )
+                           .bind("cxxBindTemporaryExpr"))))
+
+                   )
+          .bind("declStmt"),
+      this);
+  Finder->addMatcher(
+      declStmt(
+          unless(isExpansionInSystemHeader()),
+          has(varDecl(hasType(rnStringTypeMatch),
+                      anyOf(hasDescendant(declRefExpr(hasType(cStringTypeMatch))
+                                              .bind("declRefExpr")),
+                            hasDescendant(memberExpr(hasType(cStringTypeMatch))
+                                              .bind("memberExpr"))))))
+          .bind("declStmt"),
+      this);
+}
+
+void FixTypeConversionCheck::check(const MatchFinder::MatchResult &Result) {
+
+  const auto *Call =
+      Result.Nodes.getNodeAs<CXXBindTemporaryExpr>("cxxBindTemporaryExpr");
+
+  if (Call) {
+
+    diag(Call->getEndLoc(),
+         "Consider adding .GetString() to the CString object")
+        << FixItHint::CreateInsertion(Call->getEndLoc().getLocWithOffset(1),
+                                        ".GetString()");
+  }
+
+
+  const auto processExpr = [&](auto* expr){
+    if(!expr)
+      return;
+
+    const SourceManager &SM = *Result.SourceManager;
+    const LangOptions &LangOpts = Result.Context->getLangOpts();
+
+    SourceLocation EndLoc =
+        Lexer::getLocForEndOfToken(expr->getEndLoc(), 0, SM, LangOpts);
+
+    diag(expr->getEndLoc(), "Consider adding .GetString() call")
+        << FixItHint::CreateInsertion(EndLoc, ".GetString()");
+  };
+
+  const auto *declRefExpr = Result.Nodes.getNodeAs<DeclRefExpr>("declRefExpr");
+  processExpr(declRefExpr);
+
+  const auto *memberExpr = Result.Nodes.getNodeAs<MemberExpr>("memberExpr");
+  processExpr(memberExpr);
+}
+
+} // namespace clang::tidy::misc

clang-tools-extra/clang-tidy/misc/FixTypeConversionCheck.h

@@ -0,0 +1,22 @@
+//===--- FixTypeConversionCheck.h - clang-tidy -------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::misc {
+
+struct FixTypeConversionCheck : public ClangTidyCheck {
+  FixTypeConversionCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace clang::tidy::misc

clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp

@@ -14,6 +14,7 @@
 #include "CoroutineHostileRAIICheck.h"
 #include "DefinitionsInHeadersCheck.h"
 #include "FixStdstringDataAccessCheck.h"
+#include "FixTypeConversionCheck.h"
 #include "HeaderIncludeCycleCheck.h"
 #include "IncludeCleanerCheck.h"
 #include "MisleadingBidirectional.h"
@@ -51,6 +52,8 @@ class MiscModule : public ClangTidyModule {
         "misc-definitions-in-headers");
     CheckFactories.registerCheck<FixStdstringDataAccessCheck>(
         "misc-fix-stdstring-data-access");
+    CheckFactories.registerCheck<FixTypeConversionCheck>(
+        "misc-fix-type-conversion");
     CheckFactories.registerCheck<HeaderIncludeCycleCheck>(
         "misc-header-include-cycle");
     CheckFactories.registerCheck<IncludeCleanerCheck>("misc-include-cleaner");