Revert "[Sema] Diagnose default-initialization, destruction, and copying of"

This reverts commit r365985.

Prior to r365985, clang used to mark C union fields that have
non-trivial ObjC ownership qualifiers as unavailable if the union was
declared in a system header. r365985 stopped doing so, which caused the
swift compiler to crash when it tried to import a non-trivial union.

I have a patch that fixes the crash (https://reviews.llvm.org/D65256),
but I'm temporarily reverting the original patch until we can decide on
whether it's taking the right approach.

llvm-svn: 367076

Author: ahatanaka

clang/include/clang/AST/Decl.h

@@ -3746,30 +3746,6 @@ class RecordDecl : public TagDecl {
     RecordDeclBits.NonTrivialToPrimitiveDestroy = V;
   }
 
-  bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
-    return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
-  }
-
-  void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V) {
-    RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion = V;
-  }
-
-  bool hasNonTrivialToPrimitiveDestructCUnion() const {
-    return RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion;
-  }
-
-  void setHasNonTrivialToPrimitiveDestructCUnion(bool V) {
-    RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion = V;
-  }
-
-  bool hasNonTrivialToPrimitiveCopyCUnion() const {
-    return RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion;
-  }
-
-  void setHasNonTrivialToPrimitiveCopyCUnion(bool V) {
-    RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion = V;
-  }
-
   /// Determine whether this class can be passed in registers. In C++ mode,
   /// it must have at least one trivial, non-deleted copy or move constructor.
   /// FIXME: This should be set as part of completeDefinition.

clang/include/clang/AST/DeclBase.h

@@ -1440,13 +1440,6 @@ class DeclContext {
     uint64_t NonTrivialToPrimitiveCopy : 1;
     uint64_t NonTrivialToPrimitiveDestroy : 1;
 
-    /// The following bits indicate whether this is or contains a C union that
-    /// is non-trivial to default-initialize, destruct, or copy. These bits
-    /// imply the associated basic non-triviality predicates declared above.
-    uint64_t HasNonTrivialToPrimitiveDefaultInitializeCUnion : 1;
-    uint64_t HasNonTrivialToPrimitiveDestructCUnion : 1;
-    uint64_t HasNonTrivialToPrimitiveCopyCUnion : 1;
-
     /// Indicates whether this struct is destroyed in the callee.
     uint64_t ParamDestroyedInCallee : 1;
 
@@ -1455,7 +1448,7 @@ class DeclContext {
   };
 
   /// Number of non-inherited bits in RecordDeclBitfields.
-  enum { NumRecordDeclBits = 14 };
+  enum { NumRecordDeclBits = 11 };
 
   /// Stores the bits used by OMPDeclareReductionDecl.
   /// If modified NumOMPDeclareReductionDeclBits and the accessor

clang/include/clang/AST/Type.h

@@ -1129,6 +1129,12 @@ class QualType {
     PCK_Struct
   };
 
+  /// Check if this is a non-trivial type that would cause a C struct
+  /// transitively containing this type to be non-trivial. This function can be
+  /// used to determine whether a field of this type can be declared inside a C
+  /// union.
+  bool isNonTrivialPrimitiveCType(const ASTContext &Ctx) const;
+
   /// Check if this is a non-trivial type that would cause a C struct
   /// transitively containing this type to be non-trivial to copy and return the
   /// kind.
@@ -1158,22 +1164,6 @@ class QualType {
     return isDestructedTypeImpl(*this);
   }
 
-  /// Check if this is or contains a C union that is non-trivial to
-  /// default-initialize, which is a union that has a member that is non-trivial
-  /// to default-initialize. If this returns true,
-  /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
-  bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;
-
-  /// Check if this is or contains a C union that is non-trivial to destruct,
-  /// which is a union that has a member that is non-trivial to destruct. If
-  /// this returns true, isDestructedType returns DK_nontrivial_c_struct.
-  bool hasNonTrivialToPrimitiveDestructCUnion() const;
-
-  /// Check if this is or contains a C union that is non-trivial to copy, which
-  /// is a union that has a member that is non-trivial to copy. If this returns
-  /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
-  bool hasNonTrivialToPrimitiveCopyCUnion() const;
-
   /// Determine whether expressions of the given type are forbidden
   /// from being lvalues in C.
   ///
@@ -1246,11 +1236,6 @@ class QualType {
                                                  const ASTContext &C);
   static QualType IgnoreParens(QualType T);
   static DestructionKind isDestructedTypeImpl(QualType type);
-
-  /// Check if \param RD is or contains a non-trivial C union.
-  static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
-  static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
-  static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
 };
 
 } // namespace clang
