Fix assertion failure in thread safety analysis (PR34800).

[alexfh]

Summary

Fix an assertion failure (http://llvm.org/PR34800) and clean up unused code relevant to the fixed logic.

A bit of context: when SExprBuilder::translateMemberExpr is called on a member expression that involves a conversion operator, for example, til::Project constructor can't just call getName() on it, since the name is not a simple identifier. In order to handle this case I've introduced an optional string to print the member name to. I discovered that the other two til::Project constructors are not used, so it was better to delete them instead of ensuring they work correctly with the new logic.

[alexfh]

include/clang/Analysis/Analyses/ThreadSafetyTIL.h

931–936 ↗

(On Diff #117343)

BTW, alternatively, I could do:

if (!SlotName) {
  SlotName = "";
  llvm::raw_string_ostream OS(*SlotName);
  Cvdecl->printName(OS);
}

Not sure which of these would be preferred in this code.

[aaron.ballman]

LGTM!

[alexfh]

Get rid of a local string variable.

cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTIL.h

 };
 
 
 /// Project a named slot from a C++ struct or class.
 class Project : public SExpr {
 public:
   static bool classof(const SExpr *E) { return E->opcode() == COP_Project; }
 
-  Project(SExpr *R, StringRef SName)
-      : SExpr(COP_Project), Rec(R), SlotName(SName), Cvdecl(nullptr)
-  { }
   Project(SExpr *R, const clang::ValueDecl *Cvd)
-      : SExpr(COP_Project), Rec(R), SlotName(Cvd->getName()), Cvdecl(Cvd)
-  { }
-  Project(const Project &P, SExpr *R)
-      : SExpr(P), Rec(R), SlotName(P.SlotName), Cvdecl(P.Cvdecl)
-  { }
+      : SExpr(COP_Project), Rec(R), Cvdecl(Cvd) {
+    assert(Cvd && "ValueDecl must not be null");
+  }
 
   SExpr *record() { return Rec; }
   const SExpr *record() const { return Rec; }
 
   const clang::ValueDecl *clangDecl() const { return Cvdecl; }
 
   bool isArrow() const { return (Flags & 0x01) != 0; }
   void setArrow(bool b) {
     if (b) Flags |= 0x01;
     else Flags &= 0xFFFE;
   }
 
   StringRef slotName() const {
-    if (Cvdecl)
+    if (Cvdecl->getDeclName().isIdentifier())
       return Cvdecl->getName();
-    else
-      return SlotName;
+    if (!SlotName) {
+      SlotName = "";
+      llvm::raw_string_ostream OS(*SlotName);
+      Cvdecl->printName(OS);
+    }
+    return *SlotName;
   }
 
   template <class V>
   typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
     auto Nr = Vs.traverse(Rec, Vs.subExprCtx(Ctx));
     return Vs.reduceProject(*this, Nr);
   }
 
   template <class C>
   typename C::CType compare(const Project* E, C& Cmp) const {
     typename C::CType Ct = Cmp.compare(record(), E->record());
     if (Cmp.notTrue(Ct))
       return Ct;
     return Cmp.comparePointers(Cvdecl, E->Cvdecl);
   }
 
 private:
   SExpr* Rec;
-  StringRef SlotName;
+  mutable llvm::Optional<std::string> SlotName;
   const clang::ValueDecl *Cvdecl;
 };
 
 
 /// Call a function (after all arguments have been applied).
 class Call : public SExpr {
 public:
   static bool classof(const SExpr *E) { return E->opcode() == COP_Call; }

cfe/trunk/test/SemaCXX/warn-thread-safety-analysis.cpp

 
 // This used to crash.
 class acquired_before_empty_str {
   void WaitUntilSpaceAvailable() {
     lock_.ReaderLock(); // expected-note {{acquired here}}
   } // expected-warning {{mutex 'lock_' is still held at the end of function}}
   Mutex lock_ ACQUIRED_BEFORE("");
 };
+
+namespace PR34800 {
+struct A {
+  operator int() const;
+};
+struct B {
+  bool g() __attribute__((locks_excluded(h))); // expected-warning {{'locks_excluded' attribute requires arguments whose type is annotated with 'capability' attribute; type here is 'int'}}
+  int h;
+};
+struct C {
+  B *operator[](int);
+};
+C c;
+void f() { c[A()]->g(); }
+} // namespace PR34800