[NewPM][Unit] Outline pass handles into a support header for the tests

[philip.pfaffe]

Summary

There are two testcases currently that unittest pass manager features by
mocking out analyses and passes on various IRUnits. To simplify things for
these and future tests, outline the mocks into a support header.

include/llvm/Testing/IR/Passes.h

+#ifndef LLVM_TESTING_IR_PASSES_H
+#define LLVM_TESTING_IR_PASSES_H
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+// Workaround for the gcc 7.1 bug PR80916.
+#if defined(__GNUC__) && __GNUC__ > 6
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#if defined(__GNUC__) && __GNUC__ > 6
+#pragma GCC diagnostic pop
+#endif
+
+namespace llvm {
+using ::testing::Return;
+using ::testing::Invoke;
+using ::testing::_;
+
+/// \brief A CRTP base for analysis mock handles
+///
+/// This class reconciles mocking with the value semantics implementation of
+/// the
+/// AnalysisManager. Analysis mock handles should derive from this class and
+/// call \c setDefault() in their constroctur for wiring up the defaults
+/// defined
+/// by this base with their mock run() and invalidate() implementations.
+template <typename DerivedT, typename IRUnitT,
+          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
+          typename... ExtraArgTs>
+class MockAnalysisHandleBase {
+public:
+  class Analysis : public AnalysisInfoMixin<Analysis> {
+    friend AnalysisInfoMixin<Analysis>;
+    friend MockAnalysisHandleBase;
+    static AnalysisKey Key;
+
+    DerivedT *Handle;
+
+    Analysis(DerivedT &Handle) : Handle(&Handle) {
+      static_assert(std::is_base_of<MockAnalysisHandleBase, DerivedT>::value,
+                    "Must pass the derived type to this template!");
+    }
+
+  public:
+    class Result {
+      friend MockAnalysisHandleBase;
+
+      DerivedT *Handle;
+
+      Result(DerivedT &Handle) : Handle(&Handle) {}
+
+    public:
+      // Forward invalidation events to the mock handle.
+      bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
+                      typename AnalysisManagerT::Invalidator &Inv) {
+        return Handle->invalidate(IR, PA, Inv);
+      }
+    };
+
+    Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
+      return Handle->run(IR, AM, ExtraArgs...);
+    }
+  };
+
+  Analysis getAnalysis() { return Analysis(static_cast<DerivedT &>(*this)); }
+  typename Analysis::Result getResult() {
+    return typename Analysis::Result(static_cast<DerivedT &>(*this));
+  }
+
+protected:
+  // FIXME: MSVC seems unable to handle a lambda argument to Invoke from within
+  // the template, so we use a boring static function.
+  static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
+                                 typename AnalysisManagerT::Invalidator &Inv) {
+    auto PAC = PA.template getChecker<Analysis>();
+    return !PAC.preserved() &&
+           !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
+  }
+
+  /// Derived classes should call this in their constructor to set up default
+  /// mock actions. (We can't do this in our constructor because this has to
+  /// run after the DerivedT is constructed.)
+  void setDefaults() {
+    ON_CALL(static_cast<DerivedT &>(*this),
+            run(_, _, testing::Matcher<ExtraArgTs>(_)...))
+        .WillByDefault(Return(this->getResult()));
+    ON_CALL(static_cast<DerivedT &>(*this), invalidate(_, _, _))
+        .WillByDefault(Invoke(&invalidateCallback));
+  }
+};
+
+/// \brief A CRTP base for pass mock handles
+///
+/// This class reconciles mocking with the value semantics implementation of the
+/// PassManager. Pass mock handles should derive from this class and
+/// call \c setDefault() in their constroctur for wiring up the defaults defined
+/// by this base with their mock run() and invalidate() implementations.
+template <typename DerivedT, typename IRUnitT, typename AnalysisManagerT,
+          typename... ExtraArgTs>
+AnalysisKey MockAnalysisHandleBase<DerivedT, IRUnitT, AnalysisManagerT,
+                                   ExtraArgTs...>::Analysis::Key;
+
+template <typename DerivedT, typename IRUnitT,
+          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
+          typename... ExtraArgTs>
+class MockPassHandleBase {
+public:
+  class Pass : public PassInfoMixin<Pass> {
+    friend MockPassHandleBase;
+
+    DerivedT *Handle;
+
+    Pass(DerivedT &Handle) : Handle(&Handle) {
+      static_assert(std::is_base_of<MockPassHandleBase, DerivedT>::value,
+                    "Must pass the derived type to this template!");
+    }
+
+  public:
+    PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
+                          ExtraArgTs... ExtraArgs) {
+      return Handle->run(IR, AM, ExtraArgs...);
+    }
+  };
+
+  Pass getPass() { return Pass(static_cast<DerivedT &>(*this)); }
+
+protected:
+  /// Derived classes should call this in their constructor to set up default
+  /// mock actions. (We can't do this in our constructor because this has to
+  /// run after the DerivedT is constructed.)
+  void setDefaults() {
+    ON_CALL(static_cast<DerivedT &>(*this),
+            run(_, _, testing::Matcher<ExtraArgTs>(_)...))
+        .WillByDefault(Return(PreservedAnalyses::all()));
+  }
+};
+
+/// Mock handles for passes for the IRUnits Module, CGSCC, Function, Loop.
+/// These handles define the appropriate run() mock interface for the respective
+/// IRUnit type.
+template <typename IRUnitT> struct MockPassHandle;
+template <>
+struct MockPassHandle<Loop>
+    : MockPassHandleBase<MockPassHandle<Loop>, Loop, LoopAnalysisManager,
+                         LoopStandardAnalysisResults &, LPMUpdater &> {
+  MOCK_METHOD4(run,
+               PreservedAnalyses(Loop &, LoopAnalysisManager &,
+                                 LoopStandardAnalysisResults &, LPMUpdater &));
+  MockPassHandle() { setDefaults(); }
+};
+
+template <>
+struct MockPassHandle<Function>
+    : MockPassHandleBase<MockPassHandle<Function>, Function> {
+  MOCK_METHOD2(run, PreservedAnalyses(Function &, FunctionAnalysisManager &));
+
+  MockPassHandle() { setDefaults(); }
+};
+
+template <>
+struct MockPassHandle<LazyCallGraph::SCC>
+    : MockPassHandleBase<MockPassHandle<LazyCallGraph::SCC>, LazyCallGraph::SCC,
+                         CGSCCAnalysisManager, LazyCallGraph &,
+                         CGSCCUpdateResult &> {
+  MOCK_METHOD4(run,
+               PreservedAnalyses(LazyCallGraph::SCC &, CGSCCAnalysisManager &,
+                                 LazyCallGraph &G, CGSCCUpdateResult &UR));
+
+  MockPassHandle() { setDefaults(); }
+};
+
+template <>
+struct MockPassHandle<Module>
+    : MockPassHandleBase<MockPassHandle<Module>, Module> {
+  MOCK_METHOD2(run, PreservedAnalyses(Module &, ModuleAnalysisManager &));
+
+  MockPassHandle() { setDefaults(); }
+};
+
+/// Mock handles for analyses for the IRUnits Module, CGSCC, Function, Loop.
+/// These handles define the appropriate run() and invalidate() mock interfaces
+/// for the respective IRUnit type.
+template <typename IRUnitT> struct MockAnalysisHandle;
+template <>
+struct MockAnalysisHandle<Loop>
+    : MockAnalysisHandleBase<MockAnalysisHandle<Loop>, Loop,
+                             LoopAnalysisManager,
+                             LoopStandardAnalysisResults &> {
+
+  MOCK_METHOD3_T(run, typename Analysis::Result(Loop &, LoopAnalysisManager &,
+                                                LoopStandardAnalysisResults &));
+
+  MOCK_METHOD3_T(invalidate, bool(Loop &, const PreservedAnalyses &,
+                                  LoopAnalysisManager::Invalidator &));
+
+  MockAnalysisHandle<Loop>() { this->setDefaults(); }
+};
+
+template <>
+struct MockAnalysisHandle<Function>
+    : MockAnalysisHandleBase<MockAnalysisHandle<Function>, Function> {
+  MOCK_METHOD2(run, Analysis::Result(Function &, FunctionAnalysisManager &));
+
+  MOCK_METHOD3(invalidate, bool(Function &, const PreservedAnalyses &,
+                                FunctionAnalysisManager::Invalidator &));
+
+  MockAnalysisHandle<Function>() { setDefaults(); }
+};
+
+template <>
+struct MockAnalysisHandle<LazyCallGraph::SCC>
+    : MockAnalysisHandleBase<MockAnalysisHandle<LazyCallGraph::SCC>,
+                             LazyCallGraph::SCC, CGSCCAnalysisManager,
+                             LazyCallGraph &> {
+  MOCK_METHOD3(run, Analysis::Result(LazyCallGraph::SCC &,
+                                     CGSCCAnalysisManager &, LazyCallGraph &));
+
+  MOCK_METHOD3(invalidate, bool(LazyCallGraph::SCC &, const PreservedAnalyses &,
+                                CGSCCAnalysisManager::Invalidator &));
+
+  MockAnalysisHandle<LazyCallGraph::SCC>() { setDefaults(); }
+};
+
+template <>
+struct MockAnalysisHandle<Module>
+    : MockAnalysisHandleBase<MockAnalysisHandle<Module>, Module> {
+  MOCK_METHOD2(run, Analysis::Result(Module &, ModuleAnalysisManager &));
+
+  MOCK_METHOD3(invalidate, bool(Module &, const PreservedAnalyses &,
+                                ModuleAnalysisManager::Invalidator &));
+
+  MockAnalysisHandle<Module>() { setDefaults(); }
+};
+}
+#endif /* LLVM_TESTING_IR_PASSES_H */