@@ -6264,24 +6249,6 @@ inline Qualifiers::GC QualType::getObjCGCAttr() const {
   return getQualifiers().getObjCGCAttr();
 }
 
-inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
-  if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
-    return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
-  return false;
-}
-
-inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
-  if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
-    return hasNonTrivialToPrimitiveDestructCUnion(RD);
-  return false;
-}
-
-inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
-  if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
-    return hasNonTrivialToPrimitiveCopyCUnion(RD);
-  return false;
-}
-
 inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
   if (const auto *PT = t.getAs<PointerType>()) {
     if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -620,23 +620,8 @@ def warn_cstruct_memaccess : Warning<
   InGroup<NonTrivialMemaccess>;
 def note_nontrivial_field : Note<
   "field is non-trivial to %select{copy|default-initialize}0">;
-def err_non_trivial_c_union_in_invalid_context : Error<
-  "cannot %select{"
-  "use type %1 for a function/method parameter|"
-  "use type %1 for function/method return|"
-  "default-initialize an object of type %1|"
-  "declare an automatic variable of type %1|"
-  "copy-initialize an object of type %1|"
-  "assign to a variable of type %1|"
-  "construct an automatic compound literal of type %1|"
-  "capture a variable of type %1|"
-  "cannot use volatile type %1 where it causes an lvalue-to-rvalue conversion"
-  "}3 "
-  "since it %select{contains|is}2 a union that is non-trivial to "
-  "%select{default-initialize|destruct|copy}0">;
-def note_non_trivial_c_union : Note<
-  "%select{%2 has subobjects that are|%3 has type %2 that is}0 "
-  "non-trivial to %select{default-initialize|destruct|copy}1">;
+def err_nontrivial_primitive_type_in_union : Error<
+  "non-trivial C types are disallowed in union">;
 def warn_dyn_class_memaccess : Warning<
   "%select{destination for|source of|first operand of|second operand of}0 this "
   "%1 call is a pointer to %select{|class containing a }2dynamic class %3; "

clang/include/clang/Sema/Sema.h

@@ -2114,48 +2114,6 @@ class Sema {
   bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
                                SourceLocation EqualLoc);
 
-  // Contexts where using non-trivial C union types can be disallowed. This is
-  // passed to err_non_trivial_c_union_in_invalid_context.
-  enum NonTrivialCUnionContext {
-    // Function parameter.
-    NTCUC_FunctionParam,
-    // Function return.
-    NTCUC_FunctionReturn,
-    // Default-initialized object.
-    NTCUC_DefaultInitializedObject,
-    // Variable with automatic storage duration.
-    NTCUC_AutoVar,
-    // Initializer expression that might copy from another object.
-    NTCUC_CopyInit,
-    // Assignment.
-    NTCUC_Assignment,
-    // Compound literal.
-    NTCUC_CompoundLiteral,
-    // Block capture.
-    NTCUC_BlockCapture,
-    // lvalue-to-rvalue conversion of volatile type.
-    NTCUC_LValueToRValueVolatile,
-  };
-
-  /// Emit diagnostics if the initializer or any of its explicit or
-  /// implicitly-generated subexpressions require copying or
-  /// default-initializing a type that is or contains a C union type that is
-  /// non-trivial to copy or default-initialize.
-  void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);
-
-  // These flags are passed to checkNonTrivialCUnion.
-  enum NonTrivialCUnionKind {
-    NTCUK_Init = 0x1,
-    NTCUK_Destruct = 0x2,
-    NTCUK_Copy = 0x4,
-  };
-
-  /// Emit diagnostics if a non-trivial C union type or a struct that contains
-  /// a non-trivial C union is used in an invalid context.
-  void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,
-                             NonTrivialCUnionContext UseContext,
-                             unsigned NonTrivialKind);
-
   void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
   void ActOnUninitializedDecl(Decl *dcl);
   void ActOnInitializerError(Decl *Dcl);

clang/lib/AST/Decl.cpp

@@ -4252,9 +4252,6 @@ RecordDecl::RecordDecl(Kind DK, TagKind TK, const ASTContext &C,
   setNonTrivialToPrimitiveDefaultInitialize(false);
   setNonTrivialToPrimitiveCopy(false);
   setNonTrivialToPrimitiveDestroy(false);
-  setHasNonTrivialToPrimitiveDefaultInitializeCUnion(false);
-  setHasNonTrivialToPrimitiveDestructCUnion(false);
-  setHasNonTrivialToPrimitiveCopyCUnion(false);
   setParamDestroyedInCallee(false);
   setArgPassingRestrictions(APK_CanPassInRegs);
 }

