Diagnose declspecs occuring after virt-specifier-seq and generate fixit hints

[• ehsan]

Summary

This fixes PR22075.

[• ehsan]

Ping?

[rsmith]

Thanks, this is a nice improvement. Have you considered also handling ref-qualifiers here?

lib/Parse/ParseDeclCXX.cpp

2100–2113 ↗

(On Diff #17763)

Please factor this out into a loop or a lambda rather than duplicating it three times.

[• ehsan]

In D6828#108948, @rsmith wrote:

Thanks, this is a nice improvement. Have you considered also handling ref-qualifiers here?

That's a good idea! I'll do that in a separate patch, if that's OK.

[• ehsan]

Addressed the review comments

[• ehsan]

I don't know how to submit these separately, but I added a patch to handle ref-qualifiers as well, and they are both now in D7012.

[• ehsan]

I'm having difficulty fixing the issue that caused this patch to bounce when I landed it earlier this morning. Here is a link to the log of the test failure: http://lab.llvm.org:8011/builders/clang-hexagon-elf/builds/24611/steps/check-all/logs/FAIL%3A%20Clang%3A%3Afixit-cxx0x.cpp

The issue is my call to getFunctionTypeInfo(). That call is now asserting because isFunctionDeclarator() returns false on the declaration. I checked, and isDeclarationOfFunction() returns true, but I'm not sure how to get a FunctionTypeInfo out of such a declarator.

Can someone please help? Thanks!

cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td

def warn_attribute_on_function_definition : Warning<
   InGroup<GccCompat>;
 def warn_gcc_attribute_location : Warning<
   "GCC does not allow an attribute in this position on a function declaration">, 
   InGroup<GccCompat>;
 def warn_attribute_no_decl : Warning<
   "attribute %0 ignored, because it is not attached to a declaration">, 
   InGroup<IgnoredAttributes>;
 def err_expected_method_body : Error<"expected method body">;
+def err_declspec_after_virtspec : Error<
+  "'%0' qualifier may not appear after the virtual specifier '%1'">;
 def err_invalid_token_after_toplevel_declarator : Error<
   "expected ';' after top level declarator">;
 def err_invalid_token_after_declarator_suggest_equal : Error<
   "invalid %0 at end of declaration; did you mean '='?">;
 def err_expected_statement : Error<"expected statement">;
 def err_expected_lparen_after : Error<"expected '(' after '%0'">;
 def err_expected_rparen_after : Error<"expected ')' after '%0'">;
 def err_expected_punc : Error<"expected ')' or ',' after '%0'">;

cfe/trunk/include/clang/Parse/Parser.h

void ParseCXXMemberSpecification(SourceLocation StartLoc,
                                    unsigned TagType,
                                    Decl *TagDecl);
   ExprResult ParseCXXMemberInitializer(Decl *D, bool IsFunction,
                                        SourceLocation &EqualLoc);
   bool ParseCXXMemberDeclaratorBeforeInitializer(Declarator &DeclaratorInfo,
                                                  VirtSpecifiers &VS,
                                                  ExprResult &BitfieldSize,
                                                  LateParsedAttrList &LateAttrs);
+  void MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(Declarator &D,
+                                                               VirtSpecifiers &VS);
   void ParseCXXClassMemberDeclaration(AccessSpecifier AS, AttributeList *Attr,
                   const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
                   ParsingDeclRAIIObject *DiagsFromTParams = nullptr);
   void ParseConstructorInitializer(Decl *ConstructorDecl);
   MemInitResult ParseMemInitializer(Decl *ConstructorDecl);
   void HandleMemberFunctionDeclDelays(Declarator& DeclaratorInfo,
                                       Decl *ThisDecl);
 

cfe/trunk/include/clang/Sema/DeclSpec.h

 public:
   enum Specifier {
     VS_None = 0,
     VS_Override = 1,
     VS_Final = 2,
     VS_Sealed = 4
   };
 
-  VirtSpecifiers() : Specifiers(0) { }
+  VirtSpecifiers() : Specifiers(0), LastSpecifier(VS_None) { }
 
   bool SetSpecifier(Specifier VS, SourceLocation Loc,
                     const char *&PrevSpec);
 
   bool isUnset() const { return Specifiers == 0; }
 
   bool isOverrideSpecified() const { return Specifiers & VS_Override; }
   SourceLocation getOverrideLoc() const { return VS_overrideLoc; }
 
   bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed); }
   bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; }
   SourceLocation getFinalLoc() const { return VS_finalLoc; }
 
   void clear() { Specifiers = 0; }
 
   static const char *getSpecifierName(Specifier VS);
 
