[Diagnostics][Sema] warn inconstructible enum

Author: AnthonyLatsis

include/swift/AST/DiagnosticsSema.def

@@ -3209,6 +3209,8 @@ ERROR(unsupported_recursive_struct,none,
       "contains it",
       (Type))
 
+WARNING(type_not_constructible,none,
+        "value type is inconstructible", ())
 ERROR(recursive_enum_not_indirect,none,
       "recursive enum %0 is not marked 'indirect'", (Type))
 ERROR(unsupported_infinitely_sized_type,none,

lib/Sema/TypeCheckCircularity.cpp

@@ -169,6 +169,8 @@ class CircularityChecker {
   bool diagnoseInfiniteRecursion(CanType parentType, ValueDecl *member,
                                  CanType memberType);
 
+  void diagnoseInconstructible(EnumDecl *E);
+
   void addPathElementsTo(Path &path, CanType type);
   void addPathElement(Path &path, ValueDecl *member, CanType memberType);
 
@@ -272,7 +274,10 @@ bool CircularityChecker::expandStruct(CanType type, StructDecl *S,
 bool CircularityChecker::expandEnum(CanType type, EnumDecl *E,
                                    unsigned depth) {
   // Indirect enums are representational leaves.
-  if (E->isIndirect()) return false;
+  if (E->isIndirect()) {
+    diagnoseInconstructible(E);
+    return false;
+  }
 
   startExpandingType(type);
 
@@ -298,6 +303,7 @@ bool CircularityChecker::expandEnum(CanType type, EnumDecl *E,
     if (addMember(type, elt, eltType, depth))
       return true;
   }
+  diagnoseInconstructible(E);
 
   return false;
 }
@@ -601,3 +607,43 @@ bool CircularityChecker::diagnoseInfiniteRecursion(CanType parentType,
 
   return true;
 }
+
+// Show a warning if the enum is inconstructible. The outcome of this method
+// is irrelevant.
+void CircularityChecker::diagnoseInconstructible(EnumDecl *E) {
+
+  auto containsType = [](TupleType *tuple, Type E) -> bool {
+    for (auto type: tuple->getElementTypes()) {
+      if (type->isEqual(E))
+        return true;
+    }
+    return false;
+  };
+  auto isInconstructible = [containsType, E]() -> bool {
+    auto elts = E->getAllElements();
+    if (elts.empty())
+      return false;
+
+    for (auto elt: elts) {
+      if (!elt->hasInterfaceType() ||
+          !(elt->isIndirect() || E->isIndirect()))
+        return false;
+
+      auto argTy = elt->getArgumentInterfaceType();
+      if (!argTy)
+        return false;
+
+      if (auto tuple = argTy->getAs<TupleType>()) {
+        if (!containsType(tuple, E->getSelfInterfaceType()))
+          return false;
+      } else if (auto paren = dyn_cast<ParenType>(argTy.getPointer())) {
+        if (!E->getSelfInterfaceType()->isEqual(paren->getUnderlyingType()))
+          return false;
+      }
+    }
+    return true;
+  };
+
+  if (isInconstructible())
+    TC.diagnose(E, diag::type_not_constructible);
+}

test/Sema/unsupported_recursive_value_type.swift

@@ -42,6 +42,29 @@ enum RecursiveByGenericSubstitutionEnum<T> {
   case A(T)
 }
 
+enum InconstructibleEnum1 { // expected-warning {{value type is inconstructible}}
+  indirect case A(InconstructibleEnum1)
+}
+enum InconstructibleEnum2 { // OK
+  indirect case A(InconstructibleEnum2)
+  case B(Bool)
+  indirect case C(Int, InconstructibleEnum2)
+}
+enum InconstructibleEnum3 { // expected-warning {{value type is inconstructible}}
+  indirect case B(Int, InconstructibleEnum3)
+}
+indirect enum InconstructibleEnum4 { // expected-warning {{value type is inconstructible}}
+  case A(InconstructibleEnum4)
+}
+indirect enum InconstructibleEnum5 { // expected-warning {{value type is inconstructible}}
+  case B(Int, InconstructibleEnum5)
+}
+indirect enum InconstructibleEnum6 { // OK
+  case A(InconstructibleEnum6)
+  case B(Bool)
+  case C(Int, InconstructibleEnum6)
+}
+
 struct RecursiveByBeingInTupleStruct {
   let a: (Int, RecursiveByBeingInTupleStruct) // expected-error{{value type 'RecursiveByBeingInTupleStruct' cannot have a stored property that recursively contains it}}
   // expected-note@-1 {{cycle beginning here: (Int, RecursiveByBeingInTupleStruct) -> (.1: RecursiveByBeingInTupleStruct)}}