Parse: Only accept certain literals as enum case raw values

Just checking for LiteralExpr is too broad, because Sema doesn't
know what to do with RegexLiteralExpr for example.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -3781,9 +3781,6 @@ ERROR(enum_non_integer_convertible_raw_type_no_value,none,
       "expressible by integer or string literal", ())
 ERROR(enum_raw_value_not_unique,none,
       "raw value for enum case is not unique", ())
-ERROR(enum_raw_value_magic_literal,none,
-      "use of '%0' literal as raw value for enum case is not supported",
-      (StringRef))
 NOTE(enum_raw_value_used_here,none,
      "raw value previously used here", ())
 NOTE(enum_raw_value_incrementing_from_here,none,

lib/Parse/ParseDecl.cpp

@@ -9229,6 +9229,20 @@ ParserResult<EnumDecl> Parser::parseDeclEnum(ParseDeclOptions Flags,
   return DCC.fixupParserResult(Status, ED);
 }
 
+static bool isValidEnumRawValueLiteral(LiteralExpr *expr) {
+  if (expr == nullptr)
+    return false;
+
+  if (!isa<IntegerLiteralExpr>(expr) &&
+      !isa<FloatLiteralExpr>(expr) &&
+      !isa<StringLiteralExpr>(expr) &&
+      !isa<BooleanLiteralExpr>(expr) &&
+      !isa<NilLiteralExpr>(expr))
+    return false;
+
+  return true;
+}
+
 /// Parse a 'case' of an enum.
 ///
 /// \verbatim
@@ -9346,8 +9360,7 @@ Parser::parseDeclEnumCase(ParseDeclOptions Flags,
       }
       // The raw value must be syntactically a simple literal.
       LiteralRawValueExpr = dyn_cast<LiteralExpr>(RawValueExpr.getPtrOrNull());
-      if (!LiteralRawValueExpr
-          || isa<InterpolatedStringLiteralExpr>(LiteralRawValueExpr)) {
+      if (!isValidEnumRawValueLiteral(LiteralRawValueExpr)) {
         diagnose(RawValueExpr.getPtrOrNull()->getLoc(),
                  diag::nonliteral_enum_case_raw_value);
         LiteralRawValueExpr = nullptr;

lib/Sema/TypeCheckDecl.cpp

@@ -1304,15 +1304,6 @@ EnumRawValuesRequest::evaluate(Evaluator &eval, EnumDecl *ED,
     SourceLoc diagLoc = uncheckedRawValueOf(elt)->isImplicit()
                             ? elt->getLoc()
                             : uncheckedRawValueOf(elt)->getLoc();
-    if (auto magicLiteralExpr =
-            dyn_cast<MagicIdentifierLiteralExpr>(prevValue)) {
-      auto kindString =
-          magicLiteralExpr->getKindString(magicLiteralExpr->getKind());
-      Diags.diagnose(diagLoc, diag::enum_raw_value_magic_literal, kindString);
-      elt->setInvalid();
-      continue;
-    }
-
     // Check that the raw value is unique.
     RawValueKey key{prevValue};
     RawValueSource source{elt, lastExplicitValueElt};

test/decl/enum/invalid_raw_value.swift

@@ -0,0 +1,7 @@
+// RUN: %target-typecheck-verify-swift
+
+_ = a.init
+_ = b.init
+
+enum a : Int { case x = #/ /# }  // expected-error {{raw value for enum case must be a literal}}
+enum b : String { case x = #file }  // expected-error {{raw value for enum case must be a literal}}

validation-test/compiler_crashers_2/441e44e28042d5a3.swift renamed to validation-test/compiler_crashers_2_fixed/441e44e28042d5a3.swift

@@ -1,3 +1,3 @@
 // {"signature":"deriveBodyRawRepresentable_init(swift::AbstractFunctionDecl*, void*)"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 a enum a : Int { case = #/

validation-test/compiler_crashers_2_fixed/issue-55443.swift

@@ -2,20 +2,20 @@
 
 // https://github.com/apple/swift/issues/55443
 
-enum FooString: String { // expected-error {{'FooString' declares raw type 'String', but does not conform to RawRepresentable and conformance could not be synthesized}} expected-note {{add stubs for conformance}}
-  case bar1 = #file // expected-error {{use of '#file' literal as raw value for enum case is not supported}}
-  case bar2 = #function // expected-error {{use of '#function' literal as raw value for enum case is not supported}}
-  case bar3 = #filePath // expected-error {{use of '#filePath' literal as raw value for enum case is not supported}}
-  case bar4 = #line // expected-error {{cannot convert value of type 'Int' to raw type 'String'}}
-  case bar5 = #column // expected-error {{cannot convert value of type 'Int' to raw type 'String'}}
-  case bar6 = #dsohandle // expected-error {{cannot convert value of type 'UnsafeRawPointer' to raw type 'String'}}
+enum FooString: String {
+  case bar1 = #file // expected-error {{raw value for enum case must be a literal}}
+  case bar2 = #function // expected-error {{raw value for enum case must be a literal}}
+  case bar3 = #filePath // expected-error {{raw value for enum case must be a literal}}
+  case bar4 = #line // expected-error {{raw value for enum case must be a literal}}
+  case bar5 = #column // expected-error {{raw value for enum case must be a literal}}
+  case bar6 = #dsohandle // expected-error {{raw value for enum case must be a literal}}
 }
 
-enum FooInt: Int { // expected-error {{'FooInt' declares raw type 'Int', but does not conform to RawRepresentable and conformance could not be synthesized}} expected-note {{add stubs for conformance}}
-  case bar1 = #file // expected-error {{cannot convert value of type 'String' to raw type 'Int'}}
-  case bar2 = #function // expected-error {{cannot convert value of type 'String' to raw type 'Int'}}
-  case bar3 = #filePath // expected-error {{cannot convert value of type 'String' to raw type 'Int'}}
-  case bar4 = #line // expected-error {{use of '#line' literal as raw value for enum case is not supported}}
-  case bar5 = #column // expected-error {{use of '#column' literal as raw value for enum case is not supported}}
-  case bar6 = #dsohandle // expected-error {{cannot convert value of type 'UnsafeRawPointer' to raw type 'Int'}}
+enum FooInt: Int {
+  case bar1 = #file // expected-error {{raw value for enum case must be a literal}}
+  case bar2 = #function // expected-error {{raw value for enum case must be a literal}}
+  case bar3 = #filePath // expected-error {{raw value for enum case must be a literal}}
+  case bar4 = #line // expected-error {{raw value for enum case must be a literal}}
+  case bar5 = #column // expected-error {{raw value for enum case must be a literal}}
+  case bar6 = #dsohandle // expected-error {{raw value for enum case must be a literal}}
 }