[SILGen] Show a message when an unexpected enum value is switched on (#15614)

Builds on 36eae9d to emit a message instead of just trapping
when a switch over a non-frozen enum ends up not matching anything.
If the enum is known to be an @objc enum, the message is

  unexpected enum case 'MyEnum(rawValue: -42)'

and if it's anything else (a Swift enum, a tuple containing enums,
whatever), it's a more opaque

  unexpected enum case while switching on value of type 'MyEnum'

The reason for this is to avoid calling String(describing:) or
String(reflecting:) an arbitrary value when the enum might conform to
CustomStringConvertible and therefore /itself/ have a switch that's
going to fall off the end. By handling plain @objc enums (using a
bitcast), we've at least covered the 90% case.

rdar://problem/37728359

Author: jrose-apple

include/swift/AST/KnownDecls.def

@@ -63,6 +63,8 @@ FUNC_DECL(BridgeAnyObjectToAny,
 FUNC_DECL(ConvertToAnyHashable, "_convertToAnyHashable")
 
 FUNC_DECL(DiagnoseUnexpectedNilOptional, "_diagnoseUnexpectedNilOptional")
+FUNC_DECL(DiagnoseUnexpectedEnumCase, "_diagnoseUnexpectedEnumCase")
+FUNC_DECL(DiagnoseUnexpectedEnumCaseValue, "_diagnoseUnexpectedEnumCaseValue")
 
 FUNC_DECL(GetErrorEmbeddedNSError, "_getErrorEmbeddedNSError")
 

lib/SILGen/SILGenPattern.cpp

@@ -22,7 +22,9 @@
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/SILOptions.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/Types.h"
+#include "swift/Basic/Defer.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/SIL/DynamicCasts.h"
@@ -2555,19 +2557,78 @@ void SILGenFunction::usingImplicitVariablesForPattern(Pattern *pattern, CaseStmt
   variableSwapper();
 }
 
+static void emitDiagnoseOfUnexpectedEnumCaseValue(SILGenFunction &SGF,
+                                                  SILLocation loc,
+                                                  ManagedValue value,
+                                                  const EnumDecl *enumDecl) {
+  ASTContext &ctx = SGF.getASTContext();
+  auto diagnoseFailure = ctx.getDiagnoseUnexpectedEnumCaseValue(nullptr);
+  if (!diagnoseFailure) {
+    SGF.B.createBuiltinTrap(loc);
+    return;
+  }
+
+  assert(enumDecl->isObjC());
+  assert(enumDecl->hasRawType());
+  assert(value.getType().isTrivial(SGF.getModule()));
+
+  // Get the enum type as an Any.Type value.
+  CanType switchedValueSwiftType = value.getType().getSwiftRValueType();
+  SILType metatypeType = SGF.getLoweredType(
+      CanMetatypeType::get(switchedValueSwiftType,
+                           MetatypeRepresentation::Thick));
+  SILValue metatype = SGF.B.createMetatype(loc, metatypeType);
+
+  // Bitcast the enum value to its raw type. (This is only safe for @objc
+  // enums.)
+  SILType loweredRawType = SGF.getLoweredType(enumDecl->getRawType());
+  assert(loweredRawType.isTrivial(SGF.getModule()));
+  assert(loweredRawType.isObject());
+  auto rawValue = SGF.B.createUncheckedTrivialBitCast(loc, value,
+                                                      loweredRawType);
+  auto materializedRawValue = rawValue.materialize(SGF, loc);
+
+  Substitution subs[] = {
+    {switchedValueSwiftType, /*Conformances*/None},
+    {enumDecl->getRawType(), /*Conformances*/None},
+  };
+
+  SGF.emitApplyOfLibraryIntrinsic(loc, diagnoseFailure, subs,
+                                  {ManagedValue::forUnmanaged(metatype),
+                                   materializedRawValue},
+                                  SGFContext());
+}
+
+static void emitDiagnoseOfUnexpectedEnumCase(SILGenFunction &SGF,
+                                             SILLocation loc,
+                                             ManagedValue value) {
+  ASTContext &ctx = SGF.getASTContext();
+  auto diagnoseFailure = ctx.getDiagnoseUnexpectedEnumCase(nullptr);
+  if (!diagnoseFailure) {
+    SGF.B.createBuiltinTrap(loc);
+    return;
+  }
+
+  // Get the switched-upon value's type.
+  CanType switchedValueSwiftType = value.getType().getSwiftRValueType();
+  SILType metatypeType = SGF.getLoweredType(
+      CanMetatypeType::get(switchedValueSwiftType,
+                           MetatypeRepresentation::Thick));
+  ManagedValue metatype = SGF.B.createValueMetatype(loc, metatypeType, value);
+
+  Substitution sub{switchedValueSwiftType, /*Conformances*/None};
+  auto genericArgsMap =
+      diagnoseFailure->getGenericSignature()->getSubstitutionMap(sub);
+
+  SGF.emitApplyOfLibraryIntrinsic(loc, diagnoseFailure, sub,
+                                  metatype,
+                                  SGFContext());
+}
+
 void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
   DEBUG(llvm::dbgs() << "emitting switch stmt\n";
         S->print(llvm::dbgs());
         llvm::dbgs() << '\n');
-  auto failure = [this](SILLocation location) {
-    // If we fail to match anything, we trap. This can happen with a switch
-    // over an @objc enum, which may contain any value of its underlying type.
-    // FIXME: Even if we can't say what the invalid value was, we should at
-    // least mention that this was because of a non-exhaustive enum.
-    B.createBuiltinTrap(location);
-    B.createUnreachable(location);
-  };
-  
   // If the subject expression is uninhabited, we're already dead.
   // Emit an unreachable in place of the switch statement.
   if (S->getSubjectExpr()->getType()->isStructurallyUninhabited()) {
@@ -2651,10 +2712,7 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
   PatternMatchEmission emission(*this, S, completionHandler);
 
   // Add a row for each label of each case.
-  //
-  // We use std::vector because it supports emplace_back; moving a ClauseRow is
-  // expensive.
-  std::vector<ClauseRow> clauseRows;
+  SmallVector<ClauseRow, 8> clauseRows;
   clauseRows.reserve(S->getRawCases().size());
   bool hasFallthrough = false;
   for (auto caseBlock : S->getCases()) {
@@ -2695,6 +2753,27 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
   ManagedValue subjectMV = emitRValueAsSingleValue(S->getSubjectExpr());
   auto subject = ConsumableManagedValue::forOwned(subjectMV);
 
+  auto failure = [&](SILLocation location) {
+    // If we fail to match anything, we trap. This can happen with a switch
+    // over an @objc enum, which may contain any value of its underlying type,
+    // or a switch over a non-frozen Swift enum when the user hasn't written a
+    // catch-all case.
+    SWIFT_DEFER { B.createUnreachable(location); };
+
+    // Special case: if it's a single @objc enum, we can print the raw value.
+    CanType ty = S->getSubjectExpr()->getType()->getCanonicalType();
+    if (auto *singleEnumDecl = ty->getEnumOrBoundGenericEnum()) {
+      if (singleEnumDecl->isObjC()) {
+        emitDiagnoseOfUnexpectedEnumCaseValue(*this, location,
+                                              subject.getFinalManagedValue(),
+                                              singleEnumDecl);
+        return;
+      }
+    }
+    emitDiagnoseOfUnexpectedEnumCase(*this, location,
+                                     subject.getFinalManagedValue());
+  };
+
   // Set up an initial clause matrix.
   ClauseMatrix clauses(clauseRows);
 

stdlib/public/core/AssertCommon.swift

@@ -137,6 +137,31 @@ internal func _assertionFailure(
   Builtin.int_trap()
 }
 
+/// This function should be used only in the implementation of user-level
+/// assertions.
+///
+/// This function should not be inlined because it is cold and inlining just
+/// bloats code.
+@_versioned // FIXME(sil-serialize-all)
+@inline(never)
+internal func _assertionFailure(
+  _ prefix: StaticString, _ message: String,
+  flags: UInt32
+) -> Never {
+  prefix.withUTF8Buffer {
+    (prefix) -> Void in
+    message._withUnsafeBufferPointerToUTF8 {
+      (messageUTF8) -> Void in
+      _swift_stdlib_reportFatalError(
+        prefix.baseAddress!, CInt(prefix.count),
+        messageUTF8.baseAddress!, CInt(messageUTF8.count),
+        flags)
+    }
+  }
+
+  Builtin.int_trap()
+}
+
 /// This function should be used only in the implementation of stdlib
 /// assertions.
 ///
@@ -238,3 +263,37 @@ func _undefined<T>(
 ) -> T {
   _assertionFailure("Fatal error", message(), file: file, line: line, flags: 0)
 }
+
+/// Called when falling off the end of a switch and the type can be represented
+/// as a raw value.
+///
+/// This function should not be inlined because it is cold and inlining just
+/// bloats code. It doesn't take a source location because it's most important
+/// in release builds anyway (old apps that are run on new OSs).
+@inline(never)
+@_versioned // COMPILER_INTRINSIC
+internal func _diagnoseUnexpectedEnumCaseValue<SwitchedValue, RawValue>(
+  type: SwitchedValue.Type,
+  rawValue: RawValue
+) -> Never {
+  _assertionFailure("Fatal error",
+                    "unexpected enum case '\(type)(rawValue: \(rawValue))'",
+                    flags: _fatalErrorFlags())
+}
+
+/// Called when falling off the end of a switch and the value is not safe to
+/// print.
+///
+/// This function should not be inlined because it is cold and inlining just
+/// bloats code. It doesn't take a source location because it's most important
+/// in release builds anyway (old apps that are run on new OSs).
+@inline(never)
+@_versioned // COMPILER_INTRINSIC
+internal func _diagnoseUnexpectedEnumCase<SwitchedValue>(
+  type: SwitchedValue.Type
+) -> Never {
+  _assertionFailure(
+    "Fatal error",
+    "unexpected enum case while switching on value of type '\(type)'",
+    flags: _fatalErrorFlags())
+}

test/IRGen/objc_enum_multi_file.swift

@@ -34,7 +34,7 @@ func useFoo(_ x: Foo) -> Int32 {
   }
 
   // CHECK: <label>:[[DEFAULT]]
-  // CHECK-NEXT: call void @llvm.trap()
+  // CHECK: call swiftcc void @"$Ss32_diagnoseUnexpectedEnumCaseValue{{.+}}"(%swift.type* @"$S{{.+}}3FooON", %swift.opaque* noalias nocapture %{{.+}}, %swift.type* @"$Ss5Int32VN")
   // CHECK-NEXT: unreachable
 
   // CHECK: <label>:[[FINAL]]
@@ -68,7 +68,7 @@ func useBar(_ x: Bar) -> Int32 {
   }
 
   // CHECK: <label>:[[DEFAULT]]
-  // CHECK-NEXT: call void @llvm.trap()
+  // CHECK: call swiftcc void @"$Ss32_diagnoseUnexpectedEnumCaseValue{{.+}}"(%swift.type* @"$S{{.+}}3BarON", %swift.opaque* noalias nocapture %{{.+}}, %swift.type* @"$Ss5Int32VN")
   // CHECK-NEXT: unreachable
 
   // CHECK: <label>:[[FINAL]]