new plugin constparams
very basic detection of pointer and reference params that can be const. Off by default until the relevant changes have landed. Change-Id: I88bba4e67307e3fb0e11dad252ec59c913828763
This commit is contained in:
Noel Grandin
407
compilerplugins/clang/constparams.cxx
Normal file
407
compilerplugins/clang/constparams.cxx
Normal file
@@ -0,0 +1,407 @@
|
||||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
||||
/*
|
||||
* 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/.
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <set>
|
||||
#include <iostream>
|
||||
|
||||
#include "plugin.hxx"
|
||||
#include "compat.hxx"
|
||||
#include "check.hxx"
|
||||
|
||||
/**
|
||||
Find pointer and reference params that can be declared const.
|
||||
|
||||
This is not a sophisticated analysis. It deliberately skips all of the hard cases for now.
|
||||
It is an exercise in getting the most benefit for the least effort.
|
||||
*/
|
||||
namespace
|
||||
{
|
||||
|
||||
class ConstParams:
|
||||
public RecursiveASTVisitor<ConstParams>, public loplugin::Plugin
|
||||
{
|
||||
public:
|
||||
explicit ConstParams(InstantiationData const & data): Plugin(data) {}
|
||||
|
||||
virtual void run() override {
|
||||
TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
|
||||
}
|
||||
|
||||
bool VisitFunctionDecl(FunctionDecl *);
|
||||
bool VisitDeclRefExpr( const DeclRefExpr* );
|
||||
private:
|
||||
bool checkIfCanBeConst(const Stmt*);
|
||||
bool isPointerOrReferenceToConst(const QualType& qt);
|
||||
StringRef getFilename(const SourceLocation& loc);
|
||||
|
||||
bool mbInsideFunction;
|
||||
std::set<const ParmVarDecl*> interestingSet;
|
||||
std::set<const ParmVarDecl*> cannotBeConstSet;
|
||||
};
|
||||
|
||||
bool ConstParams::VisitFunctionDecl(FunctionDecl * functionDecl)
|
||||
{
|
||||
if (ignoreLocation(functionDecl) || !functionDecl->doesThisDeclarationHaveABody()) {
|
||||
return true;
|
||||
}
|
||||
// ignore stuff that forms part of the stable URE interface
|
||||
if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(
|
||||
functionDecl->getCanonicalDecl()->getNameInfo().getLoc()))) {
|
||||
return true;
|
||||
}
|
||||
// TODO ignore these for now, requires some extra work
|
||||
if (isa<CXXConstructorDecl>(functionDecl)) {
|
||||
return true;
|
||||
}
|
||||
// TODO ignore template stuff for now
|
||||
if (functionDecl->getTemplatedKind() != FunctionDecl::TK_NonTemplate) {
|
||||
return true;
|
||||
}
|
||||
if (isa<CXXMethodDecl>(functionDecl)
|
||||
&& dyn_cast<CXXMethodDecl>(functionDecl)->getParent()->getDescribedClassTemplate() != nullptr ) {
|
||||
return true;
|
||||
}
|
||||
// ignore virtual methods
|
||||
if (isa<CXXMethodDecl>(functionDecl)
|
||||
&& dyn_cast<CXXMethodDecl>(functionDecl)->isVirtual() ) {
|
||||
return true;
|
||||
}
|
||||
// ignore C main
|
||||
if (functionDecl->isMain()) {
|
||||
return true;
|
||||
}
|
||||
// ignore macro expansions so we can ignore the IMPL_LINK macros from include/tools/link.hxx
|
||||
// TODO make this more precise
|
||||
if (functionDecl->getLocation().isMacroID())
|
||||
return true;
|
||||
|
||||
if (functionDecl->getIdentifier()) {
|
||||
StringRef name = functionDecl->getName();
|
||||
if (name == "yyerror" // ignore lex/yacc callback
|
||||
// some function callbacks
|
||||
|| name == "PDFSigningPKCS7PasswordCallback"
|
||||
|| name == "VCLExceptionSignal_impl"
|
||||
|| name == "parseXcsFile"
|
||||
// UNO component entry points
|
||||
|| name.endswith("component_getFactory"))
|
||||
return true;
|
||||
}
|
||||
|
||||
StringRef aFileName = getFilename(functionDecl->getLocStart());
|
||||
if (aFileName.startswith(SRCDIR "/sal/")
|
||||
|| aFileName.startswith(SRCDIR "/bridges/")
|
||||
|| aFileName.startswith(SRCDIR "/binaryurp/")
|
||||
|| aFileName.startswith(SRCDIR "/stoc/")
|
||||
|| aFileName.startswith(WORKDIR "/YaccTarget/unoidl/source/sourceprovider-parser.cxx")
|
||||
// some weird calling through a function pointer
|
||||
|| aFileName.startswith(SRCDIR "/svtools/source/table/defaultinputhandler.cxx")
|
||||
// windows only
|
||||
|| aFileName.startswith(SRCDIR "/basic/source/sbx/sbxdec.cxx")
|
||||
|| aFileName.startswith(SRCDIR "/sfx2/source/doc/syspath.cxx")) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// calculate the ones we want to check
|
||||
interestingSet.clear();
|
||||
for (const ParmVarDecl *pParmVarDecl : compat::parameters(*functionDecl)) {
|
||||
// ignore unused params
|
||||
if (pParmVarDecl->getName().empty())
|
||||
continue;
|
||||
auto const type = loplugin::TypeCheck(pParmVarDecl->getType());
|
||||
if (!type.Pointer() && !type.LvalueReference())
|
||||
continue;
|
||||
if (type.Pointer().Const())
|
||||
continue;
|
||||
if (type.LvalueReference().Const())
|
||||
continue;
|
||||
// since we can't normally change typedefs, just ignore them
|
||||
if (isa<TypedefType>(pParmVarDecl->getType()))
|
||||
continue;
|
||||
// TODO ignore these for now, has some effects I don't understand
|
||||
if (type.Pointer().Pointer())
|
||||
continue;
|
||||
// const is meaningless when applied to function pointer types
|
||||
if (pParmVarDecl->getType()->isFunctionPointerType())
|
||||
continue;
|
||||
interestingSet.insert(pParmVarDecl);
|
||||
}
|
||||
if (interestingSet.empty()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
mbInsideFunction = true;
|
||||
cannotBeConstSet.clear();
|
||||
bool ret = RecursiveASTVisitor::TraverseStmt(functionDecl->getBody());
|
||||
mbInsideFunction = false;
|
||||
|
||||
for (const ParmVarDecl *pParmVarDecl : interestingSet) {
|
||||
if (cannotBeConstSet.find(pParmVarDecl) == cannotBeConstSet.end()) {
|
||||
report(
|
||||
DiagnosticsEngine::Warning,
|
||||
"this parameter can be const",
|
||||
pParmVarDecl->getLocStart())
|
||||
<< pParmVarDecl->getSourceRange();
|
||||
if (functionDecl->getCanonicalDecl()->getLocation() != functionDecl->getLocation()) {
|
||||
unsigned idx = pParmVarDecl->getFunctionScopeIndex();
|
||||
ParmVarDecl* pOther = functionDecl->getCanonicalDecl()->getParamDecl(idx);
|
||||
report(
|
||||
DiagnosticsEngine::Note,
|
||||
"canonical parameter declaration here",
|
||||
pOther->getLocStart())
|
||||
<< pOther->getSourceRange();
|
||||
}
|
||||
//functionDecl->dump();
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool ConstParams::VisitDeclRefExpr( const DeclRefExpr* declRefExpr )
|
||||
{
|
||||
if (!mbInsideFunction) {
|
||||
return true;
|
||||
}
|
||||
const ParmVarDecl* parmVarDecl = dyn_cast_or_null<ParmVarDecl>(declRefExpr->getDecl());
|
||||
if (!parmVarDecl) {
|
||||
return true;
|
||||
}
|
||||
if (interestingSet.find(parmVarDecl) == interestingSet.end()) {
|
||||
return true;
|
||||
}
|
||||
if (!checkIfCanBeConst(declRefExpr))
|
||||
cannotBeConstSet.insert(parmVarDecl);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ConstParams::checkIfCanBeConst(const Stmt* stmt)
|
||||
{
|
||||
const Stmt* parent = parentStmt( stmt );
|
||||
if (isa<UnaryOperator>(parent)) {
|
||||
const UnaryOperator* unaryOperator = dyn_cast<UnaryOperator>(parent);
|
||||
UnaryOperator::Opcode op = unaryOperator->getOpcode();
|
||||
if (op == UO_AddrOf || op == UO_PreInc || op == UO_PostInc
|
||||
|| op == UO_PreDec || op == UO_PostDec) {
|
||||
return false;
|
||||
}
|
||||
if (op == UO_Deref) {
|
||||
return checkIfCanBeConst(parent);
|
||||
}
|
||||
return true;
|
||||
} else if (isa<BinaryOperator>(parent)) {
|
||||
const BinaryOperator* binaryOp = dyn_cast<BinaryOperator>(parent);
|
||||
BinaryOperator::Opcode op = binaryOp->getOpcode();
|
||||
// TODO could do better, but would require tracking the LHS
|
||||
if (binaryOp->getRHS() == stmt && op == BO_Assign) {
|
||||
return false;
|
||||
}
|
||||
if (binaryOp->getRHS() == stmt) {
|
||||
return true;
|
||||
}
|
||||
if (op == BO_Assign || op == BO_PtrMemD || op == BO_PtrMemI || op == BO_MulAssign
|
||||
|| op == BO_DivAssign || op == BO_RemAssign || op == BO_AddAssign
|
||||
|| op == BO_SubAssign || op == BO_ShlAssign || op == BO_ShrAssign
|
||||
|| op == BO_AndAssign || op == BO_XorAssign || op == BO_OrAssign) {
|
||||
return false;
|
||||
}
|
||||
// for pointer arithmetic need to check parent
|
||||
if (binaryOp->getType()->isPointerType()) {
|
||||
return checkIfCanBeConst(parent);
|
||||
}
|
||||
return true;
|
||||
} else if (isa<CXXConstructExpr>(parent)) {
|
||||
const CXXConstructExpr* constructExpr = dyn_cast<CXXConstructExpr>(parent);
|
||||
const CXXConstructorDecl * constructorDecl = constructExpr->getConstructor();
|
||||
for (unsigned i = 0; i < constructExpr->getNumArgs(); ++i) {
|
||||
if (constructExpr->getArg(i) == stmt) {
|
||||
return isPointerOrReferenceToConst(constructorDecl->getParamDecl(i)->getType());
|
||||
}
|
||||
}
|
||||
std::cout << "dump0" << std::endl;
|
||||
parent->dump();
|
||||
} else if (isa<CXXOperatorCallExpr>(parent)) {
|
||||
const CXXOperatorCallExpr* operatorCallExpr = dyn_cast<CXXOperatorCallExpr>(parent);
|
||||
const CXXMethodDecl* calleeMethodDecl = dyn_cast<CXXMethodDecl>(operatorCallExpr->getDirectCallee());
|
||||
if (calleeMethodDecl) {
|
||||
// unary operator
|
||||
if (calleeMethodDecl->getNumParams() == 0) {
|
||||
return calleeMethodDecl->isConst();
|
||||
}
|
||||
// binary operator
|
||||
if (operatorCallExpr->getArg(0) == stmt) {
|
||||
return calleeMethodDecl->isConst();
|
||||
}
|
||||
if (operatorCallExpr->getArg(1) == stmt) {
|
||||
return isPointerOrReferenceToConst(calleeMethodDecl->getParamDecl(0)->getType());
|
||||
}
|
||||
} else {
|
||||
const Expr* callee = operatorCallExpr->getCallee()->IgnoreParenImpCasts();
|
||||
const DeclRefExpr* dr = dyn_cast<DeclRefExpr>(callee);
|
||||
const FunctionDecl* calleeFunctionDecl = nullptr;
|
||||
if (dr) {
|
||||
calleeFunctionDecl = dyn_cast<FunctionDecl>(dr->getDecl());
|
||||
}
|
||||
if (calleeFunctionDecl) {
|
||||
for (unsigned i = 0; i < operatorCallExpr->getNumArgs(); ++i) {
|
||||
if (operatorCallExpr->getArg(i) == stmt) {
|
||||
return isPointerOrReferenceToConst(calleeFunctionDecl->getParamDecl(i)->getType());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
std::cout << "dump1" << std::endl;
|
||||
parent->dump();
|
||||
stmt->dump();
|
||||
} else if (isa<CallExpr>(parent)) {
|
||||
const CallExpr* callExpr = dyn_cast<CallExpr>(parent);
|
||||
QualType functionType = callExpr->getCallee()->getType();
|
||||
if (functionType->isFunctionPointerType()) {
|
||||
functionType = functionType->getPointeeType();
|
||||
}
|
||||
if (const FunctionProtoType* prototype = functionType->getAs<FunctionProtoType>()) {
|
||||
// TODO could do better
|
||||
if (prototype->isVariadic()) {
|
||||
return false;
|
||||
}
|
||||
if (callExpr->getCallee() == stmt) {
|
||||
return true;
|
||||
}
|
||||
for (unsigned i = 0; i < callExpr->getNumArgs(); ++i) {
|
||||
if (callExpr->getArg(i) == stmt) {
|
||||
return isPointerOrReferenceToConst(prototype->getParamType(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
const FunctionDecl* calleeFunctionDecl = callExpr->getDirectCallee();
|
||||
if (isa<CXXMemberCallExpr>(parent)) {
|
||||
const CXXMemberCallExpr* memberCallExpr = dyn_cast<CXXMemberCallExpr>(parent);
|
||||
const MemberExpr* memberExpr = dyn_cast<MemberExpr>(stmt);
|
||||
if (memberExpr && memberCallExpr->getImplicitObjectArgument() == memberExpr->getBase())
|
||||
{
|
||||
const CXXMethodDecl* calleeMethodDecl = dyn_cast<CXXMethodDecl>(calleeFunctionDecl);
|
||||
return calleeMethodDecl->isConst();
|
||||
}
|
||||
}
|
||||
if (!calleeFunctionDecl) {
|
||||
std::cout << "---------------dump2" << std::endl;
|
||||
std::cout << "parent" << std::endl;
|
||||
parent->dump();
|
||||
std::cout << "child" << std::endl;
|
||||
stmt->dump();
|
||||
std::cout << "callee-type" << std::endl;
|
||||
callExpr->getCallee()->getType()->dump();
|
||||
for (unsigned i = 0; i < callExpr->getNumArgs(); ++i) {
|
||||
std::cout << " param " << i << std::endl;
|
||||
callExpr->getArg(i)->dump();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
// TODO could do better
|
||||
if (calleeFunctionDecl->isVariadic()) {
|
||||
return false;
|
||||
}
|
||||
if (callExpr->getCallee() == stmt) {
|
||||
return true;
|
||||
}
|
||||
for (unsigned i = 0; i < callExpr->getNumArgs(); ++i) {
|
||||
if (i >= calleeFunctionDecl->getNumParams()) // can happen in template code
|
||||
break;
|
||||
if (callExpr->getArg(i) == stmt) {
|
||||
return isPointerOrReferenceToConst(calleeFunctionDecl->getParamDecl(i)->getType());
|
||||
}
|
||||
}
|
||||
std::cout << "------------dump3" << std::endl;
|
||||
std::cout << "parent" << std::endl;
|
||||
parent->dump();
|
||||
std::cout << "child" << std::endl;
|
||||
stmt->dump();
|
||||
calleeFunctionDecl->dump();
|
||||
for (unsigned i = 0; i < callExpr->getNumArgs(); ++i) {
|
||||
std::cout << " param " << i << std::endl;
|
||||
callExpr->getArg(i)->dump();
|
||||
}
|
||||
if (isa<CXXMemberCallExpr>(parent)) {
|
||||
std::cout << "implicit" << std::endl;
|
||||
dyn_cast<CXXMemberCallExpr>(parent)->getImplicitObjectArgument()->dump();
|
||||
}
|
||||
} else if (isa<CXXReinterpretCastExpr>(parent)) {
|
||||
return false;
|
||||
} else if (isa<CXXConstCastExpr>(parent)) {
|
||||
return false;
|
||||
} else if (isa<CastExpr>(parent)) { // all other cast expression subtypes
|
||||
return checkIfCanBeConst(parent);
|
||||
} else if (isa<MemberExpr>(parent)) {
|
||||
return checkIfCanBeConst(parent);
|
||||
} else if (isa<ArraySubscriptExpr>(parent)) {
|
||||
return checkIfCanBeConst(parent);
|
||||
} else if (isa<ParenExpr>(parent)) {
|
||||
return checkIfCanBeConst(parent);
|
||||
} else if (isa<DeclStmt>(parent)) {
|
||||
// TODO could do better here, but would require tracking the target(s)
|
||||
return false;
|
||||
} else if (isa<ReturnStmt>(parent)) {
|
||||
return isPointerOrReferenceToConst(dyn_cast<Expr>(stmt)->getType());
|
||||
} else if (isa<InitListExpr>(parent)) {
|
||||
return false;
|
||||
} else if (isa<IfStmt>(parent)) {
|
||||
return true;
|
||||
} else if (isa<WhileStmt>(parent)) {
|
||||
return true;
|
||||
} else if (isa<ForStmt>(parent)) {
|
||||
return true;
|
||||
} else if (isa<CompoundStmt>(parent)) {
|
||||
return true;
|
||||
} else if (isa<SwitchStmt>(parent)) {
|
||||
return true;
|
||||
} else if (isa<CXXDeleteExpr>(parent)) {
|
||||
return false;
|
||||
} else if (isa<VAArgExpr>(parent)) {
|
||||
return false;
|
||||
} else if (isa<MaterializeTemporaryExpr>(parent)) {
|
||||
return true;
|
||||
} else if (const ConditionalOperator* conditionalExpr = dyn_cast<ConditionalOperator>(parent)) {
|
||||
if (conditionalExpr->getCond() == stmt)
|
||||
return true;
|
||||
return checkIfCanBeConst(parent);
|
||||
} else {
|
||||
std::cout << "dump5" << std::endl;
|
||||
parent->dump();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ConstParams::isPointerOrReferenceToConst(const QualType& qt) {
|
||||
auto const type = loplugin::TypeCheck(qt);
|
||||
if (type.Pointer()) {
|
||||
return bool(type.Pointer().Const());
|
||||
} else if (type.LvalueReference().Const().Pointer()) {
|
||||
// If we have a method that takes (T* t) and it calls std::vector<T*>::push_back
|
||||
// then the type of push_back is T * const &
|
||||
// There is probably a more elegant way to check this, but it will probably require
|
||||
// recalculating types while walking up the AST.
|
||||
return false;
|
||||
} else if (type.LvalueReference()) {
|
||||
return bool(type.LvalueReference().Const());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
StringRef ConstParams::getFilename(const SourceLocation& loc)
|
||||
{
|
||||
SourceLocation spellingLocation = compiler.getSourceManager().getSpellingLoc(loc);
|
||||
StringRef name { compiler.getSourceManager().getFilename(spellingLocation) };
|
||||
return name;
|
||||
}
|
||||
|
||||
loplugin::Plugin::Registration< ConstParams > X("constparams", false);
|
||||
|
||||
}
|
||||
|
||||
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
||||
Reference in New Issue
Block a user