clang/lib/AST/Type.cpp

@@ -2276,16 +2276,60 @@ bool QualType::isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const {
          getObjCLifetime() != Qualifiers::OCL_Weak;
 }
 
-bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD) {
-  return RD->hasNonTrivialToPrimitiveDefaultInitializeCUnion();
-}
+namespace {
+// Helper class that determines whether this is a type that is non-trivial to
+// primitive copy or move, or is a struct type that has a field of such type.
+template <bool IsMove>
+struct IsNonTrivialCopyMoveVisitor
+    : CopiedTypeVisitor<IsNonTrivialCopyMoveVisitor<IsMove>, IsMove, bool> {
+  using Super =
+      CopiedTypeVisitor<IsNonTrivialCopyMoveVisitor<IsMove>, IsMove, bool>;
+  IsNonTrivialCopyMoveVisitor(const ASTContext &C) : Ctx(C) {}
+  void preVisit(QualType::PrimitiveCopyKind PCK, QualType QT) {}
+
+  bool visitWithKind(QualType::PrimitiveCopyKind PCK, QualType QT) {
+    if (const auto *AT = this->Ctx.getAsArrayType(QT))
+      return this->asDerived().visit(Ctx.getBaseElementType(AT));
+    return Super::visitWithKind(PCK, QT);
+  }
+
+  bool visitARCStrong(QualType QT) { return true; }
+  bool visitARCWeak(QualType QT) { return true; }
+  bool visitTrivial(QualType QT) { return false; }
+  // Volatile fields are considered trivial.
+  bool visitVolatileTrivial(QualType QT) { return false; }
+
+  bool visitStruct(QualType QT) {
+    const RecordDecl *RD = QT->castAs<RecordType>()->getDecl();
+    // We don't want to apply the C restriction in C++ because C++
+    // (1) can apply the restriction at a finer grain by banning copying or
+    //     destroying the union, and
+    // (2) allows users to override these restrictions by declaring explicit
+    //     constructors/etc, which we're not proposing to add to C.
+    if (isa<CXXRecordDecl>(RD))
+      return false;
+    for (const FieldDecl *FD : RD->fields())
+      if (this->asDerived().visit(FD->getType()))
+        return true;
+    return false;
+  }
 
-bool QualType::hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD) {
-  return RD->hasNonTrivialToPrimitiveDestructCUnion();
-}
+  const ASTContext &Ctx;
+};
 
-bool QualType::hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD) {
-  return RD->hasNonTrivialToPrimitiveCopyCUnion();
+} // namespace
+
+bool QualType::isNonTrivialPrimitiveCType(const ASTContext &Ctx) const {
+  if (isNonTrivialToPrimitiveDefaultInitialize())
+    return true;
+  DestructionKind DK = isDestructedType();
+  if (DK != DK_none && DK != DK_cxx_destructor)
+    return true;
+  if (IsNonTrivialCopyMoveVisitor<false>(Ctx).visit(*this))
+    return true;
+  if (IsNonTrivialCopyMoveVisitor<true>(Ctx).visit(*this))
+    return true;
+  return false;
 }
 
 QualType::PrimitiveDefaultInitializeKind

clang/lib/Sema/Sema.cpp

@@ -1658,24 +1658,12 @@ static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
   // Set the EscapingByref flag of __block variables captured by
   // escaping blocks.
   for (const BlockDecl *BD : FSI.Blocks) {
+    if (BD->doesNotEscape())
+      continue;
     for (const BlockDecl::Capture &BC : BD->captures()) {
       VarDecl *VD = BC.getVariable();
-      if (VD->hasAttr<BlocksAttr>()) {
-        // Nothing to do if this is a __block variable captured by a
-        // non-escaping block.
-        if (BD->doesNotEscape())
-          continue;
+      if (VD->hasAttr<BlocksAttr>())
         VD->setEscapingByref();
-      }
-      // Check whether the captured variable is or contains an object of
-      // non-trivial C union type.
-      QualType CapType = BC.getVariable()->getType();
-      if (CapType.hasNonTrivialToPrimitiveDestructCUnion() ||
-          CapType.hasNonTrivialToPrimitiveCopyCUnion())
-        S.checkNonTrivialCUnion(BC.getVariable()->getType(),
-                                BD->getCaretLocation(),
-                                Sema::NTCUC_BlockCapture,
-                                Sema::NTCUK_Destruct|Sema::NTCUK_Copy);
     }
   }