+  SourceLocation getFirstLocation() const { return FirstLocation; }
   SourceLocation getLastLocation() const { return LastLocation; }
+  Specifier getLastSpecifier() const { return LastSpecifier; }
   
 private:
   unsigned Specifiers;
+  Specifier LastSpecifier;
 
   SourceLocation VS_overrideLoc, VS_finalLoc;
+  SourceLocation FirstLocation;
   SourceLocation LastLocation;
 };
 
 /// \brief Represents a complete lambda introducer.
 struct LambdaIntroducer {
   /// \brief An individual capture in a lambda introducer.
   struct LambdaCapture {
     LambdaCaptureKind Kind;

cfe/trunk/lib/Parse/ParseDecl.cpp

if (isFunctionDeclaratorIdentifierList()) {
     Tracker.consumeClose();
     RParenLoc = Tracker.getCloseLocation();
     LocalEndLoc = RParenLoc;
     EndLoc = RParenLoc;
 
     if (getLangOpts().CPlusPlus) {
       // FIXME: Accept these components in any order, and produce fixits to
       // correct the order if the user gets it wrong. Ideally we should deal
-      // with the virt-specifier-seq and pure-specifier in the same way.
+      // with the pure-specifier in the same way.
 
       // Parse cv-qualifier-seq[opt].
       ParseTypeQualifierListOpt(DS, AR_NoAttributesParsed,
                                 /*AtomicAllowed*/ false);
       if (!DS.getSourceRange().getEnd().isInvalid()) {
         EndLoc = DS.getSourceRange().getEnd();
         ConstQualifierLoc = DS.getConstSpecLoc();
         VolatileQualifierLoc = DS.getVolatileSpecLoc();

cfe/trunk/lib/Parse/ParseDeclCXX.cpp

else
     DeclaratorInfo.SetIdentifier(nullptr, Tok.getLocation());
 
   if (!DeclaratorInfo.isFunctionDeclarator() && TryConsumeToken(tok::colon)) {
     assert(DeclaratorInfo.isPastIdentifier() &&
            "don't know where identifier would go yet?");
     BitfieldSize = ParseConstantExpression();
     if (BitfieldSize.isInvalid())
       SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch);
-  } else
+  } else {
     ParseOptionalCXX11VirtSpecifierSeq(
         VS, getCurrentClass().IsInterface,
         DeclaratorInfo.getDeclSpec().getFriendSpecLoc());
+    if (!VS.isUnset())
+      MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(DeclaratorInfo, VS);
+  }
 
   // If a simple-asm-expr is present, parse it.
   if (Tok.is(tok::kw_asm)) {
     SourceLocation Loc;
     ExprResult AsmLabel(ParseSimpleAsm(&Loc));
     if (AsmLabel.isInvalid())
       SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch);
 
if (!VS.isUnset()) {
       // If we saw any GNU-style attributes that are known to GCC followed by a
       // virt-specifier, issue a GCC-compat warning.
       const AttributeList *Attr = DeclaratorInfo.getAttributes();
       while (Attr) {
         if (Attr->isKnownToGCC() && !Attr->isCXX11Attribute())
           Diag(Attr->getLoc(), diag::warn_gcc_attribute_location);
         Attr = Attr->getNext();
       }
+      MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(DeclaratorInfo, VS);
     }
   }
 
   // If this has neither a name nor a bit width, something has gone seriously
   // wrong. Skip until the semi-colon or }.
   if (!DeclaratorInfo.hasName() && BitfieldSize.isUnset()) {
     // If so, skip until the semi-colon or a }.
     SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
     return true;
   }
   return false;
 }
 
+/// \brief Look for declaration specifiers possibly occurring after C++11
+/// virt-specifier-seq and diagnose them.
+void Parser::MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(
+    Declarator &D,
+    VirtSpecifiers &VS) {
+  DeclSpec DS(AttrFactory);
+
+  // GNU-style and C++11 attributes are not allowed here, but they will be
+  // handled by the caller.  Diagnose everything else.
+  ParseTypeQualifierListOpt(DS, AR_NoAttributesParsed, false);
+  D.ExtendWithDeclSpec(DS);
+
+  if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
+    auto DeclSpecCheck = [&] (DeclSpec::TQ TypeQual,
+                              const char *FixItName,
+                              SourceLocation SpecLoc,
+                              unsigned* QualifierLoc) {
+      FixItHint Insertion;
+      auto &Function = D.getFunctionTypeInfo();
+      if (DS.getTypeQualifiers() & TypeQual) {
+        if (!(Function.TypeQuals & TypeQual)) {
+          std::string Name(FixItName);
+          Name += " ";
+          Insertion = FixItHint::CreateInsertion(VS.getFirstLocation(), Name.c_str());
+          Function.TypeQuals |= TypeQual;
+          *QualifierLoc = SpecLoc.getRawEncoding();
+        }
+        Diag(SpecLoc, diag::err_declspec_after_virtspec)
+          << FixItName
+          << VirtSpecifiers::getSpecifierName(VS.getLastSpecifier())
+          << FixItHint::CreateRemoval(SpecLoc)
+          << Insertion;
+      }
+    };
+    auto &Function = D.getFunctionTypeInfo();
+    DeclSpecCheck(DeclSpec::TQ_const, "const", DS.getConstSpecLoc(),
+                  &Function.ConstQualifierLoc);
+    DeclSpecCheck(DeclSpec::TQ_volatile, "volatile", DS.getVolatileSpecLoc(),
+                  &Function.VolatileQualifierLoc);
+    DeclSpecCheck(DeclSpec::TQ_restrict, "restrict", DS.getRestrictSpecLoc(),
+                  &Function.RestrictQualifierLoc);
+  }
+}
+
 /// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.
 ///
 ///       member-declaration:
 ///         decl-specifier-seq[opt] member-declarator-list[opt] ';'
 ///         function-definition ';'[opt]
 ///         ::[opt] nested-name-specifier template[opt] unqualified-id ';'[TODO]
 ///         using-declaration                                            [TODO]
 /// [C++0x] static_assert-declaration

