diff --git a/include/gmock/gmock-generated-actions.h b/include/gmock/gmock-generated-actions.h
index 6d49c60..fa02faa 100644
--- a/include/gmock/gmock-generated-actions.h
+++ b/include/gmock/gmock-generated-actions.h
@@ -443,264 +443,6 @@
 
 };  // class CallableHelper
 
-// Invokes a nullary callable argument.
-template <size_t N>
-class InvokeArgumentAction0 {
- public:
-  template <typename Result, typename ArgumentTuple>
-  static Result Perform(const ArgumentTuple& args) {
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args));
-  }
-};
-
-// Invokes a unary callable argument with the given argument.
-template <size_t N, typename A1>
-class InvokeArgumentAction1 {
- public:
-  // We deliberately pass a1 by value instead of const reference here
-  // in case it is a C-string literal.
-  //
-  // Since this function is defined inline, the compiler can get rid
-  // of the copying of the arguments.  Therefore the performance won't
-  // be hurt.
-  explicit InvokeArgumentAction1(A1 a1) : arg1_(a1) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_);
-  }
- private:
-  const A1 arg1_;
-};
-
-// Invokes a binary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2>
-class InvokeArgumentAction2 {
- public:
-  InvokeArgumentAction2(A1 a1, A2 a2) :
-      arg1_(a1), arg2_(a2) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-};
-
-// Invokes a ternary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3>
-class InvokeArgumentAction3 {
- public:
-  InvokeArgumentAction3(A1 a1, A2 a2, A3 a3) :
-      arg1_(a1), arg2_(a2), arg3_(a3) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_,
-        arg3_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-};
-
-// Invokes a 4-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4>
-class InvokeArgumentAction4 {
- public:
-  InvokeArgumentAction4(A1 a1, A2 a2, A3 a3, A4 a4) :
-      arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_,
-        arg3_, arg4_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-};
-
-// Invokes a 5-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class InvokeArgumentAction5 {
- public:
-  InvokeArgumentAction5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
-      arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    // We extract the callable to a variable before invoking it, in
-    // case it is a functor passed by value and its operator() is not
-    // const.
-    typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
-        ::std::tr1::get<N>(args);
-    return function(arg1_, arg2_, arg3_, arg4_, arg5_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-};
-
-// Invokes a 6-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class InvokeArgumentAction6 {
- public:
-  InvokeArgumentAction6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
-      arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    // We extract the callable to a variable before invoking it, in
-    // case it is a functor passed by value and its operator() is not
-    // const.
-    typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
-        ::std::tr1::get<N>(args);
-    return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-};
-
-// Invokes a 7-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class InvokeArgumentAction7 {
- public:
-  InvokeArgumentAction7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
-      arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
-          arg7_(a7) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    // We extract the callable to a variable before invoking it, in
-    // case it is a functor passed by value and its operator() is not
-    // const.
-    typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
-        ::std::tr1::get<N>(args);
-    return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-};
-
-// Invokes a 8-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-class InvokeArgumentAction8 {
- public:
-  InvokeArgumentAction8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
-      A8 a8) :
-      arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
-          arg7_(a7), arg8_(a8) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    // We extract the callable to a variable before invoking it, in
-    // case it is a functor passed by value and its operator() is not
-    // const.
-    typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
-        ::std::tr1::get<N>(args);
-    return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-  const A8 arg8_;
-};
-
-// Invokes a 9-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-class InvokeArgumentAction9 {
- public:
-  InvokeArgumentAction9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
-      A9 a9) :
-      arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
-          arg7_(a7), arg8_(a8), arg9_(a9) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    // We extract the callable to a variable before invoking it, in
-    // case it is a functor passed by value and its operator() is not
-    // const.
-    typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
-        ::std::tr1::get<N>(args);
-    return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_,
-        arg9_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-  const A8 arg8_;
-  const A9 arg9_;
-};
-
-// Invokes a 10-ary callable argument with the given arguments.
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-class InvokeArgumentAction10 {
- public:
-  InvokeArgumentAction10(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
-      A8 a8, A9 a9, A10 a10) :
-      arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6),
-          arg7_(a7), arg8_(a8), arg9_(a9), arg10_(a10) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    // We extract the callable to a variable before invoking it, in
-    // case it is a functor passed by value and its operator() is not
-    // const.
-    typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
-        ::std::tr1::get<N>(args);
-    return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_,
-        arg9_, arg10_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-  const A8 arg8_;
-  const A9 arg9_;
-  const A10 arg10_;
-};
-
 // An INTERNAL macro for extracting the type of a tuple field.  It's
 // subject to change without notice - DO NOT USE IN USER CODE!
 #define GMOCK_FIELD_(Tuple, N) \
@@ -1140,140 +882,6 @@
   return internal::ReferenceWrapper<T>(l_value);
 }
 
