[Sema] Fix location of star ('*') inside MemberPointerTypeLoc

[hlopko]

Summary

Copy of https://reviews.llvm.org/D72073?id=235842, submitting with ilya-biryukov's permission.

[gribozavr2]

clang/unittests/AST/DeclTest.cpp

125

I'd suggest to rewrite this test (and other tests in this file) to a more modern approach to testing. Specifically, I suggest that you imitate clang/unittests/Tooling/RangeSelectorTest.cpp. However, since that would be refactoring existing tests, I suggest that you do it as a follow-up change -- but please do it.

[hlopko]

[Sema] Fix location of star ('*') inside MemberPointerTypeLoc

Copy of https://reviews.llvm.org/D72073?id=235842, submitting with ilya-biryukov's permission.

[hlopko]

Refactor the test to use matchers.

[hlopko]

Reformat

[hlopko]

Rearrange

[gribozavr2]

clang/unittests/AST/SourceLocationTest.cpp

856 ↗

(On Diff #250143)

s/D/VD/? (for VarDecl)

[hlopko]

Rename D->VD, rebase master.

[hlopko]

Rebase

clang/include/clang/Sema/DeclSpec.h

struct BlockPointerTypeInfo {
 
     void destroy() {
     }
   };
 
   struct MemberPointerTypeInfo {
     /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
     unsigned TypeQuals : 5;
+    /// Location of the '*' token.
+    unsigned StarLoc;
     // CXXScopeSpec has a constructor, so it can't be a direct member.
     // So we need some pointer-aligned storage and a bit of trickery.
     alignas(CXXScopeSpec) char ScopeMem[sizeof(CXXScopeSpec)];
     CXXScopeSpec &Scope() {
       return *reinterpret_cast<CXXScopeSpec *>(ScopeMem);
     }
     const CXXScopeSpec &Scope() const {
       return *reinterpret_cast<const CXXScopeSpec *>(ScopeMem);
static DeclaratorChunk getPipe(unsigned TypeQuals,
     I.Kind          = Pipe;
     I.Loc           = Loc;
     I.Cls.TypeQuals = TypeQuals;
     return I;
   }
 
   static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS,
                                           unsigned TypeQuals,
-                                          SourceLocation Loc) {
+                                          SourceLocation StarLoc,
+                                          SourceLocation EndLoc) {
     DeclaratorChunk I;
     I.Kind          = MemberPointer;
     I.Loc           = SS.getBeginLoc();
-    I.EndLoc        = Loc;
+    I.EndLoc        = EndLoc;
+    I.Mem.StarLoc   = StarLoc.getRawEncoding();
     I.Mem.TypeQuals = TypeQuals;
     new (I.Mem.ScopeMem) CXXScopeSpec(SS);
     return I;
   }
 
   /// Return a DeclaratorChunk for a paren.
   static DeclaratorChunk getParen(SourceLocation LParenLoc,
                                   SourceLocation RParenLoc) {

clang/lib/Parse/ParseDecl.cpp

if (SS.isNotEmpty()) {
         else
           AnnotateScopeToken(SS, true);
 
         if (DirectDeclParser)
           (this->*DirectDeclParser)(D);
         return;
       }
 
-      SourceLocation Loc = ConsumeToken();
-      D.SetRangeEnd(Loc);
+      SourceLocation StarLoc = ConsumeToken();
+      D.SetRangeEnd(StarLoc);
       DeclSpec DS(AttrFactory);
       ParseTypeQualifierListOpt(DS);
       D.ExtendWithDeclSpec(DS);
 
       // Recurse to parse whatever is left.
       ParseDeclaratorInternal(D, DirectDeclParser);
 
       // Sema will have to catch (syntactically invalid) pointers into global
       // scope. It has to catch pointers into namespace scope anyway.
       D.AddTypeInfo(DeclaratorChunk::getMemberPointer(
-                        SS, DS.getTypeQualifiers(), DS.getEndLoc()),
+                        SS, DS.getTypeQualifiers(), StarLoc, DS.getEndLoc()),
                     std::move(DS.getAttributes()),
                     /* Don't replace range end. */ SourceLocation());
       return;
     }
   }
 
   tok::TokenKind Kind = Tok.getKind();
 

clang/lib/Sema/SemaType.cpp

void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
       case NestedNameSpecifier::Namespace:
       case NestedNameSpecifier::NamespaceAlias:
       case NestedNameSpecifier::Global:
       case NestedNameSpecifier::Super:
         llvm_unreachable("Nested-name-specifier must name a type");
       }
 
       // Finally fill in MemberPointerLocInfo fields.
-      TL.setStarLoc(Chunk.Loc);
+      TL.setStarLoc(SourceLocation::getFromRawEncoding(Chunk.Mem.StarLoc));
       TL.setClassTInfo(ClsTInfo);
     }
     void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
       assert(Chunk.Kind == DeclaratorChunk::Reference);
       // 'Amp' is misleading: this might have been originally
       /// spelled with AmpAmp.
       TL.setAmpLoc(Chunk.Loc);
     }

clang/unittests/AST/DeclTest.cpp

std::unique_ptr<ItaniumMangleContext> MC(
     llvm::raw_string_ostream OS_G(MangleG);
     MC->mangleName(DeclF, OS_F);
     MC->mangleName(DeclG, OS_G);
   }
 
   ASSERT_TRUE(0 == MangleF.compare("\x01" "foo"));
   ASSERT_TRUE(0 == MangleG.compare("goo"));
 }
+
+TEST(Decl, MemberPointerStarLoc) {
+  StringRef Code = R"(
+    struct X {};
+    int X::* a;
+  )";
+  auto AST = tooling::buildASTFromCodeWithArgs(Code, {});
+  SourceManager &SM = AST->getSourceManager();
+
+  SmallVector<Decl *, 1> Decls;
+  AST->findFileRegionDecls(SM.getMainFileID(), Code.find('X'), 0, Decls);
+  ASSERT_TRUE(Decls.size() == 2);
+  VarDecl *D = cast<VarDecl>(Decls[1]);
+  auto TL = D->getTypeSourceInfo()->getTypeLoc().castAs<MemberPointerTypeLoc>();
+  auto StarLoc = TL.getStarLoc().printToString(SM);
+  ASSERT_EQ(StarLoc, "input.cc:3:12");
+}