diff --git a/include/gmock/gmock-actions.h b/include/gmock/gmock-actions.h
index 215af4f9..f88ac80d 100644
--- a/include/gmock/gmock-actions.h
+++ b/include/gmock/gmock-actions.h
@@ -494,11 +494,11 @@ class ReturnAction {
     // single-argument constructor (e.g. Result is std::vector<int>) and R
     // has a type conversion operator template.  In that case, value_(value)
     // won't compile as the compiler doesn't known which constructor of
-    // Result to call.  implicit_cast forces the compiler to convert R to
+    // Result to call.  ImplicitCast_ forces the compiler to convert R to
     // Result without considering explicit constructors, thus resolving the
     // ambiguity. value_ is then initialized using its copy constructor.
     explicit Impl(R value)
-        : value_(::testing::internal::implicit_cast<Result>(value)) {}
+        : value_(::testing::internal::ImplicitCast_<Result>(value)) {}
 
     virtual Result Perform(const ArgumentTuple&) { return value_; }
 
diff --git a/include/gmock/gmock-generated-nice-strict.h b/include/gmock/gmock-generated-nice-strict.h
index 4fb69fdc..6099e81e 100644
--- a/include/gmock/gmock-generated-nice-strict.h
+++ b/include/gmock/gmock-generated-nice-strict.h
@@ -71,7 +71,7 @@ class NiceMock : public MockClass {
   // we have to avoid a possible clash with members of MockClass.
   NiceMock() {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   // C++ doesn't (yet) allow inheritance of constructors, so we have
@@ -79,32 +79,32 @@ class NiceMock : public MockClass {
   template <typename A1>
   explicit NiceMock(const A1& a1) : MockClass(a1) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
   template <typename A1, typename A2>
   NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3>
   NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4>
   NiceMock(const A1& a1, const A2& a2, const A3& a3,
       const A4& a4) : MockClass(a1, a2, a3, a4) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5>
   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -112,7 +112,7 @@ class NiceMock : public MockClass {
   NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -121,7 +121,7 @@ class NiceMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
       a6, a7) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -130,7 +130,7 @@ class NiceMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
       a2, a3, a4, a5, a6, a7, a8) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -139,7 +139,7 @@ class NiceMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -148,12 +148,12 @@ class NiceMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   virtual ~NiceMock() {
     ::testing::Mock::UnregisterCallReaction(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
  private:
@@ -167,38 +167,38 @@ class StrictMock : public MockClass {
   // we have to avoid a possible clash with members of MockClass.
   StrictMock() {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1>
   explicit StrictMock(const A1& a1) : MockClass(a1) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
   template <typename A1, typename A2>
   StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3>
   StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4>
   StrictMock(const A1& a1, const A2& a2, const A3& a3,
       const A4& a4) : MockClass(a1, a2, a3, a4) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5>
   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
       const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -206,7 +206,7 @@ class StrictMock : public MockClass {
   StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
       const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -215,7 +215,7 @@ class StrictMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
       a6, a7) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -224,7 +224,7 @@ class StrictMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
       a2, a3, a4, a5, a6, a7, a8) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -233,7 +233,7 @@ class StrictMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7, const A8& a8,
       const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1, typename A2, typename A3, typename A4, typename A5,
@@ -242,12 +242,12 @@ class StrictMock : public MockClass {
       const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
       const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   virtual ~StrictMock() {
     ::testing::Mock::UnregisterCallReaction(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
  private:
diff --git a/include/gmock/gmock-generated-nice-strict.h.pump b/include/gmock/gmock-generated-nice-strict.h.pump
index 784635bd..b7964db3 100644
--- a/include/gmock/gmock-generated-nice-strict.h.pump
+++ b/include/gmock/gmock-generated-nice-strict.h.pump
@@ -74,7 +74,7 @@ class NiceMock : public MockClass {
   // we have to avoid a possible clash with members of MockClass.
   NiceMock() {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   // C++ doesn't (yet) allow inheritance of constructors, so we have
@@ -82,7 +82,7 @@ class NiceMock : public MockClass {
   template <typename A1>
   explicit NiceMock(const A1& a1) : MockClass(a1) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
 $range i 2..n
@@ -91,14 +91,14 @@ $range j 1..i
   template <$for j, [[typename A$j]]>
   NiceMock($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
     ::testing::Mock::AllowUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
 
 ]]
   virtual ~NiceMock() {
     ::testing::Mock::UnregisterCallReaction(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
  private:
@@ -112,13 +112,13 @@ class StrictMock : public MockClass {
   // we have to avoid a possible clash with members of MockClass.
   StrictMock() {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
   template <typename A1>
   explicit StrictMock(const A1& a1) : MockClass(a1) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
 $for i [[
@@ -126,14 +126,14 @@ $range j 1..i
   template <$for j, [[typename A$j]]>
   StrictMock($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
     ::testing::Mock::FailUninterestingCalls(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
 
 ]]
   virtual ~StrictMock() {
     ::testing::Mock::UnregisterCallReaction(
-        internal::implicit_cast<MockClass*>(this));
+        internal::ImplicitCast_<MockClass*>(this));
   }
 
  private:
diff --git a/include/gmock/gmock-spec-builders.h b/include/gmock/gmock-spec-builders.h
index 1676056c..df2aef16 100644
--- a/include/gmock/gmock-spec-builders.h
+++ b/include/gmock/gmock-spec-builders.h
@@ -1388,7 +1388,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
       mock_obj_ = mock_obj;
     }
     Mock::Register(mock_obj, this);
-    return *::testing::internal::down_cast<FunctionMocker<F>*>(this);
+    return *::testing::internal::DownCast_<FunctionMocker<F>*>(this);
   }
 
   // The following two functions are from UntypedFunctionMockerBase.
diff --git a/scripts/generator/cpp/ast.py b/scripts/generator/cpp/ast.py
index 47dc9a07..6f61f877 100755
--- a/scripts/generator/cpp/ast.py
+++ b/scripts/generator/cpp/ast.py
@@ -1483,7 +1483,13 @@ class AstBuilder(object):
             assert class_token.token_type == tokenize.SYNTAX, class_token
             token = class_token
         else:
-            self._AddBackToken(class_token)
+            # Skip any macro (e.g. storage class specifiers) after the
+            # 'class' keyword.
+            next_token = self._GetNextToken()
+            if next_token.token_type == tokenize.NAME:
+                self._AddBackToken(next_token)
+            else:
+                self._AddBackTokens([class_token, next_token])
             name_tokens, token = self.GetName()
             class_name = ''.join([t.name for t in name_tokens])
         bases = None
diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py
index 607d5cf7..494720cd 100755
--- a/scripts/generator/cpp/gmock_class_test.py
+++ b/scripts/generator/cpp/gmock_class_test.py
@@ -193,6 +193,22 @@ void());
     self.assertEqualIgnoreLeadingWhitespace(
         expected, self.GenerateMocks(source))
 
+  def testClassWithStorageSpecifierMacro(self):
+    source = """
+class STORAGE_SPECIFIER Test {
+ public:
+  virtual void Foo();
+};
+"""
+    expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD0(Foo,
+void());
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        expected, self.GenerateMocks(source))
 
 if __name__ == '__main__':
   unittest.main()
diff --git a/scripts/gmock_doctor.py b/scripts/gmock_doctor.py
index 15e2433c..f7932b5e 100755
--- a/scripts/gmock_doctor.py
+++ b/scripts/gmock_doctor.py
@@ -169,7 +169,7 @@ def _NeedToReturnReferenceDiagnoser(msg):
   gcc_regex = (r'In member function \'testing::internal::ReturnAction<R>.*\n'
                + _GCC_FILE_LINE_RE + r'instantiated from here\n'
                r'.*gmock-actions\.h.*error: creating array with negative size')
-  clang_regex = (r'error: array size is negative\r?\n'
+  clang_regex = (r'error:.*array.*negative.*\r?\n'
                  r'(.*\n)*?' +
                  _CLANG_NON_GMOCK_FILE_LINE_RE +
                  r'note: in instantiation of function template specialization '
@@ -414,10 +414,10 @@ def _NeedToUseReturnNullDiagnoser(msg):
   gcc_regex = ('instantiated from \'testing::internal::ReturnAction<R>'
                '::operator testing::Action<Func>\(\) const.*\n' +
                _GCC_FILE_LINE_RE + r'instantiated from here\n'
-               r'.*error: no matching function for call to \'implicit_cast\('
+               r'.*error: no matching function for call to \'ImplicitCast_\('
                r'long int&\)')
   clang_regex = (r'\bgmock-actions.h:.* error: no matching function for '
-                 r'call to \'implicit_cast\'\r?\n'
+                 r'call to \'ImplicitCast_\'\r?\n'
                  r'(.*\n)*?' +
                  _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
                  r'of function template specialization '
@@ -501,7 +501,7 @@ def _WrongMockMethodMacroDiagnoser(msg):
                r'.*\n'
                r'.*candidates are.*FunctionMocker<[^>]+A(?P<args>\d+)\)>')
   clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
-                 r'error: array size is negative\r?\n'
+                 r'error:.*array.*negative.*r?\n'
                  r'(.*\n)*?'
                  r'(?P=file):(?P=line):(?P=column): error: too few arguments '
                  r'to function call, expected (?P<args>\d+), '