-// Various overloads for InvokeArgument<N>().
-//
-// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
-// (0-based) argument, which must be a k-ary callable, of the mock
-// function, with arguments a1, a2, ..., a_k.
-//
-// Notes:
-//
-//   1. The arguments are passed by value by default.  If you need to
-//   pass an argument by reference, wrap it inside ByRef().  For
-//   example,
-//
-//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
-//
-//   passes 5 and string("Hello") by value, and passes foo by
-//   reference.
-//
-//   2. If the callable takes an argument by reference but ByRef() is
-//   not used, it will receive the reference to a copy of the value,
-//   instead of the original value.  For example, when the 0-th
-//   argument of the mock function takes a const string&, the action
-//
-//     InvokeArgument<0>(string("Hello"))
-//
-//   makes a copy of the temporary string("Hello") object and passes a
-//   reference of the copy, instead of the original temporary object,
-//   to the callable.  This makes it easy for a user to define an
-//   InvokeArgument action from temporary values and have it performed
-//   later.
-template <size_t N>
-inline PolymorphicAction<internal::InvokeArgumentAction0<N> > InvokeArgument() {
-  return MakePolymorphicAction(internal::InvokeArgumentAction0<N>());
-}
-
-// We deliberately pass a1 by value instead of const reference here in
-// case it is a C-string literal.  If we had declared the parameter as
-// 'const A1& a1' and write InvokeArgument<0>("Hi"), the compiler
-// would've thought A1 is 'char[3]', which causes trouble as the
-// implementation needs to copy a value of type A1.  By declaring the
-// parameter as 'A1 a1', the compiler will correctly infer that A1 is
-// 'const char*' when it sees InvokeArgument<0>("Hi").
-//
-// Since this function is defined inline, the compiler can get rid of
-// the copying of the arguments.  Therefore the performance won't be
-// hurt.
-template <size_t N, typename A1>
-inline PolymorphicAction<internal::InvokeArgumentAction1<N, A1> >
-InvokeArgument(A1 a1) {
-  return MakePolymorphicAction(internal::InvokeArgumentAction1<N, A1>(a1));
-}
-
-template <size_t N, typename A1, typename A2>
-inline PolymorphicAction<internal::InvokeArgumentAction2<N, A1, A2> >
-InvokeArgument(A1 a1, A2 a2) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction2<N, A1, A2>(a1, a2));
-}
-
-template <size_t N, typename A1, typename A2, typename A3>
-inline PolymorphicAction<internal::InvokeArgumentAction3<N, A1, A2, A3> >
-InvokeArgument(A1 a1, A2 a2, A3 a3) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction3<N, A1, A2, A3>(a1, a2, a3));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4>
-inline PolymorphicAction<internal::InvokeArgumentAction4<N, A1, A2, A3, A4> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction4<N, A1, A2, A3, A4>(a1, a2, a3, a4));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-inline PolymorphicAction<internal::InvokeArgumentAction5<N, A1, A2, A3, A4,
-    A5> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction5<N, A1, A2, A3, A4, A5>(a1, a2, a3, a4,
-          a5));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-inline PolymorphicAction<internal::InvokeArgumentAction6<N, A1, A2, A3, A4, A5,
-    A6> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction6<N, A1, A2, A3, A4, A5, A6>(a1, a2, a3,
-          a4, a5, a6));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-inline PolymorphicAction<internal::InvokeArgumentAction7<N, A1, A2, A3, A4, A5,
-    A6, A7> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction7<N, A1, A2, A3, A4, A5, A6, A7>(a1, a2,
-          a3, a4, a5, a6, a7));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-inline PolymorphicAction<internal::InvokeArgumentAction8<N, A1, A2, A3, A4, A5,
-    A6, A7, A8> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction8<N, A1, A2, A3, A4, A5, A6, A7, A8>(a1,
-          a2, a3, a4, a5, a6, a7, a8));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-inline PolymorphicAction<internal::InvokeArgumentAction9<N, A1, A2, A3, A4, A5,
-    A6, A7, A8, A9> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction9<N, A1, A2, A3, A4, A5, A6, A7, A8,
-          A9>(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template <size_t N, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-inline PolymorphicAction<internal::InvokeArgumentAction10<N, A1, A2, A3, A4,
-    A5, A6, A7, A8, A9, A10> >
-InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
-    A10 a10) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction10<N, A1, A2, A3, A4, A5, A6, A7, A8, A9,
-          A10>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
-}
-
 // WithoutArgs(inner_action) can be used in a mock function with a
 // non-empty argument list to perform inner_action, which takes no
 // argument.  In other words, it adapts an action accepting no
@@ -2715,271 +2323,153 @@
 // updated.
 namespace testing {
 
-namespace internal {
+// Various overloads for InvokeArgument<N>().
+//
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
+// (0-based) argument, which must be a k-ary callable, of the mock
+// function, with arguments a1, a2, ..., a_k.
+//
+// Notes:
+//
+//   1. The arguments are passed by value by default.  If you need to
+//   pass an argument by reference, wrap it inside ByRef().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but ByRef() is
+//   not used, it will receive the reference to a copy of the value,
+//   instead of the original value.  For example, when the 0-th
+//   argument of the mock function takes a const string&, the action
+//
+//     InvokeArgument<0>(string("Hello"))
+//
+//   makes a copy of the temporary string("Hello") object and passes a
+//   reference of the copy, instead of the original temporary object,
+//   to the callable.  This makes it easy for a user to define an
+//   InvokeArgument action from temporary values and have it performed
+//   later.
 
-// Saves argument #0 to where the pointer points.
-ACTION_P(SaveArg0, pointer) { *pointer = arg0; }
-
-// Assigns 'value' to the variable referenced by argument #0.
-ACTION_P(SetArg0Referee, value) {
-  // Ensures that argument #0 is a reference.  If you get a compiler
-  // error on the next line, you are using SetArgReferee<k>(value) in
-  // a mock function whose k-th (0-based) argument is not a reference.
-  GMOCK_COMPILE_ASSERT_(internal::is_reference<arg0_type>::value,
-                        SetArgReferee_must_be_used_with_a_reference_argument);
-  arg0 = value;
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args));
 }
 
-// ReturnNewAction<T> creates and returns a new instance of an object each time
-// it is performed. It is overloaded to work with constructors that take
-// different numbers of arguments.
-// Returns a new instance of T using a  nullary constructor with the given
-// arguments.
-template <typename T>
-class ReturnNewAction0 {
- public:
-  ReturnNewAction0() {}
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(p0)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0);
+}
 
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T();
-  }
- private:
-};
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(p0, p1)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1);
+}
 
-// Returns a new instance of T using a  unary constructor with the given
-// arguments.
-template <typename T, typename A1>
-class ReturnNewAction1 {
- public:
-  explicit ReturnNewAction1(A1 a1) : arg1_(a1) {}
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_3_VALUE_PARAMS(p0, p1, p2)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2);
+}
 
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_);
-  }
- private:
-  const A1 arg1_;
-};
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2, p3);
+}
 
-// Returns a new instance of T using a  binary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2>
-class ReturnNewAction2 {
- public:
-  ReturnNewAction2(A1 a1, A2 a2) : arg1_(a1), arg2_(a2) {}
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2, p3, p4);
+}
 
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-};
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5);
+}
 
-// Returns a new instance of T using a  ternary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3>
-class ReturnNewAction3 {
- public:
-  ReturnNewAction3(A1 a1, A2 a2, A3 a3) : arg1_(a1), arg2_(a2), arg3_(a3) {}
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
+}
 
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-};
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
+}
 
-// Returns a new instance of T using a  4-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4>
-class ReturnNewAction4 {
- public:
-  ReturnNewAction4(A1 a1, A2 a2, A3 a3, A4 a4) : arg1_(a1), arg2_(a2),
-      arg3_(a3), arg4_(a4) {}
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
+}
 
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_, arg4_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-};
-
-// Returns a new instance of T using a  5-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class ReturnNewAction5 {
- public:
-  ReturnNewAction5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : arg1_(a1), arg2_(a2),
-      arg3_(a3), arg4_(a4), arg5_(a5) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_, arg4_, arg5_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-};
-
-// Returns a new instance of T using a  6-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class ReturnNewAction6 {
- public:
-  ReturnNewAction6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : arg1_(a1),
-      arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-};
-
-// Returns a new instance of T using a  7-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class ReturnNewAction7 {
- public:
-  ReturnNewAction7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-      A7 a7) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
-      arg6_(a6), arg7_(a7) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-};
-
-// Returns a new instance of T using a  8-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-class ReturnNewAction8 {
- public:
-  ReturnNewAction8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
-      A8 a8) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
-      arg6_(a6), arg7_(a7), arg8_(a8) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-  const A8 arg8_;
-};
-
-// Returns a new instance of T using a  9-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-class ReturnNewAction9 {
- public:
-  ReturnNewAction9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
-      A9 a9) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
-      arg6_(a6), arg7_(a7), arg8_(a8), arg9_(a9) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-  const A8 arg8_;
-  const A9 arg9_;
-};
-
-// Returns a new instance of T using a  10-ary constructor with the given
-// arguments.
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-class ReturnNewAction10 {
- public:
-  ReturnNewAction10(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
-      A9 a9, A10 a10) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5),
-      arg6_(a6), arg7_(a7), arg8_(a8), arg9_(a9), arg10_(a10) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_,
-        arg10_);
-  }
- private:
-  const A1 arg1_;
-  const A2 arg2_;
-  const A3 arg3_;
-  const A4 arg4_;
-  const A5 arg5_;
-  const A6 arg6_;
-  const A7 arg7_;
-  const A8 arg8_;
-  const A9 arg9_;
-  const A10 arg10_;
-};
-
-// Deletes the object pointed to by argument #0.
-ACTION(DeleteArg0) { delete arg0; }
-
-}  // namespace internal
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}
 
 // Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
 // mock function to *pointer.
-template <int k, typename Pointer>
-inline internal::WithArgsAction<internal::SaveArg0ActionP<Pointer>, k>
-SaveArg(const Pointer& pointer) {
-  return WithArg<k>(internal::SaveArg0(pointer));
+ACTION_TEMPLATE(SaveArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(pointer)) {
+  *pointer = ::std::tr1::get<k>(args);
 }
 
 // Action SetArgReferee<k>(value) assigns 'value' to the variable
 // referenced by the k-th (0-based) argument of the mock function.
-template <int k, typename Value>
-inline internal::WithArgsAction<internal::SetArg0RefereeActionP<Value>, k>
-SetArgReferee(const Value& value) {
-  return WithArg<k>(internal::SetArg0Referee(value));
+ACTION_TEMPLATE(SetArgReferee,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(value)) {
+  typedef typename ::std::tr1::tuple_element<k, args_type>::type argk_type;
+  // Ensures that argument #k is a reference.  If you get a compiler
+  // error on the next line, you are using SetArgReferee<k>(value) in
+  // a mock function whose k-th (0-based) argument is not a reference.
+  GMOCK_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
+                        SetArgReferee_must_be_used_with_a_reference_argument);
+  ::std::tr1::get<k>(args) = value;
+}
+
+// Action SetArrayArgument<k>(first, last) copies the elements in
+// source range [first, last) to the array pointed to by the k-th
+// (0-based) argument, which can be either a pointer or an
+// iterator. The action does not take ownership of the elements in the
+// source range.
+ACTION_TEMPLATE(SetArrayArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(first, last)) {
+  // Microsoft compiler deprecates ::std::copy, so we want to suppress warning
+  // 4996 (Function call with parameters that may be unsafe) there.
+#ifdef _MSC_VER
+#pragma warning(push)          // Saves the current warning state.
+#pragma warning(disable:4996)  // Temporarily disables warning 4996.
+#endif
+  ::std::copy(first, last, ::std::tr1::get<k>(args));
+#ifdef _MSC_VER
+#pragma warning(pop)           // Restores the warning state.
+#endif
 }
 
 // Various overloads for ReturnNew<T>().
@@ -2987,106 +2477,78 @@
 // The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
 // instance of type T, constructed on the heap with constructor arguments
 // a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
-template <typename T>
-inline PolymorphicAction<internal::ReturnNewAction0<T> >
-ReturnNew() {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction0<T>());
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_0_VALUE_PARAMS()) {
+  return new T();
 }
 
-template <typename T, typename A1>
-inline PolymorphicAction<internal::ReturnNewAction1<T, A1> >
-ReturnNew(A1 a1) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction1<T, A1>(a1));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_1_VALUE_PARAMS(p0)) {
+  return new T(p0);
 }
 
-template <typename T, typename A1, typename A2>
-inline PolymorphicAction<internal::ReturnNewAction2<T, A1, A2> >
-ReturnNew(A1 a1, A2 a2) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction2<T, A1, A2>(a1, a2));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_2_VALUE_PARAMS(p0, p1)) {
+  return new T(p0, p1);
 }
 
-template <typename T, typename A1, typename A2, typename A3>
-inline PolymorphicAction<internal::ReturnNewAction3<T, A1, A2, A3> >
-ReturnNew(A1 a1, A2 a2, A3 a3) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction3<T, A1, A2, A3>(a1, a2, a3));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_3_VALUE_PARAMS(p0, p1, p2)) {
+  return new T(p0, p1, p2);
 }
 
