diff options
Diffstat (limited to 'compilerplugins/clang/redundantfcast.cxx')
| -rw-r--r-- | compilerplugins/clang/redundantfcast.cxx | 357 |
1 files changed, 357 insertions, 0 deletions
diff --git a/compilerplugins/clang/redundantfcast.cxx b/compilerplugins/clang/redundantfcast.cxx new file mode 100644 index 000000000..38a7daf9f --- /dev/null +++ b/compilerplugins/clang/redundantfcast.cxx @@ -0,0 +1,357 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +#ifndef LO_CLANG_SHARED_PLUGINS + +#include "check.hxx" +#include "compat.hxx" +#include "plugin.hxx" +#include <iostream> +#include <fstream> +#include <unordered_set> +#include <vector> + +namespace +{ +class RedundantFCast final : public loplugin::FilteringPlugin<RedundantFCast> +{ +public: + explicit RedundantFCast(loplugin::InstantiationData const& data) + : FilteringPlugin(data) + { + } + + bool VisitReturnStmt(ReturnStmt const* returnStmt) + { + if (ignoreLocation(returnStmt)) + return true; + Expr const* expr = returnStmt->getRetValue(); + if (!expr) + return true; + if (auto exprWithCleanups = dyn_cast<ExprWithCleanups>(expr)) + expr = exprWithCleanups->getSubExpr(); + if (auto cxxConstructExpr = dyn_cast<CXXConstructExpr>(expr)) + { + if (cxxConstructExpr->getNumArgs() != 1) + return true; + expr = cxxConstructExpr->getArg(0); + } + if (auto materializeTemporaryExpr = dyn_cast<MaterializeTemporaryExpr>(expr)) + expr = materializeTemporaryExpr->getSubExpr(); + auto cxxFunctionalCastExpr = dyn_cast<CXXFunctionalCastExpr>(expr); + if (!cxxFunctionalCastExpr) + return true; + auto const t1 = cxxFunctionalCastExpr->getTypeAsWritten(); + auto const t2 = compat::getSubExprAsWritten(cxxFunctionalCastExpr)->getType(); + if (t1.getCanonicalType().getTypePtr() != t2.getCanonicalType().getTypePtr()) + return true; + if (!loplugin::isOkToRemoveArithmeticCast(compiler.getASTContext(), t1, t2, + cxxFunctionalCastExpr->getSubExpr())) + { + return true; + } + if (m_Seen.insert(cxxFunctionalCastExpr->getExprLoc()).second) + { + if (suppressWarningAt(cxxFunctionalCastExpr->getBeginLoc())) + { + return true; + } + report(DiagnosticsEngine::Warning, "redundant functional cast from %0 to %1", + cxxFunctionalCastExpr->getExprLoc()) + << t2 << t1 << cxxFunctionalCastExpr->getSourceRange(); + } + return true; + } + + /* Check for the creation of unnecessary temporaries when calling a method that takes a param by const & */ + bool VisitCallExpr(CallExpr const* callExpr) + { + if (ignoreLocation(callExpr)) + return true; + const FunctionDecl* functionDecl; + if (isa<CXXMemberCallExpr>(callExpr)) + functionDecl = dyn_cast<CXXMemberCallExpr>(callExpr)->getMethodDecl(); + else + functionDecl = callExpr->getDirectCallee(); + if (!functionDecl) + return true; + + unsigned len = std::min(callExpr->getNumArgs(), functionDecl->getNumParams()); + for (unsigned i = 0; i < len; ++i) + { + // check if param is const& + auto param = functionDecl->getParamDecl(i); + auto lvalueType = param->getType()->getAs<LValueReferenceType>(); + if (!lvalueType) + continue; + if (!lvalueType->getPointeeType().isConstQualified()) + continue; + auto paramClassOrStructType = lvalueType->getPointeeType()->getAs<RecordType>(); + if (!paramClassOrStructType) + continue; + // check for temporary and functional cast in argument expression + auto arg = callExpr->getArg(i)->IgnoreImpCasts(); + auto materializeTemporaryExpr = dyn_cast<MaterializeTemporaryExpr>(arg); + if (!materializeTemporaryExpr) + continue; + auto functionalCast = dyn_cast<CXXFunctionalCastExpr>( + materializeTemporaryExpr->getSubExpr()->IgnoreImpCasts()); + if (!functionalCast) + continue; + auto const t1 = functionalCast->getTypeAsWritten(); + auto const t2 = compat::getSubExprAsWritten(functionalCast)->getType(); + if (t1.getCanonicalType().getTypePtr() != t2.getCanonicalType().getTypePtr()) + continue; + // Check that the underlying expression is of the same class/struct type as the param i.e. that we are not instantiating + // something useful + if (t1.getCanonicalType().getTypePtr() != paramClassOrStructType) + continue; + // Don't warn about (necessary) cast from braced-init-list in non-deduced contexts: + if (lvalueType->getPointeeType()->getAs<SubstTemplateTypeParmType>() != nullptr + && loplugin::TypeCheck(t1).ClassOrStruct("initializer_list").StdNamespace() + && isa<CXXStdInitializerListExpr>(compat::getSubExprAsWritten(functionalCast))) + { + continue; + } + + if (m_Seen.insert(arg->getExprLoc()).second) + { + report(DiagnosticsEngine::Warning, "redundant functional cast from %0 to %1", + arg->getExprLoc()) + << t2 << t1 << arg->getSourceRange(); + report(DiagnosticsEngine::Note, "in call to method here", param->getLocation()) + << param->getSourceRange(); + } + } + return true; + } + + /* Check for the creation of unnecessary temporaries when calling a constructor that takes a param by const & */ + bool VisitCXXConstructExpr(CXXConstructExpr const* callExpr) + { + if (ignoreLocation(callExpr)) + return true; + const CXXConstructorDecl* functionDecl = callExpr->getConstructor(); + + unsigned len = std::min(callExpr->getNumArgs(), functionDecl->getNumParams()); + for (unsigned i = 0; i < len; ++i) + { + // check if param is const& + auto param = functionDecl->getParamDecl(i); + auto rvalueType = param->getType()->getAs<RValueReferenceType>(); + if (!rvalueType) + { + auto lvalueType = param->getType()->getAs<LValueReferenceType>(); + if (!lvalueType) + continue; + if (!lvalueType->getPointeeType().isConstQualified()) + continue; + } + auto valueType = param->getType()->getAs<ReferenceType>(); + auto paramClassOrStructType = valueType->getPointeeType()->getAs<RecordType>(); + if (!paramClassOrStructType) + continue; + // check for temporary and functional cast in argument expression + auto arg = compat::IgnoreParenImplicit(callExpr->getArg(i)); + auto functionalCast = dyn_cast<CXXFunctionalCastExpr>(arg); + if (!functionalCast) + continue; + auto const t1 = functionalCast->getTypeAsWritten(); + auto const t2 = compat::getSubExprAsWritten(functionalCast)->getType(); + if (t1.getCanonicalType().getTypePtr() != t2.getCanonicalType().getTypePtr()) + continue; + // Check that the underlying expression is of the same class/struct type as the param i.e. that we are not instantiating + // something useful + if (t1.getCanonicalType().getTypePtr() != paramClassOrStructType) + continue; + if (rvalueType) + { + // constructing a temporary to pass to a && argument is fine. But we will see that in the VisitFunctionalCast + // method below and generate a warning. And we don't have enough context there to determine that we're + // doing the wrong thing. So add the expression to the m_Seen list here to prevent that warning. + m_Seen.insert(functionalCast->getExprLoc()); + continue; + } + + if (m_Seen.insert(arg->getExprLoc()).second) + { + if (suppressWarningAt(arg->getBeginLoc())) + { + continue; + } + report(DiagnosticsEngine::Warning, + "redundant functional cast from %0 to %1 in construct expression", + arg->getExprLoc()) + << t2 << t1 << arg->getSourceRange(); + report(DiagnosticsEngine::Note, "in call to method here", param->getLocation()) + << param->getSourceRange(); + } + } + return true; + } + + // Find redundant cast to std::function, where clang reports + // two different types for the inner and outer + bool isRedundantStdFunctionCast(CXXFunctionalCastExpr const* expr) + { + bool deduced = false; + QualType target; + auto const written = expr->getTypeAsWritten(); + if (auto const t1 = written->getAs<DeducedTemplateSpecializationType>()) + { + auto const decl = t1->getTemplateName().getAsTemplateDecl(); + if (!decl) + { + return false; + } + if (!loplugin::DeclCheck(decl->getTemplatedDecl()) + .ClassOrStruct("function") + .StdNamespace()) + { + return false; + } + deduced = true; + } + else if (auto const t2 = written->getAs<TemplateSpecializationType>()) + { + auto const decl = t2->getTemplateName().getAsTemplateDecl(); + if (!decl) + { + return false; + } + if (!loplugin::DeclCheck(decl->getTemplatedDecl()) + .ClassOrStruct("function") + .StdNamespace()) + { + return false; + } + if (t2->getNumArgs() != 1) + { + if (isDebugMode()) + { + report(DiagnosticsEngine::Fatal, + "TODO: unexpected std::function with %0 template arguments", + expr->getExprLoc()) + << t2->getNumArgs() << expr->getSourceRange(); + } + return false; + } + if (t2->getArg(0).getKind() != TemplateArgument::Type) + { + if (isDebugMode()) + { + report(DiagnosticsEngine::Fatal, + "TODO: unexpected std::function with non-type template argument", + expr->getExprLoc()) + << expr->getSourceRange(); + } + return false; + } + target = t2->getArg(0).getAsType(); + } + else + { + return false; + } + auto cxxConstruct + = dyn_cast<CXXConstructExpr>(compat::IgnoreParenImplicit(expr->getSubExpr())); + if (!cxxConstruct) + return false; + auto const lambda + = dyn_cast<LambdaExpr>(compat::IgnoreParenImplicit(cxxConstruct->getArg(0))); + if (!lambda) + return false; + if (deduced) + // std::function([...](Args)->Ret{...}) should always be redundant: + return true; + auto const decl = lambda->getCallOperator(); + std::vector<QualType> args; + for (unsigned i = 0; i != decl->getNumParams(); ++i) + { + args.push_back(decl->getParamDecl(i)->getType()); + } + auto const source + = compiler.getASTContext().getFunctionType(decl->getReturnType(), args, {}); + // std::function<Ret1(Args1)>([...](Args2)->Ret2{...}) is redundant if target Ret1(Args1) + // matches source Ret2(Args2): + return target.getCanonicalType() == source.getCanonicalType(); + } + + bool VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr const* expr) + { + if (ignoreLocation(expr)) + return true; + // specifying the name for an init-list is necessary sometimes + if (isa<InitListExpr>(compat::IgnoreParenImplicit(expr->getSubExpr()))) + return true; + if (isa<CXXStdInitializerListExpr>(compat::IgnoreParenImplicit(expr->getSubExpr()))) + return true; + auto const t1 = expr->getTypeAsWritten(); + auto const t2 = compat::getSubExprAsWritten(expr)->getType(); + if (!(t1.getCanonicalType().getTypePtr() == t2.getCanonicalType().getTypePtr() + || isRedundantStdFunctionCast(expr))) + { + return true; + } + // (a) we do a lot of int/sal_Int32 kind of casts which might be platform necessary? + // (b) we do bool/bool casts in unit tests to avoid one of the other plugins + // so just ignore this kind of thing for now + if (const auto* BT = dyn_cast<BuiltinType>(t1->getUnqualifiedDesugaredType())) + { + auto k = BT->getKind(); + if (k == BuiltinType::Double || k == BuiltinType::Float + || (k >= BuiltinType::Bool && k <= BuiltinType::Int128)) + return true; + } + if (const auto* BT = dyn_cast<BuiltinType>(t2->getUnqualifiedDesugaredType())) + { + auto k = BT->getKind(); + if (k == BuiltinType::Double || k == BuiltinType::Float + || (k >= BuiltinType::Bool && k <= BuiltinType::Int128)) + return true; + } + auto tc = loplugin::TypeCheck(t1); + if (tc.Typedef("sal_Int32").GlobalNamespace()) + return true; + + if (m_Seen.insert(expr->getExprLoc()).second) + { + if (suppressWarningAt(expr->getBeginLoc())) + { + return true; + } + report(DiagnosticsEngine::Warning, "redundant functional cast from %0 to %1", + expr->getExprLoc()) + << t2 << t1 << expr->getSourceRange(); + } + return true; + } + + bool preRun() override + { + if (!compiler.getLangOpts().CPlusPlus) + return false; + return true; + } + + void run() override + { + if (preRun()) + TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); + } + + std::unordered_set<SourceLocation> m_Seen; +}; + +static loplugin::Plugin::Registration<RedundantFCast> redundantfcast("redundantfcast"); + +} // namespace + +#endif // LO_CLANG_SHARED_PLUGINS + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ |