https://github.com/PiotrZSL created
https://github.com/llvm/llvm-project/pull/70595
Detects explicit type casting operations that involve the same source and
destination types, and subsequently recommend their removal. Covers a range of
explicit casting operations. Its primary objective is to enhance code
readability and maintainability by eliminating unnecessary type casting.
Closes #67534
>From e17c6f3fcd14bade8295480f84ba1ce12ec27c13 Mon Sep 17 00:00:00 2001
From: Piotr Zegar <piotr.ze...@nokia.com>
Date: Tue, 10 Oct 2023 20:37:05 +0000
Subject: [PATCH] [clang-tidy] Add readability-redundant-casting check
Detects explicit type casting operations that involve the same source and
destination types, and subsequently recommend their removal. Covers a range
of explicit casting operations. Its primary objective is to enhance code
readability and maintainability by eliminating unnecessary type casting.
---
.../clang-tidy/readability/CMakeLists.txt | 1 +
.../readability/ReadabilityTidyModule.cpp | 3 +
.../readability/RedundantCastingCheck.cpp | 242 ++++++++++++++++++
.../readability/RedundantCastingCheck.h | 38 +++
.../clang-tidy/utils/FixItHintUtils.cpp | 5 +
.../clang-tidy/utils/FixItHintUtils.h | 4 +
clang-tools-extra/docs/ReleaseNotes.rst | 6 +
.../docs/clang-tidy/checks/list.rst | 1 +
.../checks/readability/redundant-casting.rst | 37 +++
.../readability/redundant-casting.cpp | 200 +++++++++++++++
10 files changed, 537 insertions(+)
create mode 100644
clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.cpp
create mode 100644
clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.h
create mode 100644
clang-tools-extra/docs/clang-tidy/checks/readability/redundant-casting.rst
create mode 100644
clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp
diff --git a/clang-tools-extra/clang-tidy/readability/CMakeLists.txt
b/clang-tools-extra/clang-tidy/readability/CMakeLists.txt
index 5452c2d48a46173..52f873d2a14b700 100644
--- a/clang-tools-extra/clang-tidy/readability/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/readability/CMakeLists.txt
@@ -33,6 +33,7 @@ add_clang_library(clangTidyReadabilityModule
QualifiedAutoCheck.cpp
ReadabilityTidyModule.cpp
RedundantAccessSpecifiersCheck.cpp
+ RedundantCastingCheck.cpp
RedundantControlFlowCheck.cpp
RedundantDeclarationCheck.cpp
RedundantFunctionPtrDereferenceCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp
b/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp
index b8e6e6414320600..d33d429f64c4421 100644
--- a/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp
@@ -36,6 +36,7 @@
#include "OperatorsRepresentationCheck.h"
#include "QualifiedAutoCheck.h"
#include "RedundantAccessSpecifiersCheck.h"
+#include "RedundantCastingCheck.h"
#include "RedundantControlFlowCheck.h"
#include "RedundantDeclarationCheck.h"
#include "RedundantFunctionPtrDereferenceCheck.h"
@@ -111,6 +112,8 @@ class ReadabilityModule : public ClangTidyModule {
"readability-qualified-auto");
CheckFactories.registerCheck<RedundantAccessSpecifiersCheck>(
"readability-redundant-access-specifiers");
+ CheckFactories.registerCheck<RedundantCastingCheck>(
+ "readability-redundant-casting");
CheckFactories.registerCheck<RedundantFunctionPtrDereferenceCheck>(
"readability-redundant-function-ptr-dereference");
CheckFactories.registerCheck<RedundantMemberInitCheck>(
diff --git a/clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.cpp
b/clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.cpp
new file mode 100644
index 000000000000000..ab18b6b7dd886f7
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.cpp
@@ -0,0 +1,242 @@
+//===--- RedundantCastingCheck.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 "RedundantCastingCheck.h"
+#include "../utils/FixItHintUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::readability {
+
+static bool areTypesEquals(QualType S, QualType D) {
+ if (S == D)
+ return true;
+
+ const auto *TS = S->getAs<TypedefType>();
+ const auto *TD = D->getAs<TypedefType>();
+ if (TS != TD)
+ return false;
+
+ QualType PtrS = S->getPointeeType();
+ QualType PtrD = D->getPointeeType();
+
+ if (!PtrS.isNull() && !PtrD.isNull())
+ return areTypesEquals(PtrS, PtrD);
+
+ const DeducedType *DT = S->getContainedDeducedType();
+ if (DT && DT->isDeduced())
+ return D == DT->getDeducedType();
+
+ return false;
+}
+
+static bool areTypesEquals(QualType TypeS, QualType TypeD,
+ bool IgnoreTypeAliases) {
+ const QualType CTypeS = TypeS.getCanonicalType();
+ const QualType CTypeD = TypeD.getCanonicalType();
+ if (CTypeS != CTypeD)
+ return false;
+
+ return IgnoreTypeAliases || areTypesEquals(TypeS.getLocalUnqualifiedType(),
+ TypeD.getLocalUnqualifiedType());
+}
+
+static bool areBinaryOperatorOperandsTypesEqual(const Expr *E,
+ bool IgnoreTypeAliases) {
+ if (!E)
+ return false;
+ const Expr *WithoutImplicitAndParen = E->IgnoreParenImpCasts();
+ if (!WithoutImplicitAndParen)
+ return false;
+ if (const auto *B = dyn_cast<BinaryOperator>(WithoutImplicitAndParen)) {
+ const QualType NonReferenceType =
+ WithoutImplicitAndParen->getType().getNonReferenceType();
+ if (!areTypesEquals(
+ B->getLHS()->IgnoreImplicit()->getType().getNonReferenceType(),
+ NonReferenceType, IgnoreTypeAliases))
+ return true;
+ if (!areTypesEquals(
+ B->getRHS()->IgnoreImplicit()->getType().getNonReferenceType(),
+ NonReferenceType, IgnoreTypeAliases))
+ return true;
+ }
+ return false;
+}
+
+static const Decl *getSourceExprDecl(const Expr *SourceExpr) {
+ const Expr *CleanSourceExpr = SourceExpr->IgnoreParenImpCasts();
+ if (const auto *E = dyn_cast<DeclRefExpr>(CleanSourceExpr)) {
+ return E->getDecl();
+ }
+
+ if (const auto *E = dyn_cast<CallExpr>(CleanSourceExpr)) {
+ return E->getCalleeDecl();
+ }
+
+ if (const auto *E = dyn_cast<MemberExpr>(CleanSourceExpr)) {
+ return E->getMemberDecl();
+ }
+ return nullptr;
+}
+
+RedundantCastingCheck::RedundantCastingCheck(StringRef Name,
+ ClangTidyContext *Context)
+ : ClangTidyCheck(Name, Context),
+ IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)),
+ IgnoreTypeAliases(Options.getLocalOrGlobal("IgnoreTypeAliases", false))
{}
+
+void RedundantCastingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+ Options.store(Opts, "IgnoreMacros", IgnoreMacros);
+ Options.store(Opts, "IgnoreTypeAliases", IgnoreTypeAliases);
+}
+
+void RedundantCastingCheck::registerMatchers(MatchFinder *Finder) {
+
+ auto SimpleType = qualType(hasCanonicalType(
+ qualType(anyOf(builtinType(), references(builtinType()),
+ references(pointsTo(qualType())),
pointsTo(qualType())))));
+
+ auto BitfieldMemberExpr = memberExpr(member(fieldDecl(isBitField())));
+
+ Finder->addMatcher(
+ explicitCastExpr(
+ unless(hasCastKind(CK_ConstructorConversion)),
+ unless(hasCastKind(CK_UserDefinedConversion)),
+
unless(cxxFunctionalCastExpr(hasDestinationType(unless(SimpleType)))),
+
+ hasDestinationType(qualType().bind("type2")),
+ hasSourceExpression(anyOf(
+ expr(unless(initListExpr()), unless(BitfieldMemberExpr),
+ hasType(qualType().bind("type1")))
+ .bind("source"),
+ initListExpr(unless(hasInit(1, expr())),
+ hasInit(0, expr(unless(BitfieldMemberExpr),
+ hasType(qualType().bind("type1")))
+ .bind("source"))))))
+ .bind("cast"),
+ this);
+}
+
+void RedundantCastingCheck::check(const MatchFinder::MatchResult &Result) {
+ const auto *SourceExpr = Result.Nodes.getNodeAs<Expr>("source");
+ auto TypeD = *Result.Nodes.getNodeAs<QualType>("type2");
+
+ if (SourceExpr->getValueKind() == VK_LValue &&
+ TypeD.getCanonicalType()->isRValueReferenceType())
+ return;
+
+ const auto TypeS =
+ Result.Nodes.getNodeAs<QualType>("type1")->getNonReferenceType();
+ TypeD = TypeD.getNonReferenceType();
+
+ if (!areTypesEquals(TypeS, TypeD, IgnoreTypeAliases))
+ return;
+
+ if (areBinaryOperatorOperandsTypesEqual(SourceExpr, IgnoreTypeAliases))
+ return;
+
+ const auto *CastExpr = Result.Nodes.getNodeAs<ExplicitCastExpr>("cast");
+ if (IgnoreMacros &&
+ (CastExpr->getBeginLoc().isMacroID() ||
+ CastExpr->getEndLoc().isMacroID() ||
CastExpr->getExprLoc().isMacroID()))
+ return;
+
+ {
+ auto Diag = diag(CastExpr->getExprLoc(),
+ "redundant explicit casting to the same type %0 as the "
+ "sub-expression, remove this casting");
+ Diag << TypeD;
+
+ const SourceManager &SM = *Result.SourceManager;
+ const SourceLocation SourceExprBegin =
+ SM.getExpansionLoc(SourceExpr->getBeginLoc());
+ const SourceLocation SourceExprEnd =
+ SM.getExpansionLoc(SourceExpr->getEndLoc());
+
+ if (SourceExprBegin != CastExpr->getBeginLoc())
+ Diag << FixItHint::CreateRemoval(SourceRange(
+ CastExpr->getBeginLoc(), SourceExprBegin.getLocWithOffset(-1)));
+
+ const SourceLocation NextToken = Lexer::getLocForEndOfToken(
+ SourceExprEnd, 0U, SM, Result.Context->getLangOpts());
+
+ if (SourceExprEnd != CastExpr->getEndLoc()) {
+ Diag << FixItHint::CreateRemoval(
+ SourceRange(NextToken, CastExpr->getEndLoc()));
+ }
+
+ if (utils::fixit::needParens(*SourceExpr)) {
+
+ Diag << FixItHint::CreateInsertion(SourceExprBegin, "(")
+ << FixItHint::CreateInsertion(NextToken, ")");
+ }
+ }
+
+ const auto *SourceExprDecl = getSourceExprDecl(SourceExpr);
+ if (!SourceExprDecl)
+ return;
+
+ if (const auto *D = dyn_cast<CXXConstructorDecl>(SourceExprDecl)) {
+ diag(D->getLocation(),
+ "source type originates from the invocation of this constructor",
+ DiagnosticIDs::Note);
+ return;
+ }
+
+ if (const auto *D = dyn_cast<FunctionDecl>(SourceExprDecl)) {
+ diag(D->getLocation(),
+ "source type originates from the invocation of this "
+ "%select{function|method}0",
+ DiagnosticIDs::Note)
+ << isa<CXXMethodDecl>(D) << D->getReturnTypeSourceRange();
+ return;
+ }
+
+ if (const auto *D = dyn_cast<FieldDecl>(SourceExprDecl)) {
+ diag(D->getLocation(),
+ "source type originates from referencing this member",
+ DiagnosticIDs::Note)
+ << SourceRange(D->getTypeSpecStartLoc(), D->getTypeSpecEndLoc());
+ return;
+ }
+
+ if (const auto *D = dyn_cast<ParmVarDecl>(SourceExprDecl)) {
+ diag(D->getLocation(),
+ "source type originates from referencing this parameter",
+ DiagnosticIDs::Note)
+ << SourceRange(D->getTypeSpecStartLoc(), D->getTypeSpecEndLoc());
+ return;
+ }
+
+ if (const auto *D = dyn_cast<VarDecl>(SourceExprDecl)) {
+ diag(D->getLocation(),
+ "source type originates from referencing this variable",
+ DiagnosticIDs::Note)
+ << SourceRange(D->getTypeSpecStartLoc(), D->getTypeSpecEndLoc());
+ return;
+ }
+
+ if (const auto *D = dyn_cast<EnumConstantDecl>(SourceExprDecl)) {
+ diag(D->getLocation(),
+ "source type originates from referencing this enum constant",
+ DiagnosticIDs::Note);
+ return;
+ }
+
+ if (const auto *D = dyn_cast<BindingDecl>(SourceExprDecl)) {
+ diag(D->getLocation(),
+ "source type originates from referencing this bound variable",
+ DiagnosticIDs::Note);
+ return;
+ }
+}
+
+} // namespace clang::tidy::readability
diff --git a/clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.h
b/clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.h
new file mode 100644
index 000000000000000..fdcfede05d43696
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.h
@@ -0,0 +1,38 @@
+//===--- RedundantCastingCheck.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTCASTINGCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTCASTINGCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::readability {
+
+/// Detects explicit type casting operations that involve the same source and
+/// destination types, and subsequently recommend their removal.
+///
+/// For the user-facing documentation see:
+///
http://clang.llvm.org/extra/clang-tidy/checks/readability/redundant-casting.html
+class RedundantCastingCheck : public ClangTidyCheck {
+public:
+ RedundantCastingCheck(StringRef Name, ClangTidyContext *Context);
+ void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+ void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+ void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+ std::optional<TraversalKind> getCheckTraversalKind() const override {
+ return TK_IgnoreUnlessSpelledInSource;
+ }
+
+private:
+ const bool IgnoreMacros;
+ const bool IgnoreTypeAliases;
+};
+
+} // namespace clang::tidy::readability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTCASTINGCHECK_H
diff --git a/clang-tools-extra/clang-tidy/utils/FixItHintUtils.cpp
b/clang-tools-extra/clang-tidy/utils/FixItHintUtils.cpp
index 226dd60b5bf5f54..11f5ad94ef1b0cb 100644
--- a/clang-tools-extra/clang-tidy/utils/FixItHintUtils.cpp
+++ b/clang-tools-extra/clang-tidy/utils/FixItHintUtils.cpp
@@ -240,6 +240,11 @@ static bool needParensAfterUnaryOperator(const Expr
&ExprNode) {
return false;
}
+bool needParens(const Expr &ExprNode) {
+ return !isa<clang::ParenExpr>(&ExprNode) &&
+ needParensAfterUnaryOperator(ExprNode);
+}
+
// Format a pointer to an expression: prefix with '*' but simplify
// when it already begins with '&'. Return empty string on failure.
std::string formatDereference(const Expr &ExprNode, const ASTContext &Context)
{
diff --git a/clang-tools-extra/clang-tidy/utils/FixItHintUtils.h
b/clang-tools-extra/clang-tidy/utils/FixItHintUtils.h
index 15894c4bf5cf8f2..41535079f4e2f34 100644
--- a/clang-tools-extra/clang-tidy/utils/FixItHintUtils.h
+++ b/clang-tools-extra/clang-tidy/utils/FixItHintUtils.h
@@ -47,6 +47,10 @@ addQualifierToVarDecl(const VarDecl &Var, const ASTContext
&Context,
// \brief Format a pointer to an expression
std::string formatDereference(const Expr &ExprNode, const ASTContext &Context);
+
+// \brief Returns ``true`` if ExprNode ought to be enclosed within parentheses.
+bool needParens(const Expr &ExprNode);
+
} // namespace clang::tidy::utils::fixit
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H
diff --git a/clang-tools-extra/docs/ReleaseNotes.rst
b/clang-tools-extra/docs/ReleaseNotes.rst
index 5ce38ab48bf295f..f7b3cdfff12755c 100644
--- a/clang-tools-extra/docs/ReleaseNotes.rst
+++ b/clang-tools-extra/docs/ReleaseNotes.rst
@@ -191,6 +191,12 @@ New checks
Recommends the smallest possible underlying type for an ``enum`` or ``enum``
class based on the range of its enumerators.
+- New :doc:`readability-redundant-casting
+ <clang-tidy/checks/readability/redundant-casting>` check.
+
+ Detects explicit type casting operations that involve the same source and
+ destination types, and subsequently recommend their removal.
+
- New :doc:`readability-reference-to-constructed-temporary
<clang-tidy/checks/readability/reference-to-constructed-temporary>` check.
diff --git a/clang-tools-extra/docs/clang-tidy/checks/list.rst
b/clang-tools-extra/docs/clang-tidy/checks/list.rst
index 6f987ba1672e3f2..82fff6e387a3a41 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/list.rst
+++ b/clang-tools-extra/docs/clang-tidy/checks/list.rst
@@ -359,6 +359,7 @@ Clang-Tidy Checks
:doc:`readability-operators-representation
<readability/operators-representation>`, "Yes"
:doc:`readability-qualified-auto <readability/qualified-auto>`, "Yes"
:doc:`readability-redundant-access-specifiers
<readability/redundant-access-specifiers>`, "Yes"
+ :doc:`readability-redundant-casting <readability/redundant-casting>`, "Yes"
:doc:`readability-redundant-control-flow
<readability/redundant-control-flow>`, "Yes"
:doc:`readability-redundant-declaration
<readability/redundant-declaration>`, "Yes"
:doc:`readability-redundant-function-ptr-dereference
<readability/redundant-function-ptr-dereference>`, "Yes"
diff --git
a/clang-tools-extra/docs/clang-tidy/checks/readability/redundant-casting.rst
b/clang-tools-extra/docs/clang-tidy/checks/readability/redundant-casting.rst
new file mode 100644
index 000000000000000..23eaa225f03a3ce
--- /dev/null
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/redundant-casting.rst
@@ -0,0 +1,37 @@
+.. title:: clang-tidy - readability-redundant-casting
+
+readability-redundant-casting
+=============================
+
+Detects explicit type casting operations that involve the same source and
+destination types, and subsequently recommend their removal. Covers a range of
+explicit casting operations, including ``static_cast``, ``const_cast``, C-style
+casts, and ``reinterpret_cast``. Its primary objective is to enhance code
+readability and maintainability by eliminating unnecessary type casting.
+
+.. code-block:: c++
+
+ int value = 42;
+ int result = static_cast<int>(value);
+
+In this example, the ``static_cast<int>(value)`` is redundant, as it performs
+a cast from an ``int`` to another ``int``.
+
+Casting operations involving constructor conversions, user-defined conversions,
+functional casts, type-dependent casts, casts between distinct type aliases
that
+refer to the same underlying type, as well as bitfield-related casts and casts
+directly from lvalue to rvalue, are all disregarded by the check.
+
+Options
+-------
+
+.. option:: IgnoreMacros
+
+ If set to `true`, the check will not give warnings inside macros. Default
+ is `true`.
+
+.. option:: IgnoreTypeAliases
+
+ When set to `false`, the check will consider type aliases, and when set to
+ `true`, it will resolve all type aliases and operate on the underlying
+ types. Default is `false`.
diff --git
a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp
b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp
new file mode 100644
index 000000000000000..7dca6921298d38f
--- /dev/null
+++
b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp
@@ -0,0 +1,200 @@
+// RUN: %check_clang_tidy -std=c++11-or-later %s readability-redundant-casting
%t
+// RUN: %check_clang_tidy -std=c++11-or-later -check-suffix=,MACROS %s
readability-redundant-casting %t -- \
+// RUN: -config='{CheckOptions: {
readability-redundant-casting.IgnoreMacros: false }}'
+// RUN: %check_clang_tidy -std=c++11-or-later -check-suffix=,ALIASES %s
readability-redundant-casting %t -- \
+// RUN: -config='{CheckOptions: {
readability-redundant-casting.IgnoreTypeAliases: true }}'
+
+struct A {};
+struct B : A {};
+A getA();
+
+void testRedundantStaticCasting(A& value) {
+ A& a1 = static_cast<A&>(value);
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:36: note: source type originates from
referencing this parameter
+ // CHECK-FIXES: {{^}} A& a1 = value;
+}
+
+void testRedundantConstCasting1(A& value) {
+ A& a2 = const_cast<A&>(value);
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:36: note: source type originates from
referencing this parameter
+ // CHECK-FIXES: {{^}} A& a2 = value;
+}
+
+void testRedundantConstCasting2(const A& value) {
+ const A& a3 = const_cast<const A&>(value);
+ // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: redundant explicit casting to
the same type 'const A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:42: note: source type originates from
referencing this parameter
+ // CHECK-FIXES: {{^}} const A& a3 = value;
+}
+
+void testRedundantReinterpretCasting(A& value) {
+ A& a4 = reinterpret_cast<A&>(value);
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:41: note: source type originates from
referencing this parameter
+ // CHECK-FIXES: {{^}} A& a4 = value;
+}
+
+void testRedundantCCasting(A& value) {
+ A& a5 = (A&)(value);
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:31: note: source type originates from
referencing this parameter
+ // CHECK-FIXES: {{^}} A& a5 = value;
+}
+
+void testDoubleCasting(A& value) {
+ A& a6 = static_cast<A&>(reinterpret_cast<A&>(value));
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: redundant explicit casting to
the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-4]]:27: note: source type originates from
referencing this parameter
+ // CHECK-FIXES: {{^}} A& a6 = value;
+}
+
+void testDiffrentTypesCast(B& value) {
+ A& a7 = static_cast<A&>(value);
+}
+
+void testCastingWithAuto() {
+ auto a = getA();
+ A& a8 = static_cast<A&>(a);
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:8: note: source type originates from
referencing this variable
+ // CHECK-FIXES: {{^}} A& a8 = a;
+}
+
+void testCastingWithConstAuto() {
+ const auto a = getA();
+ const A& a9 = static_cast<const A&>(a);
+ // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: redundant explicit casting to
the same type 'const A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:14: note: source type originates from
referencing this variable
+ // CHECK-FIXES: {{^}} const A& a9 = a;
+}
+
+void testCastingWithAutoPtr(A& ptr) {
+ auto* a = &ptr;
+ A* a10 = static_cast<A*>(a);
+ // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant explicit casting to
the same type 'A *' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-3]]:9: note: source type originates from
referencing this variable
+ // CHECK-FIXES: {{^}} A* a10 = a;
+}
+
+template<typename T>
+void testRedundantTemplateCasting(T& value) {
+ A& a = static_cast<A&>(value);
+ T& t = static_cast<T&>(value);
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: redundant explicit casting to
the same type 'T' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-MESSAGES: :[[@LINE-4]]:38: note: source type originates from
referencing this parameter
+ // CHECK-FIXES: {{^}} T& t = value;
+}
+
+void testTemplate() {
+ A value;
+ testRedundantTemplateCasting(value);
+}
+
+void testValidRefConstCast() {
+ const auto a = getA();
+ A& a11 = const_cast<A&>(a);
+}
+
+void testValidPtrConstCast(const A* ptr) {
+ A* a12 = const_cast<A*>(ptr);
+}
+
+#define CAST(X) static_cast<int>(X)
+
+void testMacroCasting(int value) {
+ int a = CAST(value);
+ // CHECK-MESSAGES-MACROS: :[[@LINE-1]]:11: warning: redundant explicit
casting to the same type 'int' as the sub-expression, remove this casting
[readability-redundant-casting]
+}
+
+#define PTR_NAME name
+
+void testMacroCasting(A* PTR_NAME) {
+ A* a13 = static_cast<A*>(PTR_NAME);
+ // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant explicit casting to
the same type 'A *' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-FIXES: {{^}} A* a13 = PTR_NAME;
+}
+
+struct CastBool {
+ operator bool() const {
+ return true;
+ }
+};
+
+void testUserOperatorCast(const CastBool& value) {
+ bool b = static_cast<bool>(value);
+}
+
+using TypeA = A;
+
+void testTypedefCast(A& value) {
+ TypeA& a = static_cast<TypeA&>(value);
+ // CHECK-MESSAGES-ALIASES: :[[@LINE-1]]:14: warning: redundant explicit
casting to the same type 'TypeA' (aka 'A') as the sub-expression, remove this
casting [readability-redundant-casting]
+ // CHECK-FIXES-ALIASES: {{^}} TypeA& a = value;
+}
+
+void testTypedefCast2(TypeA& value) {
+ A& a = static_cast<A&>(value);
+ // CHECK-MESSAGES-ALIASES: :[[@LINE-1]]:10: warning: redundant explicit
casting to the same type 'A' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-FIXES-ALIASES: {{^}} A& a = value;
+}
+
+void testFunctionalCastWithPrimitive(int a) {
+ int b = int(a);
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'int' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-FIXES: {{^}} int b = a;
+}
+
+void testFunctionalCastWithInitExpr(unsigned a) {
+ unsigned b = ~unsigned{!a};
+ unsigned c = unsigned{0};
+}
+
+void testBinaryOperator(char c) {
+ int a = int(c - 'C');
+}
+
+struct BIT {
+ bool b:1;
+};
+
+template<typename ...Args>
+void make(Args&& ...);
+
+void testBinaryOperator(BIT b) {
+ make((bool)b.b);
+}
+
+struct Class {
+ using Iterator = const char*;
+
+ Iterator begin() {
+ return static_cast<Iterator>(first());
+// CHECK-MESSAGES-ALIASES: :[[@LINE-1]]:12: warning: redundant explicit
casting to the same type 'Iterator' (aka 'const char *') as the sub-expression,
remove this casting [readability-redundant-casting]
+// CHECK-MESSAGES-ALIASES: :[[@LINE+4]]:15: note: source type originates from
the invocation of this method
+// CHECK-FIXES-ALIASES: {{^}} return first();
+ }
+
+ const char* first();
+};
+
+void testAddOperation(int aa, int bb) {
+ int c = static_cast<int>(aa + bb) * aa;
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'int' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-FIXES: {{^}} int c = (aa + bb) * aa;
+}
+
+void testAddOperationWithParen(int a, int b) {
+ int c = static_cast<int>((a+b))*a;
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to
the same type 'int' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-FIXES: {{^}} int c = (a+b)*a;
+}
+
+void testRValueCast(int&& a) {
+ int&& b = static_cast<int&&>(a);
+ int&& c = static_cast<int&&>(10);
+ // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant explicit casting to
the same type 'int' as the sub-expression, remove this casting
[readability-redundant-casting]
+ // CHECK-FIXES: {{^}} int&& c = 10;
+}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
