PR9037: Allow override, final, and new as an extension on inline members.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@124477 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td
index 7ce5017e18b6a176e5b149e0da55e4f99a056181..4142fcca65aa401939c7904f53193ca20acfa928 100644 (file)
--- a/include/clang/Basic/DiagnosticParseKinds.td
+++ b/include/clang/Basic/DiagnosticParseKinds.td
@@ -394,6 +394,8 @@ def warn_deleted_function_accepted_as_extension: ExtWarn<
 // C++0x override control
 def ext_override_control_keyword : Extension<
   "'%0' keyword accepted as a C++0x extension">, InGroup<CXX0x>;
+def ext_override_inline: Extension<
+  "'%0' keyword only allowed in declarations, allowed as an extension">;
 
 def err_duplicate_virt_specifier : Error<
   "class member already marked '%0'">;

diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index 7f22a49533d487a961503a597fcbe96aecd92062..e3ed3e8c8b42792a2e6273acc7c47ded5cc4e0f2 100644 (file)
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -910,7 +910,8 @@ private:
   void PopParsingClass();
 
   Decl *ParseCXXInlineMethodDef(AccessSpecifier AS, Declarator &D,
-                                     const ParsedTemplateInfo &TemplateInfo);
+                                const ParsedTemplateInfo &TemplateInfo,
+                                const VirtSpecifiers& VS);
   void ParseLexedMethodDeclarations(ParsingClass &Class);
   void ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM);
   void ParseLexedMethodDefs(ParsingClass &Class);

diff --git a/include/clang/Sema/DeclSpec.h b/include/clang/Sema/DeclSpec.h
index 59962ae3b70b31e53231903db5e4f5c9ed80e323..742cfe96afae6533e2ab6e8c2b2b383e17426e9e 100644 (file)
--- a/include/clang/Sema/DeclSpec.h
+++ b/include/clang/Sema/DeclSpec.h
@@ -1513,6 +1513,8 @@ public:
   bool isNewSpecified() const { return Specifiers & VS_New; }
   SourceLocation getNewLoc() const { return VS_newLoc; }
 
+  void clear() { Specifiers = 0; }
+
   static const char *getSpecifierName(Specifier VS);
 
 private:

diff --git a/lib/Parse/ParseCXXInlineMethods.cpp b/lib/Parse/ParseCXXInlineMethods.cpp
index 0a5a586f73819d249f624aed3a429a928bb5f1eb..d62e71836fa263add3490b9f7d4db48d03a4581f 100644 (file)
--- a/lib/Parse/ParseCXXInlineMethods.cpp
+++ b/lib/Parse/ParseCXXInlineMethods.cpp
@@ -21,7 +21,8 @@ using namespace clang;
 /// Declarator is a well formed C++ inline method definition. Now lex its body
 /// and store its tokens for parsing after the C++ class is complete.
 Decl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, Declarator &D,
-                                const ParsedTemplateInfo &TemplateInfo) {
+                                const ParsedTemplateInfo &TemplateInfo,
+                                const VirtSpecifiers& VS) {
   assert(D.isFunctionDeclarator() && "This isn't a function declarator!");
   assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) &&
          "Current token not a '{', ':' or 'try'!");
@@ -35,11 +36,18 @@ Decl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, Declarator &D,
     // FIXME: Friend templates
     FnD = Actions.ActOnFriendFunctionDecl(getCurScope(), D, true,
                                           move(TemplateParams));
-  else // FIXME: pass template information through
+  else { // FIXME: pass template information through
+    if (VS.isOverrideSpecified())
+      Diag(VS.getOverrideLoc(), diag::ext_override_inline) << "override";
+    if (VS.isFinalSpecified())
+      Diag(VS.getFinalLoc(), diag::ext_override_inline) << "final";
+    if (VS.isNewSpecified())
+      Diag(VS.getNewLoc(), diag::ext_override_inline) << "new";
+
     FnD = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, D,
                                            move(TemplateParams), 0, 
-                                           VirtSpecifiers(), 0,
-                                           /*IsDefinition*/true);
+                                           VS, 0, /*IsDefinition*/true);
+  }
 
   HandleMemberFunctionDefaultArgs(D, FnD);
 

diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp
index b077f73baa332c5ecb29a72e1234e1721764b97c..9466ebc844bbbf5fc78d17591b36c91fa80bdfe9 100644 (file)
--- a/lib/Parse/ParseDeclCXX.cpp
+++ b/lib/Parse/ParseDeclCXX.cpp
@@ -1531,6 +1531,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
   }
 
   ParsingDeclarator DeclaratorInfo(*this, DS, Declarator::MemberContext);
+  VirtSpecifiers VS;
 
   if (Tok.isNot(tok::colon)) {
     // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
@@ -1547,6 +1548,8 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
       return;
     }
 
+    ParseOptionalCXX0XVirtSpecifierSeq(VS);
+
     // If attributes exist after the declarator, but before an '{', parse them.
     MaybeParseGNUAttributes(DeclaratorInfo);
 
@@ -1579,7 +1582,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
         return;
       }
 
-      ParseCXXInlineMethodDef(AS, DeclaratorInfo, TemplateInfo);
+      ParseCXXInlineMethodDef(AS, DeclaratorInfo, TemplateInfo, VS);
       // Consume the optional ';'
       if (Tok.is(tok::semi))
         ConsumeToken();
@@ -1609,7 +1612,6 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
         SkipUntil(tok::comma, true, true);
     }
 
-    VirtSpecifiers VS;
     ParseOptionalCXX0XVirtSpecifierSeq(VS);
 
     // pure-specifier:
@@ -1689,6 +1691,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
 
     // Parse the next declarator.
     DeclaratorInfo.clear();
+    VS.clear();
     BitfieldSize = 0;
     Init = 0;
     Deleted = false;

diff --git a/test/CXX/class/class.mem/p8-0x-pedantic.cpp b/test/CXX/class/class.mem/p8-0x-pedantic.cpp
new file mode 100644 (file)
index 0000000..a4b775c
--- /dev/null
+++ b/test/CXX/class/class.mem/p8-0x-pedantic.cpp
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++0x -pedantic -verify %s 
+
+namespace inline_extension {
+  struct Base1 { 
+    virtual void f() {}
+  };
+
+  struct B : Base1 {
+    virtual void f() override {} // expected-warning {{'override' keyword only allowed in declarations, allowed as an extension}}
+    virtual void g() final {} // expected-warning {{'final' keyword only allowed in declarations, allowed as an extension}}
+    virtual void h() new {} // expected-warning {{'new' keyword only allowed in declarations, allowed as an extension}}
+  };
+}
+

diff --git a/test/CXX/class/class.mem/p8-0x.cpp b/test/CXX/class/class.mem/p8-0x.cpp
index ce676ae6ff509cfab4853deaa555e017ffb367d9..bf1b4c177bf87b2a929da79034fead1f62f17133 100644 (file)
--- a/test/CXX/class/class.mem/p8-0x.cpp
+++ b/test/CXX/class/class.mem/p8-0x.cpp
@@ -11,10 +11,12 @@ struct A : Base1 {
 };
 
 struct Base2 { 
+  virtual void e1(), e2();
   virtual void f();
 };
 
 struct B : Base2 {
+  virtual void e1() override, e2(int);  // No error.
   virtual void f() override;
   void g() override; // expected-error {{only virtual member functions can be marked 'override'}}
   int h override; // expected-error {{only virtual member functions can be marked 'override'}}
@@ -25,3 +27,29 @@ struct C {
   void g() final; // expected-error {{only virtual member functions can be marked 'final'}}
   int h final; // expected-error {{only virtual member functions can be marked 'final'}}
 };
+
+namespace inline_extension {
+  struct Base1 { 
+    virtual void g() {}
+  };
+
+  struct A : Base1 {
+    virtual void f() new new {} // expected-error {{class member already marked 'new'}}
+    virtual void g() override override {} // expected-error {{class member already marked 'override'}}
+    virtual void h() final final {} // expected-error {{class member already marked 'final'}}
+  };
+
+  struct Base2 { 
+    virtual void f();
+  };
+
+  struct B : Base2 {
+    virtual void f() override {}
+    void g() override {} // expected-error {{only virtual member functions can be marked 'override'}}
+  };
+
+  struct C {
+    virtual void f() final {}
+    void g() final {} // expected-error {{only virtual member functions can be marked 'final'}}
+  };
+}