Reverting r243386 because it has serious post-commit concerns that have not been...

[oota-llvm.git] / include / llvm / ADT / VariadicFunction.h

diff --git a/include/llvm/ADT/VariadicFunction.h b/include/llvm/ADT/VariadicFunction.h
index 08c9697ffc164820a9a3125d31e9d18243f856b6..403130c623ebada3c807bad9367509d617825ae6 100644 (file)
--- a/include/llvm/ADT/VariadicFunction.h
+++ b/include/llvm/ADT/VariadicFunction.h
@@ -11,8 +11,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ADT_VARIADIC_FUNCTION_H
-#define LLVM_ADT_VARIADIC_FUNCTION_H
+#ifndef LLVM_ADT_VARIADICFUNCTION_H
+#define LLVM_ADT_VARIADICFUNCTION_H
 
 #include "llvm/ADT/ArrayRef.h"
 
@@ -103,18 +103,15 @@ namespace llvm {
 /// fixed leading arguments and up-to 32 optional arguments.
 template <typename ResultT, typename ArgT,
           ResultT (*Func)(ArrayRef<const ArgT *>)>
-class VariadicFunction {
- public:
-  VariadicFunction() {}
-
+struct VariadicFunction {
   ResultT operator()() const {
-    return Func(ArrayRef<const ArgT *>());
+    return Func(None);
   }
 
 #define LLVM_DEFINE_OVERLOAD(N) \
   ResultT operator()(LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
     const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(Args); \
+    return Func(makeArrayRef(Args)); \
   }
   LLVM_DEFINE_OVERLOAD(1)
   LLVM_DEFINE_OVERLOAD(2)
@@ -153,18 +150,15 @@ class VariadicFunction {
 
 template <typename ResultT, typename Param0T, typename ArgT,
           ResultT (*Func)(Param0T, ArrayRef<const ArgT *>)>
-class VariadicFunction1 {
- public:
-  VariadicFunction1() {}
-
+struct VariadicFunction1 {
   ResultT operator()(Param0T P0) const {
-    return Func(P0, ArrayRef<const ArgT *>());
+    return Func(P0, None);
   }
 
 #define LLVM_DEFINE_OVERLOAD(N) \
   ResultT operator()(Param0T P0, LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
     const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(P0, Args); \
+    return Func(P0, makeArrayRef(Args)); \
   }
   LLVM_DEFINE_OVERLOAD(1)
   LLVM_DEFINE_OVERLOAD(2)
@@ -203,19 +197,16 @@ class VariadicFunction1 {
 
 template <typename ResultT, typename Param0T, typename Param1T, typename ArgT,
           ResultT (*Func)(Param0T, Param1T, ArrayRef<const ArgT *>)>
-class VariadicFunction2 {
- public:
-  VariadicFunction2() {}
-
+struct VariadicFunction2 {
   ResultT operator()(Param0T P0, Param1T P1) const {
-    return Func(P0, P1, ArrayRef<const ArgT *>());
+    return Func(P0, P1, None);
   }
 
 #define LLVM_DEFINE_OVERLOAD(N) \
   ResultT operator()(Param0T P0, Param1T P1, \
                      LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
     const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(P0, P1, Args); \
+    return Func(P0, P1, makeArrayRef(Args)); \
   }
   LLVM_DEFINE_OVERLOAD(1)
   LLVM_DEFINE_OVERLOAD(2)
@@ -255,19 +246,16 @@ class VariadicFunction2 {
 template <typename ResultT, typename Param0T, typename Param1T,
           typename Param2T, typename ArgT,
           ResultT (*Func)(Param0T, Param1T, Param2T, ArrayRef<const ArgT *>)>
-class VariadicFunction3 {
- public:
-  VariadicFunction3() {}
-
+struct VariadicFunction3 {
   ResultT operator()(Param0T P0, Param1T P1, Param2T P2) const {
-    return Func(P0, P1, P2, ArrayRef<const ArgT *>());
+    return Func(P0, P1, P2, None);
   }
 
 #define LLVM_DEFINE_OVERLOAD(N) \
   ResultT operator()(Param0T P0, Param1T P1, Param2T P2, \
                      LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
     const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(P0, P1, P2, Args); \
+    return Func(P0, P1, P2, makeArrayRef(Args)); \
   }
   LLVM_DEFINE_OVERLOAD(1)
   LLVM_DEFINE_OVERLOAD(2)
@@ -340,4 +328,4 @@ class VariadicFunction3 {
 
 } // end namespace llvm
 
-#endif  // LLVM_ADT_VARIADIC_FUNCTION_H
+#endif  // LLVM_ADT_VARIADICFUNCTION_H