compilerplugins/clang/unoaggregation.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 // Find classes that derive from css::uno::XAggregation, but which implement queryInterface in
  11 // violation of the protocol laid out in the documentation at
  12 // udkapi/com/sun/star/uno/XAggregation.idl (which implies that such a class either doesn't actually
  13 // make use of the deprecated XAggregation mechanism, which should thus be removed from that class
  14 // hierarchy, or that its implementation of queryInterface needs to be fixed).
  15
  16 #ifndef LO_CLANG_SHARED_PLUGINS
  17
  18 #include <cassert>
  19
  20 #include "check.hxx"
  21 #include "plugin.hxx"
  22
  23 namespace
  24 {
  25 bool isQueryInterface(CXXMethodDecl const* decl)
  26 {
  27     auto const id = decl->getIdentifier();
  28     if (id == nullptr || id->getName() != "queryInterface")
  29     {
  30         return false;
  31     }
  32     if (decl->getNumParams() != 1)
  33     {
  34         return false;
  35     }
  36     if (!loplugin::TypeCheck(decl->getParamDecl(0)->getType())
  37              .LvalueReference()
  38              .ConstNonVolatile()
  39              .Class("Type")
  40              .Namespace("uno")
  41              .Namespace("star")
  42              .Namespace("sun")
  43              .Namespace("com")
  44              .GlobalNamespace())
  45     {
  46         return false;
  47     }
  48     return true;
  49 }
  50
  51 bool derivesFromXAggregation(CXXRecordDecl const* decl, bool checkSelf)
  52 {
  53     return loplugin::isDerivedFrom(decl,
  54                                    [](Decl const* decl) -> bool {
  55                                        return bool(loplugin::DeclCheck(decl)
  56                                                        .Class("XAggregation")
  57                                                        .Namespace("uno")
  58                                                        .Namespace("star")
  59                                                        .Namespace("sun")
  60                                                        .Namespace("com")
  61                                                        .GlobalNamespace());
  62                                    },
  63                                    checkSelf);
  64 }
  65
  66 // Return true if decl is an implementation of css::uno::XInterface::queryInterface in a class
  67 // derived from css::uno::XAggregation:
  68 bool isXAggregationQueryInterface(CXXMethodDecl const* decl)
  69 {
  70     return isQueryInterface(decl) && derivesFromXAggregation(decl->getParent(), false);
  71 }
  72
  73 bool basesHaveOnlyPureQueryInterface(CXXRecordDecl const* decl)
  74 {
  75     for (auto const& b : decl->bases())
  76     {
  77         auto const d1 = b.getType()->getAsCXXRecordDecl();
  78         if (!derivesFromXAggregation(d1, true))
  79         {
  80             continue;
  81         }
  82         for (auto const d2 : d1->methods())
  83         {
  84             if (!isQueryInterface(d2))
  85             {
  86                 continue;
  87             }
  88             if (!d2->isPure())
  89             {
  90                 return false;
  91             }
  92         }
  93         if (!basesHaveOnlyPureQueryInterface(d1))
  94         {
  95             return false;
  96         }
  97     }
  98     return true;
  99 }
 100
 101 class UnoAggregation final : public loplugin::FilteringPlugin<UnoAggregation>
 102 {
 103 public:
 104     explicit UnoAggregation(loplugin::InstantiationData const& data)
 105         : FilteringPlugin(data)
 106     {
 107     }
 108
 109     bool shouldVisitTemplateInstantiations() const { return true; }
 110
 111     bool preRun() override { return compiler.getLangOpts().CPlusPlus; }
 112
 113     void run() override
 114     {
 115         if (preRun())
 116         {
 117             TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
 118         }
 119     }
 120
 121     bool VisitCXXMethodDecl(CXXMethodDecl const* decl)
 122     {
 123         if (ignoreLocation(decl))
 124         {
 125             return true;
 126         }
 127         if (!decl->isThisDeclarationADefinition())
 128         {
 129             return true;
 130         }
 131         auto const parent = decl->getParent();
 132         if (parent->getDescribedClassTemplate() != nullptr)
 133         {
 134             // For class templates with dependent base classes, loplugin::isDerivedFrom as used in
 135             // isXAggregationQueryInterface would always return true; work around that by not
 136             // looking at any templates at all, which is OK due to
 137             // shouldVisitTemplateInstantiations:
 138             return true;
 139         }
 140         if (!isXAggregationQueryInterface(decl))
 141         {
 142             return true;
 143         }
 144         if (decl->isDeleted())
 145         {
 146             // Whether or not a deleted queryInterface makes sense, just leave those alone:
 147             return true;
 148         }
 149         auto const body = decl->getBody();
 150         assert(body != nullptr);
 151         // Check whether the implementation forwards to one of the base classes that derive from
 152         // XAggregation:
 153         if (auto const s1 = dyn_cast<CompoundStmt>(body))
 154         {
 155             if (s1->size() == 1)
 156             {
 157                 if (auto const s2 = dyn_cast<ReturnStmt>(s1->body_front()))
 158                 {
 159                     if (auto const e1 = s2->getRetValue())
 160                     {
 161                         if (auto const e2
 162                             = dyn_cast<CXXMemberCallExpr>(e1->IgnoreImplicit()->IgnoreParens()))
 163                         {
 164                             return true;
 165                             if (e2->getImplicitObjectArgument() == nullptr)
 166                             {
 167                                 if (isXAggregationQueryInterface(e2->getMethodDecl()))
 168                                 {
 169                                     // e2 will thus necessarily be a call of a base class's
 170                                     // queryInterface (or a recursive call of the given decl itself,
 171                                     // but which would cause the code to have undefined behavior
 172                                     // anyway, so don't bother to rule that out):
 173                                     return true;
 174                                 }
 175                             }
 176                         }
 177                     }
 178                     else if (isDebugMode())
 179                     {
 180                         report(DiagnosticsEngine::Warning,
 181                                "suspicious implementation of queryInterface containing a return "
 182                                "statement with no operand",
 183                                decl->getLocation())
 184                             << decl->getSourceRange();
 185                     }
 186                 }
 187             }
 188         }
 189         // As a crude approximation (but which appears to work OK), if all of the base classes that
 190         // derive from XAggregation only ever declare queryInterface as pure, assume that this is
 191         // the base implementation of queryInterface (which will necessarily not match the above
 192         // check for a forwarding implementation):
 193         if (basesHaveOnlyPureQueryInterface(parent))
 194         {
 195             return true;
 196         }
 197         if (suppressWarningAt(decl->getBeginLoc()))
 198         {
 199             return true;
 200         }
 201         report(DiagnosticsEngine::Warning,
 202                "%0 derives from XAggregation, but its implementation of queryInterface does not "
 203                "delegate to an appropriate base class queryInterface",
 204                decl->getLocation())
 205             << parent << decl->getSourceRange();
 206         return true;
 207     }
 208 };
 209
 210 loplugin::Plugin::Registration<UnoAggregation> unoaggregation("unoaggregation");
 211 }
 212
 213 #endif
 214
 215 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */