From 21a5846afdd19ae9907cdc7c45264c35175b1651 Mon Sep 17 00:00:00 2001
From: "zhanyong.wan" <zhanyong.wan@8415998a-534a-0410-bf83-d39667b30386>
Date: Thu, 12 Nov 2009 19:18:08 +0000
Subject: [PATCH] Makes gmock-generated-function-mockers.h conform to the C++
 standard.

---
 .../gmock/gmock-generated-function-mockers.h  | 71 +++++++++++++++----
 .../gmock-generated-function-mockers.h.pump   | 10 +--
 2 files changed, 61 insertions(+), 20 deletions(-)

diff --git a/include/gmock/gmock-generated-function-mockers.h b/include/gmock/gmock-generated-function-mockers.h
index 3002b6c5..9f3a956c 100644
--- a/include/gmock/gmock-generated-function-mockers.h
+++ b/include/gmock/gmock-generated-function-mockers.h
@@ -42,10 +42,6 @@
 #include <gmock/internal/gmock-internal-utils.h>
 
 namespace testing {
-
-template <typename F>
-class MockSpec;
-
 namespace internal {
 
 template <typename F>
@@ -71,7 +67,11 @@ class FunctionMocker<R()> : public
   }
 
   R Invoke() {
-    return InvokeWith(ArgumentTuple());
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple());
   }
 };
 
@@ -88,7 +88,11 @@ class FunctionMocker<R(A1)> : public
   }
 
   R Invoke(A1 a1) {
-    return InvokeWith(ArgumentTuple(a1));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1));
   }
 };
 
@@ -105,7 +109,11 @@ class FunctionMocker<R(A1, A2)> : public
   }
 
   R Invoke(A1 a1, A2 a2) {
-    return InvokeWith(ArgumentTuple(a1, a2));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2));
   }
 };
 
@@ -123,7 +131,11 @@ class FunctionMocker<R(A1, A2, A3)> : public
   }
 
   R Invoke(A1 a1, A2 a2, A3 a3) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3));
   }
 };
 
@@ -141,7 +153,11 @@ class FunctionMocker<R(A1, A2, A3, A4)> : public
   }
 
   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3, a4));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
   }
 };
 
@@ -161,7 +177,11 @@ class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
   }
 
   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
   }
 };
 
@@ -182,7 +202,11 @@ class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
   }
 
   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
   }
 };
 
@@ -203,7 +227,11 @@ class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
   }
 
   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
   }
 };
 
@@ -224,7 +252,11 @@ class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
   }
 
   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
   }
 };
 
@@ -246,7 +278,11 @@ class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
   }
 
   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
   }
 };
 
@@ -270,7 +306,12 @@ class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
 
   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
       A10 a10) {
-    return InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+        a10));
   }
 };
 
diff --git a/include/gmock/gmock-generated-function-mockers.h.pump b/include/gmock/gmock-generated-function-mockers.h.pump
index 3c845632..82106eb1 100644
--- a/include/gmock/gmock-generated-function-mockers.h.pump
+++ b/include/gmock/gmock-generated-function-mockers.h.pump
@@ -45,10 +45,6 @@ $var n = 10  $$ The maximum arity we support.
 #include <gmock/internal/gmock-internal-utils.h>
 
 namespace testing {
-
-template <typename F>
-class MockSpec;
-
 namespace internal {
 
 template <typename F>
@@ -89,7 +85,11 @@ $if i >= 1 [[
   }
 
   R Invoke($Aas) {
-    return InvokeWith(ArgumentTuple($as));
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple($as));
   }
 };