[cxx-interop] Fix assertion failure from unavailable NS_ENUM typedef

The NS_OPTIONS macro sometimes uses a pattern where it loosely
associates a typedef with an anonymous enum via a shared underlying
integer type (emphasis on "loosely"). The typedef is marked as
unavailable in Swift so as to not cause name ambiguity when we associate
the anonymous enum with said typedef. We use unavailability as
a heuristic during the import process, but that conflates NS_OPTIONS
with NS_ENUMs that can be marked as unavailable for entirely unrelated
reasons.

That in and of itself is fine, because the import logic is general
enough to handle both cases, but we have an assertion that seems to be
unaware of this scenario, and trips on unavailable NS_ENUMs. (In those
cases, the typedef points to the enum rather than the underlying integer
type.) This patch fixes the assertion to be resilient against such cases
by looking through the enum a typedef refers to.

rdar://150399978

Author: j-hui

lib/ClangImporter/ImportEnumInfo.cpp

@@ -259,10 +259,23 @@ ImportedType importer::findOptionSetEnum(clang::QualType type,
   if (!clangEnum)
     return ImportedType();
 
-  // If this fails, it means that we need a stronger predicate for
+  // Only ASSERT() on assertions-enabled builds. This preserves existing
+  // behavior and de-risks existing builds, but should be removed after 6.2.
+#ifndef NDEBUG
+  // Assert that the typedef has the same underlying integer representation as
+  // the enum we think it assigns a type name to.
+  //
+  // If these fails, it means that we need a stronger predicate for
   // determining the relationship between an enum and typedef.
-  assert(clangEnum.value()->getIntegerType()->getCanonicalTypeInternal() ==
-         typedefType->getCanonicalTypeInternal());
+  if (auto *tdEnum =
+          dyn_cast<clang::EnumType>(typedefType->getCanonicalTypeInternal())) {
+    ASSERT(clangEnum.value()->getIntegerType()->getCanonicalTypeInternal() ==
+           tdEnum->getDecl()->getIntegerType()->getCanonicalTypeInternal());
+  } else {
+    ASSERT(clangEnum.value()->getIntegerType()->getCanonicalTypeInternal() ==
+           typedefType->getCanonicalTypeInternal());
+  }
+#endif // !NDEBUG
 
   if (auto *swiftEnum = Impl.importDecl(*clangEnum, Impl.CurrentVersion))
     return {cast<TypeDecl>(swiftEnum)->getDeclaredInterfaceType(), false};

test/Interop/Cxx/objc-correctness/ns-enum-with-unavailable-typedef.swift

@@ -0,0 +1,60 @@
+// RUN: split-file %s %t
+// RUN: %target-swift-frontend -typecheck -verify %t/main.swift -I %t/include -module-name main
+// RUN: %target-swift-frontend -typecheck -verify %t/main.swift -I %t/include -module-name main -cxx-interoperability-mode=default
+// REQUIRES: objc_interop
+
+//--- include/module.modulemap
+module ObjCModule {
+    header "header.h"
+}
+
+//--- include/header.h
+#include <Foundation/Foundation.h>
+
+#define UNAVAILABLE API_UNAVAILABLE(macos)
+
+UNAVAILABLE
+typedef NS_ENUM(NSUInteger, MyUnavailableEnum) {
+    MyUnavailableEnumCase1 = 0,
+    MyUnavailableEnumCase2,
+};
+
+UNAVAILABLE
+void unavailableParam(MyUnavailableEnum e);
+
+UNAVAILABLE
+MyUnavailableEnum unavailableReturn(void);
+
+struct UNAVAILABLE UnavailableStruct {
+  MyUnavailableEnum field;
+};
+
+UNAVAILABLE
+@interface UnavailableClass
+@property (nonatomic, readonly) MyUnavailableEnum prop;
+@end
+
+UNAVAILABLE
+__attribute__((swift_name("getter:UnavailableStruct.iProp(self:)")))
+inline MyUnavailableEnum getUnavailableInjProp(struct UnavailableStruct s) {
+  return MyUnavailableEnumCase1;
+}
+
+//--- main.swift
+import Foundation
+import ObjCModule
+
+@available(*, unavailable)
+func useParam(_ e: MyUnavailableEnum) { unavailableParam(e) }
+
+@available(*, unavailable)
+func useReturn() -> MyUnavailableEnum { return unavailableReturn() }
+
+@available(*, unavailable)
+func useField(_ o: UnavailableStruct) -> MyUnavailableEnum { return o.field }
+
+@available(*, unavailable)
+func useIProp(_ o: UnavailableStruct) -> MyUnavailableEnum { return o.iProp }
+
+@available(*, unavailable)
+func useProp(_ o: UnavailableClass) -> MyUnavailableEnum { return o.prop }