[NFC][Clang] Fix Static Code Analysis Concerns with copy without assign

[Manna]

Summary

This patch adds missing assignment operator to the class which has user-defined copy constructor.

[aaronpuchert]

Can only comment on ThreadSafetyTIL.h. Thanks for addressing this, I agree that these expressions should not be assignable.

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

324–325

We can probably even drop the comment. Types in an inheritance hierarchy tend to be not assignable, and I don't see why it would ever be needed for what amounts to be AST nodes.

384–386

My understanding is that deleting copy assignment on the base class automatically deletes it for the derived classes, so I'd appreciate if we could drop this and the following additions. That's just noise in my view.

Also, most of these classes don't seem to have a user-declared copy constructor, or am I missing something?

[Manna]

I have addressed review comments.

[Manna]

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

324–325

Thank you @aaronpuchert for reviews and feedbacks.

I have dropped the comment.

384–386

Yup, Sounds reasonable to me. Removed

[Manna]

I have updated patch to resolve build errors.

[aaronpuchert]

Changes to ThreadSafetyTIL.h look good to me, thanks!

[Manna]

In D150931#4358903, @aaronpuchert wrote:

Changes to ThreadSafetyTIL.h look good to me, thanks!

Thank you @aaronpuchert for reviews!

[Manna]

ping @tahonermann

[tahonermann]

These changes look fine to me.

[Manna]

Thank you @tahonermann and @aaronpuchert for reviews and comments!

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

public:
   BasicBlock *block() const { return Block; }
 
   /// Set the basic block and instruction ID for this expression.
   void setID(BasicBlock *B, unsigned id) { Block = B; SExprID = id; }
 
 protected:
   SExpr(TIL_Opcode Op) : Opcode(Op) {}
   SExpr(const SExpr &E) : Opcode(E.Opcode), Flags(E.Flags) {}
+  SExpr &operator=(const SExpr &) = delete;
 
   const TIL_Opcode Opcode;
   unsigned char Reserved = 0;
   unsigned short Flags = 0;
   unsigned SExprID = 0;
   BasicBlock *Block = nullptr;
 };
 
 // Contains various helper functions for SExprs.
 namespace ThreadSafetyTIL {
 
Variable(SExpr *D, const ValueDecl *Cvd = nullptr)
     Flags = VK_Let;
   }
 
   Variable(const Variable &Vd, SExpr *D)  // rewrite constructor
       : SExpr(Vd), Name(Vd.Name), Definition(D), Cvdecl(Vd.Cvdecl) {
     Flags = Vd.kind();
   }
 
   static bool classof(const SExpr *E) { return E->opcode() == COP_Variable; }
 
   /// Return the kind of variable (let, function param, or self)
   VariableKind kind() const { return static_cast<VariableKind>(Flags); }
 
   /// Return the name of the variable, if any.
   StringRef name() const { return Name; }
 
   /// Return the clang declaration for this variable, if any.
   const ValueDecl *clangDecl() const { return Cvdecl; }
 

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

 class CallEvent;
 
 template<typename T = CallEvent>
 class CallEventRef : public IntrusiveRefCntPtr<const T> {
 public:
   CallEventRef(const T *Call) : IntrusiveRefCntPtr<const T>(Call) {}
   CallEventRef(const CallEventRef &Orig) : IntrusiveRefCntPtr<const T>(Orig) {}
 
+  // The copy assignment operator is defined as deleted pending further
+  // motivation.
+  CallEventRef &operator=(const CallEventRef &) = delete;
+
   CallEventRef<T> cloneWithState(ProgramStateRef State) const {
     return this->get()->template cloneWithState<T>(State);
   }
 
   // Allow implicit conversions to a superclass type, since CallEventRef
   // behaves like a pointer-to-const.
   template <typename SuperT>
   operator CallEventRef<SuperT> () const {