[ClangImporter] Fix NS_CLOSED_ENUM to validate raw values

Generate switch-based validation for @Frozen enum init?(rawValue:)
instead of using unchecked reinterpretCast. This ensures only declared
enum cases are accepted, returning nil for invalid raw values.

For non-frozen enums (NS_ENUM), preserve existing reinterpretCast
behavior for C compatibility.

Fixes #85701

Author: an0

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -1247,7 +1247,52 @@ SwiftDeclSynthesizer::makeIndirectFieldAccessors(
 
 // MARK: Enum RawValue initializers
 
+/// Clone a literal expression for use in pattern matching.
+/// Based on cloneRawLiteralExpr from DerivedConformanceRawRepresentable.cpp
+static LiteralExpr *cloneRawLiteralExpr(ASTContext &C, LiteralExpr *expr) {
+  LiteralExpr *clone;
+  if (auto intLit = dyn_cast<IntegerLiteralExpr>(expr)) {
+    clone = new (C) IntegerLiteralExpr(intLit->getDigitsText(), expr->getLoc(),
+                                       /*implicit*/ true);
+    if (intLit->isNegative())
+      cast<IntegerLiteralExpr>(clone)->setNegative(expr->getLoc());
+  } else if (isa<NilLiteralExpr>(expr)) {
+    clone = new (C) NilLiteralExpr(expr->getLoc());
+  } else if (auto stringLit = dyn_cast<StringLiteralExpr>(expr)) {
+    clone = new (C) StringLiteralExpr(stringLit->getValue(), expr->getLoc());
+  } else if (auto floatLit = dyn_cast<FloatLiteralExpr>(expr)) {
+    clone = new (C) FloatLiteralExpr(floatLit->getDigitsText(), expr->getLoc(),
+                                     /*implicit*/ true);
+    if (floatLit->isNegative())
+      cast<FloatLiteralExpr>(clone)->setNegative(expr->getLoc());
+  } else {
+    llvm_unreachable("invalid raw literal expr");
+  }
+  clone->setImplicit();
+  return clone;
+}
+
 /// Synthesize the body of \c init?(rawValue:RawType) for an imported enum.
+///
+/// For non-frozen (open) enums, this generates:
+///   init?(rawValue: RawType) {
+///     self = Builtin.reinterpretCast(rawValue)
+///   }
+/// This allows arbitrary raw values for C compatibility.
+///
+/// For frozen (closed) enums, this generates:
+///   init?(rawValue: RawType) {
+///     switch rawValue {
+///     case <value1>:
+///       self = Builtin.reinterpretCast(rawValue)
+///     case <value2>:
+///       self = Builtin.reinterpretCast(rawValue)
+///     ...
+///     default:
+///       return nil
+///     }
+///   }
+/// This ensures that only declared raw values are accepted.
 static std::pair<BraceStmt *, bool>
 synthesizeEnumRawValueConstructorBody(AbstractFunctionDecl *afd,
                                       void *context) {
@@ -1290,11 +1335,92 @@ synthesizeEnumRawValueConstructorBody(AbstractFunctionDecl *afd,
                                      /*implicit*/ true);
   assign->setType(TupleType::getEmpty(ctx));
 
-  auto *ret = ReturnStmt::createImplicit(ctx, /*expr*/ nullptr);
+  // Check if the enum is frozen (closed). If so, we need to validate
+  // that the raw value is one of the declared cases.
+  bool isFrozen = enumDecl->getAttrs().hasAttribute<FrozenAttr>();
 
-  auto body = BraceStmt::create(ctx, SourceLoc(), {assign, ret}, SourceLoc(),
-                                /*implicit*/ true);
-  return {body, /*isTypeChecked=*/true};
+  if (isFrozen) {
+    // For frozen enums, generate a switch statement to validate the raw value
+    SmallVector<CaseStmt *, 8> cases;
+
+    // Build cases for each enum element
+    for (auto *elt : enumDecl->getAllElements()) {
+      // Get the raw value literal for this element
+      auto rawValueExpr = elt->getStructuralRawValueExpr();
+      if (!rawValueExpr)
+        continue;
+
+      // Clone the raw value expression for pattern matching
+      auto *litExpr = cloneRawLiteralExpr(ctx, cast<LiteralExpr>(rawValueExpr));
+      auto *litPat = ExprPattern::createImplicit(ctx, litExpr, ctorDecl);
+
+      // Create case label
+      auto labelItem = CaseLabelItem(litPat);
+
+      // Create the assignment statement for this case
+      auto *caseBodySelfRef = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(),
+                                                     /*implicit*/ true);
+      caseBodySelfRef->setType(LValueType::get(selfDecl->getTypeInContext()));
+
+      auto *caseParamRef = new (ctx) DeclRefExpr(param, DeclNameLoc(),
+                                                  /*implicit*/ true);
+      caseParamRef->setType(param->getTypeInContext());
+
+      auto *caseArgList = ArgumentList::forImplicitUnlabeled(ctx, {caseParamRef});
+      auto *caseReinterpretCastRef =
+          new (ctx) DeclRefExpr(concreteDeclRef, DeclNameLoc(), /*implicit*/ true);
+      caseReinterpretCastRef->setType(
+          FunctionType::get({FunctionType::Param(rawTy)}, enumTy, info));
+
+      auto caseReinterpreted =
+          CallExpr::createImplicit(ctx, caseReinterpretCastRef, caseArgList);
+      caseReinterpreted->setType(enumTy);
+      caseReinterpreted->setThrows(nullptr);
+
+      auto *caseAssign = new (ctx) AssignExpr(caseBodySelfRef, SourceLoc(),
+                                               caseReinterpreted, /*implicit*/ true);
+      caseAssign->setType(TupleType::getEmpty(ctx));
+
+      auto *caseBody = BraceStmt::create(ctx, SourceLoc(), {caseAssign},
+                                         SourceLoc(), /*implicit*/ true);
+
+      auto *caseStmt = CaseStmt::createImplicit(ctx, CaseParentKind::Switch,
+                                                {labelItem}, caseBody);
+      cases.push_back(caseStmt);
+    }
+
+    // Add default case that returns nil
+    auto *defaultPattern = AnyPattern::createImplicit(ctx);
+    auto defaultLabelItem = CaseLabelItem(defaultPattern);
+
+    auto *failStmt = new (ctx) FailStmt(SourceLoc(), SourceLoc(), /*implicit*/ true);
+    auto *defaultBody = BraceStmt::create(ctx, SourceLoc(), {failStmt},
+                                          SourceLoc(), /*implicit*/ true);
+
+    auto *defaultCase = CaseStmt::createImplicit(ctx, CaseParentKind::Switch,
+                                                 {defaultLabelItem}, defaultBody);
+    cases.push_back(defaultCase);
+
+    // Create the switch statement
+    auto *switchParamRef = new (ctx) DeclRefExpr(param, DeclNameLoc(),
+                                                  /*implicit*/ true);
+    switchParamRef->setType(param->getTypeInContext());
+
+    auto *switchStmt = SwitchStmt::create(LabeledStmtInfo(), SourceLoc(),
+                                          switchParamRef, SourceLoc(),
+                                          cases, SourceLoc(), SourceLoc(), ctx);
+
+    auto body = BraceStmt::create(ctx, SourceLoc(), {switchStmt}, SourceLoc(),
+                                  /*implicit*/ true);
+    return {body, /*isTypeChecked=*/false};
+  } else {
+    // For non-frozen enums, use the simple reinterpret cast approach
+    auto *ret = ReturnStmt::createImplicit(ctx, /*expr*/ nullptr);
+
+    auto body = BraceStmt::create(ctx, SourceLoc(), {assign, ret}, SourceLoc(),
+                                  /*implicit*/ true);
+    return {body, /*isTypeChecked=*/true};
+  }
 }
 
 ConstructorDecl *