emit error when a noncopyable enum has a raw type

previously I was allowing these because I thought there was
some representational difference if the enum is raw. it
turns out that a raw enum is only useful if you synthesize
conformance to RawRepresentable. since I disabled that
synthesis it's kind of silly to still allow the raw type
to be written at all.

rdar://110539937

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -3246,6 +3246,9 @@ ERROR(enum_raw_type_nonconforming_and_nonsynthable,none,
       "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_nonconforming_and_noncopyable,none,
+      "%0 declares raw type %1, but cannot yet conform to RawRepresentable "
+      "because it is noncopyable", (Type, Type))
 ERROR(enum_raw_type_access,none,
       "enum %select{must be declared %select{"
       "%select{private|fileprivate|internal|package|%error|%error}1|private or fileprivate}3"

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -277,7 +277,7 @@ static void checkInheritanceClause(
     }
 
     // If this is an enum inheritance clause, check for a raw type.
-    if (isa<EnumDecl>(decl)) {
+    if (auto enumDecl = dyn_cast<EnumDecl>(decl)) {
       // Check if we already had a raw type.
       if (superclassTy) {
         if (superclassTy->isEqual(inheritedTy)) {
@@ -293,6 +293,20 @@ static void checkInheritanceClause(
         }
         continue;
       }
+
+      // Noncopyable types cannot have a raw type until there is support for
+      // generics, since the raw type here is only useful if we'll generate
+      // a conformance to RawRepresentable, which is currently disabled.
+      if (enumDecl->isMoveOnly()) {
+        // TODO: getRemovalRange is not yet aware of ~Copyable entries so it
+        // will accidentally delete commas or colons that are needed.
+        diags.diagnose(inherited.getSourceRange().Start,
+                       diag::enum_raw_type_nonconforming_and_noncopyable,
+                       enumDecl->getDeclaredInterfaceType(), inheritedTy)
+             .highlight(inherited.getSourceRange());
+
+        // Fall through to still record this raw type.
+      }
 
       // If this is not the first entry in the inheritance clause, complain.
       if (i > 0) {

test/Sema/moveonly_objc_enum.swift

@@ -6,12 +6,14 @@
 
 @_moveOnly
 @objc enum Foo : Int { // expected-error {{noncopyable enums cannot be marked '@objc'}}
+                       // expected-error@-1 {{'Foo' declares raw type 'Int', but cannot yet conform to RawRepresentable because it is noncopyable}}
   case X, Y, Z
   deinit {} // expected-error {{deinitializers cannot be declared on an @objc enum type}}
 }
 
 @_moveOnly
 @objc enum Foo2 : Int { // expected-error {{noncopyable enums cannot be marked '@objc'}}
+                        // expected-error@-1 {{'Foo2' declares raw type 'Int', but cannot yet conform to RawRepresentable because it is noncopyable}}
   case X, Y, Z
 }
 

test/Sema/moveonly_restrictions.swift

@@ -216,8 +216,8 @@ enum Color {
     }
 }
 
-@_moveOnly
-enum StrengthLevel: Int { // ensure move-only raw enums do not conform to RawRepresentable
+// expected-error@+1:21 {{'StrengthLevel' declares raw type 'Int', but cannot yet conform to RawRepresentable because it is noncopyable}}
+enum StrengthLevel: Int, ~Copyable {
     case none = 0
     case low
     case high