Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 917 insertions, 0 deletions

diff --git a/compilerplugins/clang/sharedvisitor/README b/compilerplugins/clang/sharedvisitor/README
new file mode 100644
index 000000000..7b4a8b3c7
--- /dev/null
+++ b/compilerplugins/clang/sharedvisitor/README
@@ -0,0 +1,45 @@
+These tools generate another "plugin" which in fact only dispatches Visit* and Traverse*
+calls to all other plugins registered with it. This means that there is just one
+RecursiveASTVisitor pass for all those plugins instead of one per each, which
+with the current number of plugins actually makes a performance difference.
+
+If you work on a plugin, comment out LO_CLANG_SHARED_PLUGINS in Makefile-clang.mk in order
+to disable the feature (re-generating takes time).
+
+There are two tools:
+- analyzer, which analyses one .cxx file (one plugins) and writes info about it to a .plugininfo
+  file, this allows parallelising this part, since it can take some time
+- generator, which reads all the .plugininfo files and generates sharedvisitor.cxx
+
+Requirements for plugins:
+- Can use Visit* and Traverse* functions, but not WalkUp*.
+- Visit* functions can generally remain unmodified.
+- run() function must be split into preRun() and postRun() if there's any additional functionality
+  besides calling TraverseDecl(). The shared visitor will call the preRun() and postRun() functions
+  as necessary while calling its own run(). The run() function of the plugin must stay
+  (in case of a non-shared build) but should generally look like this:
+    if( preRun())
+        if( TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()))
+            postRun();
+- Traverse* functions must be split into PreTraverse* and PostTraverse*, similarly to how run()
+  is handled, the Traverse* function should generally look like this:
+        bool ret = true;
+        if( PreTraverse*(decl))
+        {
+            ret = RecursiveASTVisitor::Traverse*(decl);
+            PostTraverse*(decl, ret);
+        }
+        return ret;
+
+
+TODO:
+- Create macros for the standardized layout of run(), Traverse*, etc.?
+- Possibly check plugin sources more thoroughly (e.g. that run() doesn't actually do more).
+- Have one tool that extracts info from plugin .cxx files into some .txt file and another tool
+  that generates sharedvisitor.cxx based on those files? That would generally make the generation
+  faster when doing incremental changes. The .txt file could also contain some checksum of the .cxx
+  to avoid the analysing pass completely if just the timestamp has changed.
+- Do not re-compile sharedvisitor.cxx if its contents have not actually changed.
+- Is it possible to make the clang code analyze just the .cxx without also parsing all the headers?
+- Instead of having to comment out LO_CLANG_SHARED_PLUGINS, implement --enable-compiler-plugins=debug .
+- Try make analyzer use a precompiled header of Clang headers, for better performance.
diff --git a/compilerplugins/clang/sharedvisitor/analyzer.cxx b/compilerplugins/clang/sharedvisitor/analyzer.cxx
new file mode 100644
index 000000000..a000bd249
--- /dev/null
+++ b/compilerplugins/clang/sharedvisitor/analyzer.cxx
@@ -0,0 +1,299 @@
+/* -*- 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 "clang/AST/ASTConsumer.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendAction.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/StringExtras.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <fstream>
+#include <set>
+
+#include "config_clang.h"
+#include "../check.hxx"
+#include "../check.cxx"
+
+using namespace clang;
+using namespace llvm;
+
+using namespace loplugin;
+
+// Info about a Traverse* function in a plugin.
+struct TraverseFunctionInfo
+{
+    std::string name;
+    std::string argument;
+    bool hasPre = false;
+    bool hasPost = false;
+};
+
+struct TraverseFunctionInfoLess
+{
+    bool operator()( const TraverseFunctionInfo& l, const TraverseFunctionInfo& r ) const
+    {
+        return l.name < r.name;
+    }
+};
+
+static std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions;
+
+class CheckFileVisitor
+    : public RecursiveASTVisitor< CheckFileVisitor >
+{
+public:
+    void setContext(ASTContext const& context) { context_ = &context; }
+
+    bool VisitCXXRecordDecl(CXXRecordDecl *Declaration);
+
+    bool TraverseNamespaceDecl(NamespaceDecl * decl)
+    {
+        // Skip non-LO namespaces the same way FilteringPlugin does.
+        if( !ContextCheck( decl ).Namespace( "loplugin" ).GlobalNamespace()
+            && !ContextCheck( decl ).AnonymousNamespace())
+        {
+            return true;
+        }
+        return RecursiveASTVisitor<CheckFileVisitor>::TraverseNamespaceDecl(decl);
+    }
+
+private:
+    ASTContext const* context_ = nullptr;
+
+    QualType unqualifyPointeeType(QualType type)
+    {
+        assert(context_ != nullptr);
+        if (auto const t = type->getAs<clang::PointerType>())
+        {
+            return context_->getQualifiedType(
+                context_->getPointerType(t->getPointeeType().getUnqualifiedType()),
+                type.getQualifiers());
+        }
+        return type;
+    }
+};
+
+static bool inheritsPluginClassCheck( const Decl* decl )
+{
+    return bool( DeclCheck( decl ).Class( "FilteringPlugin" ).Namespace( "loplugin" ).GlobalNamespace())
+        || bool( DeclCheck( decl ).Class( "FilteringRewritePlugin" ).Namespace( "loplugin" ).GlobalNamespace());
+}
+
+static TraverseFunctionInfo findOrCreateTraverseFunctionInfo( StringRef name )
+{
+    TraverseFunctionInfo info;
+    info.name = name.str();
+    auto foundInfo = traverseFunctions.find( info );
+    if( foundInfo != traverseFunctions.end())
+    {
+        info = std::move( *foundInfo );
+        traverseFunctions.erase( foundInfo );
+    }
+    return info;
+}
+
+static bool foundSomething;
+
+bool CheckFileVisitor::VisitCXXRecordDecl( CXXRecordDecl* decl )
+{
+    if( !isDerivedFrom( decl, inheritsPluginClassCheck ))
+        return true;
+
+    if( decl->getName() == "FilteringPlugin" || decl->getName() == "FilteringRewritePlugin" )
+        return true;
+
+    std::cout << "# This file is autogenerated. Do not modify." << std::endl;
+    std::cout << "# Generated by compilerplugins/clang/sharedvisitor/analyzer.cxx ." << std::endl;
+    std::cout << "InfoVersion:1" << std::endl;
+    std::cout << "ClassName:" << decl->getName().str() << std::endl;
+    traverseFunctions.clear();
+    for( const CXXMethodDecl* method : decl->methods())
+    {
+        if( !method->getDeclName().isIdentifier())
+            continue;
+        if( method->isStatic() || method->getAccess() != AS_public )
+            continue;
+        if( method->getName().startswith( "Visit" ))
+        {
+            if( method->getNumParams() == 1 )
+            {
+                std::cout << "VisitFunctionStart" << std::endl;
+                std::cout << "VisitFunctionName:" << method->getName().str() << std::endl;
+                std::cout << "VisitFunctionArgument:"
+                    << unqualifyPointeeType(
+                        method->getParamDecl( 0 )->getTypeSourceInfo()->getType()).getAsString()
+                    << std::endl;
+                std::cout << "VisitFunctionEnd" << std::endl;
+            }
+            else
+            {
+                std::cerr << "Unhandled Visit* function: " << decl->getName().str()
+                     << "::" << method->getName().str() << std::endl;
+                abort();
+            }
+        }
+        else if( method->getName().startswith( "Traverse" ))
+        {
+            if( method->getNumParams() == 1 )
+            {
+                TraverseFunctionInfo traverseInfo = findOrCreateTraverseFunctionInfo( method->getName());
+                traverseInfo.argument = method->getParamDecl( 0 )->getTypeSourceInfo()->getType().getAsString();
+                traverseFunctions.insert( std::move( traverseInfo ));
+            }
+            else
+            {
+                std::cerr << "Unhandled Traverse* function: " << decl->getName().str()
+                     << "::" << method->getName().str() << std::endl;
+                abort();
+            }
+        }
+        else if( method->getName().startswith( "PreTraverse" ))
+        {
+            TraverseFunctionInfo traverseInfo = findOrCreateTraverseFunctionInfo( method->getName().substr( 3 ));
+            traverseInfo.hasPre = true;
+            traverseFunctions.insert( std::move( traverseInfo ));
+        }
+        else if( method->getName().startswith( "PostTraverse" ))
+        {
+                TraverseFunctionInfo traverseInfo = findOrCreateTraverseFunctionInfo( method->getName().substr( 4 ));
+                traverseInfo.hasPost = true;
+                traverseFunctions.insert( std::move( traverseInfo ));
+        }
+        else if( method->getName() == "shouldVisitTemplateInstantiations" )
+            std::cout << "ShouldVisitTemplateInstantiations:1" << std::endl;
+        else if (method->getName() == "shouldVisitImplicitCode")
+            std::cout << "ShouldVisitImplicitCode:1" << std::endl;
+        else if( method->getName().startswith( "WalkUp" ))
+        {
+            std::cerr << "WalkUp function not supported for shared visitor: " << decl->getName().str()
+                 << "::" << method->getName().str() << std::endl;
+            abort();
+        }
+    }
+
+    for( const auto& traverseFunction : traverseFunctions )
+    {
+        std::cout << "TraverseFunctionStart" << std::endl;
+        std::cout << "TraverseFunctionName:" << traverseFunction.name << std::endl;
+        std::cout << "TraverseFunctionArgument:" << traverseFunction.argument << std::endl;
+        std::cout << "TraverseFunctionHasPre:" << traverseFunction.hasPre << std::endl;
+        std::cout << "TraverseFunctionHasPost:" << traverseFunction.hasPost << std::endl;
+        std::cout << "TraverseFunctionEnd" << std::endl;
+    }
+
+    std::cout << "InfoEnd" << std::endl;
+    foundSomething = true;
+    return true;
+}
+
+class FindNamedClassConsumer
+    : public ASTConsumer
+{
+public:
+    void Initialize(ASTContext& context) override
+    {
+        visitor.setContext(context);
+    }
+    virtual void HandleTranslationUnit(ASTContext& context) override
+    {
+        visitor.TraverseDecl( context.getTranslationUnitDecl());
+    }
+private:
+    CheckFileVisitor visitor;
+};
+
+class FindNamedClassAction
+    : public ASTFrontendAction
+    {
+public:
+    virtual std::unique_ptr<ASTConsumer> CreateASTConsumer( CompilerInstance&, StringRef ) override
+    {
+        return std::unique_ptr<ASTConsumer>( new FindNamedClassConsumer );
+    }
+};
+
+
+std::string readSourceFile( const char* filename )
+{
+    std::string contents;
+    std::ifstream stream( filename );
+    if( !stream )
+    {
+        std::cerr << "Failed to open: " << filename << std::endl;
+        exit( 1 );
+    }
+    std::string line;
+    bool hasIfdef = false;
+    while( getline( stream, line ))
+    {
+        // TODO add checks that it's e.g. not "#ifdef" ?
+        if( line.find( "#ifndef LO_CLANG_SHARED_PLUGINS" ) == 0 )
+            hasIfdef = true;
+        contents += line;
+        contents += '\n';
+    }
+    if( stream.eof() && hasIfdef )
+        return contents;
+    return "";
+}
+
+int main(int argc, char** argv)
+{
+    std::vector< std::string > args;
+    int i = 1;
+    for( ; i < argc; ++ i )
+    {
+        constexpr std::size_t prefixlen = 5; // strlen("-arg=");
+        if (std::strncmp(argv[i], "-arg=", prefixlen) != 0)
+        {
+            break;
+        }
+        args.push_back(argv[i] + prefixlen);
+    }
+    SmallVector< StringRef, 20 > clangflags;
+    SplitString( CLANGFLAGS, clangflags );
+    for (auto const & i: clangflags) {
+        args.push_back(i.str());
+    }
+    args.insert(
+        args.end(),
+        {   // These must match LO_CLANG_ANALYZER_PCH_CXXFLAGS in Makefile-clang.mk .
+            "-I" BUILDDIR "/config_host" // plugin sources use e.g. config_global.h
+#if LO_CLANG_USE_ANALYZER_PCH
+            ,
+            "-include-pch", // use PCH with Clang headers to speed up parsing/analysing
+            BUILDDIR "/compilerplugins/clang/sharedvisitor/clang.pch"
+#endif
+        });
+    for( ; i < argc; ++ i )
+    {
+        std::string contents = readSourceFile(argv[i]);
+        if( contents.empty())
+            continue;
+        foundSomething = false;
+        if( !tooling::runToolOnCodeWithArgs( std::unique_ptr<FindNamedClassAction>(new FindNamedClassAction), contents, args, argv[ i ] ))
+        {
+            std::cerr << "Failed to analyze: " << argv[ i ] << std::endl;
+            return 2;
+        }
+        if( !foundSomething )
+        {
+            // there's #ifndef LO_CLANG_SHARED_PLUGINS in the source, but no class matched
+            std::cerr << "Failed to find code: " << argv[ i ] << std::endl;
+            return 2;
+        }
+    }
+    return 0;
+}
diff --git a/compilerplugins/clang/sharedvisitor/dummyplugin.hxx b/compilerplugins/clang/sharedvisitor/dummyplugin.hxx
new file mode 100644
index 000000000..1ef87416a
--- /dev/null
+++ b/compilerplugins/clang/sharedvisitor/dummyplugin.hxx
@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * Based on LLVM/Clang.
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ */
+
+#pragma once
+
+#include "config_clang.h"
+
+#include "../plugin.hxx"
+
+using namespace clang;
+using namespace llvm;
+
+namespace loplugin
+{
+
+// These classes are used as base classes when building with LO_CLANG_SHARED_PLUGINS.
+// Since plugin classes in that case should use just one shared RecursiveASTVisitor,
+// sharedvisitor/generator.cxx will make these to be the base classes used, so that
+// compiling the code doesn't spend a several minutes optimizing instances
+// of RecursiveASTVisitor that will never get used.
+
+template<typename T>
+class DummyRecursiveASTVisitor
+{
+public:
+    // These need to be reimplemented, because plugins contain calls to them,
+    // but they should actually never get called in the shared-visitor mode.
+    // This could be autogenerated too, but it's probably simpler to just extend
+    // manually as needed.
+    bool TraverseDecl( Decl* ) { return complain(); }
+    bool TraverseLinkageSpecDecl( LinkageSpecDecl* ) { return complain(); }
+    bool TraverseStmt( Stmt* ) { return complain(); }
+    bool TraverseIfStmt( IfStmt* ) { return complain(); }
+    bool TraverseWhileStmt( WhileStmt* ) { return complain(); }
+    bool TraverseDoStmt( DoStmt* ) { return complain(); }
+    bool TraverseForStmt( ForStmt* ) { return complain(); }
+    bool TraverseCompoundStmt( CompoundStmt* ) { return complain(); }
+    bool TraverseCXXForRangeStmt( CXXForRangeStmt* ) { return complain(); }
+    bool TraverseConditionalOperator( ConditionalOperator* ) { return complain(); }
+    bool TraverseCXXCatchStmt( CXXCatchStmt* ) { return complain(); }
+    bool TraverseCXXDestructorDecl( CXXDestructorDecl* ) { return complain(); }
+    bool TraverseFunctionDecl( FunctionDecl* ) { return complain(); }
+    bool TraverseSwitchStmt( SwitchStmt* ) { return complain(); }
+    bool TraverseImplicitCastExpr( ImplicitCastExpr* ) { return complain(); }
+    bool TraverseCStyleCastExpr( CStyleCastExpr* ) { return complain(); }
+    bool TraverseCXXStaticCastExpr( CXXStaticCastExpr* ) { return complain(); }
+    bool TraverseCXXFunctionalCastExpr( CXXFunctionalCastExpr* ) { return complain(); }
+    bool TraverseFriendDecl( FriendDecl* ) { return complain(); }
+    bool TraverseTypeLoc( TypeLoc ) { return complain(); }
+    bool TraverseAlignedAttr( AlignedAttr* ) { return complain(); }
+    bool TraverseVarDecl( VarDecl* ) { return complain(); }
+    bool TraverseUnaryExprOrTypeTraitExpr( UnaryExprOrTypeTraitExpr* ) { return complain(); }
+private:
+    bool complain() { assert(false && "should not be calling this in sharedplugin mode"); abort(); return false; }
+};
+
+template<typename Derived>
+class DummyFilteringPlugin : public DummyRecursiveASTVisitor<Derived>, public Plugin
+{
+public:
+    explicit DummyFilteringPlugin( const InstantiationData& data ) : Plugin(data) {}
+};
+
+template<typename Derived>
+class DummyFilteringRewritePlugin : public DummyRecursiveASTVisitor<Derived>, public RewritePlugin
+{
+public:
+    explicit DummyFilteringRewritePlugin( const InstantiationData& data ) : RewritePlugin(data) {}
+};
+
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/compilerplugins/clang/sharedvisitor/generator.cxx b/compilerplugins/clang/sharedvisitor/generator.cxx
new file mode 100644
index 000000000..ca5d2743c
--- /dev/null
+++ b/compilerplugins/clang/sharedvisitor/generator.cxx
@@ -0,0 +1,480 @@
+/* -*- 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 <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <iostream>
+#include <fstream>
+#include <memory>
+#include <set>
+#include <vector>
+
+// Info about a Visit* function in a plugin.
+struct VisitFunctionInfo
+{
+    std::string name;
+    std::string argument;
+};
+
+
+// Info about a Traverse* function in a plugin.
+struct TraverseFunctionInfo
+{
+    std::string name;
+    std::string argument;
+    bool hasPre = false;
+    bool hasPost = false;
+};
+
+struct VisitFunctionInfoLess
+{
+    bool operator()( const VisitFunctionInfo& l, const VisitFunctionInfo& r ) const
+    {
+        return l.name < r.name;
+    }
+};
+
+struct TraverseFunctionInfoLess
+{
+    bool operator()( const TraverseFunctionInfo& l, const TraverseFunctionInfo& r ) const
+    {
+        return l.name < r.name;
+    }
+};
+
+
+// Information about each LO plugin.
+struct PluginInfo
+{
+    std::string className; // e.g. "BadStatics"
+    std::string variableName; // e.g. "badStatics"
+    std::string lowercaseName;
+    bool shouldVisitTemplateInstantiations;
+    bool shouldVisitImplicitCode;
+    std::set< VisitFunctionInfo, VisitFunctionInfoLess > visitFunctions;
+    std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions;
+};
+
+// We need separate visitors for shouldVisitTemplateInstantiations and shouldVisitImplicitCode,
+// so split plugins into groups by what they should visit.
+// It seems that trying to handle the shouldVisit* functionality with just one visitor
+// is tricky.
+enum PluginType
+{
+    PluginBasic,
+    PluginVisitTemplates,
+    PluginVisitImplicit,
+    PluginVisitTemplatesImplicit,
+};
+
+const int Plugin_Begin = PluginBasic;
+const int Plugin_End = PluginVisitTemplatesImplicit + 1;
+static const char* const pluginTypeNames[ Plugin_End ]
+    = { "Basic", "VisitTemplates", "VisitImplicit", "VisitTemplatesImplicit" };
+
+static std::vector< PluginInfo > plugins[ Plugin_End ];
+
+
+void generateVisitor( PluginType type );
+
+void generate()
+{
+    std::ostream& output = std::cout;
+    output <<
+"// This file is autogenerated. Do not modify.\n"
+"// Generated by compilerplugins/clang/sharedvisitor/generator.cxx .\n"
+"\n"
+"#ifdef LO_CLANG_SHARED_PLUGINS\n"
+"\n"
+"#include <config_clang.h>\n"
+"\n"
+"#include <clang/AST/ASTContext.h>\n"
+"#include <clang/AST/RecursiveASTVisitor.h>\n"
+"\n"
+"#include \"plugin.hxx\"\n"
+"#include \"sharedvisitor/dummyplugin.hxx\"\n"
+"\n";
+
+    output << "#undef LO_CLANG_SHARED_PLUGINS // to get sources of individual plugins\n";
+    output << "// make use of the dummy base classes\n";
+    output << "#define RecursiveASTVisitor DummyRecursiveASTVisitor\n";
+    output << "#define FilteringPlugin DummyFilteringPlugin\n";
+    output << "#define FilteringRewritePlugin DummyFilteringRewritePlugin\n";
+    output << "\n";
+    for( const auto& pluginGroup : plugins )
+        for( const PluginInfo& plugin : pluginGroup )
+            output << "#include \"" << plugin.lowercaseName << ".cxx\"" << std::endl;
+    output << "\n";
+    output << "#undef RecursiveASTVisitor\n";
+    output << "#undef FilteringPlugin\n";
+    output << "#undef FilteringRewritePlugin\n";
+
+    output <<
+"\n"
+"using namespace clang;\n"
+"using namespace llvm;\n"
+"\n"
+"namespace loplugin\n"
+"{\n";
+
+    for( int type = Plugin_Begin; type < Plugin_End; ++type )
+        generateVisitor( static_cast< PluginType >( type ));
+
+    output <<
+"} // namespace loplugin\n"
+"\n"
+"#endif // LO_CLANG_SHARED_PLUGINS\n";
+}
+
+void generateVisitor( PluginType type )
+{
+    if( plugins[ type ].empty())
+        return;
+    std::ostream& output = std::cout;
+    output <<
+"\n"
+"class SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "\n"
+"    : public FilteringPlugin< SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << ">\n"
+"{\n"
+"public:\n"
+"    explicit SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "(const InstantiationData& rData)\n"
+"        : FilteringPlugin(rData)\n";
+    for( const PluginInfo& plugin : plugins[ type ] )
+        output << "        , " << plugin.variableName << "( nullptr )\n";
+    output << "        , activeRefCount( 0 )\n";
+    output << "    {}\n";
+
+    output <<
+"    ~SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "()\n"
+"    {\n"
+"        if( activeRefCount != 0 )\n"
+"            abort();\n"
+"    }\n";
+
+    output <<
+"    virtual bool preRun() override\n"
+"    {\n";
+    for( const PluginInfo& plugin : plugins[ type ] )
+    {
+        output << "        if( " << plugin.variableName << " && !" << plugin.variableName << "->preRun())\n";
+        // This will disable the plugin for the rest of the run.
+        output << "            " << plugin.variableName << " = nullptr;\n";
+    }
+    output <<
+"        return anyPluginActive();\n"
+"    }\n";
+
+    output <<
+"    virtual void postRun() override\n"
+"    {\n";
+    for( const PluginInfo& plugin : plugins[ type ] )
+    {
+        output << "        if( " << plugin.variableName << " )\n";
+        output << "            " << plugin.variableName << "->postRun();\n";
+    }
+    output <<
+"    }\n";
+
+    output <<
+"    virtual void run() override {\n"
+"        if (preRun()) {\n"
+"            TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());\n"
+"            postRun();\n"
+"        }\n"
+"    }\n"
+"    enum { isSharedPlugin = true };\n";
+
+    output <<
+"    virtual bool setSharedPlugin( Plugin* plugin, const char* name ) override\n"
+"    {\n";
+    bool first = true;
+    for( const PluginInfo& plugin : plugins[ type ] )
+    {
+        output << "        ";
+        if( !first )
+            output << "else ";
+        first = false;
+        output << "if( strcmp( name, \"" << plugin.lowercaseName << "\" ) == 0 )\n";
+        output << "            " << plugin.variableName << " = static_cast< " << plugin.className << "* >( plugin );\n";
+    }
+    output <<
+"        else\n"
+"            return false;\n"
+"        return true;\n"
+"    }\n";
+
+    if( type == PluginVisitTemplates || type == PluginVisitTemplatesImplicit )
+        output << "bool shouldVisitTemplateInstantiations() const { return true; }\n";
+    if( type == PluginVisitImplicit || type == PluginVisitTemplatesImplicit )
+        output << "bool shouldVisitImplicitCode() const { return true; }\n";
+
+    std::set< VisitFunctionInfo, VisitFunctionInfoLess > visitFunctions;
+    for( const PluginInfo& plugin : plugins[ type ] )
+        for( const VisitFunctionInfo& visit : plugin.visitFunctions )
+            visitFunctions.insert( visit );
+    for( const VisitFunctionInfo& visit : visitFunctions )
+    {
+        output << "    bool " << visit.name << "(" << visit.argument << " arg)\n";
+        output <<
+"    {\n"
+"        if( ignoreLocation( arg ))\n"
+"            return true;\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            if( plugin.visitFunctions.find( visit ) == plugin.visitFunctions.end())
+                continue;
+            output << "        if( " << plugin.variableName << " != nullptr ";
+            output << ")\n";
+            output << "        {\n";
+            output << "            if( !" << plugin.variableName << "->" << visit.name << "( arg ))\n";
+            // This will disable the plugin for the rest of the run (as would returning false
+            // from Visit* normally do in the non-shared case).
+            output << "                " << plugin.variableName << " = nullptr;\n";
+            output << "        }\n";
+        }
+        output <<
+"        return anyPluginActive();\n"
+"    }\n";
+    }
+
+    std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions;
+    for( const PluginInfo& plugin : plugins[ type ] )
+        for( const TraverseFunctionInfo& traverse : plugin.traverseFunctions )
+            traverseFunctions.insert( traverse );
+    for( const TraverseFunctionInfo& traverse : traverseFunctions )
+    {
+        output << "    bool " << traverse.name << "(" << traverse.argument << " arg)\n";
+        output << "    {\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            auto pluginTraverse = plugin.traverseFunctions.find( traverse );
+            if( pluginTraverse == plugin.traverseFunctions.end())
+                continue;
+            output << "        " << plugin.className << "* save" << plugin.className << " = " << plugin.variableName << ";\n";
+            if( pluginTraverse->hasPre )
+            {
+                output << "        if( " << plugin.variableName << " != nullptr ";
+                output << ")\n";
+                output << "        {\n";
+                output << "            if( !" << plugin.variableName << "->Pre" << traverse.name << "( arg ))\n";
+                // This will disable the plugin for the time of the traverse, until restored later,
+                // just like directly returning from Traverse* would skip that part.
+                output << "            {\n";
+                output << "                " << plugin.variableName << " = nullptr;\n";
+                output << "                ++activeRefCount;\n";
+                output << "            }\n";
+                output << "        }\n";
+            }
+        }
+        output << "        bool ret = RecursiveASTVisitor::" << traverse.name << "( arg );\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            auto pluginTraverse = plugin.traverseFunctions.find( traverse );
+            if( pluginTraverse == plugin.traverseFunctions.end())
+                continue;
+            if( pluginTraverse->hasPost )
+            {
+                output << "        if( " << plugin.variableName << " != nullptr ";
+                output << ")\n";
+                output << "        {\n";
+                output << "            if( !" << plugin.variableName << "->Post" << traverse.name << "( arg, ret ))\n";
+                // This will disable the plugin for the rest of the run.
+                output << "                save" << plugin.className << " = nullptr;\n";
+                output << "        }\n";
+            }
+            output << "        if( " << plugin.variableName << " == nullptr && save" << plugin.className << " != nullptr )\n";
+            output << "            --activeRefCount;\n";
+            output << "        " << plugin.variableName << " = save" << plugin.className << ";\n";
+        }
+        output << "        if( false ) // silence -Wunused-function warnings\n";
+        output << "        {\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            auto pluginTraverse = plugin.traverseFunctions.find( traverse );
+            if( pluginTraverse == plugin.traverseFunctions.end())
+                continue;
+            output << "            " << plugin.variableName << "->" << pluginTraverse->name << "( arg );\n";
+        }
+        output << "        }\n";
+        output << "        return ret;\n";
+        output << "    }\n";
+    }
+
+    output <<
+"private:\n";
+
+    output <<
+"    bool anyPluginActive() const\n"
+"    {\n"
+"        return activeRefCount > 0";
+    for( const PluginInfo& plugin : plugins[ type ] )
+        output << "\n            || " << plugin.variableName << " != nullptr";
+    output << ";\n";
+    output << "    }\n";
+
+    for( const PluginInfo& plugin : plugins[ type ] )
+        output << "    " << plugin.className << "* " << plugin.variableName << ";\n";
+    output << "    int activeRefCount;\n";
+
+    output <<
+"};\n"
+"\n"
+"loplugin::Plugin::Registration< SharedRecursiveASTVisitor" << pluginTypeNames[ type ]
+    << " > registration" << pluginTypeNames[ type ] << "(\"sharedvisitor" << pluginTypeNames[ type ] << "\");\n"
+"\n";
+}
+
+static std::string getValue( const std::string& line, const char* tag )
+{
+    size_t taglen = strlen( tag );
+    if( line.size() < taglen + 2 )
+        return std::string();
+    if( line.compare( 0, taglen, tag ) != 0 )
+        return std::string();
+    if( line[ taglen ] != ':' )
+        return std::string();
+    return line.substr( taglen + 1 );
+}
+
+static bool readFile( const std::string& fileName )
+{
+    std::ifstream file( fileName );
+    if( !file )
+    {
+        std::cerr << "Cannot open file " << fileName << std::endl;
+        return false;
+    }
+    PluginInfo pluginInfo;
+    std::string line;
+    do
+    {
+        getline( file, line );
+    } while( !line.empty() && line[ 0 ] == '#' );
+    std::string version = getValue( line, "InfoVersion" );
+    if( version != "1" )
+    {
+        std::cerr << "Incorrect version '" << version << "' in " << fileName << std::endl;
+        return false;
+    }
+    getline( file, line );
+    pluginInfo.className = getValue( line, "ClassName" );
+    pluginInfo.variableName = pluginInfo.className;
+    assert( pluginInfo.variableName.size() > 0 );
+    pluginInfo.variableName[ 0 ] = tolower( pluginInfo.variableName[ 0 ] );
+    pluginInfo.lowercaseName = pluginInfo.className;
+    for( char& c : pluginInfo.lowercaseName )
+        c = tolower( c );
+    pluginInfo.shouldVisitTemplateInstantiations = false;
+    pluginInfo.shouldVisitImplicitCode = false;
+    bool endOk = false;
+    for(;;)
+    {
+        std::string line;
+        getline( file, line );
+        if( file.eof() || !file )
+        {
+            std::cerr << "Unexpected end of file" << std::endl;
+            return false;
+        }
+        if( line.empty())
+            continue;
+        if( line == "InfoEnd" )
+        {
+            endOk = true;
+            break;
+        }
+        else if( line == "VisitFunctionStart" )
+        {
+            VisitFunctionInfo visitInfo;
+            getline( file, line );
+            visitInfo.name = getValue( line, "VisitFunctionName" );
+            getline( file, line );
+            visitInfo.argument = getValue( line, "VisitFunctionArgument" );
+            getline( file, line );
+            if( line != "VisitFunctionEnd" )
+            {
+                std::cerr << "Missing VisitFunctionEnd" << std::endl;
+                return false;
+            }
+            pluginInfo.visitFunctions.insert( std::move( visitInfo ));
+        }
+        else if( line == "TraverseFunctionStart" )
+        {
+            TraverseFunctionInfo traverseInfo;
+            getline( file, line );
+            traverseInfo.name = getValue( line, "TraverseFunctionName" );
+            getline( file, line );
+            traverseInfo.argument = getValue( line, "TraverseFunctionArgument" );
+            getline( file, line );
+            traverseInfo.hasPre = getValue( line, "TraverseFunctionHasPre" ) == "1";
+            getline( file, line );
+            traverseInfo.hasPost = getValue( line, "TraverseFunctionHasPost" ) == "1";
+            getline( file, line );
+            if( line != "TraverseFunctionEnd" )
+            {
+                std::cerr << "Missing TraverseFunctionEnd" << std::endl;
+                return false;
+            }
+            pluginInfo.traverseFunctions.insert( std::move( traverseInfo ));
+        }
+        else
+        {
+            std::string value;
+            value = getValue( line, "ShouldVisitTemplateInstantiations" );
+            if( value == "1" )
+                pluginInfo.shouldVisitTemplateInstantiations = true;
+            else
+            {
+                value = getValue( line, "ShouldVisitImplicitCode" );
+                if( value == "1" )
+                    pluginInfo.shouldVisitImplicitCode = true;
+                else
+                {
+                    std::cerr << "Unknown line " << line << std::endl;
+                    return false;
+                }
+            }
+        }
+    }
+
+    assert( endOk );
+    (void)endOk;
+
+    if( pluginInfo.shouldVisitTemplateInstantiations && pluginInfo.shouldVisitImplicitCode )
+        plugins[ PluginVisitTemplatesImplicit ].push_back( std::move( pluginInfo ));
+    else if( pluginInfo.shouldVisitTemplateInstantiations )
+        plugins[ PluginVisitTemplates ].push_back( std::move( pluginInfo ));
+    else if( pluginInfo.shouldVisitImplicitCode )
+        plugins[ PluginVisitImplicit ].push_back( std::move( pluginInfo ));
+    else
+        plugins[ PluginBasic ].push_back( std::move( pluginInfo ));
+
+    return true;
+}
+
+int main(int argc, char** argv)
+{
+    for( int i = 1 ; i < argc; ++i )
+    {
+        if( !readFile( argv[ i ] ))
+        {
+            std::cerr << "Error reading " << argv[ i ] << std::endl;
+            return 1;
+        }
+    }
+    for( int type = Plugin_Begin; type < Plugin_End; ++type )
+    {
+        sort( plugins[ static_cast< PluginType >( type ) ].begin(), plugins[ static_cast< PluginType >( type ) ].end(),
+            []( const PluginInfo& l, const PluginInfo& r ) { return l.className < r.className; } );
+    }
+    generate();
+    return 0;
+}
diff --git a/compilerplugins/clang/sharedvisitor/precompiled_clang.hxx b/compilerplugins/clang/sharedvisitor/precompiled_clang.hxx
new file mode 100644
index 000000000..3baf4b04f
--- /dev/null
+++ b/compilerplugins/clang/sharedvisitor/precompiled_clang.hxx
@@ -0,0 +1,12 @@
+/* -*- 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/.
+ */
+
+// Used by the analyzer to speed up processing plugin sources.
+
+#include "../plugin.hxx"