Remove false positive from -Wpessimizing-move and GNU statement expressions

[rtrieu]

Summary

Track whether the initialization came from a GNU statement expression. If it does, prevent the -Wpessiming-move warning from being emitted since the suggested fix can cause a compile error.

Fix for https://llvm.org/bugs/show_bug.cgi?id=25640

include/clang/Sema/Initialization.h

struct LN {
     /// location of the 'return', 'throw', or 'new' keyword,
     /// respectively. When Kind == EK_Temporary, the location where
     /// the temporary is being created.
     unsigned Location;
 
     /// \brief Whether the entity being initialized may end up using the
     /// named return value optimization (NRVO).
     bool NRVO;
+
+    /// \brief Whether the initialization is from the last expression of
+    /// a GNU statement expression.
+    bool GNUStatementExpression;
   };
 
   struct C {
     /// \brief The name of the variable being captured by an EK_LambdaCapture.
     IdentifierInfo *VarID;
 
     /// \brief The source location at which the capture occurs.
     unsigned Location;
private:
   InitializedEntity(VarDecl *Var)
     : Kind(EK_Variable), Parent(nullptr), Type(Var->getType()),
       ManglingNumber(0), VariableOrMember(Var) { }
   
   /// \brief Create the initialization entity for the result of a
   /// function, throwing an object, performing an explicit cast, or
   /// initializing a parameter for which there is no declaration.
   InitializedEntity(EntityKind Kind, SourceLocation Loc, QualType Type,
-                    bool NRVO = false)
+                    bool NRVO = false, bool GNUStatementExpression = false)
     : Kind(Kind), Parent(nullptr), Type(Type), ManglingNumber(0)
   {
     LocAndNRVO.Location = Loc.getRawEncoding();
     LocAndNRVO.NRVO = NRVO;
+    LocAndNRVO.GNUStatementExpression = GNUStatementExpression;
   }
   
   /// \brief Create the initialization entity for a member subobject.
   InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent) 
     : Kind(EK_Member), Parent(Parent), Type(Member->getType()),
       ManglingNumber(0), VariableOrMember(Member) { }
   
   /// \brief Create the initialization entity for an array element.
static InitializedEntity InitializeParameter(ASTContext &Context,
     Entity.Kind = EK_Parameter;
     Entity.Type = Context.getVariableArrayDecayedType(Type);
     Entity.Parent = nullptr;
     Entity.Parameter = (Consumed);
     return Entity;
   }
 
   /// \brief Create the initialization entity for the result of a function.
-  static InitializedEntity InitializeResult(SourceLocation ReturnLoc,
-                                            QualType Type, bool NRVO) {
-    return InitializedEntity(EK_Result, ReturnLoc, Type, NRVO);
+  static InitializedEntity
+  InitializeResult(SourceLocation ReturnLoc, QualType Type, bool NRVO,
+                   bool GNUStatementExpression = false) {
+    return InitializedEntity(EK_Result, ReturnLoc, Type, NRVO,
+                             GNUStatementExpression);
   }
 
   static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc,
                                            QualType Type, bool NRVO) {
     return InitializedEntity(EK_BlockElement, BlockVarLoc, Type, NRVO);
   }
   
   /// \brief Create the initialization entity for an exception object.
public:
   
   /// \brief Retrieve the ObjectiveC method being initialized.
   ObjCMethodDecl *getMethodDecl() const { return MethodDecl; }
 
   /// \brief Determine whether this initialization allows the named return 
   /// value optimization, which also applies to thrown objects.
   bool allowsNRVO() const;
 
+  /// \brief Determine whether this initializiation is from the final
+  /// expression of GNU statement expression.
+  bool isGNUStatementExpression() const;
+
   bool isParameterKind() const {
     return (getKind() == EK_Parameter  ||
             getKind() == EK_Parameter_CF_Audited);
   }
   /// \brief Determine whether this initialization consumes the
   /// parameter.
   bool isParameterConsumed() const {
     assert(isParameterKind() && "Not a parameter");

lib/Sema/SemaExpr.cpp

if (Expr *LastE = dyn_cast<Expr>(LastStmt)) {
         // initialization will create a produce.  In both cases the
         // result will be +1, and we'll need to balance that out with
         // a bind.
         if (Expr *rebuiltLastStmt
               = maybeRebuildARCConsumingStmt(LastExpr.get())) {
           LastExpr = rebuiltLastStmt;
         } else {
           LastExpr = PerformCopyInitialization(
-                            InitializedEntity::InitializeResult(LPLoc, 
-                                                                Ty,
-                                                                false),
-                                                   SourceLocation(),
-                                               LastExpr);
+              InitializedEntity::InitializeResult(LPLoc, Ty, false, true),
+              SourceLocation(), LastExpr);
         }
 
         if (LastExpr.isInvalid())
           return ExprError();
         if (LastExpr.get() != nullptr) {
           if (!LastLabelStmt)
             Compound->setLastStmt(LastExpr.get());
           else

lib/Sema/SemaInit.cpp

bool InitializedEntity::allowsNRVO() const {
   case EK_LambdaCapture:
   case EK_RelatedResult:
     break;
   }
 
   return false;
 }
 
+bool InitializedEntity::isGNUStatementExpression() const {
+  switch (getKind()) {
+  case EK_Result:
+    return LocAndNRVO.GNUStatementExpression;
+
+  case EK_Exception:
+  case EK_Variable:
+  case EK_Parameter:
+  case EK_Parameter_CF_Audited:
+  case EK_Member:
+  case EK_New:
+  case EK_Temporary:
+  case EK_CompoundLiteralInit:
+  case EK_Base:
+  case EK_Delegating:
+  case EK_ArrayElement:
+  case EK_VectorElement:
+  case EK_ComplexElement:
+  case EK_BlockElement:
+  case EK_LambdaCapture:
+  case EK_RelatedResult:
+    break;
+  }
+
+  return false;
+}
+
+
 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
   assert(getParent() != this);
   unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
   for (unsigned I = 0; I != Depth; ++I)
     OS << "`-";
 
   switch (getKind()) {
   case EK_Variable: OS << "Variable"; break;
InitializationSequence::Perform(Sema &S,
   if (Entity.getKind() == InitializedEntity::EK_Member &&
       cast<FieldDecl>(Entity.getDecl())->isBitField())
     S.CheckBitFieldInitialization(Kind.getLocation(),
                                   cast<FieldDecl>(Entity.getDecl()),
                                   CurInit.get());
 
   // Check for std::move on construction.
   if (const Expr *E = CurInit.get()) {
+    if (!Entity.isGNUStatementExpression())
       CheckMoveOnConstruction(S, E,
                               Entity.getKind() == InitializedEntity::EK_Result);
   }
 
   return CurInit;
 }
 
 /// Somewhere within T there is an uninitialized reference subobject.
 /// Dig it out and diagnose it.
 static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,

test/SemaCXX/warn-pessmizing-move.cpp

T1 test2() {
     T2 t;
     return std::move(t);
   }
   void run_test2() {
     test2<A, A>();
     test2<B, A>();
   }
 }
+
+// Don't warn on GNU statement expressions.
+namespace GNU {
+  class A {};
+  class B {
+  public:
+    B();
+    B(B &&);
+  private:
+    B(const B &);
+  };
+
+  void test() {
+    A a = ({auto a = A(); std::move(a); });
+    B b = ({auto b = B(); std::move(b); });
+  }
+
+  auto b = std::move(B());
+}