-template <typename T, typename A1, typename A2, typename A3, typename A4>
-inline PolymorphicAction<internal::ReturnNewAction4<T, A1, A2, A3, A4> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction4<T, A1, A2, A3, A4>(a1, a2, a3, a4));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+  return new T(p0, p1, p2, p3);
 }
 
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-inline PolymorphicAction<internal::ReturnNewAction5<T, A1, A2, A3, A4, A5> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction5<T, A1, A2, A3, A4, A5>(a1, a2, a3, a4, a5));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+  return new T(p0, p1, p2, p3, p4);
 }
 
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-inline PolymorphicAction<internal::ReturnNewAction6<T, A1, A2, A3, A4, A5, A6> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction6<T, A1, A2, A3, A4, A5, A6>(a1, a2, a3, a4, a5,
-          a6));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+  return new T(p0, p1, p2, p3, p4, p5);
 }
 
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-inline PolymorphicAction<internal::ReturnNewAction7<T, A1, A2, A3, A4, A5, A6,
-    A7> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction7<T, A1, A2, A3, A4, A5, A6, A7>(a1, a2, a3, a4,
-          a5, a6, a7));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6);
 }
 
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-inline PolymorphicAction<internal::ReturnNewAction8<T, A1, A2, A3, A4, A5, A6,
-    A7, A8> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction8<T, A1, A2, A3, A4, A5, A6, A7, A8>(a1, a2, a3,
-          a4, a5, a6, a7, a8));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
 }
 
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-inline PolymorphicAction<internal::ReturnNewAction9<T, A1, A2, A3, A4, A5, A6,
-    A7, A8, A9> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction9<T, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a1, a2,
-          a3, a4, a5, a6, a7, a8, a9));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
 }
 
-template <typename T, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-inline PolymorphicAction<internal::ReturnNewAction10<T, A1, A2, A3, A4, A5, A6,
-    A7, A8, A9, A10> >
-ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
-    A10 a10) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction10<T, A1, A2, A3, A4, A5, A6, A7, A8, A9,
-          A10>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
 }
 
 // Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
 // function.
-template <int k>
-inline internal::WithArgsAction<internal::DeleteArg0Action, k>
-DeleteArg() {
-  return WithArg<k>(internal::DeleteArg0());
+ACTION_TEMPLATE(DeleteArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  delete ::std::tr1::get<k>(args);
 }
 
 // Action Throw(exception) can be used in a mock function of any type
diff --git a/include/gmock/gmock-generated-actions.h.pump b/include/gmock/gmock-generated-actions.h.pump
index 39f8080..b5223a3 100644
--- a/include/gmock/gmock-generated-actions.h.pump
+++ b/include/gmock/gmock-generated-actions.h.pump
@@ -198,77 +198,6 @@
 
 };  // class CallableHelper
 
-// Invokes a nullary callable argument.
-template <size_t N>
-class InvokeArgumentAction0 {
- public:
-  template <typename Result, typename ArgumentTuple>
-  static Result Perform(const ArgumentTuple& args) {
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args));
-  }
-};
-
-// Invokes a unary callable argument with the given argument.
-template <size_t N, typename A1>
-class InvokeArgumentAction1 {
- public:
-  // We deliberately pass a1 by value instead of const reference here
-  // in case it is a C-string literal.
-  //
-  // Since this function is defined inline, the compiler can get rid
-  // of the copying of the arguments.  Therefore the performance won't
-  // be hurt.
-  explicit InvokeArgumentAction1(A1 a1) : arg1_(a1) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_);
-  }
- private:
-  const A1 arg1_;
-};
-
-$range i 2..n
-$for i [[
-$var arity = [[$if i==2 [[binary]] $elif i==3 [[ternary]] $else [[$i-ary]]]]
-$range j 1..i
-$var typename_As = [[$for j, [[typename A$j]]]]
-$var args_ = [[$for j, [[arg$j[[]]_]]]]
-
-// Invokes a $arity callable argument with the given arguments.
-template <size_t N, $typename_As>
-class InvokeArgumentAction$i {
- public:
-  InvokeArgumentAction$i($for j, [[A$j a$j]]) :
-      $for j, [[arg$j[[]]_(a$j)]] {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-$if i <= 4 [[
-
-    return CallableHelper<Result>::Call(::std::tr1::get<N>(args), $args_);
-
-]] $else [[
-
-    // We extract the callable to a variable before invoking it, in
-    // case it is a functor passed by value and its operator() is not
-    // const.
-    typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function =
-        ::std::tr1::get<N>(args);
-    return function($args_);
-
-]]
-  }
- private:
-$for j [[
-
-  const A$j arg$j[[]]_;
-]]
-
-};
-
-]]
-
 // An INTERNAL macro for extracting the type of a tuple field.  It's
 // subject to change without notice - DO NOT USE IN USER CODE!
 #define GMOCK_FIELD_(Tuple, N) \
@@ -478,74 +407,6 @@
   return internal::ReferenceWrapper<T>(l_value);
 }
 
-// Various overloads for InvokeArgument<N>().
-//
-// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
-// (0-based) argument, which must be a k-ary callable, of the mock
-// function, with arguments a1, a2, ..., a_k.
-//
-// Notes:
-//
-//   1. The arguments are passed by value by default.  If you need to
-//   pass an argument by reference, wrap it inside ByRef().  For
-//   example,
-//
-//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
-//
-//   passes 5 and string("Hello") by value, and passes foo by
-//   reference.
-//
-//   2. If the callable takes an argument by reference but ByRef() is
-//   not used, it will receive the reference to a copy of the value,
-//   instead of the original value.  For example, when the 0-th
-//   argument of the mock function takes a const string&, the action
-//
-//     InvokeArgument<0>(string("Hello"))
-//
-//   makes a copy of the temporary string("Hello") object and passes a
-//   reference of the copy, instead of the original temporary object,
-//   to the callable.  This makes it easy for a user to define an
-//   InvokeArgument action from temporary values and have it performed
-//   later.
-template <size_t N>
-inline PolymorphicAction<internal::InvokeArgumentAction0<N> > InvokeArgument() {
-  return MakePolymorphicAction(internal::InvokeArgumentAction0<N>());
-}
-
-// We deliberately pass a1 by value instead of const reference here in
-// case it is a C-string literal.  If we had declared the parameter as
-// 'const A1& a1' and write InvokeArgument<0>("Hi"), the compiler
-// would've thought A1 is 'char[3]', which causes trouble as the
-// implementation needs to copy a value of type A1.  By declaring the
-// parameter as 'A1 a1', the compiler will correctly infer that A1 is
-// 'const char*' when it sees InvokeArgument<0>("Hi").
-//
-// Since this function is defined inline, the compiler can get rid of
-// the copying of the arguments.  Therefore the performance won't be
-// hurt.
-template <size_t N, typename A1>
-inline PolymorphicAction<internal::InvokeArgumentAction1<N, A1> >
-InvokeArgument(A1 a1) {
-  return MakePolymorphicAction(internal::InvokeArgumentAction1<N, A1>(a1));
-}
-
-$range i 2..n
-$for i [[
-$range j 1..i
-$var typename_As = [[$for j, [[typename A$j]]]]
-$var As = [[$for j, [[A$j]]]]
-$var Aas = [[$for j, [[A$j a$j]]]]
-$var as = [[$for j, [[a$j]]]]
-
-template <size_t N, $typename_As>
-inline PolymorphicAction<internal::InvokeArgumentAction$i<N, $As> >
-InvokeArgument($Aas) {
-  return MakePolymorphicAction(
-      internal::InvokeArgumentAction$i<N, $As>($as));
-}
-
-]]
-
 // WithoutArgs(inner_action) can be used in a mock function with a
 // non-empty argument list to perform inner_action, which takes no
 // argument.  In other words, it adapts an action accepting no