unittests/IR/PassBuilderCallbacksTest.cpp

 #include <gtest/gtest.h>
 #include <llvm/Analysis/CGSCCPassManager.h>
 #include <llvm/Analysis/LoopAnalysisManager.h>
 #include <llvm/AsmParser/Parser.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/PassManager.h>
 #include <llvm/Passes/PassBuilder.h>
 #include <llvm/Support/SourceMgr.h>
+#include <llvm/Testing/IR/Passes.h>
 #include <llvm/Transforms/Scalar/LoopPassManager.h>
 
 using namespace llvm;
 
 namespace llvm {
 /// Provide an ostream operator for StringRef.
 ///
 /// For convenience we provide a custom matcher below for IRUnit's and analysis
 /// result's getName functions, which most of the time returns a StringRef. The
 /// matcher makes use of this operator.
 static std::ostream &operator<<(std::ostream &O, StringRef S) {
   return O << S.str();
 }
 }
 
 namespace {
 using testing::DoDefault;
 using testing::Return;
 using testing::Expectation;
 using testing::Invoke;
 using testing::WithArgs;
 using testing::_;
 
-/// \brief A CRTP base for analysis mock handles
-///
-/// This class reconciles mocking with the value semantics implementation of the
-/// AnalysisManager. Analysis mock handles should derive from this class and
-/// call \c setDefault() in their constroctur for wiring up the defaults defined
-/// by this base with their mock run() and invalidate() implementations.
-template <typename DerivedT, typename IRUnitT,
-          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
-          typename... ExtraArgTs>
-class MockAnalysisHandleBase {
-public:
-  class Analysis : public AnalysisInfoMixin<Analysis> {
-    friend AnalysisInfoMixin<Analysis>;
-    friend MockAnalysisHandleBase;
-    static AnalysisKey Key;
-
-    DerivedT *Handle;
-
-    Analysis(DerivedT &Handle) : Handle(&Handle) {
-      static_assert(std::is_base_of<MockAnalysisHandleBase, DerivedT>::value,
-                    "Must pass the derived type to this template!");
-    }
-
-  public:
-    class Result {
-      friend MockAnalysisHandleBase;
-
-      DerivedT *Handle;
-
-      Result(DerivedT &Handle) : Handle(&Handle) {}
-
-    public:
-      // Forward invalidation events to the mock handle.
-      bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
-                      typename AnalysisManagerT::Invalidator &Inv) {
-        return Handle->invalidate(IR, PA, Inv);
-      }
-    };
-
-    Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
-      return Handle->run(IR, AM, ExtraArgs...);
-    }
-  };
-
-  Analysis getAnalysis() { return Analysis(static_cast<DerivedT &>(*this)); }
-  typename Analysis::Result getResult() {
-    return typename Analysis::Result(static_cast<DerivedT &>(*this));
-  }
-
-protected:
-  // FIXME: MSVC seems unable to handle a lambda argument to Invoke from within
-  // the template, so we use a boring static function.
-  static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
-                                 typename AnalysisManagerT::Invalidator &Inv) {
-    auto PAC = PA.template getChecker<Analysis>();
-    return !PAC.preserved() &&
-           !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
-  }
-
-  /// Derived classes should call this in their constructor to set up default
-  /// mock actions. (We can't do this in our constructor because this has to
-  /// run after the DerivedT is constructed.)
-  void setDefaults() {
-    ON_CALL(static_cast<DerivedT &>(*this),
-            run(_, _, testing::Matcher<ExtraArgTs>(_)...))
-        .WillByDefault(Return(this->getResult()));
-    ON_CALL(static_cast<DerivedT &>(*this), invalidate(_, _, _))
-        .WillByDefault(Invoke(&invalidateCallback));
-  }
-};
-
-/// \brief A CRTP base for pass mock handles
-///
-/// This class reconciles mocking with the value semantics implementation of the
-/// PassManager. Pass mock handles should derive from this class and
-/// call \c setDefault() in their constroctur for wiring up the defaults defined
-/// by this base with their mock run() and invalidate() implementations.
-template <typename DerivedT, typename IRUnitT, typename AnalysisManagerT,
-          typename... ExtraArgTs>
-AnalysisKey MockAnalysisHandleBase<DerivedT, IRUnitT, AnalysisManagerT,
-                                   ExtraArgTs...>::Analysis::Key;
-
-template <typename DerivedT, typename IRUnitT,
-          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
-          typename... ExtraArgTs>
-class MockPassHandleBase {
-public:
-  class Pass : public PassInfoMixin<Pass> {
-    friend MockPassHandleBase;
-
-    DerivedT *Handle;
-
-    Pass(DerivedT &Handle) : Handle(&Handle) {
-      static_assert(std::is_base_of<MockPassHandleBase, DerivedT>::value,
-                    "Must pass the derived type to this template!");
-    }
-
-  public:
-    PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
-                          ExtraArgTs... ExtraArgs) {
-      return Handle->run(IR, AM, ExtraArgs...);
-    }
-  };
-
-  Pass getPass() { return Pass(static_cast<DerivedT &>(*this)); }
-
-protected:
-  /// Derived classes should call this in their constructor to set up default
-  /// mock actions. (We can't do this in our constructor because this has to
-  /// run after the DerivedT is constructed.)
-  void setDefaults() {
-    ON_CALL(static_cast<DerivedT &>(*this),
-            run(_, _, testing::Matcher<ExtraArgTs>(_)...))
-        .WillByDefault(Return(PreservedAnalyses::all()));
-  }
-};
-
-/// Mock handles for passes for the IRUnits Module, CGSCC, Function, Loop.
-/// These handles define the appropriate run() mock interface for the respective
-/// IRUnit type.
-template <typename IRUnitT> struct MockPassHandle;
-template <>
-struct MockPassHandle<Loop>
-    : MockPassHandleBase<MockPassHandle<Loop>, Loop, LoopAnalysisManager,
-                         LoopStandardAnalysisResults &, LPMUpdater &> {
-  MOCK_METHOD4(run,
-               PreservedAnalyses(Loop &, LoopAnalysisManager &,
-                                 LoopStandardAnalysisResults &, LPMUpdater &));
-  MockPassHandle() { setDefaults(); }
-};
-
-template <>
-struct MockPassHandle<Function>
-    : MockPassHandleBase<MockPassHandle<Function>, Function> {
-  MOCK_METHOD2(run, PreservedAnalyses(Function &, FunctionAnalysisManager &));
-
-  MockPassHandle() { setDefaults(); }
-};
-
-template <>
-struct MockPassHandle<LazyCallGraph::SCC>
-    : MockPassHandleBase<MockPassHandle<LazyCallGraph::SCC>, LazyCallGraph::SCC,
-                         CGSCCAnalysisManager, LazyCallGraph &,
-                         CGSCCUpdateResult &> {
-  MOCK_METHOD4(run,
-               PreservedAnalyses(LazyCallGraph::SCC &, CGSCCAnalysisManager &,
-                                 LazyCallGraph &G, CGSCCUpdateResult &UR));
-
-  MockPassHandle() { setDefaults(); }
-};
-
-template <>
-struct MockPassHandle<Module>
-    : MockPassHandleBase<MockPassHandle<Module>, Module> {
-  MOCK_METHOD2(run, PreservedAnalyses(Module &, ModuleAnalysisManager &));
-
-  MockPassHandle() { setDefaults(); }
-};
-
-/// Mock handles for analyses for the IRUnits Module, CGSCC, Function, Loop.
-/// These handles define the appropriate run() and invalidate() mock interfaces
-/// for the respective IRUnit type.
-template <typename IRUnitT> struct MockAnalysisHandle;
-template <>
-struct MockAnalysisHandle<Loop>
-    : MockAnalysisHandleBase<MockAnalysisHandle<Loop>, Loop,
-                             LoopAnalysisManager,
-                             LoopStandardAnalysisResults &> {
-
-  MOCK_METHOD3_T(run, typename Analysis::Result(Loop &, LoopAnalysisManager &,
-                                                LoopStandardAnalysisResults &));
-
-  MOCK_METHOD3_T(invalidate, bool(Loop &, const PreservedAnalyses &,
-                                  LoopAnalysisManager::Invalidator &));
-
-  MockAnalysisHandle<Loop>() { this->setDefaults(); }
-};
-
-template <>
-struct MockAnalysisHandle<Function>
-    : MockAnalysisHandleBase<MockAnalysisHandle<Function>, Function> {
-  MOCK_METHOD2(run, Analysis::Result(Function &, FunctionAnalysisManager &));
-
-  MOCK_METHOD3(invalidate, bool(Function &, const PreservedAnalyses &,
-                                FunctionAnalysisManager::Invalidator &));
-
-  MockAnalysisHandle<Function>() { setDefaults(); }
-};
-
-template <>
-struct MockAnalysisHandle<LazyCallGraph::SCC>
-    : MockAnalysisHandleBase<MockAnalysisHandle<LazyCallGraph::SCC>,
-                             LazyCallGraph::SCC, CGSCCAnalysisManager,
-                             LazyCallGraph &> {
-  MOCK_METHOD3(run, Analysis::Result(LazyCallGraph::SCC &,
-                                     CGSCCAnalysisManager &, LazyCallGraph &));
-
-  MOCK_METHOD3(invalidate, bool(LazyCallGraph::SCC &, const PreservedAnalyses &,
-                                CGSCCAnalysisManager::Invalidator &));
-
-  MockAnalysisHandle<LazyCallGraph::SCC>() { setDefaults(); }
-};
-
-template <>
-struct MockAnalysisHandle<Module>
-    : MockAnalysisHandleBase<MockAnalysisHandle<Module>, Module> {
-  MOCK_METHOD2(run, Analysis::Result(Module &, ModuleAnalysisManager &));
-
-  MOCK_METHOD3(invalidate, bool(Module &, const PreservedAnalyses &,
-                                ModuleAnalysisManager::Invalidator &));
-
-  MockAnalysisHandle<Module>() { setDefaults(); }
-};
-
 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
   SMDiagnostic Err;
   return parseAssemblyString(IR, Err, C);
 }
 
 template <typename PassManagerT> class PassBuilderCallbacksTest;
 
 /// This test fixture is shared between all the actual tests below and