cfe/trunk/lib/Sema/DeclSpec.cpp

for (unsigned I = 0; I != 3; ++I) {
     
     if (SymbolLocations[I].isValid())
       EndLocation = SymbolLocations[I];
   }
 }
 
 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
                                   const char *&PrevSpec) {
+  if (!FirstLocation.isValid())
+    FirstLocation = Loc;
   LastLocation = Loc;
+  LastSpecifier = VS;
   
   if (Specifiers & VS) {
     PrevSpec = getSpecifierName(VS);
     return true;
   }
 
   Specifiers |= VS;
 

cfe/trunk/test/FixIt/fixit-cxx0x.cpp

namespace MisplacedParameterPack {
   void redundantEllipsisInTemplateTypeParameter(Args<int>...);
 
   template <int N...> // expected-error {{'...' must immediately precede declared identifier}}
   void misplacedEllipsisInNonTypeTemplateParameter();
 
   template <int... N...> // expected-error {{'...' must immediately precede declared identifier}}
   void redundantEllipsisInNonTypeTemplateParameter();
 }
+
+namespace MisplacedDeclSpecAfterVirtSpec {
+  struct B {
+    virtual void f();
+    virtual void f() volatile const;
+  };
+  struct D : B {
+    virtual void f() override;
+    virtual void f() override final const volatile; // expected-error {{'const' qualifier may not appear after the virtual specifier 'final'}} expected-error {{'volatile' qualifier may not appear after the virtual specifier 'final'}}
+  };
+}