Fix SR-2134: emit 'rawValue' bodies for enums with a generic raw value

include/swift/AST/DiagnosticsSema.def

@@ -1702,6 +1702,11 @@ ERROR(raw_type_not_literal_convertible,none,
 ERROR(enum_raw_type_not_equatable,none,
       "RawRepresentable 'init' cannot be synthesized because raw type %0 is not "
       "Equatable", (Type))
+ERROR(enum_raw_type_nonconforming_and_nonsynthable,none,
+      "%0 declares raw type %1, but does not conform to RawRepresentable "
+      "and conformance could not be synthesized", (Type, Type))
+NOTE(enum_declares_rawrep_with_raw_type,none,
+      "%0 declares raw type %1, which implies RawRepresentable", (Type, Type))
 ERROR(enum_raw_type_access,none,
       "enum %select{must be declared "
       "%select{private|fileprivate|internal|PUBLIC}2"

lib/AST/Decl.cpp

@@ -2031,8 +2031,8 @@ bool NominalTypeDecl::derivesProtocolConformance(ProtocolDecl *protocol) const {
 
   if (auto *enumDecl = dyn_cast<EnumDecl>(this)) {
     switch (*knownProtocol) {
-    // Enums with raw types can implicitly derive their RawRepresentable
-    // conformance.
+    // The presence of a raw type is an explicit declaration that
+    // the compiler should derive a RawRepresentable conformance.
     case KnownProtocolKind::RawRepresentable:
       return enumDecl->hasRawType();
 

lib/AST/DeclContext.cpp

@@ -213,6 +213,7 @@ GenericParamList *DeclContext::getGenericParamsOfContext() const {
     }
     llvm_unreachable("bad DeclContextKind");
   }
+  llvm_unreachable("unknown parent");
 }
 
 GenericSignature *DeclContext::getGenericSignatureOfContext() const {

lib/AST/ProtocolConformance.cpp

@@ -606,10 +606,14 @@ void NominalTypeDecl::prepareConformanceTable() const {
     if (resolver)
       resolver->resolveRawType(theEnum);
     if (theEnum->hasRawType()) {
-      if (auto rawRepresentable = getASTContext().getProtocol(
-                                    KnownProtocolKind::RawRepresentable)) {
-        ConformanceTable->addSynthesizedConformance(mutableThis,
-                                                    rawRepresentable);
+      if (auto rawRepresentable = ctx.getProtocol(KnownProtocolKind::RawRepresentable)) {
+
+        // The presence of a raw type is an explicit declaration that
+        // the compiler should derive a RawRepresentable conformance.
+        auto conformance = ctx.getConformance(mutableThis->getDeclaredTypeInContext(), rawRepresentable,
+                                              mutableThis->getNameLoc(), mutableThis->getInnermostDeclContext(),
+                                              ProtocolConformanceState::Incomplete);
+        ConformanceTable->registerProtocolConformance(conformance);
       }
     }
   }

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -82,11 +82,12 @@ static void deriveBodyRawRepresentable_raw(AbstractFunctionDecl *toRawDecl) {
 
   Type rawTy = enumDecl->getRawType();
   assert(rawTy);
+  rawTy = ArchetypeBuilder::mapTypeIntoContext(toRawDecl, rawTy);
+
   for (auto elt : enumDecl->getAllElements()) {
-    if (!elt->getTypeCheckedRawValueExpr() ||
-        !elt->getTypeCheckedRawValueExpr()->getType()->isEqual(rawTy)) {
-      return;
-    }
+    assert(elt->getTypeCheckedRawValueExpr() &&
+		"Enum element has no literal - missing a call to checkEnumRawValues()");
+    assert(elt->getTypeCheckedRawValueExpr()->getType()->isEqual(rawTy));
   }
 
   Type enumType = parentDC->getDeclaredTypeInContext();
@@ -186,10 +187,9 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl) {
   rawTy = ArchetypeBuilder::mapTypeIntoContext(initDecl, rawTy);
 
   for (auto elt : enumDecl->getAllElements()) {
-    if (!elt->getTypeCheckedRawValueExpr() ||
-        !elt->getTypeCheckedRawValueExpr()->getType()->isEqual(rawTy)) {
-      return;
-    }
+    assert(elt->getTypeCheckedRawValueExpr() &&
+		"Enum element has no literal - missing a call to checkEnumRawValues()");
+    assert(elt->getTypeCheckedRawValueExpr()->getType()->isEqual(rawTy));
   }
 
   Type enumType = parentDC->getDeclaredTypeInContext();
@@ -257,18 +257,11 @@ static ConstructorDecl *deriveRawRepresentable_init(TypeChecker &tc,
   auto rawType = ArchetypeBuilder::mapTypeIntoContext(parentDC,
                                                       rawInterfaceType);
 
-  // Make sure that the raw type is Equatable. We need it to ensure that we have
-  // a suitable ~= for the switch.
   auto equatableProto = tc.getProtocol(enumDecl->getLoc(),
                                        KnownProtocolKind::Equatable);
-  if (!equatableProto)
-    return nullptr;
-
-  if (!tc.conformsToProtocol(rawType, equatableProto, enumDecl, None)) {
-    SourceLoc loc = enumDecl->getInherited()[0].getSourceRange().Start;
-    tc.diagnose(loc, diag::enum_raw_type_not_equatable, rawType);
-    return nullptr;
-  }
+  assert(equatableProto);
+  assert(tc.conformsToProtocol(rawType, equatableProto, enumDecl, None));
+  (void)equatableProto;
 
   Type enumType = parentDC->getDeclaredTypeInContext();
   auto *selfDecl = ParamDecl::createUnboundSelf(SourceLoc(), parentDC,
@@ -353,31 +346,62 @@ static ConstructorDecl *deriveRawRepresentable_init(TypeChecker &tc,
   return initDecl;
 }
 
-ValueDecl *DerivedConformance::deriveRawRepresentable(TypeChecker &tc,
-                                                      Decl *parentDecl,
-                                                      NominalTypeDecl *type,
-                                                      ValueDecl *requirement) {
-  // Check preconditions. These should already have been diagnosed by
-  // type-checking but we may still get here after recovery.
-
-  // The type must be an enum.
-  auto enumDecl = dyn_cast<EnumDecl>(type);
-  if (!enumDecl)
-    return nullptr;
-
+static bool canSynthesizeRawRepresentable(TypeChecker &tc, Decl *parentDecl, EnumDecl *enumDecl) {
+
   // It must have a valid raw type.
-  if (!enumDecl->hasRawType())
-    return nullptr;
+  Type rawType = enumDecl->getRawType();
+  if (!rawType)
+    return false;
+  auto parentDC = cast<DeclContext>(parentDecl);
+  rawType       = ArchetypeBuilder::mapTypeIntoContext(parentDC, rawType);
+
   if (!enumDecl->getInherited().empty() &&
       enumDecl->getInherited().front().isError())
-    return nullptr;
+    return false;
+
+  // The raw type must be Equatable, so that we have a suitable ~= for synthesized switch statements.
+  auto equatableProto = tc.getProtocol(enumDecl->getLoc(),
+                                       KnownProtocolKind::Equatable);
+  if (!equatableProto)
+    return false;
+
+  if (!tc.conformsToProtocol(rawType, equatableProto, enumDecl, None)) {
+    SourceLoc loc = enumDecl->getInherited()[0].getSourceRange().Start;
+    tc.diagnose(loc, diag::enum_raw_type_not_equatable, rawType);
+    return false;
+  }
 
   // There must be enum elements.
   if (enumDecl->getAllElements().empty())
-    return nullptr;
+    return false;
 
-  for (auto elt : enumDecl->getAllElements())
+  // Have the type-checker validate that:
+  // - the enum elements all have the same type
+  // - they all match the enum type
+  for (auto elt : enumDecl->getAllElements()) {
     tc.validateDecl(elt);
+    if (elt->isInvalid()) {
+      return false;
+    }
+  }
+
+  // If it meets all of those requirements, we can synthesize RawRepresentable conformance.
+  return true;
+}
+
+ValueDecl *DerivedConformance::deriveRawRepresentable(TypeChecker &tc,
+                                                      Decl *parentDecl,
+                                                      NominalTypeDecl *type,
+                                                      ValueDecl *requirement) {
+
+  // We can only synthesize RawRepresentable for enums.
+  auto enumDecl = dyn_cast<EnumDecl>(type);
+  if (!enumDecl)
+    return nullptr;
+
+  // Check other preconditions for synthesized conformance.
+  if (!canSynthesizeRawRepresentable(tc, parentDecl, enumDecl))
+    return nullptr;
 
   if (requirement->getName() == tc.Context.Id_rawValue)
     return deriveRawRepresentable_raw(tc, parentDecl, enumDecl);
@@ -394,27 +418,15 @@ Type DerivedConformance::deriveRawRepresentable(TypeChecker &tc,
                                                 Decl *parentDecl,
                                                 NominalTypeDecl *type,
                                                 AssociatedTypeDecl *assocType) {
-  // Check preconditions. These should already have been diagnosed by
-  // type-checking but we may still get here after recovery.
-
-  // The type must be an enum.
+
+  // We can only synthesize RawRepresentable for enums.
   auto enumDecl = dyn_cast<EnumDecl>(type);
   if (!enumDecl)
     return nullptr;
-
-  // It must have a valid raw type.
-  if (!enumDecl->hasRawType())
-    return nullptr;
-  if (!enumDecl->getInherited().empty() &&
-      enumDecl->getInherited().front().isError())
-    return nullptr;
-
-  // There must be enum elements.
-  if (enumDecl->getAllElements().empty())
-    return nullptr;
 
-  for (auto elt : enumDecl->getAllElements())
-    tc.validateDecl(elt);
+  // Check other preconditions for synthesized conformance.
+  if (!canSynthesizeRawRepresentable(tc, parentDecl, enumDecl))
+    return nullptr;
 
   if (assocType->getName() == tc.Context.Id_RawValue) {
     return deriveRawRepresentable_Raw(tc, parentDecl, enumDecl);

lib/Sema/TypeCheckDecl.cpp

@@ -2569,6 +2569,7 @@ static void checkEnumRawValues(TypeChecker &TC, EnumDecl *ED) {
                   diag::enum_with_raw_type_case_with_argument);
       TC.diagnose(ED->getInherited().front().getSourceRange().Start,
                   diag::enum_raw_type_here, rawTy);
+      elt->setInvalid();
       continue;
     }
 
@@ -2587,6 +2588,7 @@ static void checkEnumRawValues(TypeChecker &TC, EnumDecl *ED) {
       // is the first element.
       auto nextValue = getAutomaticRawValueExpr(TC, valueKind, elt, prevValue);
       if (!nextValue) {
+        elt->setInvalid();
         break;
       }
       elt->setRawValueExpr(nextValue);

lib/Sema/TypeCheckProtocol.cpp

@@ -3924,13 +3924,25 @@ static void diagnoseConformanceFailure(TypeChecker &TC, Type T,
     return;
   }
 
-  // As a special case, diagnose conversion to ExpressibleByNilLiteral, since we
+  // Special case: diagnose conversion to ExpressibleByNilLiteral, since we
   // know this is something involving 'nil'.
   if (Proto->isSpecificProtocol(KnownProtocolKind::ExpressibleByNilLiteral)) {
     TC.diagnose(ComplainLoc, diag::cannot_use_nil_with_this_type, T);
     return;
   }
 
+  // Special case: for enums with a raw type, explain that the failing
+  // conformance to RawRepresentable was inferred.
+  if (auto enumDecl = T->getEnumOrBoundGenericEnum()) {
+	if (Proto->isSpecificProtocol(KnownProtocolKind::RawRepresentable) &&
+		enumDecl->derivesProtocolConformance(Proto) && enumDecl->hasRawType()) {
+
+      TC.diagnose(enumDecl->getInherited()[0].getSourceRange().Start,
+                  diag::enum_raw_type_nonconforming_and_nonsynthable,
+                  T, enumDecl->getRawType());
+      return;
+    }
+  }
 
   TC.diagnose(ComplainLoc, diag::type_does_not_conform,
               T, Proto->getDeclaredType());
@@ -4718,6 +4730,19 @@ void TypeChecker::checkConformancesInContext(DeclContext *dc,
              dc->getDeclaredTypeInContext(),
              diag.Protocol->getName());
 
+    // Special case: explain that 'RawRepresentable' conformance
+    // is implied for enums which already declare a raw type.
+    if (auto enumDecl = dyn_cast<EnumDecl>(existingDecl)) {
+      if (diag.Protocol->isSpecificProtocol(KnownProtocolKind::RawRepresentable) &&
+          enumDecl->derivesProtocolConformance(diag.Protocol) &&
+          enumDecl->hasRawType()) {
+        diagnose(enumDecl->getInherited()[0].getSourceRange().Start,
+                 diag::enum_declares_rawrep_with_raw_type,
+                 dc->getDeclaredTypeInContext(), enumDecl->getRawType());
+        continue;
+      }
+    }
+
     diagnose(existingDecl, diag::declared_protocol_conformance_here,
              dc->getDeclaredTypeInContext(),
              static_cast<unsigned>(diag.ExistingKind),

test/Generics/inheritance.swift

@@ -56,21 +56,27 @@ func testGenericInherit() {
 
 
 struct SS<T> : T { } // expected-error{{inheritance from non-protocol type 'T'}}
-enum SE<T> : T { case X } // expected-error{{raw type 'T' is not expressible by any literal}}
-// expected-error@-1{{type 'SE<T>' does not conform to protocol 'RawRepresentable'}}
+enum SE<T> : T { case X } // expected-error{{raw type 'T' is not expressible by any literal}} expected-error {{SE<T>' declares raw type 'T', but does not conform to RawRepresentable and conformance could not be synthesized}}
 
 // Also need Equatable for init?(RawValue)
-enum SE2<T : ExpressibleByIntegerLiteral> 
-  : T // expected-error{{RawRepresentable 'init' cannot be synthesized because raw type 'T' is not Equatable}}
+enum SE2<T : ExpressibleByIntegerLiteral>
+  : T // expected-error {{'SE2<T>' declares raw type 'T', but does not conform to RawRepresentable and conformance could not be synthesized}} expected-error{{RawRepresentable 'init' cannot be synthesized because raw type 'T' is not Equatable}}
 { case X }
 
-// ... but not if init?(RawValue) is directly implemented some other way.
-enum SE3<T : ExpressibleByIntegerLiteral> : T { 
+// ... but not if init?(RawValue) and `rawValue` are directly implemented some other way.
+protocol InstanceGettable {
+  static var someInstance : Self { get }
+}
+enum SE3<T : ExpressibleByIntegerLiteral> : T where T: InstanceGettable {
   case X 
 
   init?(rawValue: T) {
     self = SE3.X
   }
+
+  var rawValue : T {
+    return T.someInstance
+  }
 }
 
 enum SE4<T : ExpressibleByIntegerLiteral & Equatable> : T { case X }

test/IDE/print_ast_tc_decls_errors.swift

@@ -120,17 +120,17 @@ enum EnumWithInheritance2 : FooNonExistentProtocol, BarNonExistentProtocol {} //
 // TYREPR: {{^}}enum EnumWithInheritance2 : FooNonExistentProtocol, BarNonExistentProtocol {{{$}}
 
 enum EnumWithInheritance3 : FooClass { case X } // expected-error {{raw type 'FooClass' is not expressible by any literal}}
-// expected-error@-1{{type 'EnumWithInheritance3' does not conform to protocol 'RawRepresentable'}}
+// expected-error@-1{{'EnumWithInheritance3' declares raw type 'FooClass', but does not conform to RawRepresentable and conformance could not be synthesized}}
 // NO-TYREPR: {{^}}enum EnumWithInheritance3 : <<error type>> {{{$}}
 // TYREPR: {{^}}enum EnumWithInheritance3 : FooClass {{{$}}
 
 enum EnumWithInheritance4 : FooClass, FooProtocol { case X } // expected-error {{raw type 'FooClass' is not expressible by any literal}}
-// expected-error@-1{{type 'EnumWithInheritance4' does not conform to protocol 'RawRepresentable'}}
+// expected-error@-1{{'EnumWithInheritance4' declares raw type 'FooClass', but does not conform to RawRepresentable and conformance could not be synthesized}}
 // NO-TYREPR: {{^}}enum EnumWithInheritance4 : <<error type>>, FooProtocol {{{$}}
 // TYREPR: {{^}}enum EnumWithInheritance4 : FooClass, FooProtocol {{{$}}
 
 enum EnumWithInheritance5 : FooClass, BarClass { case X } // expected-error {{raw type 'FooClass' is not expressible by any literal}} expected-error {{multiple enum raw types 'FooClass' and 'BarClass'}}
-// expected-error@-1{{type 'EnumWithInheritance5' does not conform to protocol 'RawRepresentable'}}
+// expected-error@-1{{'EnumWithInheritance5' declares raw type 'FooClass', but does not conform to RawRepresentable and conformance could not be synthesized}}
 // NO-TYREPR: {{^}}enum EnumWithInheritance5 : <<error type>>, <<error type>> {{{$}}
 // TYREPR: {{^}}enum EnumWithInheritance5 : FooClass, BarClass {{{$}}
 

test/IRGen/enum_derived.swift

@@ -47,5 +47,3 @@ enum Phantom<T> : Int64 {
   case Up
   case Down
 }
-
-extension Phantom : RawRepresentable {}