@@ -1025,76 +886,89 @@
 // updated.
 namespace testing {
 
-namespace internal {
+// Various overloads for InvokeArgument<N>().
+//
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
+// (0-based) argument, which must be a k-ary callable, of the mock
+// function, with arguments a1, a2, ..., a_k.
+//
+// Notes:
+//
+//   1. The arguments are passed by value by default.  If you need to
+//   pass an argument by reference, wrap it inside ByRef().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but ByRef() is
+//   not used, it will receive the reference to a copy of the value,
+//   instead of the original value.  For example, when the 0-th
+//   argument of the mock function takes a const string&, the action
+//
+//     InvokeArgument<0>(string("Hello"))
+//
+//   makes a copy of the temporary string("Hello") object and passes a
+//   reference of the copy, instead of the original temporary object,
+//   to the callable.  This makes it easy for a user to define an
+//   InvokeArgument action from temporary values and have it performed
+//   later.
 
-// Saves argument #0 to where the pointer points.
-ACTION_P(SaveArg0, pointer) { *pointer = arg0; }
-
-// Assigns 'value' to the variable referenced by argument #0.
-ACTION_P(SetArg0Referee, value) {
-  // Ensures that argument #0 is a reference.  If you get a compiler
-  // error on the next line, you are using SetArgReferee<k>(value) in
-  // a mock function whose k-th (0-based) argument is not a reference.
-  GMOCK_COMPILE_ASSERT_(internal::is_reference<arg0_type>::value,
-                        SetArgReferee_must_be_used_with_a_reference_argument);
-  arg0 = value;
-}
-
-// ReturnNewAction<T> creates and returns a new instance of an object each time
-// it is performed. It is overloaded to work with constructors that take
-// different numbers of arguments.
 $range i 0..n
 $for i [[
-$var arity = [[ $if i==0 [[nullary]]
-                $elif i==1 [[unary]]
-                $elif i==2 [[binary]]
-                $elif i==3 [[ternary]]
-                $else [[$i-ary]]]]
-$range j 1..i
-$var typename_As = [[$for j [[, typename A$j]]]]
-$var args_ = [[$for j, [[arg$j[[]]_]]]]
+$range j 0..i-1
 
-// Returns a new instance of T using a $arity constructor with the given
-// arguments.
-template <typename T$typename_As>
-class ReturnNewAction$i {
- public:
-  $if i==1 [[explicit ]]ReturnNewAction$i($for j, [[A$j a$j]])$if i>0 [[ : ]]
-$for j, [[arg$j[[]]_(a$j)]] {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) {
-    return new T($args_);
-  }
- private:
-$for j [[
-
-  const A$j arg$j[[]]_;
-]]
-
-};
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) {
+  return internal::CallableHelper<return_type>::Call(
+      ::std::tr1::get<k>(args)$for j [[, p$j]]);
+}
 
 ]]
 
-// Deletes the object pointed to by argument #0.
-ACTION(DeleteArg0) { delete arg0; }
-
-}  // namespace internal
-
 // Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
 // mock function to *pointer.
-template <int k, typename Pointer>
-inline internal::WithArgsAction<internal::SaveArg0ActionP<Pointer>, k>
-SaveArg(const Pointer& pointer) {
-  return WithArg<k>(internal::SaveArg0(pointer));
+ACTION_TEMPLATE(SaveArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(pointer)) {
+  *pointer = ::std::tr1::get<k>(args);
 }
 
 // Action SetArgReferee<k>(value) assigns 'value' to the variable
 // referenced by the k-th (0-based) argument of the mock function.
-template <int k, typename Value>
-inline internal::WithArgsAction<internal::SetArg0RefereeActionP<Value>, k>
-SetArgReferee(const Value& value) {
-  return WithArg<k>(internal::SetArg0Referee(value));
+ACTION_TEMPLATE(SetArgReferee,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(value)) {
+  typedef typename ::std::tr1::tuple_element<k, args_type>::type argk_type;
+  // Ensures that argument #k is a reference.  If you get a compiler
+  // error on the next line, you are using SetArgReferee<k>(value) in
+  // a mock function whose k-th (0-based) argument is not a reference.
+  GMOCK_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
+                        SetArgReferee_must_be_used_with_a_reference_argument);
+  ::std::tr1::get<k>(args) = value;
+}
+
+// Action SetArrayArgument<k>(first, last) copies the elements in
+// source range [first, last) to the array pointed to by the k-th
+// (0-based) argument, which can be either a pointer or an
+// iterator. The action does not take ownership of the elements in the
+// source range.
+ACTION_TEMPLATE(SetArrayArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(first, last)) {
+  // Microsoft compiler deprecates ::std::copy, so we want to suppress warning
+  // 4996 (Function call with parameters that may be unsafe) there.
+#ifdef _MSC_VER
+#pragma warning(push)          // Saves the current warning state.
+#pragma warning(disable:4996)  // Temporarily disables warning 4996.
+#endif
+  ::std::copy(first, last, ::std::tr1::get<k>(args));
+#ifdef _MSC_VER
+#pragma warning(pop)           // Restores the warning state.
+#endif
 }
 
 // Various overloads for ReturnNew<T>().
@@ -1104,27 +978,23 @@
 // a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
 $range i 0..n
 $for i [[
-$range j 1..i
-$var typename_As = [[$for j [[, typename A$j]]]]
-$var As = [[$for j [[, A$j]]]]
-$var Aas = [[$for j, [[A$j a$j]]]]
-$var as = [[$for j, [[a$j]]]]
+$range j 0..i-1
+$var ps = [[$for j, [[p$j]]]]
 
-template <typename T$typename_As>
-inline PolymorphicAction<internal::ReturnNewAction$i<T$As> >
-ReturnNew($Aas) {
-  return MakePolymorphicAction(
-      internal::ReturnNewAction$i<T$As>($as));
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_$i[[]]_VALUE_PARAMS($ps)) {
+  return new T($ps);
 }
 
 ]]
 
 // Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
 // function.
-template <int k>
-inline internal::WithArgsAction<internal::DeleteArg0Action, k>
-DeleteArg() {
-  return WithArg<k>(internal::DeleteArg0());
+ACTION_TEMPLATE(DeleteArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  delete ::std::tr1::get<k>(args);
 }
 
 // Action Throw(exception) can be used in a mock function of any type
diff --git a/include/gmock/gmock-matchers.h b/include/gmock/gmock-matchers.h
index bf049d4..0497be2 100644
--- a/include/gmock/gmock-matchers.h
+++ b/include/gmock/gmock-matchers.h
@@ -39,6 +39,7 @@
 #define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
 
 #include <algorithm>
+#include <limits>
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <string>
@@ -340,6 +341,16 @@
   GMOCK_COMPILE_ASSERT_(
       internal::is_reference<T>::value || !internal::is_reference<U>::value,
       cannot_convert_non_referentce_arg_to_reference);
+  // In case both T and U are arithmetic types, enforce that the
+  // conversion is not lossy.
+  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(T)) RawT;
+  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(U)) RawU;
+  const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
+  const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
+  GMOCK_COMPILE_ASSERT_(
+      kTIsOther || kUIsOther ||
+      (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
+      conversion_of_arithmetic_types_must_be_lossless);
   return MatcherCast<T>(matcher);
 }
 