unittests/Transforms/Scalar/LoopPassManagerTest.cpp

 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Testing/IR/Passes.h"
 
 // Workaround for the gcc 7.1 bug PR80916.
 #if defined(__GNUC__) && __GNUC__ > 6
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wunused-function"
 #endif
 
 #include "gmock/gmock.h"

 
 using testing::DoDefault;
 using testing::Return;
 using testing::Expectation;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::_;
 
-template <typename DerivedT, typename IRUnitT,
-          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
-          typename... ExtraArgTs>
-class MockAnalysisHandleBase {
-public:
-  class Analysis : public AnalysisInfoMixin<Analysis> {
-    friend AnalysisInfoMixin<Analysis>;
-    friend MockAnalysisHandleBase;
-    static AnalysisKey Key;
-
-    DerivedT *Handle;
-
-    Analysis(DerivedT &Handle) : Handle(&Handle) {
-      static_assert(std::is_base_of<MockAnalysisHandleBase, DerivedT>::value,
-                    "Must pass the derived type to this template!");
-    }
-
-  public:
-    class Result {
-      friend MockAnalysisHandleBase;
-
-      DerivedT *Handle;
-
-      Result(DerivedT &Handle) : Handle(&Handle) {}
-
-    public:
-      // Forward invalidation events to the mock handle.
-      bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
-                      typename AnalysisManagerT::Invalidator &Inv) {
-        return Handle->invalidate(IR, PA, Inv);
-      }
-    };
-
-    Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
-      return Handle->run(IR, AM, ExtraArgs...);
-    }
-  };
-
-  Analysis getAnalysis() { return Analysis(static_cast<DerivedT &>(*this)); }
-  typename Analysis::Result getResult() {
-    return typename Analysis::Result(static_cast<DerivedT &>(*this));
-  }
-
-protected:
-  // FIXME: MSVC seems unable to handle a lambda argument to Invoke from within
-  // the template, so we use a boring static function.
-  static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
-                                 typename AnalysisManagerT::Invalidator &Inv) {
-    auto PAC = PA.template getChecker<Analysis>();
-    return !PAC.preserved() &&
-           !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
-  }
-
-  /// Derived classes should call this in their constructor to set up default
-  /// mock actions. (We can't do this in our constructor because this has to
-  /// run after the DerivedT is constructed.)
-  void setDefaults() {
-    ON_CALL(static_cast<DerivedT &>(*this),
-            run(_, _, testing::Matcher<ExtraArgTs>(_)...))
-        .WillByDefault(Return(this->getResult()));
-    ON_CALL(static_cast<DerivedT &>(*this), invalidate(_, _, _))
-        .WillByDefault(Invoke(&invalidateCallback));
-  }
-};
-
-template <typename DerivedT, typename IRUnitT, typename AnalysisManagerT,
-          typename... ExtraArgTs>
-AnalysisKey MockAnalysisHandleBase<DerivedT, IRUnitT, AnalysisManagerT,
-                                   ExtraArgTs...>::Analysis::Key;
-
 /// Mock handle for loop analyses.
 ///
 /// This is provided as a template accepting an (optional) integer. Because
 /// analyses are identified and queried by type, this allows constructing
 /// multiple handles with distinctly typed nested 'Analysis' types that can be
 /// registered and queried. If you want to register multiple loop analysis
 /// passes, you'll need to instantiate this type with different values for I.
 /// For example:
