[clang][dataflow] Allow MatchSwitch to return a value

[samestep]

Summary

Reland of D128467. This version replaces return {}; with return Result();, since the former failed on GCC with Result = void.

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

template <typename LatticeT> struct TransferState {
 
   /// Current lattice element.
   LatticeT &Lattice;
   Environment &Env;
 };
 
 /// Matches against `Stmt` and, based on its structure, dispatches to an
 /// appropriate handler.
-template <typename State>
-using MatchSwitch = std::function<void(const Stmt &, ASTContext &, State &)>;
+template <typename State, typename Result = void>
+using MatchSwitch = std::function<Result(const Stmt &, ASTContext &, State &)>;
 
 /// Collects cases of a "match switch": a collection of matchers paired with
 /// callbacks, which together define a switch that can be applied to a
 /// `Stmt`. This structure can simplify the definition of `transfer` functions
 /// that rely on pattern-matching.
 ///
 /// For example, consider an analysis that handles particular function calls. It
 /// can define the `MatchSwitch` once, in the constructor of the analysis, and
 /// then reuse it each time that `transfer` is called, with a fresh state value.
 ///
 /// \code
 /// MatchSwitch<TransferState<MyLattice> BuildSwitch() {
 ///   return MatchSwitchBuilder<TransferState<MyLattice>>()
 ///     .CaseOf(callExpr(callee(functionDecl(hasName("foo")))), TransferFooCall)
 ///     .CaseOf(callExpr(argumentCountIs(2),
 ///                      callee(functionDecl(hasName("bar")))),
 ///             TransferBarCall)
 ///     .Build();
 /// }
 /// \endcode
-template <typename State> class MatchSwitchBuilder {
+template <typename State, typename Result = void> class MatchSwitchBuilder {
 public:
   /// Registers an action that will be triggered by the match of a pattern
   /// against the input statement.
   ///
   /// Requirements:
   ///
   ///  `Node` should be a subclass of `Stmt`.
   template <typename Node>
   MatchSwitchBuilder &&
   CaseOf(ast_matchers::internal::Matcher<Stmt> M,
-         std::function<void(const Node *,
+         std::function<Result(const Node *,
                               const ast_matchers::MatchFinder::MatchResult &,
                               State &)>
              A) && {
     Matchers.push_back(std::move(M));
     Actions.push_back(
         [A = std::move(A)](const Stmt *Stmt,
                            const ast_matchers::MatchFinder::MatchResult &R,
-                           State &S) { A(cast<Node>(Stmt), R, S); });
+                           State &S) { return A(cast<Node>(Stmt), R, S); });
     return std::move(*this);
   }
 
-  MatchSwitch<State> Build() && {
+  MatchSwitch<State, Result> Build() && {
     return [Matcher = BuildMatcher(), Actions = std::move(Actions)](
-               const Stmt &Stmt, ASTContext &Context, State &S) {
+               const Stmt &Stmt, ASTContext &Context, State &S) -> Result {
       auto Results = ast_matchers::matchDynamic(Matcher, Stmt, Context);
       if (Results.empty())
-        return;
+        return Result();
       // Look through the map for the first binding of the form "TagN..." use
       // that to select the action.
       for (const auto &Element : Results[0].getMap()) {
         llvm::StringRef ID(Element.first);
         size_t Index = 0;
         if (ID.consume_front("Tag") && !ID.getAsInteger(10, Index) &&
             Index < Actions.size()) {
-          Actions[Index](
+          return Actions[Index](
               &Stmt,
               ast_matchers::MatchFinder::MatchResult(Results[0], &Context), S);
-          return;
         }
       }
+      return Result();
     };
   }
 
 private:
   ast_matchers::internal::DynTypedMatcher BuildMatcher() {
     using ast_matchers::anything;
     using ast_matchers::stmt;
     using ast_matchers::unless;
ast_matchers::internal::DynTypedMatcher BuildMatcher() {
     // The matcher type on the cases ensures that `Expr` kind is compatible with
     // all of the matchers.
     return DynTypedMatcher::constructVariadic(
         DynTypedMatcher::VO_AnyOf, ASTNodeKind::getFromNodeKind<Stmt>(),
         std::move(Matchers));
   }
 
   std::vector<ast_matchers::internal::DynTypedMatcher> Matchers;
-  std::vector<std::function<void(
+  std::vector<std::function<Result(
       const Stmt *, const ast_matchers::MatchFinder::MatchResult &, State &)>>
       Actions;
 };
 } // namespace dataflow
 } // namespace clang
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_MATCHSWITCH_H_

clang/unittests/Analysis/FlowSensitive/MatchSwitchTest.cpp

std::string Code = R"(
     void fun(bool b) {
       Bar();
       // [[p]]
     }
   )";
   RunDataflow(Code,
               UnorderedElementsAre(Pair("p", Holds(BooleanLattice(false)))));
 }
+
+TEST_F(MatchSwitchTest, ReturnNonVoid) {
+  using namespace ast_matchers;
+
+  auto Unit =
+      tooling::buildASTFromCode("void f() { int x = 42; }", "input.cc",
+                                std::make_shared<PCHContainerOperations>());
+  auto &Context = Unit->getASTContext();
+  const auto *S =
+      selectFirst<FunctionDecl>(
+          "f",
+          match(functionDecl(isDefinition(), hasName("f")).bind("f"), Context))
+          ->getBody();
+
+  MatchSwitch<const int, std::vector<int>> Switch =
+      MatchSwitchBuilder<const int, std::vector<int>>()
+          .CaseOf<Stmt>(stmt(),
+                        [](const Stmt *, const MatchFinder::MatchResult &,
+                           const int &State) -> std::vector<int> {
+                          return {1, State, 3};
+                        })
+          .Build();
+  std::vector<int> Actual = Switch(*S, Context, 7);
+  std::vector<int> Expected{1, 7, 3};
+  EXPECT_EQ(Actual, Expected);
+}