Merge pull request #16987 from AnthonyLatsis/warn-unconstructible-enum

[Diagnostics][Sema] warn inconstructible enum

Author: jckarter

include/swift/AST/DiagnosticsSema.def

@@ -3207,6 +3207,8 @@ ERROR(unsupported_recursive_struct,none,
       "contains it",
       (Type))
 
+WARNING(enum_non_well_founded,none,
+        "enum containing only recursive cases is impossible to instantiate", ())
 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 diagnoseNonWellFoundedEnum(EnumDecl *E);
+
   void addPathElementsTo(Path &path, CanType type);
   void addPathElement(Path &path, ValueDecl *member, CanType memberType);
 
@@ -272,7 +274,11 @@ 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()) {
+    // Diagnose whether the enum is non-well-founded before bailing
+    diagnoseNonWellFoundedEnum(E);
+    return false;
+  }
 
   startExpandingType(type);
 
@@ -298,6 +304,7 @@ bool CircularityChecker::expandEnum(CanType type, EnumDecl *E,
     if (addMember(type, elt, eltType, depth))
       return true;
   }
+  diagnoseNonWellFoundedEnum(E);
 
   return false;
 }
@@ -601,3 +608,44 @@ bool CircularityChecker::diagnoseInfiniteRecursion(CanType parentType,
 
   return true;
 }
+
+/// Show a warning if all cases of the given enum are recursive,
+/// making it impossible to be instantiated. Such an enum is 'non-well-founded'.
+/// The outcome of this method is irrelevant.
+void CircularityChecker::diagnoseNonWellFoundedEnum(EnumDecl *E) {
+
+  auto containsType = [](TupleType *tuple, Type E) -> bool {
+    for (auto type: tuple->getElementTypes()) {
+      if (type->isEqual(E))
+        return true;
+    }
+    return false;
+  };
+  auto isNonWellFounded = [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 (isNonWellFounded())
+    TC.diagnose(E, diag::enum_non_well_founded);
+}

test/Sema/unsupported_recursive_value_type.swift

@@ -42,6 +42,31 @@ enum RecursiveByGenericSubstitutionEnum<T> {
   case A(T)
 }
 
+enum InconstructibleEnum1 { // expected-warning {{enum containing only recursive cases is impossible to instantiate}}
+  indirect case A(InconstructibleEnum1)
+}
+enum InconstructibleEnum2 { // OK
+  indirect case A(InconstructibleEnum2)
+  case B(Bool)
+  indirect case C(Int, InconstructibleEnum2)
+}
+enum InconstructibleEnum3 { // expected-warning {{enum containing only recursive cases is impossible to instantiate}}
+  indirect case B(Int, InconstructibleEnum3)
+}
+indirect enum InconstructibleEnum4 {
+  // expected-warning@-1 {{enum containing only recursive cases is impossible to instantiate}}
+  case A(InconstructibleEnum4)
+}
+indirect enum InconstructibleEnum5 {
+  // expected-warning@-1 {{enum containing only recursive cases is impossible to instantiate}}
+  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)}}