@@ -1164,8 +1175,8 @@
   // both Matcher1 and Matcher2 can match.
   template <typename T>
   operator Matcher<T>() const {
-    return Matcher<T>(new EitherOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
-                                                 SafeMatcherCast<T>(matcher2_)));
+    return Matcher<T>(new EitherOfMatcherImpl<T>(
+        SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
   }
  private:
   Matcher1 matcher1_;
@@ -1184,7 +1195,7 @@
   // argument is passed by reference as the predicate may be
   // interested in the address of the argument.
   template <typename T>
-  bool Matches(T& x) const {
+  bool Matches(T& x) const {  // NOLINT
 #if GTEST_OS_WINDOWS
     // MSVC warns about converting a value into bool (warning 4800).
 #pragma warning(push)          // Saves the current warning state.
diff --git a/include/gmock/gmock-printers.h b/include/gmock/gmock-printers.h
index 6997a6c..9900243 100644
--- a/include/gmock/gmock-printers.h
+++ b/include/gmock/gmock-printers.h
@@ -341,12 +341,11 @@
   PrintTo(implicit_cast<const char*>(s), os);
 }
 
-// MSVC compiler can be configured to define whar_t as a typedef
-// of unsigned short. Defining an overload for const wchar_t* in that case
-// would cause pointers to unsigned shorts be printed as wide strings,
-// possibly accessing more memory than intended and causing invalid
-// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
-// wchar_t is implemented as a native type.
+// MSVC can be configured to define wchar_t as a typedef of unsigned
+// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
+// type.  When wchar_t is a typedef, defining an overload for const
+// wchar_t* would cause unsigned short* be printed as a wide string,
+// possibly causing invalid memory accesses.
 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
 // Overloads for wide C strings
 void PrintTo(const wchar_t* s, ::std::ostream* os);
diff --git a/include/gmock/gmock-spec-builders.h b/include/gmock/gmock-spec-builders.h
index af2e8ad..cc48bc0 100644
--- a/include/gmock/gmock-spec-builders.h
+++ b/include/gmock/gmock-spec-builders.h
@@ -1359,6 +1359,20 @@
   std::vector<DefaultActionSpec<F> > default_actions_;
   // All expectations for this function mocker.
   Expectations expectations_;
+
+  // There is no generally useful and implementable semantics of
+  // copying a mock object, so copying a mock is usually a user error.
+  // Thus we disallow copying function mockers.  If the user really
+  // wants to copy a mock object, he should implement his own copy
+  // operation, for example:
+  //
+  //   class MockFoo : public Foo {
+  //    public:
+  //     // Defines a copy constructor explicitly.
+  //     MockFoo(const MockFoo& src) {}
+  //     ...
+  //   };
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(FunctionMockerBase);
 };  // class FunctionMockerBase
 
 #ifdef _MSC_VER
diff --git a/include/gmock/internal/gmock-internal-utils.h b/include/gmock/internal/gmock-internal-utils.h
index b3d1a1d..b02682f 100644
--- a/include/gmock/internal/gmock-internal-utils.h
+++ b/include/gmock/internal/gmock-internal-utils.h
@@ -157,7 +157,7 @@
 // This comparator allows linked_ptr to be stored in sets.
 template <typename T>
 struct LinkedPtrLessThan {
-  bool operator()(const ::testing::internal::linked_ptr<T>& lhs, 
+  bool operator()(const ::testing::internal::linked_ptr<T>& lhs,
                   const ::testing::internal::linked_ptr<T>& rhs) const {
     return lhs.get() < rhs.get();
   }
@@ -210,17 +210,154 @@
 template <typename From, typename To>
 const bool ImplicitlyConvertible<From, To>::value;
 
+// In what follows, we use the term "kind" to indicate whether a type
+// is bool, an integer type (excluding bool), a floating-point type,
+// or none of them.  This categorization is useful for determining
+// when a matcher argument type can be safely converted to another
+// type in the implementation of SafeMatcherCast.
+enum TypeKind {
+  kBool, kInteger, kFloatingPoint, kOther
+};
+
+// KindOf<T>::value is the kind of type T.
+template <typename T> struct KindOf {
+  enum { value = kOther };  // The default kind.
+};
+
+// This macro declares that the kind of 'type' is 'kind'.
+#define GMOCK_DECLARE_KIND_(type, kind) \
+  template <> struct KindOf<type> { enum { value = kind }; }
+
+GMOCK_DECLARE_KIND_(bool, kBool);
+
+// All standard integer types.
+GMOCK_DECLARE_KIND_(char, kInteger);
+GMOCK_DECLARE_KIND_(signed char, kInteger);
+GMOCK_DECLARE_KIND_(unsigned char, kInteger);
+GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(int, kInteger);
+GMOCK_DECLARE_KIND_(unsigned int, kInteger);
+GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
+
+// MSVC can be configured to define wchar_t as a typedef of unsigned
+// short. It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t is a
+// native type.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+GMOCK_DECLARE_KIND_(wchar_t, kInteger);
+#endif
+
+// Non-standard integer types.
+GMOCK_DECLARE_KIND_(Int64, kInteger);
+GMOCK_DECLARE_KIND_(UInt64, kInteger);
+
+// All standard floating-point types.
+GMOCK_DECLARE_KIND_(float, kFloatingPoint);
+GMOCK_DECLARE_KIND_(double, kFloatingPoint);
+GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
+
+#undef GMOCK_DECLARE_KIND_
+
+// Evaluates to the kind of 'type'.
+#define GMOCK_KIND_OF_(type) \
+  static_cast< ::testing::internal::TypeKind>( \
+      ::testing::internal::KindOf<type>::value)
+
+// Evaluates to true iff integer type T is signed.
+#define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0)
+
+// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
+// is true iff arithmetic type From can be losslessly converted to
+// arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types, kFromKind is the kind of
+// From, and kToKind is the kind of To; the value is
+// implementation-defined when the above pre-condition is violated.
+template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
+struct LosslessArithmeticConvertibleImpl : public false_type {};
+
+// Converting bool to bool is lossless.
+template <>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool>
+    : public true_type {};  // NOLINT
+
+// Converting bool to any integer type is lossless.
+template <typename To>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To>
+    : public true_type {};  // NOLINT
+
+// Converting bool to any floating-point type is lossless.
+template <typename To>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To>
+    : public true_type {};  // NOLINT
+
+// Converting an integer to bool is lossy.
+template <typename From>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool>
+    : public false_type {};  // NOLINT
+
+// Converting an integer to another non-bool integer is lossless iff
+// the target type's range encloses the source type's range.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To>
+    : public bool_constant<
+      // When converting from a smaller size to a larger size, we are
+      // fine as long as we are not converting from signed to unsigned.
+      ((sizeof(From) < sizeof(To)) &&
+       (!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) ||
+      // When converting between the same size, the signedness must match.
+      ((sizeof(From) == sizeof(To)) &&
+       (GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {};  // NOLINT
+
+#undef GMOCK_IS_SIGNED_
+
+// Converting an integer to a floating-point type may be lossy, since
+// the format of a floating-point number is implementation-defined.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to bool is lossy.
+template <typename From>
+struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to an integer is lossy.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger, To>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to another floating-point is lossless
+// iff the target type is at least as big as the source type.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<
+  kFloatingPoint, From, kFloatingPoint, To>
+    : public bool_constant<sizeof(From) <= sizeof(To)> {};  // NOLINT
+
+// LosslessArithmeticConvertible<From, To>::value is true iff arithmetic
+// type From can be losslessly converted to arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types; the value is
+// implementation-defined when the above pre-condition is violated.
+template <typename From, typename To>
+struct LosslessArithmeticConvertible
+    : public LosslessArithmeticConvertibleImpl<
+  GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {};  // NOLINT
+
 // IsAProtocolMessage<T>::value is a compile-time bool constant that's
 // true iff T is type ProtocolMessage, proto2::Message, or a subclass
 // of those.
 template <typename T>
-struct IsAProtocolMessage {
-  static const bool value =
-      ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
-      ImplicitlyConvertible<const T*, const ::proto2::Message*>::value;
+struct IsAProtocolMessage
+    : public bool_constant<
+  ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
+  ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
 };
-template <typename T>
-const bool IsAProtocolMessage<T>::value;
 
 // When the compiler sees expression IsContainerTest<C>(0), the first
 // overload of IsContainerTest will be picked if C is an STL-style
@@ -314,6 +451,8 @@
 // to declare an unused << operator in the global namespace.
 struct Unused {};
 
+// TODO(wan@google.com): group all type utilities together.
+
 // Type traits.
 
 // is_reference<T>::value is non-zero iff T is a reference type.
@@ -325,8 +464,8 @@
 template <typename T> struct type_equals<T, T> : public true_type {};
 
 // remove_reference<T>::type removes the reference from type T, if any.
-template <typename T> struct remove_reference { typedef T type; };
-template <typename T> struct remove_reference<T&> { typedef T type; };
+template <typename T> struct remove_reference { typedef T type; };  // NOLINT
+template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT
 
 // Invalid<T>() returns an invalid value of type T.  This is useful
 // when a value of type T is needed for compilation, but the statement
diff --git a/scripts/gmock_doctor.py b/scripts/gmock_doctor.py
index ca7935c..907089e 100755
--- a/scripts/gmock_doctor.py
+++ b/scripts/gmock_doctor.py
@@ -36,7 +36,7 @@
 import re
 import sys
 
-_VERSION = '0.1.0.80421'
+_VERSION = '1.0.0'
 
 _COMMON_GMOCK_SYMBOLS = [
     # Matchers
@@ -148,11 +148,14 @@
 def _NeedToReturnSomethingDiagnoser(msg):
   """Diagnoses the NRS disease, given the error messages by gcc."""
 
-  regex = (r'(?P<file>.*):(?P<line>\d+):\s+instantiated from here\n'
-           r'.*gmock-actions\.h.*error: void value not ignored')
+  regex = (r'(?P<file>.*):(?P<line>\d+):\s+'
+           r'(instantiated from here\n.'
+           r'*gmock-actions\.h.*error: void value not ignored)'
+           r'|(error: control reaches end of non-void function)')
   diagnosis = """%(file)s:%(line)s:
 You are using an action that returns void, but it needs to return
-*something*.  Please tell it *what* to return."""
+*something*.  Please tell it *what* to return.  Perhaps you can use
+the pattern DoAll(some_action, Return(some_value))?"""
   return _GenericDiagnoser('NRS', 'Need to Return Something',
                            regex, diagnosis, msg)
 
@@ -324,6 +327,23 @@
                            regex, diagnosis, msg)
 
 
+def _WrongMockMethodMacroDiagnoser(msg):
+  """Diagnoses the WMM disease, given the error messages by gcc."""
+
+  regex = (r'(?P<file>.*):(?P<line>\d+):\s+'
+           r'.*this_method_does_not_take_(?P<wrong_args>\d+)_argument.*\n'
+           r'.*\n'
+           r'.*candidates are.*FunctionMocker<[^>]+A(?P<args>\d+)\)>'
+           )
+
+  diagnosis = """%(file)s:%(line)s:
+You are using MOCK_METHOD%(wrong_args)s to define a mock method that has
+%(args)s arguments. Use MOCK_METHOD%(args)s (or MOCK_CONST_METHOD%(args)s,
+MOCK_METHOD%(args)s_T, MOCK_CONST_METHOD%(args)s_T as appropriate) instead."""
+  return _GenericDiagnoser('WMM', 'Wrong MOCK_METHODn macro',
+                           regex, diagnosis, msg)
+
+
 
 _DIAGNOSERS = [
     _IncompleteByReferenceArgumentDiagnoser,
@@ -337,6 +357,7 @@
     _OverloadedFunctionMatcherDiagnoser,
     _OverloadedMethodActionDiagnoser1,
     _OverloadedMethodActionDiagnoser2,
+    _WrongMockMethodMacroDiagnoser,
     ]
 
 
diff --git a/test/gmock-internal-utils_test.cc b/test/gmock-internal-utils_test.cc
index b678a9e..5e4dc03 100644
--- a/test/gmock-internal-utils_test.cc
+++ b/test/gmock-internal-utils_test.cc
@@ -34,6 +34,7 @@
 // This file tests the internal utilities.
 
 #include <gmock/internal/gmock-internal-utils.h>
+#include <stdlib.h>
 #include <map>
 #include <string>
 #include <sstream>
@@ -43,6 +44,10 @@
 #include <gtest/gtest.h>
 #include <gtest/gtest-spi.h>
 
+#if GTEST_OS_CYGWIN
+#include <sys/types.h>  // For ssize_t. NOLINT
+#endif
+
 namespace testing {
 namespace internal {
 
@@ -232,6 +237,141 @@
   EXPECT_FALSE((ImplicitlyConvertible<Base&, Derived&>::value));
 }
 
+// Tests KindOf<T>.
+
+TEST(KindOfTest, Bool) {
+  EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool));  // NOLINT
+}
+
+TEST(KindOfTest, Integer) {
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));  // NOLINT
+#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
+  // ssize_t is not defined on Windows and possibly some other OSes.
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t));  // NOLINT
+#endif
+}
+
+TEST(KindOfTest, FloatingPoint) {
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float));  // NOLINT
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double));  // NOLINT
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double));  // NOLINT
+}
+
+TEST(KindOfTest, Other) {
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*));  // NOLINT
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**));  // NOLINT
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base));  // NOLINT
+}
+
+// Tests LosslessArithmeticConvertible<T, U>.
+
+TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value));
+  EXPECT_TRUE(
+      (LosslessArithmeticConvertible<bool, unsigned long>::value));  // NOLINT
+}
+
+TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
+  EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
+  // Unsigned => larger signed is fine.
+  EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));
+
+  // Unsigned => larger unsigned is fine.
+  EXPECT_TRUE(
+      (LosslessArithmeticConvertible<unsigned short, UInt64>::value)); // NOLINT
+
+  // Signed => unsigned is not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<short, UInt64>::value)); // NOLINT
+  EXPECT_FALSE((LosslessArithmeticConvertible<
+      signed char, unsigned int>::value));  // NOLINT
+
+  // Same size and same signedness: fine too.
+  EXPECT_TRUE((LosslessArithmeticConvertible<
+               unsigned char, unsigned char>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<
+               unsigned long, unsigned long>::value));  // NOLINT
+
+  // Same size, different signedness: not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<
+                unsigned char, signed char>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<UInt64, Int64>::value));
+
+  // Larger size => smaller size is not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value));  // NOLINT
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<Int64, unsigned int>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
+  // Integers cannot be losslessly converted to floating-points, as
+  // the format of the latter is implementation-defined.
+  EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<
+                short, long double>::value));  // NOLINT
+}
+
+TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
+  EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
+  EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value));  // NOLINT
+  EXPECT_FALSE((LosslessArithmeticConvertible<double, Int64>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
+  // Smaller size => larger size is fine.
+  EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value));
+
+  // Same size: fine.
+  EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value));
+
+  // Larger size => smaller size is not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
+  if (sizeof(double) == sizeof(long double)) {  // NOLINT
+    // In some implementations (e.g. MSVC), double and long double
+    // have the same size.
+    EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
+  } else {
+    EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value));
+  }
+}
+
 // Tests that IsAProtocolMessage<T>::value is a compile-time constant.
 TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) {
   GMOCK_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value, const_true);
@@ -265,8 +405,10 @@
 }
 
 TEST(IsContainerTestTest, WorksForContainer) {
-  EXPECT_EQ(sizeof(IsContainer), sizeof(IsContainerTest<std::vector<bool> >(0)));
-  EXPECT_EQ(sizeof(IsContainer), sizeof(IsContainerTest<std::map<int, double> >(0)));
+  EXPECT_EQ(sizeof(IsContainer),
+            sizeof(IsContainerTest<std::vector<bool> >(0)));
+  EXPECT_EQ(sizeof(IsContainer),
+            sizeof(IsContainerTest<std::map<int, double> >(0)));
 }
 
 // Tests the TupleMatches() template function.
diff --git a/test/gmock-matchers_test.cc b/test/gmock-matchers_test.cc
index ab5ca35..e770901 100644
--- a/test/gmock-matchers_test.cc
+++ b/test/gmock-matchers_test.cc
@@ -376,13 +376,18 @@
   EXPECT_FALSE(m2.Matches('\n'));
 }
 
-// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T
-// can be implicitly converted to U.
-TEST(SafeMatcherCastTest, FromImplicitlyConvertibleType) {
+// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
+// T and U are arithmetic types and T can be losslessly converted to
+// U.
+TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
   Matcher<double> m1 = DoubleEq(1.0);
-  Matcher<int> m2 = SafeMatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(1));
-  EXPECT_FALSE(m2.Matches(2));
+  Matcher<float> m2 = SafeMatcherCast<float>(m1);
+  EXPECT_TRUE(m2.Matches(1.0f));
+  EXPECT_FALSE(m2.Matches(2.0f));
+
+  Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
+  EXPECT_TRUE(m3.Matches('a'));
+  EXPECT_FALSE(m3.Matches('b'));
 }
 
 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U