struct MockLoopAnalysisHandleTemplate
 
   MOCK_METHOD3_T(invalidate, bool(Loop &, const PreservedAnalyses &,
                                   LoopAnalysisManager::Invalidator &));
 
   MockLoopAnalysisHandleTemplate() { this->setDefaults(); }
 };
 
 typedef MockLoopAnalysisHandleTemplate<> MockLoopAnalysisHandle;
+typedef MockAnalysisHandle<Function> MockFunctionAnalysisHandle;
 
-struct MockFunctionAnalysisHandle
-    : MockAnalysisHandleBase<MockFunctionAnalysisHandle, Function> {
-  MOCK_METHOD2(run, Analysis::Result(Function &, FunctionAnalysisManager &));
-
-  MOCK_METHOD3(invalidate, bool(Function &, const PreservedAnalyses &,
-                                FunctionAnalysisManager::Invalidator &));
-
-  MockFunctionAnalysisHandle() { setDefaults(); }
-};
-
-template <typename DerivedT, typename IRUnitT,
-          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
-          typename... ExtraArgTs>
-class MockPassHandleBase {
-public:
-  class Pass : public PassInfoMixin<Pass> {
-    friend MockPassHandleBase;
-
-    DerivedT *Handle;
-
-    Pass(DerivedT &Handle) : Handle(&Handle) {
-      static_assert(std::is_base_of<MockPassHandleBase, DerivedT>::value,
-                    "Must pass the derived type to this template!");
-    }
-
-  public:
-    PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
-                          ExtraArgTs... ExtraArgs) {
-      return Handle->run(IR, AM, ExtraArgs...);
-    }
-  };
-
-  Pass getPass() { return Pass(static_cast<DerivedT &>(*this)); }
-
-protected:
-  /// Derived classes should call this in their constructor to set up default
-  /// mock actions. (We can't do this in our constructor because this has to
-  /// run after the DerivedT is constructed.)
-  void setDefaults() {
-    ON_CALL(static_cast<DerivedT &>(*this),
-            run(_, _, testing::Matcher<ExtraArgTs>(_)...))
-        .WillByDefault(Return(PreservedAnalyses::all()));
-  }
-};
-
-struct MockLoopPassHandle
-    : MockPassHandleBase<MockLoopPassHandle, Loop, LoopAnalysisManager,
-                         LoopStandardAnalysisResults &, LPMUpdater &> {
-  MOCK_METHOD4(run,
-               PreservedAnalyses(Loop &, LoopAnalysisManager &,
-                                 LoopStandardAnalysisResults &, LPMUpdater &));
-  MockLoopPassHandle() { setDefaults(); }
-};
-
-struct MockFunctionPassHandle
-    : MockPassHandleBase<MockFunctionPassHandle, Function> {
-  MOCK_METHOD2(run, PreservedAnalyses(Function &, FunctionAnalysisManager &));
-
-  MockFunctionPassHandle() { setDefaults(); }
-};
-
-struct MockModulePassHandle : MockPassHandleBase<MockModulePassHandle, Module> {
-  MOCK_METHOD2(run, PreservedAnalyses(Module &, ModuleAnalysisManager &));
-
-  MockModulePassHandle() { setDefaults(); }
-};
+typedef MockPassHandle<Loop> MockLoopPassHandle;
+typedef MockPassHandle<Function> MockFunctionPassHandle;
+typedef MockPassHandle<Module> MockModulePassHandle;
 
 /// Define a custom matcher for objects which support a 'getName' method
 /// returning a StringRef.
 ///
 /// LLVM often has IR objects or analysis objects which expose a StringRef name
 /// and in tests it is convenient to match these by name for readability. This
 /// matcher supports any type exposing a getName() method of this form.
 ///