naming changes

Author: AnthonyLatsis

include/swift/AST/DiagnosticsSema.def

@@ -3209,8 +3209,8 @@ ERROR(unsupported_recursive_struct,none,
       "contains it",
       (Type))
 
-WARNING(enum_not_constructible,none,
-        "enum containing only recursive cases is not constructible", ())
+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,7 +169,7 @@ class CircularityChecker {
   bool diagnoseInfiniteRecursion(CanType parentType, ValueDecl *member,
                                  CanType memberType);
 
-  void diagnoseNotConstructible(EnumDecl *E);
+  void diagnoseNonWellFoundedEnum(EnumDecl *E);
 
   void addPathElementsTo(Path &path, CanType type);
   void addPathElement(Path &path, ValueDecl *member, CanType memberType);
@@ -275,7 +275,8 @@ bool CircularityChecker::expandEnum(CanType type, EnumDecl *E,
                                    unsigned depth) {
   // Indirect enums are representational leaves.
   if (E->isIndirect()) {
-    diagnoseNotConstructible(E);
+    // Diagnose whether the enum is non-well-founded before bailing
+    diagnoseNonWellFoundedEnum(E);
     return false;
   }
 
@@ -303,7 +304,7 @@ bool CircularityChecker::expandEnum(CanType type, EnumDecl *E,
     if (addMember(type, elt, eltType, depth))
       return true;
   }
-  diagnoseNotConstructible(E);
+  diagnoseNonWellFoundedEnum(E);
 
   return false;
 }
@@ -608,9 +609,10 @@ bool CircularityChecker::diagnoseInfiniteRecursion(CanType parentType,
   return true;
 }
 
-/// Show a warning if the enum is not constructible. The outcome of this method
-/// is irrelevant.
-void CircularityChecker::diagnoseNotConstructible(EnumDecl *E) {
+/// 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()) {
@@ -619,7 +621,7 @@ void CircularityChecker::diagnoseNotConstructible(EnumDecl *E) {
     }
     return false;
   };
-  auto isNotConstructible = [containsType, E]() -> bool {
+  auto isNonWellFounded = [containsType, E]() -> bool {
     auto elts = E->getAllElements();
     if (elts.empty())
       return false;
@@ -644,6 +646,6 @@ void CircularityChecker::diagnoseNotConstructible(EnumDecl *E) {
     return true;
   };
 
-  if (isNotConstructible())
-    TC.diagnose(E, diag::enum_not_constructible);
+  if (isNonWellFounded())
+    TC.diagnose(E, diag::enum_non_well_founded);
 }

test/Sema/unsupported_recursive_value_type.swift

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